MuonR4::MsTrackSeeder Class Reference

Helper class to group muon sgements that may belong to a muon trajectory. More...

#include <MsTrackSeeder.h>

Inheritance diagram for MuonR4::MsTrackSeeder:

Collaboration diagram for MuonR4::MsTrackSeeder:

Classes
struct	Config
	Configuration object. More...

Public Types
enum class	SectorProjector : std::int8_t { leftOverlap = -1 , center = 0 , rightOverlap = 1 }
	Enumeration to select the sector projection. More...
enum class	SeedCoords : std::uint8_t { eDetSection , eSector , ePosOnCylinder }
	Abrivation of the seed coordinates. More...
using	SearchTree_t = Acts::KDTree<3, const xAOD::MuonSegment*, double, std::array, 6>
	Definition of the search tree class.
using	Location = MsTrackSeed::Location
	Enum toggling whether the segment is in the endcap or barrel.
using	VecOpt_t = std::optional<Amg::Vector3D>

Public Member Functions
	MsTrackSeeder (const std::string &msgName, Config &&cfg)
	Standard constructor.
SearchTree_t	constructTree (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegmentContainer &segments) const
	Construct a complete search tree from a MuonSegment container.
Amg::Vector2D	expressOnCylinder (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, const Location loc, const SectorProjector proj) const
	Expresses the segment on the cylinder surface.
Amg::Vector3D	projectOntoPhiPlane (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, const double projectPhi) const
Amg::Vector3D	projectOntoSector (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, const SectorProjector proj) const
	Projects the segment's position onto the sector centre or onto the overlap point with one of the neighbouring sector.
Amg::Vector3D	projectOntoSector (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment &segment, const MsTrackSeed &seed) const
	Projects the segment's position onto the sector centre or onto the overlap point with one of the neighbouring sector.
double	estimateQtimesP (const ActsTrk::GeometryContext &gctx, const AtlasFieldCacheCondObj &magField, const MsTrackSeed &seed) const
	Estimate the q /p of the seed candidate from the contained segments.
bool	withinBounds (const Amg::Vector2D &projPos, const Location loc) const
	Returns whether the expression on the cylinder is within the surface bounds.
std::unique_ptr< MsTrackSeedContainer >	findTrackSeeds (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegmentContainer &segments) const
	Constructs the MS track seeds from the segment container.
const MuonGMR4::SpectrometerSector *	envelope (const xAOD::MuonSegment &segment) const
	Returns the spectrometer envelope associated to the segment (Coord system where the parameter are expressed)
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Static Public Member Functions
static double	projectedPhi (const int sector, const SectorProjector proj)
	Returns the projected phi for a given sector and projector.
static SectorProjector	projectorFromSeed (const xAOD::MuonSegment &seg, const MsTrackSeed &refSeed)
	Returns the Sector projector within the context of a MsTrackSeed.

Private Types
using	TreeRawVec_t = SearchTree_t::vector_t
	Abbrivation of the KDTree raw data vector.

Private Member Functions
std::optional< double >	calculateRadius (VecOpt_t &&pI, VecOpt_t &&pM, VecOpt_t &&pO, const Amg::Vector3D &planeNorm) const
	Calculates the radius of the bending circle from three points using the sagitta.
void	appendSegment (const ActsTrk::GeometryContext &gctx, const xAOD::MuonSegment *segment, const Location loc, TreeRawVec_t &outContainer) const
	Append the to the raw data container.
std::unique_ptr< MsTrackSeedContainer >	resolveOverlaps (MsTrackSeedContainer &&unresolved) const
	Removes exact duplciates or partial subsets of the MsTrackSeeds.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
Config	m_cfg {}
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Helper class to group muon sgements that may belong to a muon trajectory.

The reconstructed muon segments are projected onto the surface of a cylinder crossing roughly the middle stations of the MS. They are then appended to a 3-dimensional search tree using the extrapolated coordinate on the cylnder, the cylinder surface index and the segment's associated sector number.

Definition at line 29 of file MsTrackSeeder.h.

Member Typedef Documentation

Location

using MuonR4::MsTrackSeeder::Location = MsTrackSeed::Location

Enum toggling whether the segment is in the endcap or barrel.

Definition at line 56 of file MsTrackSeeder.h.

SearchTree_t

using MuonR4::MsTrackSeeder::SearchTree_t = Acts::KDTree<3, const xAOD::MuonSegment*, double, std::array, 6>

Definition of the search tree class.

Definition at line 54 of file MsTrackSeeder.h.

TreeRawVec_t

using MuonR4::MsTrackSeeder::TreeRawVec_t = SearchTree_t::vector_t

private

Abbrivation of the KDTree raw data vector.

Definition at line 160 of file MsTrackSeeder.h.

VecOpt_t

using MuonR4::MsTrackSeeder::VecOpt_t = std::optional<Amg::Vector3D>

Definition at line 58 of file MsTrackSeeder.h.

Member Enumeration Documentation

SectorProjector

enum class MuonR4::MsTrackSeeder::SectorProjector : std::int8_t

strong

Enumeration to select the sector projection.

Enumerator
leftOverlap
center	Project the segment onto the overlap with the previous sector.
rightOverlap	Project the segment onto the sector centre.

Definition at line 60 of file MsTrackSeeder.h.

                                       : std::int8_t {
                leftOverlap = -1,   
                center = 0,         
                rightOverlap = 1    
            };

SeedCoords

enum class MuonR4::MsTrackSeeder::SeedCoords : std::uint8_t

strong

Abrivation of the seed coordinates.

Enumerator
eDetSection	Encode the seed location (-1,1 -> endcaps, 0 -> barrel.
eSector	Sector of the associated spectrometer sector.
ePosOnCylinder	Extrapolation position along the cylinder surface.

Definition at line 66 of file MsTrackSeeder.h.

                                  : std::uint8_t{
                eDetSection,
                eSector,
                ePosOnCylinder
            };

Constructor & Destructor Documentation

MsTrackSeeder()

MuonR4::MsTrackSeeder::MsTrackSeeder	(	const std::string &	msgName,
		Config &&	cfg )

Standard constructor.

Parameters

msgName	Name of the seeder's msgStream
cfg	Configured cylinder dimensions, cuts & selection tool

Definition at line 79 of file MsTrackSeeder.cxx.

                                                                      :
        AthMessaging{msgName},
        m_cfg{std::move(cfg)}{
        auto& v{m_cfg.fieldExtpSteps};
        v.insert(0.); v.insert(1.);
        if (std::ranges::any_of(v, [](const double x){
            return x < 0. || x > 1.;
        })) {
            THROW_EXCEPTION("Found invalid extrapolation steps.");
        }
    }

Member Function Documentation

appendSegment()

void MuonR4::MsTrackSeeder::appendSegment ( const ActsTrk::GeometryContext & gctx, const xAOD::MuonSegment * segment, const Location loc, TreeRawVec_t & outContainer ) const

private

Append the to the raw data container.

If the projection onto the barrel cylinder / endcap discs exceeds the bounds, the segment is not added. Segments in sector 1/16 are mirrored into sector 0/17 to complete the search range

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
segment	Pointer to the segment to add
loc	Switch whether the segment shall be projected onto barrel/endcap
outContainer	Raw KDTree data vector where the segment is appended

Check whether the segment belongs to the left or right sector as well

Blow-up the number of sectors by a factor of 2. The even numbers represent the segments expressed @ the sector centre. The odd numbers represent the overlap region between two adjacent sectors. For sector 16, the right overlap region is mapped to 1

Enumeration to indicate whether the segment is expressed on the negative endcap (-1), the barrel (0) or the positive endcap

Coordinate on the cylinder

Definition at line 348 of file MsTrackSeeder.cxx.

                                                                        {
        
        const int segSector = segment->sector();
        for (const auto proj : {SectorProjector::leftOverlap, SectorProjector::center, SectorProjector::rightOverlap}) {
            const int projSector = ringSector(segSector + Acts::toUnderlying(proj));
            if (segment->nPhiLayers() > 0 && proj != SectorProjector::center && 
                !sectorMap.insideSector(projSector, segment->position().phi())) {
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Segment @"<<Amg::toString(segment->position())
                    <<" is not in sector "<<projSector<<" which is "<<to_string(proj) <<" to "<<segment->sector());
                continue;
            }
            const Amg::Vector2D refPoint{expressOnCylinder(gctx, *segment, loc, proj)};
            if (!withinBounds(refPoint, loc)) {
                 continue;
            }
            using enum SeedCoords;
            std::array<double, 3> coords{};
            const int treeSector = 2*segSector + Acts::toUnderlying(proj);
            coords[Acts::toUnderlying(eSector)] = ringOverlap(treeSector); 
            coords[Acts::toUnderlying(eDetSection)] =  Acts::copySign(Acts::toUnderlying(loc), refPoint[1]);
            coords[Acts::toUnderlying(ePosOnCylinder)] = refPoint[Location::Barrel == loc];
            ATH_MSG_VERBOSE("Add segment "<<print(*segment)<<", seed quality: "
            <<m_cfg.selector->passSeedingQuality(Gaudi::Hive::currentContext(), *detailedSegment(*segment))
            <<" with "<<coords<<" to the search tree");
            outContainer.emplace_back(std::move(coords), segment);
        }
    }

calculateRadius()

std::optional< double > MuonR4::MsTrackSeeder::calculateRadius ( VecOpt_t && pI, VecOpt_t && pM, VecOpt_t && pO, const Amg::Vector3D & planeNorm ) const

private

Calculates the radius of the bending circle from three points using the sagitta.

If one point is not defined, the origin is inserted instead. If two or more points are not set, a nullopt is returned

Derive the radius from the two equations. The line connecting pI and pO divides up the radius in the sagitta and the complementary section H R = S + H Also H is the catheter of the triangle <R, L / 2, H> R^{2} = L^{2} / 4 + H^{2} ---> R^{2} = L^{2} / 4 + (R-S)^{2} ---> 2*S*R = L^{2} / 4 + S^{2} (Approximating S^{2} = 0) ---> R = L^{2} / (8 * s)

Definition at line 186 of file MsTrackSeeder.cxx.

                                                                                             {
        if (!pI || !pM || !pO) {
            return std::nullopt;
        } 
        const Amg::Vector3D leverL = (*pO) - (*pI);
 
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Construct sagitta from "
                <<"\n --- Inner:  "<<print(*pI) <<"\n --- Middle: "<<print(*pM)
                <<"\n --- Outer:  "<<print(*pO));
        if (std::abs(planeNorm.dot(leverL)) > Acts::s_onSurfaceTolerance || 
            std::abs(planeNorm.dot( (*pM) - (*pI))) > Acts::s_onSurfaceTolerance) {
            THROW_EXCEPTION("The lever arm is in the bending plane: "<<Amg::toString(planeNorm)
                        <<", "<<Amg::toString(leverL.unit())<<", "<<Amg::toString( ((*pM) - (*pI)).unit()));
        }
        const Amg::Vector3D sagittaDir = leverL.cross(planeNorm).unit();
        std::optional<double> sagitta = Amg::intersect<3>(*pI, leverL.unit(), *pM, sagittaDir);
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Estimated sagitta: "<<(sagitta ? 
                     std::to_string(sagitta.value_or(0.)) : "---")<<", lever arm: "
                    <<(leverL.mag() / Gaudi::Units::m)<<" [m]"  );
        if (!sagitta) {
            return std::nullopt;
        }
        return leverL.dot(leverL) / (8. * (*sagitta));
    }

constructTree()

SearchTree_t MuonR4::MsTrackSeeder::constructTree	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegmentContainer &	segments ) const

Construct a complete search tree from a MuonSegment container.

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
segments	Reference to the segment container to construct.

Definition at line 385 of file MsTrackSeeder.cxx.

                                                                                             {
        TreeRawVec_t rawData{};
        rawData.reserve(3*segments.size());
        for (const xAOD::MuonSegment* segment : segments){
            appendSegment(gctx, segment, Location::Barrel, rawData);
            appendSegment(gctx, segment, Location::Endcap, rawData);
        }
        ATH_MSG_VERBOSE("Create a new tree with "<<rawData.size()<<" entries. ");
        return SearchTree_t{std::move(rawData)};
    }

envelope()

const MuonGMR4::SpectrometerSector * MuonR4::MsTrackSeeder::envelope

(

const xAOD::MuonSegment &

segment

)

const

Returns the spectrometer envelope associated to the segment (Coord system where the parameter are expressed)

Parameters

segment

Reference to the segment of interest

Definition at line 97 of file MsTrackSeeder.cxx.

                                                                   {
        return m_cfg.detMgr->getSectorEnvelope(segment.chamberIndex(), 
                                               segment.sector(), 
                                               segment.etaIndex());
    }

estimateQtimesP()

double MuonR4::MsTrackSeeder::estimateQtimesP	(	const ActsTrk::GeometryContext &	gctx,
		const AtlasFieldCacheCondObj &	magField,
		const MsTrackSeed &	seed ) const

Estimate the q /p of the seed candidate from the contained segments.

A circle from the inner, middle & outer segment points is constructed. To avoid side effects from (non)-present phi measurements, the segments are expressed on the sector planes

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
magFiel	Reference to the magnetic field holder
seed	Reference to the seed of interest.

Calculate the averaged phi from the segments

Calculate the sagitta points

Sample the magnetic field

Calculate the radius from the barrel segments

Calculate the radius from the endcap segments

If no radius could be calculated return the straight line estimator

Definition at line 219 of file MsTrackSeeder.cxx.

                                                                         {
        
        MagField::AtlasFieldCache fieldCache{};
        magField.getInitializedCache(fieldCache); 
        
        double circPhi{0.};
        unsigned nSegsWithPhi{0};
        for (const xAOD::MuonSegment* segment : seed.segments()) {
            if (segment->nPhiLayers() > 0) {
                circPhi += std::atan2(segment->y(), segment->x());
                ++nSegsWithPhi;
            }
        }
        if (!nSegsWithPhi){
            circPhi = projectedPhi(seed.segments()[0]->sector(),
                                    projectorFromSeed(*seed.segments()[0], seed));
        } else {
            circPhi /=nSegsWithPhi;
        }
        auto layerPos{Acts::filledArray<VecOpt_t, 6>(std::nullopt)};
        double avgBField{0.}, avgTheta{0.};
        const xAOD::TruthParticle* truthMuon{nullptr};
        const Amg::Vector3D planeNorm = Acts::makeDirectionFromPhiTheta(circPhi+ 90._degree, 90._degree);
 
        {
            Amg::Vector3D projPos = projectOntoPhiPlane(gctx, *seed.segments()[0], circPhi);
            Amg::Vector3D projDir = dirForBField(*seed.segments()[0], circPhi); 
            Amg::Vector3D locField{Amg::Vector3D::Zero()};
            unsigned nBFieldPoints{0};
            const unsigned nSeedSeg = seed.segments().size();
            using namespace Muon::MuonStationIndex;
            for (unsigned int s = 0; s < nSeedSeg; ++s) {
                avgTheta += projDir.theta();
                const xAOD::MuonSegment& segment{*seed.segments()[s]};
                if (!truthMuon) {
                    truthMuon = getTruthMatchedParticle(segment);
                }
                switch (toStationIndex(segment.chamberIndex())) {
                    using enum StIndex;
                    case BI:
                    case BE:{
                        average(projPos, layerPos[0]);
                        break;
                    } case BM: {
                        average(projPos, layerPos[1]);
                        break;
                    } case BO: {
                        average(projPos, layerPos[2]);
                        break;
                    } case EI:
                      case EE: {
                        average(projPos, layerPos[3]);
                        break;
                    } case EM : {
                        average(projPos, layerPos[4]);
                        break;
                    } case EO : {
                        average(projPos, layerPos[5]);
                        break;
                    } default: {
                        break;
                    }
                }
                if (s + 1 == nSeedSeg) {
                    break;
                }
                Amg::Vector3D nextDir = dirForBField(*seed.segments()[s+1], circPhi);
                Amg::Vector3D nextPos = projectOntoPhiPlane(gctx, *seed.segments()[s+1], circPhi);
 
                for (double fieldStep : m_cfg.fieldExtpSteps) {
                    /* The */
                    if (fieldStep == 0. && s > 0) {
                        continue;
                    }
                    const Amg::Vector3D extPos =  (1. -fieldStep) * projPos + fieldStep * nextPos;
                    const Amg::Vector3D extDir = ((1. -fieldStep) * projDir + fieldStep * nextDir).unit();
                    // const Amg::Vector3D loc
                    fieldCache.getField(extPos.data(), locField.data());
                    const double localB = extDir.cross(locField).mag();
 
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Segment "<<s<<", step: "<<fieldStep
                                <<", position: "<<Amg::toString(extPos)<<", dir: "<<Amg::toString(extDir)
                                <<" --> localB: "<<(localB * 1000.)<<" T."
                                <<", B: "<<Amg::toString(locField* 1000.)
                                <<", PxB:"<<Amg::toString(extDir.cross(locField).unit())
                                <<", planeNorm: "<<Amg::toString(planeNorm));
                    avgBField += localB;
                    ++nBFieldPoints;
                }
                projPos = std::move(nextPos);
                projDir = std::move(nextDir);
            }
            avgBField /= std::max(nBFieldPoints, 1u);
            ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - averaged field: "<<(avgBField * 1000.)
                        <<" T, number of points: "<<nBFieldPoints<<".");
        }
        avgTheta /= seed.segments().size();
        std::optional<double> barrelR = calculateRadius(std::move(layerPos[0]), 
                                                        std::move(layerPos[1]), 
                                                        std::move(layerPos[2]), planeNorm);
        std::optional<double> endcapR = calculateRadius(std::move(layerPos[3]), 
                                                        std::move(layerPos[4]), 
                                                        std::move(layerPos[5]), planeNorm);
        if (!barrelR && !endcapR) {
            return 5.*Gaudi::Units::TeV;
        }
        const double r = 0.5* ((barrelR ? *barrelR : *endcapR) +
                               (endcapR ? *endcapR : *barrelR));
        const double P = 0.3* Gaudi::Units::GeV* avgBField * r / std::abs(std::sin(avgTheta)); 
 
        ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Estimated radius "<<r / Gaudi::Units::m<<" [m] --> P: "<<
                        (P / Gaudi::Units::GeV)<<" [GeV]");        
 
        if (truthMuon && Acts::copySign(1.f, P) !=  truthMuon->charge() && truthMuon->abseta() < 2.5 && 
                (truthMuon->abseta() < 1.3 || truthMuon->abseta() > 1.4) ) {
            ATH_MSG_WARNING("Invalid charge, pT: "<<(truthMuon->pt() / Gaudi::Units::GeV)<<" [GeV], eta: "
                    <<truthMuon->eta()<<", phi: "<<(truthMuon->phi() / 1._degree)<<", q: "<<truthMuon->charge());
        }
        return P;
    }

expressOnCylinder()

Amg::Vector2D MuonR4::MsTrackSeeder::expressOnCylinder	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		const Location	loc,
		const SectorProjector	proj ) const

Expresses the segment on the cylinder surface.

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
segment	Reference to the segment of consideration
loc	Surface location: [barrel/endcap]

extrapolated position

Definition at line 150 of file MsTrackSeeder.cxx.

                                                                                     {
        const Amg::Vector3D pos{projectOntoSector(gctx, segment, proj)};
        const Amg::Vector3D dir{segment.direction()};
 
        const Amg::Vector2D projPos{pos.perp(), pos.z()};
        const Amg::Vector2D projDir{dir.perp(), dir.z()};
 
        double lambda{0.};
        if (Location::Barrel == loc) {
            lambda = Amg::intersect<2>(projPos, projDir, Amg::Vector2D::UnitX(), 
                                        m_cfg.barrelRadius).value_or(10. * Gaudi::Units::km);
        } else {
            lambda = Amg::intersect<2>(projPos, projDir, Amg::Vector2D::UnitY(), 
                                       Acts::copySign(m_cfg.endcapDiscZ, projPos[1])).value_or(10. * Gaudi::Units::km);
        }
        return projPos + lambda * projDir;  
    }

findTrackSeeds()

std::unique_ptr< MsTrackSeedContainer > MuonR4::MsTrackSeeder::findTrackSeeds	(	const EventContext &	ctx,
		const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegmentContainer &	segments ) const

Constructs the MS track seeds from the segment container.

Parameters

ctx	EventContext to access conditions / event data
segments	Refrence to the overall event's segment container

Bad segment not suitable for track seeding or the segment coordinates are just mirrored at the overlap between sector 1 -> 16

Define the search range.

Ensure that only endcap / barrel seeds are considered. The values are integers -> add tiny margin

Move 25 cm along the projected plane

Include the neighbouring sectors

Using the cube above, let the tree search for all compatible segments

Ensure that the sector overlap and momentum vectors are compatible with a MS trajectory

No segments were combined

Calculate the seed's position

Definition at line 396 of file MsTrackSeeder.cxx.

                                                                                                                        {
        SearchTree_t orderedSegs{constructTree(gctx, segments)};
        MsTrackSeedContainer trackSeeds{};
        using enum SeedCoords;
        for (const auto& [coords, seedCandidate] : orderedSegs) {
            const Segment* recoSeedCandidate = detailedSegment(*seedCandidate);
             if (!m_cfg.selector->passSeedingQuality(ctx, *recoSeedCandidate)){
                continue;
            }    
            SearchTree_t::range_t selectRange{};
            selectRange[Acts::toUnderlying(eDetSection)].shrink(coords[Acts::toUnderlying(eDetSection)] - 0.1, 
                                                                coords[Acts::toUnderlying(eDetSection)] + 0.1);
            selectRange[Acts::toUnderlying(ePosOnCylinder)].shrink(coords[Acts::toUnderlying(ePosOnCylinder)] - m_cfg.seedHalfLength, 
                                                                   coords[Acts::toUnderlying(ePosOnCylinder)] + m_cfg.seedHalfLength);
            selectRange[Acts::toUnderlying(eSector)].shrink(coords[Acts::toUnderlying(eSector)] -0.25, 
                                                            coords[Acts::toUnderlying(eSector)] +0.25);
            
            MsTrackSeed newSeed{static_cast<Location>(std::abs(coords[Acts::toUnderlying(eDetSection)])),
                                static_cast<int>(coords[Acts::toUnderlying(eSector)])};
            ATH_MSG_VERBOSE("Search for compatible segments to "<<print(*seedCandidate)<<".");
            orderedSegs.rangeSearchMapDiscard(selectRange, [&](
                    const SearchTree_t::coordinate_t& /*coords*/,
                    const xAOD::MuonSegment* extendWithMe) {
                        const Segment* extendCandidate = detailedSegment(*extendWithMe);
                        if (!m_cfg.selector->compatibleForTrack(ctx, *recoSeedCandidate, *extendCandidate)) {
                            ATH_MSG_VERBOSE("Segment "<<print(*extendWithMe)<<" is not compatible.");
                            return;
                        }
                        auto itr = std::ranges::find_if(newSeed.segments(), [extendWithMe](const xAOD::MuonSegment* onSeed){
                            return extendWithMe->chamberIndex() == onSeed->chamberIndex();
                        });
                        if (itr == newSeed.segments().end()){
                            ATH_MSG_VERBOSE("Add segment "<<print(*extendWithMe)<<" to seed.");
                            newSeed.addSegment(extendWithMe);
                        } else if (reducedChi2(**itr) > reducedChi2(*extendWithMe) &&
                                     (*itr)->nPhiLayers() <= extendWithMe->nPhiLayers()) {
                            newSeed.replaceSegment(*itr, extendWithMe);
                        }
            });
            if (newSeed.segments().empty()) {
                continue;
            }
            newSeed.addSegment(seedCandidate);
            const double r = newSeed.location() == Location::Barrel ? m_cfg.barrelRadius 
                                                                    : coords[Acts::toUnderlying(ePosOnCylinder)];
            const double z = newSeed.location() == Location::Barrel ? coords[Acts::toUnderlying(ePosOnCylinder)] 
                                                                    : coords[Acts::toUnderlying(eDetSection)]* m_cfg.endcapDiscZ;
            const int secCoord = coords[Acts::toUnderlying(eSector)];
 
            const double phi = sectorMap.sectorOverlapPhi( (secCoord - secCoord % 2) / 2, (secCoord + secCoord % 2) / 2 );
            Amg::Vector3D pos = r * Acts::makeDirectionFromPhiTheta(phi, 90._degree)
                              + z * Amg::Vector3D::UnitZ();
            
            newSeed.setPosition(std::move(pos));
            ATH_MSG_VERBOSE("Add new seed "<<newSeed);
            trackSeeds.emplace_back(std::move(newSeed));
        }
        ATH_MSG_VERBOSE("Found in total "<<trackSeeds.size()<<" before overlap removal");
        return resolveOverlaps(std::move(trackSeeds));
    }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

projectedPhi()

double MuonR4::MsTrackSeeder::projectedPhi ( const int sector, const SectorProjector proj )

static

Returns the projected phi for a given sector and projector.

Parameters

sector	Sector of interest [1-16]
proj	Enum indicating whether the angle at the left/right overlap or sector center shall be returned

Definition at line 92 of file MsTrackSeeder.cxx.

                                                                   {
        return sectorMap.sectorOverlapPhi(sector, ringSector(sector + Acts::toUnderlying(proj)));
    }

projectOntoPhiPlane()

Amg::Vector3D MuonR4::MsTrackSeeder::projectOntoPhiPlane	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		const double	projectPhi ) const

Recall that the sector coordinate system is defined such that the x-axis is aligned with the nominal wire direction

Calculate the proper intersection point

Definition at line 129 of file MsTrackSeeder.cxx.

                                                                                    {
        using enum SectorProjector;
        const Amg::Vector3D segPos3D{segment.position()};
        const Amg::Vector3D dirAlongTube{envelope(segment)->localToGlobalTrans(gctx).linear().col(0)};
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Project onto phi: "<<inDeg(projectPhi));
        const Amg::Vector3D radialDir = Amg::getRotateZ3D(projectPhi) * Amg::Vector3D::UnitX();
        using namespace Acts::detail::LineHelper;
        const auto isect = lineIntersect<3>(segPos3D.z()*Amg::Vector3D::UnitZ(), radialDir,
                                            segPos3D, dirAlongTube);
        using namespace Muon::MuonStationIndex;
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Projected "<<printID(segment) 
            <<" segment in @"<<Amg::toString(segPos3D)<<" + "
            <<Amg::toString(segment.direction())<<", chi2: "<<(segment.chiSquared() / std::max(1.f, segment.numberDoF()))
            <<", nDoF: "<<segment.numberDoF()<<" --> "<<Amg::toString(isect.position()));
        return isect.position();
    }

projectOntoSector() [1/2]

Amg::Vector3D MuonR4::MsTrackSeeder::projectOntoSector	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		const MsTrackSeed &	seed ) const

Projects the segment's position onto the sector centre or onto the overlap point with one of the neighbouring sector.

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
segment	Reference to the segment to project
seed	Reference to the seed w.r.t. which the segment shall be projected

Definition at line 115 of file MsTrackSeeder.cxx.

                                                                                  {
       return projectOntoSector(gctx, segment, projectorFromSeed(segment, seed));
    }

projectOntoSector() [2/2]

Amg::Vector3D MuonR4::MsTrackSeeder::projectOntoSector	(	const ActsTrk::GeometryContext &	gctx,
		const xAOD::MuonSegment &	segment,
		const SectorProjector	proj ) const

Projects the segment's position onto the sector centre or onto the overlap point with one of the neighbouring sector.

Parameters

gctx	Geometry context to fetch the transforms of the associated sector envelope
segment	Reference to the segment to project
proj	Projector indicating onto which fix point of the sector the projection happens

Fetch the phi onto which we want to project the segment without leaving the wire.

Definition at line 120 of file MsTrackSeeder.cxx.

                                                                                     {
        const double sectorPhi{projectedPhi(segment.sector(), proj)};
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Project onto "<<to_string(proj)<<" in "
                        <<envelope(segment)->identString());
        return projectOntoPhiPlane(gctx, segment, sectorPhi);
    }

projectorFromSeed()

MsTrackSeeder::SectorProjector MuonR4::MsTrackSeeder::projectorFromSeed ( const xAOD::MuonSegment & seg, const MsTrackSeed & refSeed )

static

Returns the Sector projector within the context of a MsTrackSeed.

Parameters

seg	Reference to the segment for which the Sector projector shall be returned
refSeed	Seed context in which the segment is embedded

Definition at line 103 of file MsTrackSeeder.cxx.

                                                                     {
        
        int doubSector = 2 * seg.sector();
        constexpr int nSectors = 2*Muon::MuonStationIndex::numberOfSectors();
        if (refSeed.sector() == nSectors && doubSector ==2) {
            return SectorProjector::leftOverlap;
        } else if (refSeed.sector() == 1 && doubSector == nSectors) {
            return SectorProjector::rightOverlap;
        }
        return static_cast<SectorProjector>(refSeed.sector() - doubSector );
    }

resolveOverlaps()

std::unique_ptr< MsTrackSeedContainer > MuonR4::MsTrackSeeder::resolveOverlaps ( MsTrackSeedContainer && unresolved ) const

private

Removes exact duplciates or partial subsets of the MsTrackSeeds.

Parameters

unresolved

Input MsTrackSeedContainer with duplicates

Resort the seeds starting from the ones with the most segments to the lowest

There is no segment which shares at least one segment with this candidate

Take the longer seed

Definition at line 470 of file MsTrackSeeder.cxx.

                                                                              {

        std::ranges::sort(unresolved, [](const MsTrackSeed& a, const MsTrackSeed&b) {
            return a.segments().size() > b.segments().size();
        });
        auto outputSeeds = std::make_unique<MsTrackSeedContainer>();
        outputSeeds->reserve(unresolved.size());
        std::ranges::copy_if(std::move(unresolved), std::back_inserter(*outputSeeds),
            [this, &outputSeeds](const MsTrackSeed& testMe) {
                MsTrackSeedContainer::iterator test_itr = 
                    std::ranges::find_if(*outputSeeds, [&testMe](const MsTrackSeed& good) {
                        if (ringOverlap(good.sector() - testMe.sector()) > 1) {
                            return false;
                        }
                        return std::ranges::find_if(testMe.segments(), 
                            [&good](const xAOD::MuonSegment* segInTest) {
                            return std::ranges::find(good.segments(), segInTest) != good.segments().end();
                        }) != testMe.segments().end();
                    });
                if (test_itr == outputSeeds->end()) {
                    ATH_MSG_VERBOSE("Add new seed "<<testMe);
                    return true;
                }
                if ( (*test_itr).segments().size() < testMe.segments().size()){
                    (*test_itr) = testMe;
                }
                return false;
            });
        return outputSeeds;
    } 

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

withinBounds()

bool MuonR4::MsTrackSeeder::withinBounds	(	const Amg::Vector2D &	projPos,
		const Location	loc ) const

Returns whether the expression on the cylinder is within the surface bounds.

Parameters

projPos	Projected position on the cylinder
loc	Surface location: [barrel/endcap]

Definition at line 171 of file MsTrackSeeder.cxx.

                                                               {
        using enum Location;
        if (loc == Barrel && std::abs(projPos[1]) > std::min(m_cfg.endcapDiscZ, m_cfg.barrelLength)) {
            ATH_MSG_VERBOSE(__func__<<"()  "<<__LINE__<<" - Position "<<Amg::toString(projPos)<<
                            " exceeds cylinder boundaries ("<<m_cfg.barrelRadius<<", "
                            <<std::min(m_cfg.endcapDiscZ, m_cfg.barrelLength)<<")");
            return false;
        } else if (loc == Endcap && (0 > projPos[0] || projPos[0] > m_cfg.endcapDiscRadius)) {
            ATH_MSG_VERBOSE(__func__<<"()  "<<__LINE__<<" - Position "<<Amg::toString(projPos)<<
            " exceeds endcap boundaries ("<<m_cfg.endcapDiscRadius<<", "<<Acts::copySign(m_cfg.endcapDiscZ, projPos[1])<<")");
            return false;
        }
        return true;
    }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_cfg

Config MuonR4::MsTrackSeeder::m_cfg {}

private

Definition at line 176 of file MsTrackSeeder.h.

{};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• MsTrackSeeder.h
• MsTrackSeeder.cxx