MuonR4::FastReco::GlobalPatternFinder Class Reference

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

#include <GlobalPatternFinder.h>

Collaboration diagram for MuonR4::FastReco::GlobalPatternFinder:

Classes
struct	Config
	Configuration object for the patter finder. More...
struct	HitPayload
	Base class for hit struct containing hit information. More...
struct	SearchTreeData
	Structure to hold the search tree data. More...
struct	CandidateHit
	Small wrapper for candidate hits used to build patterns. More...
struct	PatternState
	Pattern state object storing pattern information during construction. More...
struct	PatternPrintView
	A view of the pattern state for printing purposes. More...

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.

Public Member Functions
	GlobalPatternFinder (Config &&config, std::unique_ptr< const Acts::Logger > logger=Acts::getDefaultLogger("GlobalPatternFinder", Acts::Logging::Level::INFO))
	Standard constructor.
std::vector< GlobalPattern >	findPatterns (const ActsTrk::GeometryContext &gctx, std::span< const SpacePointContainer * > spacepoints) const
	Main methods steering the pattern finding.

Private Types
enum class	SeedCoords : std::uint8_t { eSector , eTheta }
	Abrivation of the seed coordinates. More...
enum class	LayerOrdering : std::int8_t { eSameLayer , eLowerLayer , eHigherLayer }
	Enum to express the logical measurement layer ordering given two hits. More...
using	PatternStateVec = std::vector<PatternState>
	Type alias for a vector of pattern states.
using	PatHitVisual = MuonValR4::IFastRecoVisualizationTool::PatternHitVisualInfo
	Type alias for the visual information of a pattern.
using	SearchTree_t = Acts::KDTree<2, const HitPayload*, double, std::array, 50>
	Definition of the search tree class.

Private Member Functions
SearchTreeData	constructTree (const ActsTrk::GeometryContext &gctx, std::span< const SpacePointContainer * > spacepoints) const
	Construct the search tree from the given spacepoint containers.
PatternStateVec	findPatternsInEta (const Acts::GeometryContext &gctx, const SearchTree_t &orderedSpacepoints, std::vector< PatHitVisual > *visualInfo=nullptr) const
	Method steering the global pattern building in the bending plane.
void	extendPatterns (const Acts::GeometryContext &gctx, PatternStateVec &startPatterns, PatternStateVec &endPatterns, const CandidateHit &testHit, const Amg::Vector3D &beamSpot, std::vector< PatHitVisual > *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, std::vector< PatHitVisual > *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.
std::vector< GlobalPattern >	convertToPattern (const PatternStateVec &candidates) const
	Method to convert a vector of PatternStates into GlobalPattern objects.
void	addVisualInfo (const PatternState &candidate, PatHitVisual::PatternStatus status, std::vector< PatHitVisual > *visualInfo) const
	Helper function to add visual information of a given pattern (which is usually going to be destroyed) to the final container.
const Acts::Logger &	logger () const

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 PatternPrintView	brief (const PatternState &p)
	Print the pattern state with brief information.
static PatternPrintView	detailed (const PatternState &p)
	Print the pattern state with detailed information.

Private Attributes
SpacePointPerLayerSorter	m_spSorter {}
	Spacepoint sorter per logical measurement layer.
Config	m_cfg
	Global Pattern Recognition configuration.
std::unique_ptr< const Acts::Logger >	m_logger {}
	Logger for the Global Pattern Finder.

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

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.

Note

The definition and implementation of structs and classes used in the pattern finding are contained in the GlobalPatternFinderDefs.h

Definition at line 28 of file GlobalPatternFinder.h.

Member Typedef Documentation

LayerIndex

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

Type alias for the station layer index.

Definition at line 33 of file GlobalPatternFinder.h.

PatHitVisual

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

private

Type alias for the visual information of a pattern.

Definition at line 111 of file GlobalPatternFinder.h.

PatternStateVec

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

private

Type alias for a vector of pattern states.

Definition at line 109 of file GlobalPatternFinder.h.

SearchTree_t

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

private

Definition of the search tree class.

Definition at line 113 of file GlobalPatternFinder.h.

StIndex

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

Type alias for the station index.

Definition at line 31 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 187 of file GlobalPatternFinder.h.

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

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 115 of file GlobalPatternFinder.h.

                                  : std::uint8_t{
                eSector,
                eTheta
            };

Constructor & Destructor Documentation

GlobalPatternFinder()

MuonR4::FastReco::GlobalPatternFinder::GlobalPatternFinder	(	Config &&	config,
		std::unique_ptr< const Acts::Logger >	logger = Acts::getDefaultLogger(                                    "GlobalPatternFinder", Acts::Logging::Level::INFO) )

Standard constructor.

Parameters

name	Name to be printed in the messaging
config	Configuration parameters

Definition at line 22 of file GlobalPatternFinder.cxx.

                                                                                 :
    m_cfg{config},
    m_logger{std::move(logger)} {
        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

: Vector of added phi-only hits

We use useBeamspot as a flag to indicate whether the pattern line has been determined successfully

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

Reject hits from a layer that already contains a phi hit

Definition at line 477 of file GlobalPatternFinder.cxx.

                                                                          {
    auto computePatternLineInStation = [&](PatternState& pat, 
                                           const StIndex station) -> bool {
        const std::vector<CandidateHit>& stationHits {
            pat.hitsPerStation[Acts::toUnderlying(station)]};
        if(stationHits.empty()) {
            return false;
        }

        pat.useBeamspot = true;
 
        if (stationHits.size() > 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(stationHits, {},
                [](const CandidateHit& c){ return c.globLayer; })};
            pat.lineAnchorHit = *minIt;
            pat.lastInsertedHit = *maxIt;
            pat.updateLineParameters(gctx.context(), Amg::Vector3D::Zero());
        }
        if (pat.useBeamspot) {
            // if we have only one eta hit or the layer separation is too small, to find the second hit 
            // we use the functionality of anchor hit
            pat.moveLineAnchorHit(stationHits.front());
            pat.lastInsertedHit = *std::ranges::max_element(stationHits, {},
                [&](const CandidateHit& c){ 
                    return (pat.projToPhiPlane(gctx.context(), *c) - 
                            pat.projToPhiPlane(gctx.context(), *pat.lineAnchorHit)).mag(); }); 
            pat.updateLineParameters(gctx.context(), Amg::Vector3D::Zero());
        }
        return !pat.useBeamspot;
    };
 
    PatternStateVec survivingPatterns{};
    survivingPatterns.reserve(patterns.size());
    for (PatternState& pat : patterns) {
        ACTS_VERBOSE(__func__<<"() Search for phi-only hits for pattern: " << brief(pat));
 
        std::optional<StIndex> patterLineStation{std::nullopt};
 
        auto projOntoPhiPlane = [&pat](const Amg::Vector3D& pos) -> Amg::Vector3D {
            return pos - pos.dot(pat.bendPlaneNorm) * pat.bendPlaneNorm;
        };
 
        for (const SpacePointBucket* bucket : pat.getParentBuckets()) {
 
            const Acts::Transform3& localToGlobal {bucket->msSector()->localToGlobalTransform(gctx)};
            const StIndex station {m_cfg.idHelperSvc->stationIndex(bucket->front()->identify())};
            
            for (const auto& hit : *bucket) {
                // We are looking for phi-only hits
                if (hit->measuresEta()){
                    continue;
                }
                ACTS_VERBOSE(__func__<<"() *** Test phi-only hit "<<*hit);
                HitPayload newHit {gctx.context(), hit.get(), bucket, localToGlobal};

                const std::vector<CandidateHit>& stationHits {
                    pat.hitsPerStation[Acts::toUnderlying(station)]};
                assert(!stationHits.empty());
                if (std::ranges::any_of(stationHits, [&](const CandidateHit& h){
                        return h.sp()->measuresPhi() && 
                               hit->msSector() == h.sp()->msSector() && 
                               newHit.locLayer == h->locLayer;
                        }) ||
                    std::ranges::any_of(pat.phiOnlyHits, [&](const HitPayload& h){
                        return station == h.station && 
                               hit->msSector() == h->msSector() && 
                               newHit.locLayer == h.locLayer; 
                        })) {
                    ACTS_VERBOSE(__func__<<"() The pattern already has a phi hit in the same layer - skip hit.");
                    continue;
                }
                
                if (!pat.isPhiCompatible(newHit)) {
                    ACTS_VERBOSE(__func__<<"() Phi-only hit not compatible");
                    continue;
                }
 
                if (!patterLineStation || *patterLineStation != station) {
                    if (!computePatternLineInStation(pat, station)) {
                        ACTS_VERBOSE(__func__<<"() Invalid projection model for station "<<station<<" - skip hit.");
                        continue;
                    }
                    patterLineStation = station;
                }
 
                const double stripHalfLength {
                    std::sqrt(hit->covariance()[Acts::toUnderlying(SpacePoint::CovIdx::etaCov)])};
                const Amg::Vector3D sensorDir {newHit.sensorDir(gctx.context())};
                const Amg::Vector3D stripLow {
                    projOntoPhiPlane(newHit.position - stripHalfLength * sensorDir)};
                const Amg::Vector3D stripHigh {
                    projOntoPhiPlane(newHit.position + stripHalfLength * sensorDir)};
                const Amg::Vector3D stripDirOnPlane {(stripHigh - stripLow).unit()};
                
                const double stripIntersect {Acts::detail::LineHelper::lineIntersect<3>(
                    pat.linePos, pat.lineDir, stripLow, stripDirOnPlane).pathLength()};
                const double stripProjLength {(stripHigh - stripLow).mag()};
 
                ACTS_VERBOSE(__func__<<"() Intersect distance from lower strip edge: "
                    <<stripIntersect<<", proj strip length: "<< (stripHigh - stripLow).mag());
                
                constexpr double margin {10 * Gaudi::Units::mm};
                if (stripIntersect < -margin || stripIntersect > (stripProjLength + margin)) {
                    ACTS_VERBOSE(__func__<<"() The pattern falls outside the test hit strip in eta - skip hit.");
                    continue;
                }
                pat.phiOnlyHits.push_back(std::move(newHit));
                pat.nPhiLayers++;
                pat.updatePatternPhi();
            }
        }
        if (pat.nPhiLayers < m_cfg.minPhiLayers) {
            ACTS_VERBOSE(__func__<<"() Pattern "<<detailed(pat)
                <<" has only "<<static_cast<int>(pat.nPhiLayers)
                <<" phi layers, below the minimum required - reject this pattern.");
            continue;
        }
        survivingPatterns.push_back(std::move(pat));
    }
    std::swap(patterns, survivingPatterns);
}

addVisualInfo()

void MuonR4::FastReco::GlobalPatternFinder::addVisualInfo ( const PatternState & candidate, PatHitVisual::PatternStatus status, std::vector< PatHitVisual > * 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 824 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;
}

brief()

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

staticprivate

Print the pattern state with brief information.

Definition at line 608 of file GlobalPatternFinderDefs.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 763 of file GlobalPatternFinder.cxx.

                                                                {
    using enum LayerOrdering;
    auto getLayerOrdering = [](const bool isLayer1Lower) {
        return isLayer1Lower ? eLowerLayer : eHigherLayer;
    };
    if (hit1 == hit2) {
        return eSameLayer;
    }
    StIndex st1 {hit1.station};
    StIndex st2 {hit2.station};
    if (st1 == st2) {
        if (hit1->msSector() == hit2->msSector()) {
            if (hit1.locLayer == hit2.locLayer) {
                return eSameLayer;
            }
            return getLayerOrdering(hit1.locLayer < hit2.locLayer);
        }
        const double delta {isBarrel(st1) 
            ? hit1.position.perp() - hit2.position.perp() 
            : std::abs(hit1.position.z()) - std::abs(hit2.position.z())}; 
        if (std::abs(delta) <= Acts::s_epsilon) {
            return eSameLayer;
        }
        return getLayerOrdering(delta < 0.);
    }
    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.position.perp() < hit2.position.perp());
        }
        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::SearchTreeData MuonR4::FastReco::GlobalPatternFinder::constructTree ( const ActsTrk::GeometryContext & gctx, std::span< const SpacePointContainer * > spacepoints ) const

private

Construct the search tree from the given spacepoint containers.

The hit payloads are stored in a vector, and the tree will contain the index of the hits in the vector. Hits duplicated across overlapping sectors share the same payload. The tree does not contain only-phi hits.

Parameters

gctx	Geometry context
spacepoints	Vector of space point containers
hitPayloads	Vector of hit payloads to be filled with the spacepoints.

Returns

: Constructed search tree

First estimate the number of hits

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 651 of file GlobalPatternFinder.cxx.

                                                                                          {
    
    std::vector<HitPayload> hitPayloads{};
    using SectorProjector = ExpandedSector::SectorProjector;
    using enum SectorProjector;
    size_t totalHits = 0;
    for (const SpacePointContainer* spc : spacepoints) {
        for (const SpacePointBucket* bucket : *spc) {
            totalHits += bucket->size();
        }
    }
    hitPayloads.reserve(totalHits);
 
    for (const SpacePointContainer* spc : spacepoints) {
        for (const SpacePointBucket* bucket : *spc) {
            
            const Acts::Transform3& localToGlobal {bucket->msSector()->localToGlobalTransform(gctx)};
 
            for (const auto& hit : *bucket) {
                // Ignore only-phi hits and MDT hits if desired
                if (!hit->measuresEta() || (!m_cfg.useMdtHits && hit->isStraw())) {
                    continue;
                }
         
                hitPayloads.emplace_back(gctx.context(), hit.get(), bucket, localToGlobal);
  
                if (m_logger->level() <= Acts::Logging::Level::VERBOSE) {
                    const HitPayload& newHit {hitPayloads.back()};
                    std::ostringstream oss{};
                    oss<<__func__<<"() Building hit from "<<*hit<<std::endl<<"PhiCov: "<<newHit.phiCov
                        <<", Pos: "<<Amg::toString(newHit.position)<<", SensorDir: "<<Amg::toString(newHit.sensorDir(gctx.context()));
                    if (newHit->isStraw()) {
                        oss<<", discCov: "<<newHit.stripAngle;
                    } else {
                        oss<<"orthogonalStrips: "<<!newHit.nonOrthogonalStrips;
                    }
                    ACTS_VERBOSE(oss.str());
                }
            }
        }
    }
 
    SearchTree_t::vector_t treeData{};
    treeData.reserve(3 * hitPayloads.size());
 
    uint8_t msSector = hitPayloads.front()->msSector()->sector();
    const SpacePointBucket* currentBucket = hitPayloads.front().bucket;
    for (const HitPayload& hit : hitPayloads) {
        ACTS_VERBOSE(__func__<<"() Spacepoint: " << *hit);
        const Amg::Vector3D& pos {hit.position};
        const ExpandedSector hitExpSector {pos.phi()};
        if (hit.bucket != currentBucket) {
            currentBucket = hit.bucket;
            msSector = hit->msSector()->sector();
        }
         
        for (const SectorProjector proj : {leftOverlap, center, rightOverlap}) {
            const ExpandedSector expSect {msSector, proj};
            if (proj != SectorProjector::center && hit->measuresPhi() && expSect != hitExpSector) {
                ACTS_VERBOSE("addHitToTree() 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 Amg::Vector3D planeNormal {expSect.normalDir()};
            const double projR {hit->measuresPhi()
                ? pos.perp() 
                : (pos - pos.dot(planeNormal) * planeNormal).perp()};
            
            std::array<double, 2> coords{};
            coords[Acts::toUnderlying(SeedCoords::eTheta)] = atan2(projR, pos.z());
            coords[Acts::toUnderlying(SeedCoords::eSector)] = expSect.sector();
 
            ACTS_VERBOSE("addHitToTree() Add hit: Z: " << pos.z() << ", R: " << pos.perp() 
                <<", ProjR: "<<projR<< ", Phi: "<< inDeg(pos.phi()) 
                <<", SectorPhi: "<< inDeg(expSect.phi())<<" and coordinates ["
                <<coords[0]<<", "<<coords[1]<<"] to search tree");
            treeData.emplace_back(std::move(coords), &hit);
        }  
    }
    ACTS_VERBOSE(__func__<<"() Create a new tree with "<<treeData.size()
        <<" entries and "<<hitPayloads.size()<<" hits.");
    return SearchTreeData{std::move(hitPayloads), SearchTree_t{std::move(treeData)}};
}

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 603 of file GlobalPatternFinder.cxx.

                                                                                   {
    GlobalPattern::HitCollection hitPerStation{};
    std::vector<const SpacePointBucket*> parentBuckets{};
    for (uint8_t st{0u}; st < s_nStations; ++st) {
        const auto& hits {cache.hitsPerStation[st]};
        if (hits.empty()) continue;
 
        auto& outHits {hitPerStation[static_cast<StIndex>(st)]};
        outHits.reserve(hits.size());
        
        std::ranges::for_each(hits, [&outHits, &parentBuckets](const CandidateHit& h){
            outHits.push_back(h.sp());
            if (std::ranges::find(parentBuckets, h->bucket) == parentBuckets.end()) {
                parentBuckets.push_back(h->bucket);
            }
        });
    }

    for (const HitPayload& hit : cache.phiOnlyHits) {
        hitPerStation[static_cast<StIndex>(hit.station)].push_back(hit.spacePoint);
    }
    GlobalPattern pattern{std::move(hitPerStation), std::move(parentBuckets)};
    pattern.setTheta(cache.patTheta);
    pattern.setPhi(cache.patPhi);
    // 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]

std::vector< GlobalPattern > 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 640 of file GlobalPatternFinder.cxx.

                                                                        {
    std::vector<GlobalPattern> 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

Print the pattern state with detailed information.

Definition at line 612 of file GlobalPatternFinderDefs.cxx.

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

extendPatterns()

void MuonR4::FastReco::GlobalPatternFinder::extendPatterns ( const Acts::GeometryContext & gctx, PatternStateVec & startPatterns, PatternStateVec & endPatterns, const CandidateHit & testHit, const Amg::Vector3D & beamSpot, std::vector< PatHitVisual > * 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)

Check the pattern has not already missed too many layers compared to other patterns.

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

TO DO: Study feasibility of loosening the criteria for low-confidence hits with OR

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

Definition at line 254 of file GlobalPatternFinder.cxx.

                                                                                    {
    endPatterns.clear();
    ACTS_VERBOSE(__func__<<"() *** Test "<<testHit<<" 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. 
    auto missedLayers = [&testHit](const PatternState& pat) -> unsigned {
        return std::abs(pat.lastInsertedHit.globLayer - testHit.globLayer);
    };
 
    unsigned minMissedLayers {std::numeric_limits<unsigned>::max()};
    std::ranges::for_each(startPatterns, [&missedLayers, &minMissedLayers](const PatternState& pat){
        minMissedLayers = std::min(minMissedLayers, missedLayers(pat));
    });
 
    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) {
            addVisualInfo(pat, PatHitVisual::PatternStatus::eFailed, visualInfo);
            continue;
        }
        if (pat.lastInsertedHit->station == testHit->station && 
            missedLayers(pat) > std::max(m_cfg.maxMissLayersInStation, minMissedLayers)) {
            ACTS_VERBOSE(__func__<<"() Pattern " << detailed(pat) << "\nhas missed " << (int)missedLayers(pat) 
                                    << " layer hits, above the max allowed - abort pattern.");
            addVisualInfo(pat, PatHitVisual::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)) {
                    ACTS_VERBOSE("extendPatterns() Pruning: "<<detailed(pat)<<"\nis BETTER than "<<detailed(p));
                    p.isOverlap = true;
                    return false;
                }
                ACTS_VERBOSE("extendPatterns() Pruning: "<<detailed(p)<<"\nis BETTER than "<<detailed(pat));
                return true; }) != startPatterns.end()) {
            addVisualInfo(pat, PatHitVisual::PatternStatus::eFailed, visualInfo);
            continue;
        }
        const auto [residual, resSigma, result] {pat.checkLineComp(gctx,testHit, beamSpot)};
        switch (result) {
            case LineTestDecision::eAddHit: {
                const bool lowConfidenceRes {resSigma > m_cfg.lowConfidenceResSigma && 
                                             residual / resSigma > 2.};
                if (lowConfidenceRes) {
                    ACTS_VERBOSE(__func__<<"() Low-confidence hit: residual pull "<<residual / resSigma);
                    if (std::ranges::any_of(endPatterns, [&testHit, &pat](const PatternState& p) {
                            return p.lastInsertedHit == testHit && 
                                   (p.prevLayerHit == pat.lastInsertedHit || p.nBendingLayers() > (pat.nBendingLayers() + 1u)); })) {
                        ACTS_VERBOSE(__func__<<"() Forking leads to existing pattern - reject.");
                        break;
                    }
                    endPatterns.push_back(pat);
                    endPatterns.back().addHit(testHit, residual, resSigma);
                    if (visualInfo) {
                        pat.visualInfo->discardedHits.push_back(testHit.sp());
                    }
                    break;
                }
                ACTS_VERBOSE(__func__<<"() Hit compatible - add to pattern. Residual pull "<<residual / resSigma);
                pat.addHit(testHit, residual, resSigma);
                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.lastInsertedHit == testHit && p.prevLayerHit == pat.prevLayerHit; })) {
                    ACTS_VERBOSE(__func__<<"() Hit compatible & on same layer of last added hit - branched pattern already exists.");
                    break;
                }
                ACTS_VERBOSE(__func__<<"() Hit compatible & on same layer of last added hit - branch pattern.");
                endPatterns.push_back(pat);
                endPatterns.back().overWriteHit(testHit, residual, resSigma);
            
                if (visualInfo) {
                    pat.visualInfo->discardedHits.push_back(testHit.sp());
                }
                break;
            }
            case LineTestDecision::eRejectHit: {
                ACTS_VERBOSE(__func__<<"() Hit is not compatible with the pattern - reject hit.");
                if (visualInfo) {
                    pat.visualInfo->discardedHits.push_back(testHit.sp());
                }
                break;
            }
        }
        endPatterns.push_back(std::move(pat));
    }
    startPatterns.clear();
};

findPatterns()

std::vector< GlobalPattern > MuonR4::FastReco::GlobalPatternFinder::findPatterns	(	const ActsTrk::GeometryContext &	gctx,
		std::span< const SpacePointContainer * >	spacepoints ) 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

Returns

: Vector of found patterns

Create the search tree by ordering hits in theta and expanded spectrometer sector and find patterns in eta. The hit payloads are stored in a vector, and the tree will contain the index of the hits in the vector.

Add phi-only hits to the patterns

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

Plot patterns

Definition at line 36 of file GlobalPatternFinder.cxx.

                                                                                         {
    const SearchTreeData treeData {constructTree(gctx, spacepoints)};
 
    auto visualInfo {m_cfg.visionTool ? std::make_unique<std::vector<PatHitVisual>>() : nullptr};
    PatternStateVec patterns{findPatternsInEta(gctx.context(), treeData.tree, visualInfo.get())};

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

    if (visualInfo) {
        m_cfg.visionTool->plotPatternBuckets(Gaudi::Hive::currentContext(), "GlobPatFind_", std::move(*visualInfo));
    }
    return convertToPattern(patterns);
}

findPatternsInEta()

GlobalPatternFinder::PatternStateVec MuonR4::FastReco::GlobalPatternFinder::findPatternsInEta ( const Acts::GeometryContext & gctx, const SearchTree_t & orderedSpacepoints, std::vector< PatHitVisual > * 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 candidate hit buffer

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

Get the seed hit

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 61 of file GlobalPatternFinder.cxx.

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

    std::vector<CandidateHit> candidateHits{};
    candidateHits.reserve(100);

    PatternStateVec startPatternBuff{}, endPatternBuff{};
    startPatternBuff.reserve(10);
    endPatternBuff.reserve(10);

    const Amg::Vector3D beamSpot{Amg::Vector3D::Zero()};
    
    PatternStateVec outPatterns{};
    outPatterns.reserve(10);
    auto countPatterns = [this](const PatternStateVec& patterns,
                                const HitPayload& hit,
                                const SearchTree_t::coordinate_t& coords) -> uint8_t {
        return std::ranges::count_if(patterns, [&](const PatternState& pattern){
            if (std::abs(pattern.patTheta - 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, seedPtr] : orderedSpacepoints) {
            const HitPayload& seed {*seedPtr};
            const LayerIndex seedLayer {toLayerIndex(seed.station)};
            if (seedLayer != seedingLayer || (seed->isStraw() && !m_cfg.seedFromMdt)) {
                continue;
            }
            ACTS_VERBOSE(__func__<<"() New seed hit "<<*seed<<", coordinates ["<<seedCoords[0]<<", "<<seedCoords[1]<<"]");
            uint8_t nExistingPatterns {countPatterns(outPatterns, 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(outPatterns,seed, seedCoords);
                if (nExistingPatterns >= m_cfg.maxSeedAttempts) {
                    ACTS_VERBOSE(__func__<<"() Seed has already been used in "
                        <<static_cast<int>(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);
            candidateHits.clear();
            orderedSpacepoints.rangeSearchMapDiscard(selectRange, [&](const SearchTree_t::coordinate_t& /*coords*/,
                                                                      const HitPayload* hit) {
                candidateHits.emplace_back(hit, 0u);
            });
            if (candidateHits.size() < m_cfg.minTriggerLayers + m_cfg.minPrecisionLayers) {
                ACTS_VERBOSE(__func__<<"() Found "<<candidateHits.size()<<" candidate hits, below minimum required - skip seed.");
                continue;
            }
            if (std::ranges::none_of(candidateHits, [this, seedLayer](const CandidateHit& c){
                    return m_cfg.idHelperSvc->layerIndex(c.sp()->identify()) != seedLayer; }) ) {
                ACTS_VERBOSE(__func__<<"() All candidates in same station layer, and we need at least two - skip seed.");
                continue;
            }
            std::ranges::sort(candidateHits, [](const CandidateHit& c1, const CandidateHit& c2){
                LayerOrdering ordering {checkLayerOrdering(*c1, *c2)};
                if (ordering == LayerOrdering::eSameLayer) {
                    return c1.sp()->localPosition().y() < c2.sp()->localPosition().y();
                }
                return ordering == LayerOrdering::eLowerLayer;
            });
            for (std::size_t i {1}; i < candidateHits.size(); ++i) {
                candidateHits[i].globLayer = candidateHits[i - 1].globLayer + 
                    (checkLayerOrdering(*candidateHits[i - 1], *candidateHits[i]) != LayerOrdering::eSameLayer);
            }
            if (candidateHits.back().globLayer + 1u < (m_cfg.minTriggerLayers + m_cfg.minPrecisionLayers)) {
                ACTS_VERBOSE(__func__<<"() Found "<<candidateHits.size()<<" candidate hits on "
                    <<static_cast<int>(candidateHits.back().globLayer + 1u)
                    <<" layers, below the minimum required - skip this seed.");
                continue;
            }
            if (m_logger->level() <= Acts::Logging::Level::VERBOSE) {
                ACTS_VERBOSE(__func__<<"() Found "<< candidateHits.size()<<" candidate hits: ");
                for (const auto& c : candidateHits) {
                    ACTS_VERBOSE(__func__<<"() \t**"<<c);
                }
            }

            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]), &m_cfg, m_logger.get()};
            if (visualInfo) {
                patternSeed.visualInfo = std::make_unique<PatHitVisual>(
                    seed.spacePoint, 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) {
                        continue; // skip hits on the same layer as the seed
                    }
                    extendPatterns(gctx, 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))};

            ACTS_VERBOSE(__func__<<"() Finished forward search, found "<<forwardExtended.size()<<" forward patterns, start backward search.");
            PatternStateVec backwardExtended{};
            backwardExtended.reserve(2*forwardExtended.size());
            
            for (PatternState& pat : forwardExtended) {
                ACTS_VERBOSE(__func__<<"() Start backward search for pattern "<<detailed(pat));
                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, PatHitVisual::PatternStatus::eFailed, visualInfo);
                    continue;
                }
                ACTS_VERBOSE(__func__<<"() Add new pattern "<<detailed(pat));
                pat.isFinalized = true;
                outPatterns.push_back(std::move(pat));
            }
        }
    }
    ACTS_VERBOSE(__func__<<"() Found in total "<<outPatterns.size()<<" patterns in eta before overlap removal");
    return resolveOverlaps(outPatterns, visualInfo);
}

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

For patterns that differ by 1–2 layers, don't sacrifice fit quality
unless the extra layers are genuinely comparable. For a ≥3-layer difference,
the multiplicity advantage is strong enough to dominate.

Definition at line 741 of file GlobalPatternFinder.cxx.

                                                                               {
    const double resA {a.getMeanResidual2()};
    const double resB {b.getMeanResidual2()};
    const double resDiff {
        std::abs(resA - resB) / std::max(resA, resB)
    };
    const int nLayerDiff {a.nBendingLayers() - b.nBendingLayers()};
    const int nPrecLayDiff {a.nPrecisionLayers - b.nPrecisionLayers};

    if ((nLayerDiff == 0 && nPrecLayDiff == 0) ||
        (std::abs(nLayerDiff) < 3 && resDiff > 0.1)) {
        return resA < resB;
    }
    if (nLayerDiff == 0) {
        return nPrecLayDiff > 0;
    }
    return nLayerDiff > 0;
}

logger()

const Acts::Logger & MuonR4::FastReco::GlobalPatternFinder::logger ( ) const

inlineprivate

Definition at line 220 of file GlobalPatternFinder.h.

                                             {
                return *m_logger;
            }

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 369 of file GlobalPatternFinder.cxx.

                                                                       {
    if (pat.nTriggerLayers < m_cfg.minTriggerLayers || 
        pat.nPrecisionLayers < m_cfg.minPrecisionLayers ||
        std::ranges::count_if(pat.hitsPerStation, 
            [this](const auto& hits) { return hits.size() >= m_cfg.minStationLayers; }) < 2) {
        ACTS_VERBOSE(__func__<<"() Pattern " << detailed(pat) << "\ndoes not meet minimum layer requirements - reject.");
        return false;
    }
    if (pat.meanNormResidual2 > m_cfg.meanNormRes2Cut) {
        ACTS_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, std::vector< PatHitVisual > * 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

Check the angular difference between the seed hits

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 386 of file GlobalPatternFinder.cxx.

                                                                                {
    ACTS_VERBOSE(__func__<<"() Resolving overlaps among "<<toResolve.size()<<" patterns.");
    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.patTheta - b.patTheta) > 2.*m_cfg.thetaSearchWindow) {
            return false;
        }
        if (a.nPhiLayers > 0 && b.nPhiLayers > 0) {
            if (std::abs(P4Helpers::deltaPhi(a.patPhi, b.patPhi)) > 5.*Gaudi::Units::deg) {
                return false;
            }
        } else if (a.nPhiLayers > 0) {
            if (!sectorMap.insideSector(b.expSect.msSector(),         a.patPhi) || 
                !sectorMap.insideSector(b.expSect.adjacentMsSector(), a.patPhi)) {
                return false;
            }
        } else if (b.nPhiLayers > 0) {
            if (!sectorMap.insideSector(a.expSect.msSector(),         b.patPhi) || 
                !sectorMap.insideSector(a.expSect.adjacentMsSector(), b.patPhi)) {
                return false;
            }
        }
        std::size_t nSharedHits{0}, nSharedStations{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;
            }
            const std::size_t nSharedInStation = 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();
                });
            });
            nSharedHits += nSharedInStation;
            if (nSharedInStation >= m_cfg.minStationLayers) {
                nSharedStations++;
            }
        }
        const std::size_t minHits {std::min(a.nBendingLayers(), b.nBendingLayers())};
        const std::size_t minStations {std::min(a.nStations(/*onlyGoodStations=*/ true), b.nStations(/*onlyGoodStations=*/ true))};
        return nSharedHits >= 0.5 *minHits && nSharedStations >= std::min(2ul, minStations);
    };
    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, PatHitVisual::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)) {
                ACTS_VERBOSE(__func__<<"() Pattern "<<detailed(*it)<<"\nis BETTER than "<<detailed(*jt));
                jt->isOverlap = true;
            } else {
                it->isOverlap = true;
                ACTS_VERBOSE(__func__<<"() Pattern "<<detailed(*jt)<<"\nis BETTER than "<<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, PatHitVisual::PatternStatus::eOverlap, visualInfo);
        }
    }
    ACTS_VERBOSE(__func__<<"() Patterns surviving overlap removal: "<< outputPatterns.size());
    return outputPatterns;
}

Member Data Documentation

m_cfg

Config MuonR4::FastReco::GlobalPatternFinder::m_cfg

private

Global Pattern Recognition configuration.

Definition at line 217 of file GlobalPatternFinder.h.

m_logger

std::unique_ptr<const Acts::Logger> MuonR4::FastReco::GlobalPatternFinder::m_logger {}

private

Logger for the Global Pattern Finder.

Definition at line 219 of file GlobalPatternFinder.h.

{};

m_spSorter

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

private

Spacepoint sorter per logical measurement layer.

Definition at line 214 of file GlobalPatternFinder.h.

{};

s_nStations

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

staticprivate

Number of stations.

Definition at line 99 of file GlobalPatternFinder.h.

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

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx
• GlobalPatternFinderDefs.cxx