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	PatternState
	Pattern state object storing pattern information during construction. 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.
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	CompatibilityResult : std::int8_t { eAddHit = 0 , eBranchPattern = 1 , eRejectHit = -1 }
	: Enum for the possible outcomes of the line compatibility test of one pattern against one test hit 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, 10>
	Definition of the search tree class.
using	TreeNode = std::pair<SearchTree_t::coordinate_t, HitPayload>
	Type alias for a tree node, formed by a hit payload and its indexing coordinates.
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 building of patterns in eta.
void	extendPatterns (PatternStateVec &activePatterns, const HitPayload &test, const StIndex testStation, const HitPayload &seed, const HitPayload &prevCandidate, const StIndex prevCandidateStation, PatternHitVisualInfoVec *visualInfo=nullptr) const
	Function testing pattern compatibility of a set of active patterns (patterns produced from the same seed hit) against one test hit.
std::pair< CompatibilityResult, double >	checkLineCompatibility (const HitPayload &seed, const HitPayload &test, const StIndex testStation, const PatternState &pattern) const
	Method to check the line compatibility of a test hit with a given pattern.
bool	isPhiCompatible (const HitPayload &test, const HitPayload &seed, const PatternState &pattern) const
	Method to check the phi compatibility of a test hit with a given pattern.
double	computeLineSlope (const HitPayload &lastPatHit, const HitPayload &seed, const bool useSeed2Beamspot, const Amg::Vector3D &beamSpot) const
	Helper method to compute the line slope between the seed and the last hit in a given pattern in the R-Z plane.
double	computeResidual (const HitPayload &testHit, const HitPayload &seed, const double lineSlope) const
	Method to compute the residual in globalR given the pattern line and test hit.
double	computeAcceptanceWindow (const HitPayload &testHit, const HitPayload &seed, const HitPayload &lastPatHit, const double lineSlope, const bool useSeed2Beamspot, const Amg::Vector3D &beamSpot) const
	Method to compute the acceptance window in global R for a given pattern line and test hit.
PatternStateVec	resolveOverlaps (PatternStateVec &&toResolve, PatternHitVisualInfoVec *visualInfo=nullptr) const
	Method to remove overlapping patterns.
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.
LayerOrdering	checkLayerOrdering (const HitPayload &hit1, const HitPayload &hit2, const StIndex station1, const StIndex station2) const
	Method to check the logical layer ordering of two hits.
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.

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)

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. It will optionally write the final GlobalPatterns into the event store for downstream use.

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

LayerIndex

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

Type alias for the station layer index.

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

PatternHitVisualInfoVec

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

Abrivation for a vector of visual information objects.

Definition at line 44 of file GlobalPatternFinder.h.

PatternStateVec

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

private

Definition at line 199 of file GlobalPatternFinder.h.

PatternVec

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

Abrivation for a vector of global patterns.

Definition at line 38 of file GlobalPatternFinder.h.

SearchTree_t

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

private

Definition of the search tree class.

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

StIndex

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

Type alias for the station index.

Definition at line 32 of file GlobalPatternFinder.h.

TreeNode

using MuonR4::FastReco::GlobalPatternFinder::TreeNode = std::pair<SearchTree_t::coordinate_t, HitPayload>

private

Type alias for a tree node, formed by a hit payload and its indexing coordinates.

Definition at line 115 of file GlobalPatternFinder.h.

Member Enumeration Documentation

CompatibilityResult

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

strongprivate

: Enum for the possible outcomes of the line compatibility test of one pattern against one test hit

Enumerator
eAddHit	Test successfull, add the hit to the pattern.
eBranchPattern	Test successfull with multiple pattern hits in the same logical measurement layer, branch the pattern.
eRejectHit	Test failed, discard the hit.

Definition at line 231 of file GlobalPatternFinder.h.

                                           : std::int8_t{
                eAddHit = 0,
                eBranchPattern = 1,
                eRejectHit = -1,
            };

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 304 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 117 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 71 of file GlobalPatternFinder.cxx.

                                                                               :
    AthMessaging{name},
    m_cfg{config} {
};

Member Function Documentation

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

                                                                                      {
    if (!visualInfo) {
        return;
    }
    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);
    auto& bucketVec {visualInfo->back().parentBuckets};
    for (const auto& [_, buckets] : cache.bucketsPerContainer) {
        bucketVec.insert(bucketVec.end(), buckets.begin(), buckets.end());
    }
    visualInfo->back().patternCopy = std::make_unique<GlobalPattern>(std::move(pattern));
    visualInfo->back().status = status;
}

checkLayerOrdering()

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

private

Method to check the logical layer ordering of two hits.

Parameters

hit1	first hit
hit2	second hit
station1	station index of the first hit
station2	station index of the 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 576 of file GlobalPatternFinder.cxx.

                                                                      {
    auto getLayerOrdering = [](const bool isLayer1Lower) {
        return isLayer1Lower ? LayerOrdering::eLowerLayer : LayerOrdering::eHigherLayer;
    };
    if (hit1.hit->msSector() == hit2.hit->msSector()) {
        unsigned lay1 {m_spSorter.sectorLayerNum(*hit1.hit)};
        unsigned lay2 {m_spSorter.sectorLayerNum(*hit2.hit)};
        if (lay1 == lay2) {
            return LayerOrdering::eSameLayer;
        } else {
            return getLayerOrdering(lay1 < lay2);
        }
    }
    if (station1 == station2) {
        return getLayerOrdering(hit1.hit->msSector()->barrel() ? hit1.R < hit2.R : hit1.Z < hit2.Z);
    }
    LayerIndex layer1 {toLayerIndex(station1)};
    LayerIndex layer2 {toLayerIndex(station2)};
    if (layer1 == layer2) {
        if (layer1 == LayerIndex::Middle) {
            return getLayerOrdering(station1 == StIndex::BM);
        } else if (layer1 == LayerIndex::Inner) {
            return getLayerOrdering(hit1.R < hit2.R);
        } else {
            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(station2 == StIndex::EM);
    }
    return getLayerOrdering(station1 == StIndex::BM);
}

checkLineCompatibility()

std::pair< GlobalPatternFinder::CompatibilityResult, double > MuonR4::FastReco::GlobalPatternFinder::checkLineCompatibility ( const HitPayload & seed, const HitPayload & test, const StIndex testStation, const PatternState & pattern ) const

private

Method to check the line compatibility of a test hit with a given pattern.

Parameters

seed	seed hit information
test	test hit information
testStation	station of the test hit
pattern	pattern to be extended

Returns

: a pair of the result of the test and the computed line residual for the test hit

Here we can retrieve the beamspot if desired

Helper function to get whether the test hit is within the acceptance window of the last pattern hit

Fetch the last filled station and the last inserted hit

Check the layer ordering between the last inserted hit and the test hit

Check whether the test hit is in the same layer as the last hit in the pattern

Check that the hits are not the same

We add the test hit to the pattern if they are consecutive MDT hits

If they are not consecutive MDT hits && we have no inserted hits yet (last hit = seed), we give priority to the seed and reject the test hit

If they are not consecutive MDT hits && we have inserted hits, we We draw a line using the seed and last hit being on a different layer from the second-to-last inserted hit, and we check that the test hit residual is within the acceptance window. If we have no at least 2 inserted hits yet, we compute the line using the seed and the beamspot.

Fallback when we have all the previously inserted hits on the same layer

The new hit is in a new layer. We draw a line using the last inserted hit and the seed, and we check that the test hit residual is within the acceptance window. If we have no inserted hits yet, we compute the line using the seed and the beamspot.

Definition at line 306 of file GlobalPatternFinder.cxx.

                                                                               {
    if (!isPhiCompatible(test, seed, pattern)) {
        return std::make_pair(CompatibilityResult::eRejectHit, 0.);
    }
    const Amg::Vector3D beamSpot{Amg::Vector3D::Zero()};

    auto checkResidualInWindow = [&](const HitPayload& lastPatHit,
                                               const bool isUnique) {
        // Check whether we have to use the beamspot instead of the last pattern hit to draw the line with the seed.
        const bool useSeed2Beamspot {lastPatHit.hit == seed.hit || 
                                     std::abs( lastPatHit.Z - seed.Z) <= m_cfg.minZDiff4Line ||
                                     std::abs( lastPatHit.R - seed.R) <= m_cfg.minRDiff4Line};
        const double lineSlope {computeLineSlope(lastPatHit, seed, useSeed2Beamspot, beamSpot)};
        const double testResidual {computeResidual(test, seed, lineSlope)};
        const double acceptanceWindow {computeAcceptanceWindow(test, seed, lastPatHit, lineSlope, useSeed2Beamspot, beamSpot)};
        ATH_MSG_VERBOSE("Check residual in window... Residual: " << testResidual << ", Acceptance Window: " << acceptanceWindow);
        if (pattern.visualInfo) {
            pattern.visualInfo->hitLineInfo[test.hit] = std::make_pair(lineSlope, acceptanceWindow);
        }
        if (testResidual < acceptanceWindow) {
            return std::make_pair(isUnique ? CompatibilityResult::eAddHit : CompatibilityResult::eBranchPattern, testResidual);
        }
        return std::make_pair(CompatibilityResult::eRejectHit, 0.);
    };

    const auto [lastHitRef, lastFilledSt] {pattern.getNthLastHit(1u)};
    const HitPayload& lastInsertedHit {lastHitRef.get()};
    ATH_MSG_VERBOSE("Last pat hit: " << *lastInsertedHit.hit << ", station: " << Muon::MuonStationIndex::stName(lastFilledSt));
    const LayerOrdering orderingTest2Last {checkLayerOrdering(test, lastInsertedHit, testStation, lastFilledSt)};

    if(orderingTest2Last == LayerOrdering::eSameLayer) {
        if (test == lastInsertedHit) {
            ATH_MSG_VERBOSE("The test hit is the same as the last inserted hit. Do not add it to the pattern.");
            return std::make_pair(CompatibilityResult::eRejectHit, 0.);
        }
        if (areConsecutiveMdt(*test.hit, *lastInsertedHit.hit)) {
            ATH_MSG_VERBOSE("The test hit is in the same layer of the last inserted one. They are consecutive MDT hits, so they are compatible.");
            return std::make_pair(CompatibilityResult::eAddHit, 0.);
        }
        if (pattern.nInsertedHits == 0) {
            ATH_MSG_VERBOSE("The test hit is in the same layer of the seed. They are not consecutive MDT hits, so they are not compatible.");
            return std::make_pair(CompatibilityResult::eRejectHit, 0.);
        }
        std::size_t n {2};
        while (n < pattern.nInsertedHits) {
            auto [hit, st] {pattern.getNthLastHit(n)};
            if (checkLayerOrdering(test, hit, testStation, st) != LayerOrdering::eSameLayer) {
                return checkResidualInWindow(hit, false);
            }
            ++n;
        }
        return checkResidualInWindow(pattern.getNthLastHit(n).first, false);
    }
    return checkResidualInWindow(lastInsertedHit, true);
}

computeAcceptanceWindow()

double MuonR4::FastReco::GlobalPatternFinder::computeAcceptanceWindow ( const HitPayload & testHit, const HitPayload & seed, const HitPayload & lastPatHit, const double lineSlope, const bool useSeed2Beamspot, const Amg::Vector3D & beamSpot ) const

private

Method to compute the acceptance window in global R for a given pattern line and test hit.

Parameters

testHit	test hit information
seed	seed hit information
lastPatHit	last hit in the pattern, used to compute the pattern line
lineSlope	pattern line slope in the R-Z plane
useSeed2Beamspot	whether we used the beamspot instead of the last pattern hit to compute the pattern line with the seed
beamspot	beamspot global position

Returns

: the acceptance window in global R of the test hit given the pattern line

The acceptance window is defined according to the error propagation law for the residual. We have a contribution given by the geometrical amplification of the measurement error and a contribution from the uncertainty in the line slope

Reference z: last hit in the pattern or beamspot

Alpha parameter determining the propagation/ line extrapolation magnitude

Definition at line 426 of file GlobalPatternFinder.cxx.

                                                                                          {
    const double geometricalFactor {1.+ Acts::square(lineSlope)};
    const double& refZ {useSeed2Beamspot ? beamSpot.z() : lastPatHit.Z};
    const double alpha {(testHit.Z-seed.Z) / (refZ - seed.Z)};
    const double propagationFactor {1. - alpha + Acts::square(alpha)};
    ATH_MSG_VERBOSE("Computing the acceptance window... Geometrical Factor: " << std::sqrt(geometricalFactor) << " alpha: " << alpha
                    << ", Propagation Factor: " << std::sqrt(propagationFactor) << ", Computed Window: " << m_cfg.baseRWindow * std::sqrt(geometricalFactor * propagationFactor));
    return m_cfg.baseRWindow * std::sqrt(2*geometricalFactor * propagationFactor);
}

computeLineSlope()

double MuonR4::FastReco::GlobalPatternFinder::computeLineSlope ( const HitPayload & lastPatHit, const HitPayload & seed, const bool useSeed2Beamspot, const Amg::Vector3D & beamSpot ) const

private

Helper method to compute the line slope between the seed and the last hit in a given pattern in the R-Z plane.

Parameters

lastPatHit	reference to the last hit in the pattern
seed	seed hit information
useSeed2Beamspot	whether we should use the beamspot instead of the last pattern hit to compute the pattern line with the seed
beamSpot	beamspot global position

Returns

: the pattern line slope in the R-Z plane

Safe-guard check: if we are inserting the first hit or if the last pattern hit and the seed are too close in Z, we use the beamspot

Definition at line 405 of file GlobalPatternFinder.cxx.

                                                                                   {
    const double deltaR {(useSeed2Beamspot ? beamSpot.perp() - seed.R : lastPatHit.R - seed.R) };
    const double deltaZ {(useSeed2Beamspot ? beamSpot.z() - seed.Z : lastPatHit.Z - seed.Z)};
    ATH_MSG_VERBOSE("Computing line seed-to-lastPatHit... deltaR = " << lastPatHit.R - seed.R << ", deltaZ = " << lastPatHit.Z - seed.Z 
                    << ", we use" << (useSeed2Beamspot ? " beamSpot" : " lastPatHit") << " giving " << std::format("deltaR_slope: {}, deltaZ_slope: {}", deltaR, deltaZ)
                    << ". The line slope is: " << deltaR / deltaZ);
    return deltaR / deltaZ;
}

computeResidual()

double MuonR4::FastReco::GlobalPatternFinder::computeResidual ( const HitPayload & testHit, const HitPayload & seed, const double lineSlope ) const

private

Method to compute the residual in globalR given the pattern line and test hit.

Parameters

testHit	test hit information
seed	seed hit information
lineSlope	pattern line slope in the R-Z plane

Returns

: the residual in global R of the test hit with respect to the pattern line

Definition at line 418 of file GlobalPatternFinder.cxx.

                                                                             {
    const double signedResidual { testHit.R - seed.R - lineSlope * (testHit.Z - seed.Z)};
    ATH_MSG_VERBOSE("Computing residual... slope: " << lineSlope << ", deltaR_residual: " << (testHit.R - seed.R) << ", deltaZ_residual: " << (testHit.Z - seed.Z) << ", signed residual: " << signedResidual);
    return std::abs(signedResidual);
}

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.

Parameters

gctx	Geometry context
spacepoints	Vector of space point containers

Returns

: Constructed search tree

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

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

Definition at line 527 of file GlobalPatternFinder.cxx.

                                                                                       {
    SearchTree_t::vector_t rawData{};
    using SectorProjector = MsTrackSeeder::SectorProjector;
    for (const SpacePointContainer* spc : spacepoints) {
        ATH_MSG_VERBOSE("Adding to the search tree "<<spc->size()<<" space point buckets");
        for (const SpacePointBucket* bucket : *spc) {
            ATH_MSG_VERBOSE("Processing " << bucket->size() << " spacepoint...");
            // We can have up to 3 entries per hit (when the hit does not measure phi).
            rawData.reserve(rawData.size() + 3*bucket->size());
            const int sector = bucket->msSector()->sector();
 
            for (const auto& hit : *bucket) {
                if (hit->isStraw() && !m_cfg.useMdtHits) {
                    continue;
                }
                const Amg::Vector3D globalPos {bucket->msSector()->localToGlobalTransform(gctx) * hit->localPosition()};
                // 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.
                for (const auto proj : {SectorProjector::leftOverlap, SectorProjector::center, SectorProjector::rightOverlap}) {
                    const int projSector = MsTrackSeeder::ringSector(sector + Acts::toUnderlying(proj));
                    const double phi {Acts::VectorHelpers::phi(globalPos)};
                    if (hit->measuresPhi() && proj != SectorProjector::center && 
                        !sectorMap.insideSector(projSector, phi)) {
                        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" Hit @"<< *hit
                            <<" is not in sector "<<projSector<<" which is "<<MsTrackSeeder::to_string(proj) <<" to "<< sector);
                        continue;
                    }
                    std::array<double, 2> coords{};
                    coords[Acts::toUnderlying(SeedCoords::eTheta)] = Acts::VectorHelpers::theta(globalPos);

                    coords[Acts::toUnderlying(SeedCoords::eSector)] = MsTrackSeeder::ringOverlap(2*sector + Acts::toUnderlying(proj));
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" Add hit @"<< *hit 
                                            <<"\nwith global position "<<Amg::toString(globalPos) <<" and coordinates "<<coords<<" to the search tree");
                    rawData.emplace_back(std::move(coords), 
                                         HitPayload{hit.get(), bucket, spc, globalPos.perp(), globalPos.z(), phi});
                }  
            }
        }
    }
    ATH_MSG_VERBOSE("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

Definition at line 492 of file GlobalPatternFinder.cxx.

                                                                                   {
    GlobalPattern::HitCollection hitPerStation{};
    for (const auto& [station, hits] : cache.hitsPerStation) {
        auto& out = hitPerStation[station];
        out.reserve(hits.size());
        std::ranges::transform(hits, std::back_inserter(out), [](const HitPayload& h){ return h.hit;});
    }
    GlobalPattern pattern{std::move(hitPerStation)};
    pattern.setTheta(cache.theta);
    pattern.setPhi(cache.phi);
    // Set the pattern sector(s) and theta.
    const int& secCoord = cache.sectorCoord;
    pattern.setSector((secCoord - secCoord % 2) / 2);
    pattern.setSecondarySector((secCoord + secCoord % 2) / 2);
    // Set pattern quality information.
    pattern.setNPrecisionHits(cache.nPrecisionHits);
    pattern.setNEtaNonPrecisionHits(cache.nBendingTriggerHits);
    pattern.setNPhiHits(cache.nPhiHits);
    pattern.setTotalResidual(cache.totalResidual);
    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 515 of file GlobalPatternFinder.cxx.

                                                                        {
    PatternVec patterns{};
    patterns.reserve(cache.size());
    std::transform(cache.begin(), cache.end(), std::back_inserter(patterns), [this](const PatternState& cacheEntry) {
        GlobalPattern pattern {convertToPattern(cacheEntry)};
        ATH_MSG_VERBOSE("Converted new pattern "<<pattern);
        return pattern;
    });
    return patterns;
}

extendPatterns()

void MuonR4::FastReco::GlobalPatternFinder::extendPatterns ( PatternStateVec & activePatterns, const HitPayload & test, const StIndex testStation, const HitPayload & seed, const HitPayload & prevCandidate, const StIndex prevCandidateStation, PatternHitVisualInfoVec * visualInfo = nullptr ) const

private

Function testing 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

activePatterns	Vector of active patterns to be extended
testPair	TreeNode (Hit with its tree coordinates) corresponding to the hit to be tested
testStation	Station index of the hit to be tested
seed	Seed hit information
prevCandidate	Previous candidate hit information
prevCandidateStation	Station index of the previous candidate hit (used to check the layer ordering)
visualInfo	Pointer to visual information for pattern visualization (nullptr if the VisualizationTool is disabled)

Check angular compatibility of the test hit and the pattern

Add the test hit to the pattern

We branch only once, otherwise we would create duplicate patterns

Branch the pattern: we clone it and overwrite the existing hit with the test hit. Watch out, from now on lastPatHit will be the test hit

Update visual information of the original pattern

Add the new pattern to the list of next patterns

Definition at line 234 of file GlobalPatternFinder.cxx.

                                                                                    {
    PatternStateVec nextPatterns{};
    nextPatterns.reserve(activePatterns.size()* 2);
 
    const unsigned refMissedLayerHits {std::ranges::min_element(activePatterns,
            [](const auto& a, const auto& b) { return a.nMissedLayerHits < b.nMissedLayerHits; }
        )->nMissedLayerHits};
    
    for (PatternState& pattern : activePatterns) {
 
        if (pattern.nMissedLayerHits >= m_cfg.maxMissedLayerHits && (!nextPatterns.empty() || pattern.nMissedLayerHits > refMissedLayerHits)) {
            ATH_MSG_VERBOSE("Pattern " << pattern << " has already missed " << pattern.nMissedLayerHits << " hits in different layers, which is above the maximum allowed. Do not try to extend it with new hits.");
            addVisualInfo(pattern, PatternHitVisualInfo::PatternStatus::eFailed, visualInfo);
            continue;
        }

        auto [result, residual] = checkLineCompatibility(seed, test, testStation, pattern);
        switch (result) {
            case CompatibilityResult::eAddHit: {
                pattern.addHit(test, testStation, residual);
                ATH_MSG_VERBOSE("Hit is compatible, add it to the pattern. Updated pattern: " << pattern);
                break;
            }
            case CompatibilityResult::eBranchPattern: {
                auto isNew = std::ranges::find_if(nextPatterns, [&test](const PatternState& p) {
                        auto [hitRef, _] = p.getNthLastHit(1u);
                        return hitRef.get() == test;
                    }) == nextPatterns.end();
                if (!isNew) {
                    ATH_MSG_VERBOSE("Hit is compatible & in the same layer of the last added hit. The branched pattern is already in the list of next patterns. Do not add it again.");
                    continue;
                }
                PatternState newPattern {pattern};
                const auto [lastHitRef, _] {pattern.getNthLastHit(1u)};
                const HitPayload& lastPatHit {lastHitRef.get()};
                newPattern.overWriteHit(lastPatHit, test, testStation, residual);
                ATH_MSG_VERBOSE("Hit is compatible & in the same layer of the last added hit. Branch the pattern, new pattern: " << newPattern);
                if (pattern.visualInfo) {
                    pattern.visualInfo->replacedHits.push_back(test.hit);
                    newPattern.visualInfo->replacedHits.push_back(lastPatHit.hit);
                }
                nextPatterns.push_back(std::move(newPattern));
                break;
            }
            case CompatibilityResult::eRejectHit: {
                ATH_MSG_VERBOSE("Hit is not compatible with the pattern.");
                if (pattern.visualInfo) {
                    pattern.visualInfo->discardedHits.push_back(test.hit);
                }
                if (checkLayerOrdering(test, prevCandidate, testStation, prevCandidateStation) != LayerOrdering::eSameLayer){
                    pattern.nMissedLayerHits++;
                }
                break;
            }
        }
        nextPatterns.push_back(std::move(pattern));
    }
    std::swap(activePatterns, nextPatterns);
};

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

Find patterns in eta first

Fill the output buckets

Plot patterns

Definition at line 78 of file GlobalPatternFinder.cxx.

                                                                        {                                
    SearchTree_t orderedSpacepoints {constructTree(gctx, spacepoints)};
    auto visualInfo {m_cfg.visionTool ? std::make_unique<PatternHitVisualInfoVec>() : nullptr};
    PatternStateVec patterns{findPatternsInEta(orderedSpacepoints, visualInfo.get())};
 
    // TO DO search for phi hits snd attach them to (compatible) patterns
    
    for (const PatternState& pat : patterns) {
        for (const auto& [spc, bucketVec] : pat.bucketsPerContainer) {
            if (outBuckets.find(spc) == outBuckets.end()) {
                throw std::runtime_error("The space point container associated to the pattern is not present in the output bucket map.");
            }
            for (const SpacePointBucket* bucket : bucketVec) {
                outBuckets[spc].push_back(bucket);
            }
        }
    }
    if (visualInfo) {
        m_cfg.visionTool->plotPatternBuckets(Gaudi::Hive::currentContext(), "GlobPatternFinder", 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 building of patterns in eta.

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)

Returns

: resulting vector of PatternStates successfully built

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

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

check how many existing patterns contain this hit

Define the search range.

Allowing just one value for the expanded sector range, we also include patterns extending in the overlap region of neighbouring physical sectors

Pattern search is performed within a theta window of size m_thetaSearchWindow. This window corresponds to the maximum allowed theta spread for the target pT.

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.

Initialize a pattern from the seed hit

Helper function to process a new candidate hit. During pattern building, we can have pattern branching when the initial pattern is compatible with multiple hits in the same layer. These patters will be stored in activePatterns. For each new hit, extendPatterns will try to extend every active pattern and remove the ones not meeting continuation criteria.

Only-phi measurement will be treated later

Helper funtion insuring we have at the end one pattern for seed hit. If multiple survived at the end, we keep the best.

First search for compatible hits from the seed layer onwards

Then try to proceed toward the innermost layer

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

Definition at line 108 of file GlobalPatternFinder.cxx.

                                                                                     {
    constexpr auto thetaIdx {Acts::toUnderlying(SeedCoords::eTheta)};
    constexpr auto sectorIdx {Acts::toUnderlying(SeedCoords::eSector)};
    PatternStateVec patterns{};
    using enum SeedCoords;
    for (const auto seedingLayer : m_cfg.layerSeedings) {
        ATH_MSG_VERBOSE("Start pattern search in eta with seeding layer "<< layerName(seedingLayer));
        for (const auto& [seedCoords, seed] : orderedSpacepoints) {
            const SpacePoint* seedHit {seed.hit};
            const StIndex seedStation {m_cfg.idHelperSvc->stationIndex(seedHit->identify())};
            const LayerIndex seedLayer {toLayerIndex(seedStation)};
            if (seedLayer != seedingLayer || !seedHit->measuresEta() || (seedHit->isStraw() && !m_cfg.seedFromMdt)) {
                continue;
            }
            auto nExistingPatterns {std::ranges::count_if(patterns, [&seed, &seedStation](const PatternState& pattern){
                return pattern.isInPattern(seed, seedStation);
            })};
            if (nExistingPatterns >= m_cfg.maxSeedAttempts) {
                ATH_MSG_DEBUG("The seed hit "<<*seedHit<<"\n coordinates "<<seedCoords<<" has already been used to build "<<nExistingPatterns<<" patterns, which is above the maximum number of attempts allowed to build a pattern from hits already used in existing patterns. Do not use it as seed for a new pattern.");
                continue;
            }    
            SearchTree_t::range_t selectRange{};
            selectRange[sectorIdx].shrink(seedCoords[sectorIdx] - 0.1, seedCoords[sectorIdx] + 0.1); 
            const double thetaWindow {(seedLayer == LayerIndex::Inner || seedLayer == LayerIndex::Outer) 
                                    ? m_cfg.thetaSearchWindow : 0.5*m_cfg.thetaSearchWindow};
            selectRange[thetaIdx].shrink(seedCoords[thetaIdx] - thetaWindow, seedCoords[thetaIdx] + thetaWindow);
            auto candidateHits = orderedSpacepoints.rangeSearchWithKey(selectRange);
            if (candidateHits.size() < m_cfg.minBendingTriggerHits + m_cfg.minBendingPrecisionHits) {
                ATH_MSG_VERBOSE("Found "<<candidateHits.size()<<" candidate hits for seed hit "<<*seedHit<<", coordinates "<<seedCoords
                                <<". This is below the minimum number of hits required to build a pattern. Do not create a pattern.");
                continue;
            }
            if (std::ranges::find_if(candidateHits, [this, seedLayer](const auto& c){
                    return m_cfg.idHelperSvc->layerIndex(c.second.hit->identify()) != seedLayer;
                    }) == candidateHits.end()) {
                ATH_MSG_VERBOSE("All candidate hits for seed hit "<<*seedHit<<", coordinates "<<seedCoords
                                <<" are in the same layer. We need hits in at least two layers to build a pattern. Do not create a pattern.");
                continue;
            }
            std::ranges::sort(candidateHits, [this](const auto& c1, const auto& c2){
                const HitPayload& hit1 {c1.second};
                const HitPayload& hit2 {c2.second};
                StIndex station1 {m_cfg.idHelperSvc->stationIndex(hit1.hit->identify())};
                StIndex station2 {m_cfg.idHelperSvc->stationIndex(hit2.hit->identify())};
                LayerOrdering ordering {checkLayerOrdering(hit1, hit2, station1, station2)};
                if (ordering == LayerOrdering::eSameLayer) {
                    return hit1.hit->localPosition().y() < hit2.hit->localPosition().y();
                }
                return ordering == LayerOrdering::eLowerLayer;
            });
            const auto seedItr {std::ranges::find_if(candidateHits,
                [&seed](const auto& c){ return c.second == seed; })};
            assert(seedItr != candidateHits.end());
            std::vector<PatternState> activePatterns{};
            activePatterns.emplace_back(seed, seedStation, static_cast<int>(seedCoords[sectorIdx]), seedCoords[thetaIdx]);
            if (visualInfo) {
                activePatterns.back().visualInfo = std::make_unique<PatternHitVisualInfo>(seedHit, seedCoords[thetaIdx] - thetaWindow, seedCoords[thetaIdx] + thetaWindow);
            }
 
            const HitPayload* prevCandidate {&seed};
            StIndex prevCandidateStation {seedStation};
            auto processNewHit = [&](const TreeNode& testPair){
                const HitPayload& test {testPair.second};
                const SpacePoint* testHit {testPair.second.hit};
                if (!testHit->measuresEta()) {
                    return;
                }
                const StIndex testStation {m_cfg.idHelperSvc->stationIndex(testHit->identify())};
                ATH_MSG_VERBOSE("** Check compatibility of hit "<<*testHit<<", coordinates "<<testPair.first << ". We start from " << activePatterns.size() << " active patterns.");
                extendPatterns(activePatterns, test, testStation, seed, *prevCandidate, prevCandidateStation, visualInfo);
                prevCandidate = &test;
                prevCandidateStation = testStation;
            };
            auto ensureOnePattern = [&activePatterns, &visualInfo, this]() {
                if (activePatterns.size() > 1) {
                    ATH_MSG_VERBOSE("Found "<<activePatterns.size()<<" patterns during the search. Remove overlaps.");
                    activePatterns = resolveOverlaps(std::move(activePatterns), visualInfo);
                    resetVisualToOverlap(visualInfo);
                    assert(activePatterns.size() == 1);
                }
            };
            activePatterns.back().nInsertedHits = 0;
            ATH_MSG_VERBOSE("Search between " << candidateHits.size() <<" candidates for compatible hits to "<<*seedHit<<", coordinates: "<<seedCoords);
            for (auto it = std::next(seedItr); it != candidateHits.end(); ++it) {
                processNewHit(*it);
            }
            ensureOnePattern();
            activePatterns.back().nInsertedHits = 0;
            for (auto it = std::reverse_iterator(seedItr); it != candidateHits.rend(); ++it) {
                processNewHit(*it);
            }
            ensureOnePattern();
            PatternState newPattern {std::move(activePatterns.back())};
            if (newPattern.nBendingTriggerHits < m_cfg.minBendingTriggerHits || newPattern.nPrecisionHits < m_cfg.minBendingPrecisionHits) {
                ATH_MSG_VERBOSE("Pattern " << newPattern << " does not meet minimum hit requirements, n bending precision/trigger hits = " << newPattern.nPrecisionHits << "/" << newPattern.nBendingTriggerHits << ". Do not create a pattern.");
                addVisualInfo(newPattern, PatternHitVisualInfo::PatternStatus::eFailed, visualInfo);
                continue;
            }
            newPattern.finalizePattern();
            ATH_MSG_VERBOSE("Add new pattern "<<newPattern);
            patterns.push_back(std::move(newPattern));
        }
    }
    ATH_MSG_VERBOSE("Found in total "<<patterns.size()<<" patterns in eta before overlap removal");
    return resolveOverlaps(std::move(patterns), 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;
  }
}

isPhiCompatible()

bool MuonR4::FastReco::GlobalPatternFinder::isPhiCompatible ( const HitPayload & test, const HitPayload & seed, const PatternState & pattern ) const

private

Method to check the phi compatibility of a test hit with a given pattern.

Parameters

seed	seed hit information
test	test hit information
pattern	pattern to be extended

Returns

: true if the test hit is phi compatible with the pattern, false otherwise

If the test hits does not measure phi but the pattern has already a phi, we check that the pattern is within the test hit sector.

If the test hit measures phi we check that it's compatible with the pattern phi, if avalilable, which is the average of the phi values of accepted hits of the pattern. If the pattern doesn't have a defined phi yet, we check that the test hit is in the same sector as the seed hit

Definition at line 378 of file GlobalPatternFinder.cxx.

                                                                             {
    const SpacePoint* testHit {test.hit};
    const SpacePoint* seedHit {seed.hit};
    if (!testHit->measuresPhi()) {
        if (pattern.nPhiHits && !sectorMap.insideSector(testHit->msSector()->sector(), pattern.phi)) {
            ATH_MSG_VERBOSE("The pattern with phi = "<<inDegrees(pattern.phi)<<" is not inside the sector of the test hit: "<<testHit->msSector()->sector());
            return false;
        }
    } else {
        if (pattern.nPhiHits) {
            if (std::abs(CxxUtils::deltaPhi(pattern.phi, test.phi)) > m_cfg.phiTolerance) {
                ATH_MSG_VERBOSE("The pattern with phi = "<<inDegrees(pattern.phi)<<" is not compatible with the test hit with phi "<<inDegrees(test.phi));
                return false;
            }
        } else if (!sectorMap.insideSector(seedHit->msSector()->sector(), test.phi)) {
            ATH_MSG_VERBOSE("The test hit with phi = "<<inDegrees(test.phi)<<" is not inside the sector of the seed hit: "<<seedHit->msSector()->sector());
            return false;
        }
    }
    return true;
}

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

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

Determine if one pattern is better than another

Definition at line 447 of file GlobalPatternFinder.cxx.

                                                                                   {
    PatternStateVec outputPatterns{};
    outputPatterns.reserve(toResolve.size());
    auto areOverlapping = [this](const PatternState& a, const PatternState& b) {
        const bool isSectorOverlap {a.sectorCoord == b.sectorCoord || 
            (std::abs(a.sectorCoord - b.sectorCoord) == 1 && std::abs(a.phi - b.phi) <= m_cfg.phiTolerance)};
        return isSectorOverlap && std::abs(a.theta - b.theta) <= m_cfg.thetaSearchWindow;
    };
    auto isBetter = [](const PatternState& a, const PatternState& b) {
        if (a.nBendingTriggerHits != b.nBendingTriggerHits) {
            return a.nBendingTriggerHits > b.nBendingTriggerHits;
        }
        if (a.nPrecisionHits != b.nPrecisionHits) {
            return a.nPrecisionHits > b.nPrecisionHits;
        }
        return a.totalResidual < b.totalResidual;
    };
    for (auto it = toResolve.begin(); it != toResolve.end(); ++it) {
        if (it->isOverlap) {
            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 (isBetter(*it, *jt)) {
                jt->isOverlap = true;
            } else {
                it->isOverlap = true;
                break;
            }
        }
        addVisualInfo(*it, it->isOverlap ? PatternHitVisualInfo::PatternStatus::eOverlap 
                                                        : PatternHitVisualInfo::PatternStatus::eSuccessful, visualInfo);
        if (!it->isOverlap) {
            outputPatterns.push_back( std::move(*it));
        }
    }
    ATH_MSG_VERBOSE("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;
}

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

{};

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx