MuonR4::FastReco::GlobalPatternFinder Class Reference

Standalone module to handle global pattern recognition. More...

#include <GlobalPatternFinder.h>

Inheritance diagram for MuonR4::FastReco::GlobalPatternFinder:

Collaboration diagram for MuonR4::FastReco::GlobalPatternFinder:

Classes
struct	Config
	Configuration object. More...
struct	HitPayload
	Hit information stored during pattern building. More...
struct	CandidateHit
	Small wrapper for candidate hits used to build patterns. More...
struct	LineTestRes
	: Small struct to encapsulate the result of the line compatibility test More...
struct	PatternState
	Pattern state object storing pattern information during construction. More...
struct	PatternPrintView

Public Types
using	StIndex = Muon::MuonStationIndex::StIndex
	Type alias for the station index.
using	LayerIndex = Muon::MuonStationIndex::LayerIndex
	Type alias for the station layer index.
using	SpacePointContainerVec = std::vector<const SpacePointContainer*>
	Abrivation for a vector of space-point containers.
using	PatternVec = std::vector<GlobalPattern>
	Abrivation for a vector of global patterns.
using	BucketPerContainer = std::unordered_map<const SpacePointContainer*, std::vector<const SpacePointBucket*>>
	Abrivation for a collection of space-point buckets grouped by their corresponding input container.
using	PatternHitVisualInfo = MuonValR4::IFastRecoVisualizationTool::PatternHitVisualInfo
	Type alias for the visual information of a pattern.
using	PatternHitVisualInfoVec = std::vector<PatternHitVisualInfo>
	Abrivation for a vector of visual information objects.

Public Member Functions
	GlobalPatternFinder (const std::string &name, Config &&config)
	Standard constructor.
PatternVec	findPatterns (const ActsTrk::GeometryContext &gctx, const SpacePointContainerVec &spacepoints, BucketPerContainer &outBuckets) const
	Main methods steering the pattern finding.
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.

Private Types
enum class	SeedCoords : std::uint8_t { eSector , eTheta }
	Abrivation of the seed coordinates. More...
enum class	LineTestDecision : std::int8_t {   eAddHit , eBranchPattern , eRejectHit , eConsecutiveMdt ,   eOverwriteLastHit }
	: Enum for possible outcomes of pattern line compatibility test More...
enum class	LayerOrdering : std::int8_t { eSameLayer , eLowerLayer , eHigherLayer }
	Enum to express the logical measurement layer ordering given two hits. More...
using	SearchTree_t = Acts::KDTree<2, HitPayload, double, std::array, 5>
	Definition of the search tree class.
using	PatternStateVec = std::vector<PatternState>

Private Member Functions
SearchTree_t	constructTree (const ActsTrk::GeometryContext &gctx, const SpacePointContainerVec &spacepoints) const
	Method to construct the search tree by filling it up with spacepoints from the given containers.
PatternStateVec	findPatternsInEta (const SearchTree_t &orderedSpacepoints, PatternHitVisualInfoVec *visualInfo=nullptr) const
	Method steering the global pattern building in the bending plane.
void	extendPatterns (PatternStateVec &startPatterns, PatternStateVec &endPatterns, const CandidateHit &testHit, const Amg::Vector3D &beamSpot, PatternHitVisualInfoVec *visualInfo=nullptr) const
	Main function controlling the development of patterns, including pattern branching when necessary.
bool	passPatternCuts (const PatternState &pat) const
	Method to check if a pattern passes the quality cuts.
PatternStateVec	resolveOverlaps (PatternStateVec &toResolve, PatternHitVisualInfoVec *visualInfo=nullptr) const
	Method to remove overlapping patterns.
void	addPhiOnlyHits (const ActsTrk::GeometryContext &gctx, PatternStateVec &patterns) const
	Method to add phi-only measurements to existing PatternStates.
GlobalPattern	convertToPattern (const PatternState &candidate) const
	Method to convert a PatternState into a GlobalPattern object.
PatternVec	convertToPattern (const PatternStateVec &candidates) const
	Method to convert a vector of PatternStates into GlobalPattern objects.
void	addVisualInfo (const PatternState &candidate, PatternHitVisualInfo::PatternStatus status, PatternHitVisualInfoVec *visualInfo) const
	Helper function to add visual information of a given pattern (which is usually going to be destroyed) to the final container.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static bool	isBetter (const PatternState &a, const PatternState &b)
	Method to compare two patterns and define which one is better.
static LayerOrdering	checkLayerOrdering (const HitPayload &hit1, const HitPayload &hit2)
	Method to check the logical layer ordering of two hits.
static bool	areConsecutiveMdt (const CandidateHit &hit1, const CandidateHit &hit2)
	Helper function to check whether two hits are consecutive MDT measurements.
static PatternPrintView	brief (const PatternState &p)
	Print the pattern candidate and stream operator.
static PatternPrintView	detailed (const PatternState &p)

Private Attributes
SpacePointPerLayerSorter	m_spSorter {}
	Spacepoint sorter per logical measurement layer.
Config	m_cfg
	Global Pattern Recognition configuration.
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).

Static Private Attributes
static const int	s_nStations {Acts::toUnderlying(StIndex::StIndexMax)}

Friends
std::ostream &	operator<< (std::ostream &os, const PatternPrintView &v)

Detailed Description

Standalone module to handle global pattern recognition.

This tool performs global pattern recognition as the first step of the Phase-2 fast reconstruction stage. It builds global patterns of precision and non-precision hits using space-points created in upstream algorithms. It first builds patterns in eta and then adds compatible phi-only hits to the patterns. The resulting patterns are returned by the main method of the tool.

Definition at line 30 of file GlobalPatternFinder.h.

Member Typedef Documentation

BucketPerContainer

using MuonR4::FastReco::GlobalPatternFinder::BucketPerContainer = std::unordered_map<const SpacePointContainer*, std::vector<const SpacePointBucket*>>

Abrivation for a collection of space-point buckets grouped by their corresponding input container.

Definition at line 41 of file GlobalPatternFinder.h.

LayerIndex

using MuonR4::FastReco::GlobalPatternFinder::LayerIndex = Muon::MuonStationIndex::LayerIndex

Type alias for the station layer index.

Definition at line 35 of file GlobalPatternFinder.h.

PatternHitVisualInfo

using MuonR4::FastReco::GlobalPatternFinder::PatternHitVisualInfo = MuonValR4::IFastRecoVisualizationTool::PatternHitVisualInfo

Type alias for the visual information of a pattern.

Definition at line 43 of file GlobalPatternFinder.h.

PatternHitVisualInfoVec

using MuonR4::FastReco::GlobalPatternFinder::PatternHitVisualInfoVec = std::vector<PatternHitVisualInfo>

Abrivation for a vector of visual information objects.

Definition at line 45 of file GlobalPatternFinder.h.

PatternStateVec

using MuonR4::FastReco::GlobalPatternFinder::PatternStateVec = std::vector<PatternState>

private

Definition at line 331 of file GlobalPatternFinder.h.

PatternVec

using MuonR4::FastReco::GlobalPatternFinder::PatternVec = std::vector<GlobalPattern>

Abrivation for a vector of global patterns.

Definition at line 39 of file GlobalPatternFinder.h.

SearchTree_t

using MuonR4::FastReco::GlobalPatternFinder::SearchTree_t = Acts::KDTree<2, HitPayload, double, std::array, 5>

private

Definition of the search tree class.

Definition at line 139 of file GlobalPatternFinder.h.

SpacePointContainerVec

using MuonR4::FastReco::GlobalPatternFinder::SpacePointContainerVec = std::vector<const SpacePointContainer*>

Abrivation for a vector of space-point containers.

Definition at line 37 of file GlobalPatternFinder.h.

StIndex

using MuonR4::FastReco::GlobalPatternFinder::StIndex = Muon::MuonStationIndex::StIndex

Type alias for the station index.

Definition at line 33 of file GlobalPatternFinder.h.

Member Enumeration Documentation

LayerOrdering

enum class MuonR4::FastReco::GlobalPatternFinder::LayerOrdering : std::int8_t

strongprivate

Enum to express the logical measurement layer ordering given two hits.

Enumerator
eSameLayer
eLowerLayer
eHigherLayer

Definition at line 389 of file GlobalPatternFinder.h.

                                     : std::int8_t{
                eSameLayer,
                eLowerLayer,
                eHigherLayer
            };

LineTestDecision

enum class MuonR4::FastReco::GlobalPatternFinder::LineTestDecision : std::int8_t

strongprivate

: Enum for possible outcomes of pattern line compatibility test

Enumerator
eAddHit	Test successfull, add hit to pattern.
eBranchPattern	Test successfull with multiple pattern hits on same layer, branch the pattern.
eRejectHit	Test failed, discard the hit.
eConsecutiveMdt	Test hit is a consecutive MDT hit.
eOverwriteLastHit	Test successful, overwrite the hit. Needed e.g. for sTGCs

Definition at line 171 of file GlobalPatternFinder.h.

                                        : std::int8_t{
                eAddHit,
                eBranchPattern,
                eRejectHit,
                eConsecutiveMdt,
                eOverwriteLastHit
            };

SeedCoords

enum class MuonR4::FastReco::GlobalPatternFinder::SeedCoords : std::uint8_t

strongprivate

Abrivation of the seed coordinates.

Enumerator
eSector	Expanded sector coordinate of the associated spectrometer sector
eTheta	Global Theta.

Definition at line 141 of file GlobalPatternFinder.h.

                                  : std::uint8_t{
                eSector,
                eTheta
            };

Constructor & Destructor Documentation

GlobalPatternFinder()

MuonR4::FastReco::GlobalPatternFinder::GlobalPatternFinder	(	const std::string &	name,
		Config &&	config )

Standard constructor.

Parameters

name	Name to be printed in the messaging
config	Configuration parameters

Definition at line 28 of file GlobalPatternFinder.cxx.

                                                                               :
    AthMessaging{name},
    m_cfg{config} {
        static_assert(std::is_move_assignable_v<PatternState>);
        static_assert(std::is_move_constructible_v<PatternState>);
        static_assert(std::is_copy_assignable_v<PatternState>);
        static_assert(std::is_copy_constructible_v<PatternState>);
        static_assert(std::is_nothrow_move_constructible_v<PatternState>);
        static_assert(std::is_nothrow_move_assignable_v<PatternState>);
};

Member Function Documentation

addPhiOnlyHits()

void MuonR4::FastReco::GlobalPatternFinder::addPhiOnlyHits ( const ActsTrk::GeometryContext & gctx, PatternStateVec & patterns ) const

private

Method to add phi-only measurements to existing PatternStates.

Parameters

gctx	Geometry context
patterns	Vector of pattern states to which to add phi-only hits

Returns

: void

Struct to model the projection of the pattern line onto the phi strip in a certain station

Parameters

refLay	Reference layer coordinate (e.g. R or Z) increasing with the layer number
refStrip	Reference strip coordinate (normal to the layer coordinate, along the strip direction)
invSlope	Inverse slope, defined as deltaStrip / deltaLay

We look for phi-only hits in the buckets associated with the pattern

Definition at line 510 of file GlobalPatternFinder.cxx.

                                                                          {
    constexpr auto covIdxEta {Acts::toUnderlying(SpacePoint::CovIdx::etaCov)};
    struct PhiStripProjectionModel {
        StIndex station{};
        double refLay{0.};
        double refStrip{0.};
        double invSlope{0.};
        bool isValid{false};
 
        double project(const Amg::Vector3D& pos) const {
            const double layCoord   = isBarrel(station) ? pos.perp() : pos.z();
            return refStrip + (layCoord - refLay) * invSlope;
        }
        double residual(const Amg::Vector3D& pos) const {
            const double stripCoord = isBarrel(station) ? pos.z() : pos.perp();
            return std::abs(project(pos) - stripCoord);
        }
    };
    auto makeProjectionModel = [this](PatternState& pat, const StIndex station) {
        PhiStripProjectionModel result{};
        result.station = station;
        const auto& hits {pat.hitsPerStation[Acts::toUnderlying(station)]};
        if (hits.empty()) return result;
 
        // Define the coordinate across the layers, i.e. orthogonal to the strip
        const auto layCoord = [&result](const HitPayload& hit) {
            return isBarrel(result.station) ? hit.R : hit.Z;
        };
        // Define the coordinate along the strip, i.e. orthogonal to the measureent layers
        const auto stripCoord = [&result](const HitPayload& hit) {
            return isBarrel(result.station) ? hit.Z : hit.R;
        };
 
        const HitPayload* sp1 {nullptr};
        const HitPayload* sp2 {nullptr};
        if (pat.nMeasurementLayers[Acts::toUnderlying(station)] > 1) {
            // if we have >= 2 eta hits in the station, we use the furthestmost to define the pattern line
            const auto [minIt, maxIt] = std::ranges::minmax_element(hits, {},
                [](const CandidateHit& c){ return c.globLayer; });
            sp1 = minIt->hit;
            sp2 = maxIt->hit;
        }
        if (!sp1 || !sp2 || std::abs(layCoord(*sp2) - layCoord(*sp1)) < m_cfg.minLayerSeparation) {
            // if we have only one eta hit, to find the second hit we use the we use the functionality of anchor hit
            pat.moveLineAnchorHit(hits.front());
 
            sp1 = hits.front().hit;
            sp2 = pat.lineAnchorHit.hit;
        }
        if (!sp1 || !sp2 ) return result;
 
        result.refLay = layCoord(*sp1);
        result.refStrip = stripCoord(*sp1);
        result.invSlope = (stripCoord(*sp2) - stripCoord(*sp1)) / (layCoord(*sp2) - layCoord(*sp1));
        result.isValid = true;
        return result;
    };
 
    PatternStateVec survivingPatterns{};
    survivingPatterns.reserve(patterns.size());
    for (PatternState& pat : patterns) {
        pat.finalizePatternEta();
        ATH_MSG_VERBOSE(__func__<<"() Search for phi-only hits for pattern: " << brief(pat));
        // Projection model of pattern line onto a given phi strip
        std::optional<PhiStripProjectionModel> patProjOnStrip{};
        for (const SpacePointBucket* bucket : pat.getParentBuckets()) {
            const Amg::Transform3D& localToGlobal {bucket->msSector()->localToGlobalTransform(gctx)};
            const StIndex station {m_cfg.idHelperSvc->stationIndex(bucket->front()->identify())};
            // If the projection model is not valid, we will use the pattern theta. We cache the local Y in glob frame
            const Amg::Vector3D locY {localToGlobal.linear() * Amg::Vector3D::UnitY()};
            
            for (const auto& hit : *bucket) {
                // We are looking for phi-only hits
                if (hit->measuresEta()){
                    continue;
                }
                ATH_MSG_VERBOSE(__func__<<"() *** Test phi-only hit "<<*hit);
                // Check phi compatibility
                const Amg::Vector3D locPosTest {hit->localPosition()};
                const Amg::Vector3D globPosTest {localToGlobal * locPosTest};
                const double globPhi {globPosTest.phi()};
                if (!pat.isPhiCompatible(globPhi)) {
                    ATH_MSG_VERBOSE(__func__<<"() Phi-only hit not compatible");
                    continue;
                }
                // Check there are not other phi hits in the same layer
                const uint8_t layNum = m_spSorter.sectorLayerNum(*hit);
                const uint8_t stIdx = Acts::toUnderlying(station);
                assert(!pat.hitsPerStation[stIdx].empty());
                if (std::ranges::any_of(pat.hitsPerStation[stIdx], [&](const CandidateHit& h){
                        return h.sp()->measuresPhi() && hit->msSector() == h.sp()->msSector() && layNum == h->locLayer; }) ||
                    std::ranges::any_of(pat.phiOnlyHits, [&](const HitPayload& h){
                        return station == h.station && hit->msSector() == h->msSector() && layNum == h.locLayer; })) {
                    ATH_MSG_VERBOSE(__func__<<"() The pattern already has a phi hit in the same layer - skip this test hit.");
                    continue;
                }
                // Check eta compatibility. Try first to use the pattern line projection model
                bool isEtaCompatible {false};
                const double sigmaEta {std::sqrt(hit->covariance()[covIdxEta])};
                if (!patProjOnStrip.has_value() || patProjOnStrip->station != station) {
                    patProjOnStrip = makeProjectionModel(pat, station);
                }
                if(patProjOnStrip->isValid) {
                    isEtaCompatible = patProjOnStrip->residual(globPosTest) <= 1.1*sigmaEta;
                    ATH_MSG_VERBOSE(__func__<<"() Distance pattern line from strip center: "<<patProjOnStrip->residual(globPosTest)
                                            <<", strip half-length: "<<sigmaEta<<", isCompatible: "<<isEtaCompatible);
                } else {
                    // Check pattern theta against global theta at the boundaries of the phi strip
                    double thetaMin {(globPosTest - sigmaEta * locY).theta()};
                    double thetaMax {(globPosTest + sigmaEta * locY).theta()};
                    if (thetaMax < thetaMin) {
                        std::swap(thetaMin, thetaMax);
                    }
                    isEtaCompatible = std::max(pat.theta - thetaMax, thetaMin - pat.theta) < 0.5 * m_cfg.thetaSearchWindow;
                    ATH_MSG_VERBOSE(__func__<<"() Pattern theta "<<inDegrees(pat.theta)
                                            <<", strip theta window: ["<<inDegrees(thetaMin)<<", "<<inDegrees(thetaMax)<<"]");
                    
                }
                if (!isEtaCompatible) {
                    ATH_MSG_VERBOSE(__func__<<"() The pattern falls outside the test hit strip in eta - skip this test hit.");
                    continue;
                }
                // Create the hit payload and add the hit to the pattern. Save only relevant quantities for phi-only hits.
                ATH_MSG_VERBOSE(__func__<<"() Phi-only hit compatible - add it to the pattern.");
                pat.phiOnlyHits.emplace_back(hit.get(), /*bucket*/nullptr, /*container*/nullptr, /*R*/0.f, /*Z*/0.f, 
                    globPhi, station, layNum, /*sector*/0u, /*isPrecision*/false, /*isStraw*/false);
                if (pat.nPhiLayers == 0) pat.phi = globPhi;
                pat.nPhiLayers++;
            }
        }
        if (pat.nPhiLayers < m_cfg.minPhiLayers) {
            ATH_MSG_VERBOSE(__func__<<"() Pattern "<< detailed(pat)<<" has only "<<pat.nPhiLayers
                                    <<" phi layers, below the minimum required - reject this pattern.");
            continue;
        }
        pat.finalizePatternPhi();
        survivingPatterns.push_back(std::move(pat));
    }
    std::swap(patterns, survivingPatterns);
}

addVisualInfo()

void MuonR4::FastReco::GlobalPatternFinder::addVisualInfo ( const PatternState & candidate, PatternHitVisualInfo::PatternStatus status, PatternHitVisualInfoVec * visualInfo ) const

private

Helper function to add visual information of a given pattern (which is usually going to be destroyed) to the final container.

Parameters

candidate	PatternState whome visual information is to be added
status	Status of the pattern (e.g. successfull, failed or overlap)
visualInfo	Final vector of visual information to store the visual information

Definition at line 1266 of file GlobalPatternFinder.cxx.

                                                                                   {
    if (!visualInfo) {
        return;
    }
    // First save the buckets
    std::vector<const SpacePointBucket*> buckets{cache.getParentBuckets()};
 
    GlobalPattern pattern {convertToPattern(cache)};
    // Check whether the visual info about this pattern is already in the container
    if (auto it =std::ranges::find_if(*visualInfo, [&pattern](const auto& v){ 
        return v.patternCopy && *v.patternCopy == pattern; }); it != visualInfo->end()) {
        it->status = status; // Update the status if the pattern is already in the container
        return;
    }
    visualInfo->push_back(*cache.visualInfo);
 
    std::ranges::copy(buckets, std::back_inserter(visualInfo->back().parentBuckets));
 
    visualInfo->back().patternCopy = std::make_unique<GlobalPattern>(std::move(pattern));
    visualInfo->back().status = status;
}

areConsecutiveMdt()

bool MuonR4::FastReco::GlobalPatternFinder::areConsecutiveMdt ( const CandidateHit & hit1, const CandidateHit & hit2 )

staticprivate

Helper function to check whether two hits are consecutive MDT measurements.

To understand: in principle we should not have two MDT hits in the same tube... but this can happen now when running run4 digitization. Therefore, for now we don't throw when hit1==hit2 but we just reject one of the two... to understand for future improvements

Definition at line 1251 of file GlobalPatternFinder.cxx.

                                                                      {
        if (!hit1.isStraw || !hit2.isStraw) {
            return false;
        }
        const uint16_t tubeNum1 {static_cast<const xAOD::MdtDriftCircle*>(hit1.sp()->primaryMeasurement())->driftTube()};
        const uint16_t tubeNum2 {static_cast<const xAOD::MdtDriftCircle*>(hit2.sp()->primaryMeasurement())->driftTube()};
        if(tubeNum1 == tubeNum2) {
            return false;
        }; 
        return std::abs(tubeNum1-tubeNum2) < 2;
    }

brief()

GlobalPatternFinder::PatternPrintView MuonR4::FastReco::GlobalPatternFinder::brief ( const PatternState & p )

staticprivate

Print the pattern candidate and stream operator.

Definition at line 1314 of file GlobalPatternFinder.cxx.

                                                {
    return {p, /*detailed=*/false};
}

checkLayerOrdering()

GlobalPatternFinder::LayerOrdering MuonR4::FastReco::GlobalPatternFinder::checkLayerOrdering ( const HitPayload & hit1, const HitPayload & hit2 )

staticprivate

Method to check the logical layer ordering of two hits.

Parameters

hit1	first hit
hit2	second hit

Returns

: the logical measurement layer ordering of the two hits

Hits in the same spectrometer sector

Hits in the same station and different sectors. We can have this case for hits in the overlap region of two adjacent sectors.

Hit in different stations but same station layer. Expected to happen only for Inner and Middle

If both hits are in the middle layer, the one in the barrel comes first

If both hits are in the inner layer, we use the global R, since in large sector BI comes first, while in small sector EI comes first.

If we have one hit in Inner layer for sure it comes first

If we have one hit in Outer layer for sure it comes last

If we have one hit in BarrelExtended and the other in the Middle layer, the former comes first

If we have one hit in Extended (EE) layer and the other in the Middle layer, it depends if the latter is endcap or barrel

Definition at line 1197 of file GlobalPatternFinder.cxx.

                                                                {
    auto getLayerOrdering = [](const bool isLayer1Lower) {
        return isLayer1Lower ? eLowerLayer : eHigherLayer;
    };
    if (hit1 == hit2) {
        return eSameLayer;
    }
    if (hit1->msSector() == hit2->msSector()) {
        if (hit1.locLayer == hit2.locLayer) {
            return eSameLayer;
        } else {
            return getLayerOrdering(hit1.locLayer < hit2.locLayer);
        }
    }
    StIndex st1 {hit1.station};
    StIndex st2 {hit2.station};
    if (st1 == st2) {
        return getLayerOrdering(hit1->msSector()->barrel() ? hit1.R < hit2.R : std::abs(hit1.Z) < std::abs(hit2.Z));
    }
    LayerIndex layer1 {toLayerIndex(st1)};
    LayerIndex layer2 {toLayerIndex(st2)};
    if (layer1 == layer2) {
        if (layer1 == LayerIndex::Middle) {
            return getLayerOrdering(st1 == StIndex::BM);
        } 
        if (layer1 == LayerIndex::Inner) {
            return getLayerOrdering(hit1.R < hit2.R);
        }
        throw std::runtime_error("Unexpected to have two pattern-compatible hits one in BO and the other in EO.");
    }
    if (layer1 == LayerIndex::Inner || layer2 == LayerIndex::Inner) {
        return getLayerOrdering(layer1 == LayerIndex::Inner);
    }
    if (layer1 == LayerIndex::Outer || layer2 == LayerIndex::Outer) {
        return getLayerOrdering(layer2 == LayerIndex::Outer);
    }
    if (layer1 == LayerIndex::BarrelExtended || layer2 == LayerIndex::BarrelExtended) {
        return getLayerOrdering(layer1 == LayerIndex::BarrelExtended);
    }
    if (layer1 == LayerIndex::Extended) {
        return getLayerOrdering(st2 == StIndex::EM);
    }
    return getLayerOrdering(st1 == StIndex::BM);
}

constructTree()

GlobalPatternFinder::SearchTree_t MuonR4::FastReco::GlobalPatternFinder::constructTree ( const ActsTrk::GeometryContext & gctx, const SpacePointContainerVec & spacepoints ) const

private

Method to construct the search tree by filling it up with spacepoints from the given containers.

The tree does not contain only-phi hits.

Parameters

gctx	Geometry context
spacepoints	Vector of space point containers

Returns

: Constructed search tree

Try to duplicate the hit in the neighboring sectors if it is close to the sector border. This ensures that we can find patterns crossing the sector borders.

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

Definition at line 698 of file GlobalPatternFinder.cxx.

                                                                                    {
    SearchTree_t::vector_t rawData{};
    using SectorProjector = ExpandedSector::SectorProjector;
    // Before the loops: estimate the total number of hits 
    size_t totalHits = 0;
    for (const SpacePointContainer* spc : spacepoints) {
        for (const SpacePointBucket* bucket : *spc) {
            totalHits += bucket->size();
        }
    }
    // We can have up to 3 entries per hit (when the hit does not measure phi).
    rawData.reserve(3 * totalHits);
 
    for (const SpacePointContainer* spc : spacepoints) {
        ATH_MSG_VERBOSE(__func__<<"() Processing "<<spc->size()<<" space point buckets...");
        for (const SpacePointBucket* bucket : *spc) {
            ATH_MSG_VERBOSE(__func__<<"() Processing " << bucket->size() << " spacepoints...");
            const Amg::Transform3D& localToGlobal {bucket->msSector()->localToGlobalTransform(gctx)};
            const StIndex bucketStation {m_cfg.idHelperSvc->stationIndex(bucket->front()->identify())};
            const uint8_t sector = bucket->msSector()->sector();
 
            for (const auto& hit : *bucket) {
                // Ignore only-phi hits and MDT hits if desired
                const bool isStraw {hit->isStraw()};
                if (!hit->measuresEta() || (!m_cfg.useMdtHits && isStraw)) {
                    continue;
                }
                ATH_MSG_VERBOSE(__func__<<"() Spacepoint: " << *hit);
                const Amg::Vector3D globalPos {localToGlobal * hit->localPosition()};
                const double globalPhi {globalPos.phi()};
                const ExpandedSector hitExpSector {globalPhi};
                const uint8_t localLayer = m_spSorter.sectorLayerNum(*hit);
                const bool isPrecision {MuonR4::isPrecisionHit(*hit)};
 
                /* Determine the projection direction, which is the direction normal to the radial direction */
                const Amg::Vector3D projDir {ExpandedSector{sector, SectorProjector::center}.normalDir()};
 
                for (const auto proj : {SectorProjector::leftOverlap, SectorProjector::center, SectorProjector::rightOverlap}) {
                    const ExpandedSector expSect {sector, proj};
                    if (proj != SectorProjector::center && hit->measuresPhi() && expSect != hitExpSector) {
                        ATH_MSG_VERBOSE(__func__<<"() Hit with "<<hitExpSector<<" is not compatible with "<<expSect);
                        continue;
                    }
 
                    /* Project the hit onto the plane along the sector radial direction. 
                     * This allows to remove the bias of hit displacement in phi direction */
                    const double projR {(globalPos - globalPos.dot(projDir) * projDir).perp()};
                    
                    std::array<double, 2> coords{};
                    coords[Acts::toUnderlying(SeedCoords::eTheta)] = atan2(projR, globalPos.z());
                    coords[Acts::toUnderlying(SeedCoords::eSector)] = expSect.sector();
 
                    ATH_MSG_VERBOSE(__func__<<"() Add hit: Z: " << globalPos.z() << ", R: " << globalPos.perp() << ", ProjR: " << projR
                                            << ", Phi: "<< inDegrees(globalPhi) << ", SectorPhi: " << inDegrees(expSect.phi()) << " and coordinates "<<coords<<" to the search tree");
                    rawData.emplace_back(std::move(coords), HitPayload{hit.get(), bucket, spc, 
                        static_cast<float>(projR), static_cast<float>(globalPos.z()), static_cast<float>(globalPhi), 
                        bucketStation, localLayer, sector, isPrecision, isStraw});
                }  
            }
        }
    }
    ATH_MSG_VERBOSE(__func__<<"() Create a new tree with "<<rawData.size()<<" entries. ");
    return SearchTree_t{std::move(rawData)};
}

convertToPattern() [1/2]

GlobalPattern MuonR4::FastReco::GlobalPatternFinder::convertToPattern ( const PatternState & candidate ) const

private

Method to convert a PatternState into a GlobalPattern object.

Parameters

candidate

PatternState to be converted

Returns

: Converted GlobalPattern

Add eta hits

Add phi-only hits

Definition at line 656 of file GlobalPatternFinder.cxx.

                                                                                   {
    GlobalPattern::HitCollection hitPerStation{};
    for (uint8_t st{0u}; st < s_nStations; ++st) {
        const auto& hits {cache.hitsPerStation[st]};
        if (hits.empty()) continue;
 
        auto& out {hitPerStation[static_cast<StIndex>(st)]};
        out.reserve(hits.size());
        std::ranges::transform(hits, std::back_inserter(out), 
            [](const CandidateHit& h){ return h.sp();});
    }
    for (const HitPayload& hit : cache.phiOnlyHits) {
        auto& out {hitPerStation[static_cast<StIndex>(hit.station)]};
        out.push_back(hit.sp());
    }
    GlobalPattern pattern{std::move(hitPerStation)};
    pattern.setTheta(cache.theta);
    pattern.setPhi(cache.phi);
    // Set the pattern sector(s) and theta.
    pattern.setSector(cache.expSect.sector());
    // Set pattern quality information.
    pattern.setNPrecisionLayers(cache.nPrecisionLayers);
    pattern.setNTriggerLayers(cache.nTriggerLayers);
    pattern.setNPhiLayers(cache.nPhiLayers);
    pattern.setMeanNormResidual2(cache.getMeanResidual2());
    return pattern;
}

convertToPattern() [2/2]

GlobalPatternFinder::PatternVec MuonR4::FastReco::GlobalPatternFinder::convertToPattern ( const PatternStateVec & candidates ) const

private

Method to convert a vector of PatternStates into GlobalPattern objects.

Parameters

candidates

PatternStates to be converted

Returns

: Vector of converted GlobalPatterns

Definition at line 687 of file GlobalPatternFinder.cxx.

                                                                        {
    PatternVec patterns{};
    patterns.reserve(cache.size());
    std::transform(cache.begin(), cache.end(), std::back_inserter(patterns), 
        [this](const PatternState& cacheEntry) {
            return convertToPattern(cacheEntry);
    });
    return patterns;
}

detailed()

GlobalPatternFinder::PatternPrintView MuonR4::FastReco::GlobalPatternFinder::detailed ( const PatternState & p )

staticprivate

Definition at line 1318 of file GlobalPatternFinder.cxx.

                                                   {
    return {p, /*detailed=*/true};
}

extendPatterns()

void MuonR4::FastReco::GlobalPatternFinder::extendPatterns ( PatternStateVec & startPatterns, PatternStateVec & endPatterns, const CandidateHit & testHit, const Amg::Vector3D & beamSpot, PatternHitVisualInfoVec * visualInfo = nullptr ) const

private

Main function controlling the development of patterns, including pattern branching when necessary.

It tests pattern compatibility of a set of active patterns (patterns produced from the same seed hit) against one test hit. At the end, activePatterns contains the surviving patterns.

Parameters

startPatterns	Vector of active patterns to be extended
endPatterns	Vector to store the surviving patterns after testing against the test hit.
testHit	Hit to be tested against the patterns
beamSpot	Beam spot position, needed when the pattern line cannot be reliably defined from the pattern hits
visualInfo	Pointer to visual information for pattern visualization (nullptr if the VisualizationTool is disabled)

Prunes pattern hypotheses within groups sharing the same last-hit layer. This step reduces branching by
keeping only the best-scoring pattern within each last-hit equivalence group, while preserving all patterns when the last-hit layer matches the reference layer (to allow further branching).

Check angular compatibility of the test hit and the pattern

If hit is compatible but with poor confidence, we create both a pattern with the hit and a pattern without the hit, to keep also the possibility of rejecting this hit in the next iterations. First we make sure that the low-confidence pattern is original, i.e. accumulating not seen hits

Add the new pattern to the list of next patterns

Update visual information of the original pattern

Branch the pattern: we clone it and overwrite the existing hit with the test hit

Update visual information of the original pattern

Check the MDT cluster size on the last layer is not above the maximum, otherwise we break the cluster

We break the residual at the second-to-last hit. So we compute the new cluster residual

We remove all hits on last layer, except the last hit. Then we add the new hit.

Update visual information of the original pattern

Definition at line 261 of file GlobalPatternFinder.cxx.

                                                                                    {
    endPatterns.clear();
    ATH_MSG_VERBOSE("processHitRange() *** Test "<<**testHit<<" R/Z/globLayer: "<<testHit.R<<", "<<testHit.Z
        <<", "<<static_cast<int>(testHit.globLayer)<<" against " << startPatterns.size() << " active patterns.");
 
    // Compute the minimum number of missed layer hits among the active patterns, 
    // to use as reference for pruning patterns with too many missed layers. 
    std::vector<unsigned> missedLayersVec{};
    missedLayersVec.reserve(startPatterns.size());
    std::ranges::transform(startPatterns, std::back_inserter(missedLayersVec), [&testHit](const PatternState& pat){
        return std::abs(pat.lastInsertedHit.globLayer - testHit.globLayer);
    });
    const unsigned minMissedLayers {std::ranges::min(missedLayersVec)};
 
    const bool shouldPrune {startPatterns.size() > 1 && 
        std::ranges::any_of(startPatterns, [](const PatternState& p){
            return p.nBendingLayers() > 2; })};
    
    for (auto [i, pat] : Acts::enumerate(startPatterns)) {
        if (pat.isOverlap) {
            continue;
        }
        // Check the pattern has not already missed too many layers compared to other patterns.
        if (pat.lastInsertedHit.station == testHit.station && 
            missedLayersVec[i] > std::max(m_cfg.maxMissLayersInStation, minMissedLayers)) {
            ATH_MSG_VERBOSE(__func__<<"() Pattern " << detailed(pat) << "\nhas missed " << (int)missedLayersVec[i] 
                                    << " layer hits, above the max allowed - abort pattern.");
            addVisualInfo(pat, PatternHitVisualInfo::PatternStatus::eFailed, visualInfo);
            continue;
        }
        if (shouldPrune && pat.lastInsertedHit.globLayer != testHit.globLayer &&
            std::ranges::find_if(std::next(startPatterns.begin(), i + 1), startPatterns.end(), [&](PatternState& p){
                if (p.lastInsertedHit != pat.lastInsertedHit || p.isOverlap) return false;
 
                if (isBetter(pat, p)) {
                    ATH_MSG_VERBOSE("extendPatterns() Pruning: REJECT " << detailed(p));
                    p.isOverlap = true;
                    return false;
                }
                ATH_MSG_VERBOSE("extendPatterns() Pruning: REJECT " << detailed(pat));
                return true; }) != startPatterns.end()) {
            continue;
        }
        const auto [result, residual, accWindow] {pat.checkLineComp(testHit, beamSpot)};
        switch (result) {
            case LineTestDecision::eAddHit: {
                if (accWindow > 4.*m_cfg.baseRWindow && residual > m_cfg.baseRWindow) {
                    if (std::ranges::any_of(endPatterns, [&testHit, &pat](const PatternState& p) {
                            return p.isInLastLayer(testHit) && 
                                   (p.prevLayerHit == pat.lastInsertedHit || p.nBendingLayers() > (pat.nBendingLayers() + 1u)); })) {
                        ATH_MSG_VERBOSE(__func__<<"() Low-confidence hit: forking leads to existing pattern - reject.");
                        break;
                    }
                    ATH_MSG_VERBOSE(__func__<<"() Low-confidence hit: forking leads to new pattern - fork.");
                    endPatterns.push_back(pat);
                    endPatterns.back().addHit(testHit, residual, accWindow);
                    if (visualInfo) {
                        pat.visualInfo->discardedHits.push_back(testHit.sp());
                    }
                    break;
                }
                ATH_MSG_VERBOSE(__func__<<"() Hit compatible - add to pattern.");
                pat.addHit(testHit, residual, accWindow);
                break;
            }
            case LineTestDecision::eBranchPattern: {
                /* Check first if the branched pattern already exists*/
                if (std::ranges::any_of(endPatterns, [&testHit, &pat](const PatternState& p) {
                        return p.isInLastLayer(testHit) && p.prevLayerHit == pat.prevLayerHit; })) {
                    ATH_MSG_VERBOSE(__func__<<"() Hit compatible & on same layer of last added hit - branched pattern already exists.");
                    break;
                }
                ATH_MSG_VERBOSE(__func__<<"() Hit compatible & on same layer of last added hit - branch pattern.");
                endPatterns.push_back(pat);
                endPatterns.back().overWriteHit(testHit, residual, accWindow);
            
                if (visualInfo) {
                    pat.visualInfo->replacedHits.push_back(testHit.sp());
                    endPatterns.back().visualInfo->replacedHits.push_back(pat.lastInsertedHit.sp());
                }
                ATH_MSG_VERBOSE("New pattern: " << brief(endPatterns.back()));
                break;
            }
            case LineTestDecision::eRejectHit: {
                ATH_MSG_VERBOSE(__func__<<"() Hit is not compatible with the pattern - reject hit.");
                if (visualInfo) {
                    pat.visualInfo->discardedHits.push_back(testHit.sp());
                }
                break;
            }
            case LineTestDecision::eConsecutiveMdt: { 
                if (const uint8_t nMdtLastLayer{pat.nMDTLastLayer()}; nMdtLastLayer >= 3) {
                    LineTestRes newClusterRes {pat.computeLineResidual(pat.lastInsertedHit)};
                    if (newClusterRes.residual > newClusterRes.accWindow) {
                        ATH_MSG_VERBOSE(__func__<<"() Hit is the #"<<nMdtLastLayer+1
                            <<" consecutive MDT hit: new cluster is not compatible - reject.");
                        break;
                    }
                    ATH_MSG_VERBOSE(__func__<<"() Hit is the #"<<nMdtLastLayer + 1
                        <<" consecutive MDT hit: new cluster is compatible - create new pattern with new cluster.");
                    endPatterns.push_back(pat);
                    endPatterns.back().overWriteHit(pat.lastInsertedHit, newClusterRes.residual, newClusterRes.accWindow);
                    endPatterns.back().addHit(testHit, residual, accWindow);
            
                    if (visualInfo) {
                        pat.visualInfo->discardedHits.push_back(testHit.sp());
                        endPatterns.back().visualInfo->replacedHits.push_back(pat.lastInsertedHit.sp());
                    }
                    ATH_MSG_VERBOSE("New pattern: " << brief(endPatterns.back()));
                    break;
                }
                ATH_MSG_VERBOSE(__func__<<"() Consecutive MDT hits on same layer - accept. " << brief(pat));
                pat.addHit(testHit, residual, accWindow);
                break;
            }
            case LineTestDecision::eOverwriteLastHit: {
                ATH_MSG_VERBOSE(__func__<<"() Hit compatible & on same layer of last added hit - overwrite last hit.");
                pat.overWriteHit(testHit, residual, accWindow);
 
                if (visualInfo) {
                    pat.visualInfo->replacedHits.push_back(pat.lastInsertedHit.sp());
                }
                break;
            }
        }
        endPatterns.push_back(std::move(pat));
    }
    startPatterns.clear();
};

findPatterns()

GlobalPatternFinder::PatternVec MuonR4::FastReco::GlobalPatternFinder::findPatterns	(	const ActsTrk::GeometryContext &	gctx,
		const SpacePointContainerVec &	spacepoints,
		BucketPerContainer &	outBuckets ) const

Main methods steering the pattern finding.

Given the space-point containers, it creates the search tree,
builds patterns in eta, attach compatible only-phi measurements, and convert PatternStates into GlobalPatterns

Parameters

gctx	Geometry context
spacepoints	Vector of space point containers
outBuckets	output collection of space-point buckets grouped by their corresponding input container to be written into StoreGate.

Returns

: Vector of found patterns

Create the search tree by ordering hits in theta and expanded spectrometer sector and find patterns in eta. The tree should outlive the pattern finding process

Add phi-only hits to the patterns

Add the successfull pattern to visual info, as we won't touch it again

Fill the output buckets

Plot patterns

Definition at line 41 of file GlobalPatternFinder.cxx.

                                                                        {
    const SearchTree_t orderedSpacepoints {constructTree(gctx, spacepoints)};
    auto visualInfo {m_cfg.visionTool ? std::make_unique<PatternHitVisualInfoVec>() : nullptr};
    PatternStateVec patterns{findPatternsInEta(orderedSpacepoints, visualInfo.get())};

    addPhiOnlyHits(gctx, patterns);
 
    
    for (const PatternState& pat : patterns) {
        addVisualInfo(pat, PatternHitVisualInfo::PatternStatus::eSuccessful, visualInfo.get());

        for (const std::vector<CandidateHit>&  hits : pat.hitsPerStation) {
            for (const auto& hit : hits) {
                if (outBuckets.find(hit->container) == outBuckets.end()) {
                    throw std::runtime_error("The space point container associated to the pattern is not present in the output bucket map.");
                }
                auto& outBucketVec = outBuckets[hit->container];
                if (std::ranges::find(outBucketVec, hit->bucket) == outBucketVec.end()) {
                    outBucketVec.push_back(hit->bucket);
                }
            }
        }
    }
    if (visualInfo) {
        m_cfg.visionTool->plotPatternBuckets(Gaudi::Hive::currentContext(), "GlobPatFind_", std::move(*visualInfo));
    }
    return convertToPattern(patterns);
}

findPatternsInEta()

GlobalPatternFinder::PatternStateVec MuonR4::FastReco::GlobalPatternFinder::findPatternsInEta ( const SearchTree_t & orderedSpacepoints, PatternHitVisualInfoVec * visualInfo = nullptr ) const

private

Method steering the global pattern building in the bending plane.

Parameters

orderedSpacepoints	Search tree with spacepoints ordered by their corresponding coordinates
visualInfo	Pointer to visual information for pattern visualization (nullptr if the VisualizationTool is disabled). Needed to add visual info about pattern candidates discarded during the building stage.

Returns

: resulting vector of PatternStates successfully built

Define two PatternState buffers to avoid reallocations

TODO: Retrieve the beamspot if desired

Helper function to count existing patterns containing a hit

Parameters

hit	The hit to check
coords	The coordinates of the hit

Returns

The number of existing patterns containing the hit

We try to build a pattern in eta starting from every hit in the three

Check the seed is in the current seeding layer, and if seeding from MDT hits is enabled

check how many existing patterns contain this hit

Define the search range.

Search hits with same expanded sector

Define theta window size. While a middle-layer seed already constrains the track direction more tightly (the line must connect to hits on both sides), inner- and outer-layer seeds are more loosely constraining, and we need a larger theta window with double size to achieve the same angular acceptance as inner/outer seeds

Search for compatible spacepoints with the seed and check if there are enough to build a pattern

Check that the candidate hits extend at least in two layers

Sort the compatible spacepoints by global logical layer

If the two hits are in the same layer, sort them by local y coordinate.

Assign global layer number. This will avoid re-computing it many times later

Start pattern building from the seed

Helper function to extend a given pattern with a set of hits. We can have pattern branching when a pattern is compatible with multiple hits on the same layer, increasing the number of active patterns. For each new hit, extendPatterns will try to extend every active pattern and remove the ones not meeting continuation criteria.

Parameters

begin	The iterator pointing to the first hit to process.
end	The iterator pointing to the end of the hit range.
toExtend	The pattern to extend.

Returns

The vector of resulting patterns.

First search for compatible hits from the seed layer onwards

When inverting the search direction, update last inserted hit and line anchor

Then try to proceed toward the innermost layer

Ensure there are no overlaps

Definition at line 78 of file GlobalPatternFinder.cxx.

                                                                                  {
    constexpr auto thetaIdx {Acts::toUnderlying(SeedCoords::eTheta)};
    constexpr auto sectorIdx {Acts::toUnderlying(SeedCoords::eSector)};

    PatternStateVec startPatternBuff{};
    startPatternBuff.reserve(20);
    PatternStateVec endPatternBuff{};
    endPatternBuff.reserve(20);

    const Amg::Vector3D beamSpot{Amg::Vector3D::Zero()};
    
    PatternStateVec outPatterns{};
    outPatterns.reserve(40);
    auto countPatterns = [&outPatterns, this](const HitPayload& hit, 
                                              const SearchTree_t::coordinate_t& coords) -> uint8_t {
        return std::ranges::count_if(outPatterns, [&](const PatternState& pattern){
            if (std::abs(pattern.theta - coords[thetaIdx]) > 2.*m_cfg.thetaSearchWindow ||
                !pattern.expSect.isNeighbour(ExpandedSector{static_cast<std::int8_t>(coords[sectorIdx])})) {
                return false;
            }
            return pattern.isInPattern(hit);
        });
    };
    using enum SeedCoords;
    for (const auto seedingLayer : m_cfg.layerSeedings) {
        for (const auto& [seedCoords, seed] : orderedSpacepoints) {
            const LayerIndex seedLayer {toLayerIndex(seed.station)};
            if (seedLayer != seedingLayer || (seed.isStraw && !m_cfg.seedFromMdt)) {
                continue;
            }
            ATH_MSG_VERBOSE(__func__<<"() New seed hit "<<*seed<<", coordinates "<<seedCoords);
            uint8_t nExistingPatterns {countPatterns(seed, seedCoords)};
            if (nExistingPatterns >= m_cfg.maxSeedAttempts) {
                // Try first to resolve overlaps and re-count the number of patterns containing the seed
                outPatterns = resolveOverlaps(outPatterns, visualInfo);
                nExistingPatterns = countPatterns(seed, seedCoords);
                if (nExistingPatterns > m_cfg.maxSeedAttempts) {
                    ATH_MSG_VERBOSE(__func__<<"() Seed has already been used in "<<nExistingPatterns<<" patterns, which is above the limit - skip this seed.");
                    continue;
                }   
            }
            SearchTree_t::range_t selectRange{};
            selectRange[sectorIdx].shrink(seedCoords[sectorIdx] - 0.1, seedCoords[sectorIdx] + 0.1); 
            const double thetaHalfWindow {(seedLayer == LayerIndex::Inner || seedLayer == LayerIndex::Outer) 
                                    ? m_cfg.thetaSearchWindow : 0.5*m_cfg.thetaSearchWindow};
            selectRange[thetaIdx].shrink(seedCoords[thetaIdx] - thetaHalfWindow, seedCoords[thetaIdx] + thetaHalfWindow);
            std::vector<CandidateHit> candidateHits{};
            orderedSpacepoints.rangeSearchMapDiscard(selectRange, [&candidateHits](const SearchTree_t::coordinate_t& /*coords*/,
                                                                                        const HitPayload& hit){
                candidateHits.emplace_back(&hit, hit.R, hit.Z, hit.station, 0u, hit.sector, hit.isStraw);
            });
            if (candidateHits.size() < m_cfg.minTriggerLayers + m_cfg.minPrecisionLayers) {
                ATH_MSG_VERBOSE(__func__<<"() Found "<<candidateHits.size()<<" candidate hits, below the minimum required - skip this seed.");
                continue;
            }
            if (std::ranges::none_of(candidateHits, [this, seedLayer](const CandidateHit& c){
                    return m_cfg.idHelperSvc->layerIndex(c.sp()->identify()) != seedLayer; }) ) {
                ATH_MSG_VERBOSE(__func__<<"() All candidates are in the same station layer, and we need at least two - skip this seed.");
                continue;
            }
            std::ranges::sort(candidateHits, [](const CandidateHit& c1, const CandidateHit& c2){
                LayerOrdering ordering {checkLayerOrdering(*c1, *c2)};
                if (ordering == eSameLayer) {
                    return c1.sp()->localPosition().y() < c2.sp()->localPosition().y();
                }
                return ordering == eLowerLayer;
            });
            for (std::size_t i {1}; i < candidateHits.size(); ++i) {
                candidateHits[i].globLayer = candidateHits[i - 1].globLayer + 
                    (checkLayerOrdering(*candidateHits[i - 1], *candidateHits[i]) != eSameLayer);
            }
            if (candidateHits.back().globLayer + 1u < (m_cfg.minTriggerLayers + m_cfg.minPrecisionLayers)) {
                ATH_MSG_VERBOSE(__func__<<"() Found "<<candidateHits.size()<<" candidate hits on "<<candidateHits.back().globLayer + 1
                                        <<" layers, below the minimum required - skip this seed.");
                continue;
            }
            if (msgLvl(MSG::VERBOSE)) {
                ATH_MSG_VERBOSE(__func__<<"() Found "<< candidateHits.size()<<" candidate hits: ");
                for (const auto& c : candidateHits) {
                    ATH_MSG_VERBOSE(__func__<<"() \t**"<<**c<<", glob Z/R/phi: "<<c.Z<<" / "<<c.R<<" / "<<inDegrees(c->phi) 
                        << ", st/layer: " << stName(c.station) << " / "<< (int)c.globLayer);
                }
            }

            const auto seedItr {std::ranges::find_if(candidateHits,
                [&seed](const CandidateHit& c){ return *c == seed; })};
            assert(seedItr != candidateHits.end());
            const CandidateHit& seedCand {*seedItr};
 
            PatternState patternSeed{seedCand, static_cast<std::int8_t>(seedCoords[sectorIdx]), 
                seedCoords[thetaIdx], &m_cfg, this};
            if (visualInfo) {
                patternSeed.visualInfo = std::make_unique<PatternHitVisualInfo>(
                    seed.hit, seedCoords[thetaIdx] - thetaHalfWindow, seedCoords[thetaIdx] + thetaHalfWindow);
            }
            
            auto processHitRange = [&](const auto begin, 
                                                 const auto end, 
                                                 PatternState&& toExtend) -> PatternStateVec {
                startPatternBuff.clear();
                startPatternBuff.push_back(std::move(toExtend));
                
                for (auto testItr = begin; testItr != end; ++testItr) {
                    const CandidateHit& testHit {*testItr};
                    if (testHit.globLayer == seedCand.globLayer && !seedCand.isStraw) {
                        continue; // skip hits on the same layer as the seed, if straw
                    }
                    extendPatterns(startPatternBuff, endPatternBuff, testHit, beamSpot, visualInfo);
                    // Swap the buffers for the next iteration
                    std::swap(startPatternBuff, endPatternBuff);
                }
                return startPatternBuff.size() > 1 
                    ? resolveOverlaps(startPatternBuff, visualInfo) 
                    : PatternStateVec{std::move(startPatternBuff.back())};
            };

            PatternStateVec forwardExtended {processHitRange(std::next(seedItr), candidateHits.end(), std::move(patternSeed))};

            ATH_MSG_VERBOSE(__func__<<"() Finished forward search, found "<<forwardExtended.size()<<" forward patterns, start backward search.");
            PatternStateVec backwardExtended{};
            backwardExtended.reserve(2*forwardExtended.size());
            
            for (PatternState& pat : forwardExtended) {
                pat.moveLineAnchorHit(seedCand);
                pat.lastInsertedHit = seedCand;

                std::ranges::move(
                    processHitRange(std::reverse_iterator(seedItr), candidateHits.rend(), std::move(pat)), 
                    std::back_inserter(backwardExtended)
                );
            }
            if (backwardExtended.size() > 1) {
                backwardExtended = resolveOverlaps(backwardExtended, visualInfo);
            }
 
            for (PatternState& pat : backwardExtended) {
                pat.meanNormResidual2 /= pat.nBendingLayers();
                if (!passPatternCuts(pat)) {
                    addVisualInfo(pat, PatternHitVisualInfo::PatternStatus::eFailed, visualInfo);
                    continue;
                }
                ATH_MSG_VERBOSE(__func__<<"() Add new pattern "<<detailed(pat));
                pat.isFinalized = true;
                outPatterns.push_back(std::move(pat));
            }
        }
    }
    ATH_MSG_VERBOSE(__func__<<"() Found in total "<<outPatterns.size()<<" patterns in eta before overlap removal");
    return resolveOverlaps(outPatterns, visualInfo);
}

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;
  }
}

isBetter()

bool MuonR4::FastReco::GlobalPatternFinder::isBetter ( const PatternState & a, const PatternState & b )

staticprivate

Method to compare two patterns and define which one is better.

Parameters

a	first pattern
b	second pattern

Returns

: true if pattern a is better than pattern b, false otherwise

Definition at line 1189 of file GlobalPatternFinder.cxx.

                                                                               {
    const int nLayerDiff {a.nBendingLayers() - b.nBendingLayers()};
    if (std::abs(nLayerDiff) >= 3) {
        return nLayerDiff > 0;
    }
    return a.getMeanResidual2() < b.getMeanResidual2();
}

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 167 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 182 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

passPatternCuts()

bool MuonR4::FastReco::GlobalPatternFinder::passPatternCuts ( const PatternState & pat ) const

private

Method to check if a pattern passes the quality cuts.

Parameters

pattern

Pattern to be checked

Returns

: true if the pattern passes the cuts, false otherwise

Check that the pattern meets the minimum requirements for trigger and precision layers

Check requirement on the residual

Definition at line 409 of file GlobalPatternFinder.cxx.

                                                                       {
    if (pat.nTriggerLayers < m_cfg.minTriggerLayers || 
        pat.nPrecisionLayers < m_cfg.minPrecisionLayers ||
        std::ranges::count_if(pat.nMeasurementLayers, 
            [this](const uint8_t nLayers) { return nLayers >= m_cfg.minStationLayers; }) < 2) {
        ATH_MSG_VERBOSE(__func__<<"() Pattern " << detailed(pat) << "\ndoes not meet minimum layer requirements - reject.");
        return false;
    }
    if (pat.meanNormResidual2 > m_cfg.meanNormRes2Cut) {
        ATH_MSG_VERBOSE(__func__<<"() Pattern " << detailed(pat) << "\ndoes not meet the mean norm residual2 cut - reject.");
        return false;
    }
    return true;
}

resolveOverlaps()

GlobalPatternFinder::PatternStateVec MuonR4::FastReco::GlobalPatternFinder::resolveOverlaps ( PatternStateVec & toResolve, PatternHitVisualInfoVec * visualInfo = nullptr ) const

private

Method to remove overlapping patterns.

Parameters

toResolve	pattern to be resolved
visualInfo	Pointer to visual information for pattern visualization (nullptr if the VisualizationTool is disabled)

Returns

: resolved patterns

Check if two patterns overlap in space

Check first the geometrical overlap

If we reach here, the patterns can overlap geometrically, so check the hit content

Overlap if more than 50% of the hits of the smaller pattern are shared

Determine best pattern

Definition at line 426 of file GlobalPatternFinder.cxx.

                                                                                {
    PatternStateVec outputPatterns{};
    outputPatterns.reserve(toResolve.size());
    auto areOverlapping = [this](const PatternState& a, const PatternState& b) {
        if(!a.expSect.isNeighbour(b.expSect)) {
            return false;
        }
        if (std::abs(a.theta - b.theta) > 2.*m_cfg.thetaSearchWindow) {
            return false;
        }
        if (a.nPhiLayers > 0 && b.nPhiLayers > 0) {
            if (std::abs(CxxUtils::deltaPhi(a.phi, b.phi)) > 2.*m_cfg.phiTolerance) {
                return false;
            }
        } else if (a.nPhiLayers > 0) {
            if (!sectorMap.insideSector(b.expSect.msSector(),         a.phi) || 
                !sectorMap.insideSector(b.expSect.adjacentMsSector(), a.phi)) {
                return false;
            }
        } else if (b.nPhiLayers > 0) {
            if (!sectorMap.insideSector(a.expSect.msSector(),         b.phi) || 
                !sectorMap.insideSector(a.expSect.adjacentMsSector(), b.phi)) {
                return false;
            }
        }
        int nSharedHits{0};
        for (std::size_t st{0u}; st < s_nStations; ++st) {
            const auto& hitsA {a.hitsPerStation[st]};
            const auto& hitsB {b.hitsPerStation[st]};
            if (hitsA.empty() || hitsB.empty()) {
                continue;
            }
            nSharedHits += std::ranges::count_if(hitsA, [&](const CandidateHit& hitA){
                return std::ranges::any_of(hitsB, [&hitA](const CandidateHit& hitB) {
                    return hitA.sp()->primaryMeasurement() == hitB.sp()->primaryMeasurement();
                });
            });
        }
        const int minHits {std::min(a.nBendingHits(), b.nBendingHits())};
        return nSharedHits >= 0.5 *minHits;
    };
    auto isBetterOverlap = [](const PatternState& a, const PatternState& b) {
        const int nGoodStationDiff {a.nStations(/*onlyGoodStations=*/ true) - b.nStations(/*onlyGoodStations=*/ true)};
        if (nGoodStationDiff != 0) {
            return nGoodStationDiff > 0;
        }
        return isBetter(a,b);
    };
 
    for (auto it = toResolve.begin(); it != toResolve.end(); ++it) {
        if (it->isOverlap) {
            // If already marked as overlap, add to visual info, and discard the pattern
            addVisualInfo(*it, PatternHitVisualInfo::PatternStatus::eOverlap, visualInfo);
            continue;
        }
        for (auto jt = std::next(it); jt != toResolve.end(); ++jt) {
            if (jt->isOverlap || !areOverlapping(*it, *jt)) {
                continue;
            }
            if (isBetterOverlap(*it, *jt)) {
                ATH_MSG_VERBOSE(__func__<<"() Pattern "<<detailed(*it)<<"\nis BETTER than\n"<<detailed(*jt));
                jt->isOverlap = true;
            } else {
                it->isOverlap = true;
                ATH_MSG_VERBOSE(__func__<<"() Pattern "<<detailed(*jt)<<"\nis BETTER than\n"<<detailed(*it));
                break;
            }
        }
        if (!it->isOverlap) {
            outputPatterns.push_back( std::move(*it));
        } else {
            // If overlap, add to visual info, as the pattern will be discarded
            addVisualInfo(*it, PatternHitVisualInfo::PatternStatus::eOverlap, visualInfo);
        }
    }
    ATH_MSG_VERBOSE(__func__<<"() Patterns surviving overlap removal: "<< outputPatterns.size());
    return outputPatterns;
}

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;
}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & os, const PatternPrintView & v )

friend

Definition at line 1321 of file GlobalPatternFinder.cxx.

                                                                                     {
    v.pat.print(os, v.detailed);
    return os;
}

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::FastReco::GlobalPatternFinder::m_cfg

private

Global Pattern Recognition configuration.

Definition at line 415 of file GlobalPatternFinder.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.

m_spSorter

SpacePointPerLayerSorter MuonR4::FastReco::GlobalPatternFinder::m_spSorter {}

private

Spacepoint sorter per logical measurement layer.

Definition at line 413 of file GlobalPatternFinder.h.

{};

s_nStations

const int MuonR4::FastReco::GlobalPatternFinder::s_nStations {Acts::toUnderlying(StIndex::StIndexMax)}

staticprivate

Definition at line 104 of file GlobalPatternFinder.h.

{Acts::toUnderlying(StIndex::StIndexMax)};

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx