MuonR4::FastReco::GlobalPatternFinder::PatternState Struct Reference

Pattern state object storing pattern information during construction. More...

Collaboration diagram for MuonR4::FastReco::GlobalPatternFinder::PatternState:

Public Member Functions
	PatternState (const CandidateHit &seed, const std::int8_t expSector, const double seedTheta, const Config *cfg, const AthMessaging *logger)
	Constructor taking the seed information.
	PatternState ()=delete
	Delete default destructor - ensure patterns are always constructed from a seed or another pattern.
	PatternState (PatternState &&other) noexcept=default
	Move constructor.
PatternState &	operator= (PatternState &&other) noexcept=default
	Move assignment operator.
	PatternState (const PatternState &other)=default
	Copy constructor.
PatternState &	operator= (const PatternState &other)=default
	Copy assignment operator.
	~PatternState ()=default
	Destructor.
void	addHit (const CandidateHit &hit, const double residual, const double acceptWindow)
	Add a hit to the pattern and update the internal state.
void	overWriteHit (const CandidateHit &newHit, const double newResidual, const double newAcceptWindow)
	Overwrite the hits on the last layer with the new one.
LineTestRes	checkLineComp (const CandidateHit &testHit, const Amg::Vector3D &beamSpot)
	Method checking line compatibility of a test hit against the pattern.
LineTestRes	computeLineResidual (const CandidateHit &testHit) const
	Method to compute the residual of a test hit against the pattern line.
bool	isPhiCompatible (const double testPhi) const
	Method to check the phi compatibility of a test hit with a given pattern.
bool	isInPattern (const HitPayload &hit) const
	Check wheter a hit is present in the pattern.
void	finalizePatternEta ()
	Finalize the pattern building in eta and update its state.
void	finalizePatternPhi ()
	Finalize the pattern building in phi and update its state.
void	moveLineAnchorHit (const CandidateHit &refHit)
	Move the line anchor hit given a reference hit.
void	updateLineParameters (const Amg::Vector3D &beamSpot)
	Update the line parameters based on the current hits.
double	getMeanResidual2 () const
	Return the mean normalized residual squared.
uint8_t	nBendingHits () const
	Return the number of hits in bending coordinate.
uint8_t	nBendingLayers () const
	Return the number of layers in bending coordinate.
uint8_t	nStations (const bool onlyGoodStations) const
	Method returning the number of stations.
uint8_t	nMDTLastLayer () const
	Gives the number of MDT hits on the last layer.
std::vector< const SpacePointBucket * >	getParentBuckets () const
	Get the buckets associated with the pattern.
bool	isInLastLayer (const CandidateHit &hit) const
	Check whether a given hit is in the last layer.
bool	operator== (const PatternState &other) const =delete
	Patterns are considered identical if they have the same hit content.
void	print (std::ostream &ostr, bool detailed) const
	Print the pattern candidate.

Public Attributes
const Config *	cfg {nullptr}
	Pointer to cfg option.
const AthMessaging *	logger {nullptr}
	Logger.
Acts::CloneablePtr< PatternHitVisualInfo >	visualInfo {nullptr}
	Pointer to Visual Information for pattern visualization.
CandidateHit	lastInsertedHit {}
	Pointer to the last inserted hit.
CandidateHit	prevLayerHit {}
	Pointer to the last hit in the second-to-last layer.
CandidateHit	lineAnchorHit {}
	Pointer to the line anchor hit.
double	theta {0.}
	Average theta & average phi of the pattern.
double	phi {0.}
double	meanNormResidual2 {0.}
	Mean over eta hits of the square of their residual divided by acceptance window.
double	lastResidual {0.}
	Residual & acceptance window of the last inserted hit (needed when replacing a hit).
double	lastAcceptWindow {0.}
double	lineSlope {0.}
	Simple line model: slope and associated delta Z, i.e.
double	dZ_slope {0.}
double	LR_factor {-1.}
	Simple line model: factor for LR correction to be applied.
double	anchorZ {0.}
	Simple line model: anchor Z and R.
double	anchorR {0.}
ExpandedSector	expSect {static_cast<int8_t>(0)}
	expanded MS sector
uint8_t	nPrecisionLayers {0u}
	Counts of precision / non-precision / phi layers.
uint8_t	nTriggerLayers {0u}
uint8_t	nPhiLayers {0u}
bool	isFinalized {false}
	Flag to indicate if the pattern has been finalized.
bool	isOverlap {false}
	Flag to indicate if the pattern is overlapping with another one, used during overlap removal.
bool	useBeamspot {false}
	Whether we used the beamspot to compute the line parameters.
bool	needLineUpdate {false}
	Whether we need to update the pattern line the next time we find a hit in a new layer.
std::array< uint8_t, s_nStations >	nMeasurementLayers {}
	Counts of measurement layers per station.
std::array< std::vector< CandidateHit >, s_nStations >	hitsPerStation {}
	Map collection of hits per station.
std::vector< HitPayload >	phiOnlyHits {}
	Array holding phi-only hits.

Detailed Description

Pattern state object storing pattern information during construction.

Definition at line 190 of file GlobalPatternFinder.h.

Constructor & Destructor Documentation

PatternState() [1/4]

MuonR4::FastReco::GlobalPatternFinder::PatternState::PatternState	(	const CandidateHit &	seed,
		const std::int8_t	expSector,
		const double	seedTheta,
		const Config *	cfg,
		const AthMessaging *	logger )

Constructor taking the seed information.

Parameters

seed	seed hit
expSector	expanded sector coordinate
seedTheta	global theta of the seed

Update the hit counts in bending direction

Update the phi of the pattern

Add now the new hit

Definition at line 766 of file GlobalPatternFinder.cxx.

        : cfg{cfg},
          logger{logger},
          lastInsertedHit{seed},
          prevLayerHit{seed},
          lineAnchorHit{seed},
          theta{seedTheta},
          expSect{ExpandedSector{expSector}} {
          
    nMeasurementLayers[Acts::toUnderlying(seed.station)]++;
    if (seed->isPrecision) nPrecisionLayers++;
    else nTriggerLayers++;
    if (seed->sp()->measuresPhi()) {
        phi = seed->phi;
        nPhiLayers++;
    }
    hitsPerStation[Acts::toUnderlying(seed.station)].push_back(seed);
    needLineUpdate = true;
}

PatternState() [2/4]

MuonR4::FastReco::GlobalPatternFinder::PatternState::PatternState ( )

delete

Delete default destructor - ensure patterns are always constructed from a seed or another pattern.

PatternState() [3/4]

MuonR4::FastReco::GlobalPatternFinder::PatternState::PatternState ( PatternState && other )

defaultnoexcept

Move constructor.

Parameters

other

other pattern state to move from

PatternState() [4/4]

MuonR4::FastReco::GlobalPatternFinder::PatternState::PatternState ( const PatternState & other )

default

Copy constructor.

Parameters

other

other pattern state to copy from

~PatternState()

MuonR4::FastReco::GlobalPatternFinder::PatternState::~PatternState ( )

default

Destructor.

Member Function Documentation

addHit()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::addHit	(	const CandidateHit &	hit,
		const double	residual,
		const double	acceptWindow )

Add a hit to the pattern and update the internal state.

Parameters

hit	hit to be added
residual	residual of the hit
acceptWindow	acceptance window

Update the pointers to previous layer hit

Update the hit counts in bending direction

Update the phi of the pattern if there are no phi hits yet

Add now the new hit

Update the residual. Since we can also add consecutive MDT hits without updating the residual, we need to check the accept window

Definition at line 1004 of file GlobalPatternFinder.cxx.

                                                                          {
    
    if (hit.globLayer != lastInsertedHit.globLayer) {
        prevLayerHit = lastInsertedHit;

        nMeasurementLayers[Acts::toUnderlying(hit.station)]++;
        if (hit->isPrecision) nPrecisionLayers++;
        else nTriggerLayers++;
        if (hit.sp()->measuresPhi()) {
            if (nPhiLayers == 0) phi = hit->phi;
            nPhiLayers++;
        }
    }
    hitsPerStation[Acts::toUnderlying(hit.station)].push_back(hit);
    lastInsertedHit = hit;

    if (acceptWindow > 0.) {
        meanNormResidual2 += Acts::square(residual / acceptWindow);
        lastAcceptWindow = acceptWindow;
        lastResidual = residual;
    }
    // If the new compatible hit is in a different station, update the line anchor
    if (hit.station != lastInsertedHit.station) {
        moveLineAnchorHit(hit);
    }
    needLineUpdate = true;
}

checkLineComp()

GlobalPatternFinder::LineTestRes MuonR4::FastReco::GlobalPatternFinder::PatternState::checkLineComp	(	const CandidateHit &	testHit,
		const Amg::Vector3D &	beamSpot )

Method checking line compatibility of a test hit against the pattern.

Parameters

testHit	test hit information
beamSpot	Beam spot position, needed to update the pattern line

Returns

: result of the test, including the computed line residual and acceptance window

Helper function to make the result

Parameters

decision

The decision for the test result if the residual is within the acceptance window

Returns

The test result

Sanity check: Test hit coincides with the last inserted hit

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

If they are not consecutive MDT hits && all insterted hits are on the same layer

If the primary measurement is the same and both measure phi, we keep the most compatibble in phi

sTGCs: we can have trigger hits (Pad) and precision hits (strip) on the same layer

Test hit is a trigger hit and last inserted is precision, keep the precision hit

Test hit is a precision hit and last inserted is trigger, if compatible we overwrite the last inserted hit

Definition at line 793 of file GlobalPatternFinder.cxx.

                                                                              {
    // We test hits in the same **expanded** sector, so we need just to compare hit's phi with the pattern's phi, if both available
    if (nPhiLayers) {
        const double maxPhiDiff {testHit.sp()->measuresPhi() ? 
            cfg->phiTolerance : sectorMap.sectorWidth(testHit.sector)};
        if (std::abs(CxxUtils::deltaPhi(phi, static_cast<double>(testHit->phi))) > maxPhiDiff) {
            PRINT_VERBOSE(__func__<<"() The pattern with phi = "<<inDegrees(phi)
                <<" is not compatible with the test hit with phi "<<inDegrees(testHit->phi) << " - reject.");
            return LineTestRes{};
        }
    }
    
    auto makeResult = [&testHit, this](const LineTestDecision decision) -> LineTestRes {
        LineTestRes res{computeLineResidual(testHit)};
        if (res.residual < res.accWindow) {
            res.result = decision;
        }
        if (visualInfo) {
            visualInfo->hitLineInfo[testHit.sp()] = std::make_pair(lineSlope, res.accWindow);
        }
        return res;
    };
 
    /*************** Test hit is on a new layer — draw line from line anchor to lastHit */
    if(testHit.globLayer != lastInsertedHit.globLayer) {
        updateLineParameters(beamSpot);
        return makeResult(LineTestDecision::eAddHit);
    }
    /*************** Test hit is on the same layer as the last inserted hit ***************/
    if (testHit == lastInsertedHit) {
        PRINT_VERBOSE(__func__<<"() Test hit is the same as last inserted hit - reject.");
        return LineTestRes{};
    }
    if (areConsecutiveMdt(testHit, lastInsertedHit)) {
        return LineTestRes{LineTestDecision::eConsecutiveMdt, -1., -1.};
    }
    if (lineAnchorHit.globLayer == lastInsertedHit.globLayer) {
        PRINT_VERBOSE(__func__<<"() Test hit on same layer as seed with no prior hits, but not consecutive MDT hits - reject.");
        return LineTestRes{};
    }
    if (testHit.sp()->primaryMeasurement() == lastInsertedHit.sp()->primaryMeasurement()) { 
        if (testHit.sp()->measuresPhi() && !lastInsertedHit.sp()->measuresPhi()) {
            return makeResult(LineTestDecision::eOverwriteLastHit);
        }
        if (!testHit.sp()->measuresPhi() && lastInsertedHit.sp()->measuresPhi()) {
            return LineTestRes{};
        }
        if (nPhiLayers && std::abs(CxxUtils::deltaPhi(phi, static_cast<double>(testHit->phi))) < 
                        std::abs(CxxUtils::deltaPhi(phi, static_cast<double>(lastInsertedHit->phi)))) {
            return makeResult(LineTestDecision::eOverwriteLastHit);
        }
        return LineTestRes{};
    }
    if (testHit->isPrecision != lastInsertedHit->isPrecision) {
        if (lastInsertedHit->isPrecision) {
            PRINT_VERBOSE(__func__<<"() Test hit is a trigger hit and last inserted hit is precision on the same layer - keep the precision hit.");
            return LineTestRes{};
        }
        PRINT_VERBOSE(__func__<<"() Test hit is a precision hit and last inserted hit is trigger on the same layer - check residual...");
        return makeResult(LineTestDecision::eOverwriteLastHit);
    }
    return makeResult(LineTestDecision::eBranchPattern);
}

computeLineResidual()

GlobalPatternFinder::LineTestRes MuonR4::FastReco::GlobalPatternFinder::PatternState::computeLineResidual

(

const CandidateHit &

testHit

)

const

Method to compute the residual of a test hit against the pattern line.

Parameters

testHit

test hit information

Returns

: Test result holding the residual and acceptance window. The decision is set later.

The dynamic acceptance window is defined using the error propagation law for the residual. We have two contributions: the line extrapolation distance (propagation factor) and the uncertainty on the line slope (geometrical factor)

Alpha parameter determining the propagation/ line extrapolation magnitude

Loosen the window when using the beamspot as reference, as the line slope is less well defined

Apply LR correction if needed

Definition at line 945 of file GlobalPatternFinder.cxx.

                                                                                      {
    LineTestRes res{};
 
    // Compute the residual
    const double dZ_res {testHit.Z - anchorZ};
    res.residual = (testHit.R - anchorR) - lineSlope * dZ_res;

    const double geoFactor {1.+ Acts::square(lineSlope)};
    const double alpha {dZ_res / dZ_slope};  
    const double propFactor {1. - alpha + Acts::square(alpha)};
    res.accWindow = cfg->baseRWindow * std::sqrt(2*geoFactor * propFactor);
    if (useBeamspot) res.accWindow *= 1.5;
    if (testHit->station != lastInsertedHit.station ||
        (testHit->station != prevLayerHit.station && testHit.globLayer == lastInsertedHit.globLayer)) {
        res.accWindow *= 2.;
    }

    if (LR_factor > 0.) {
        const double LRcorrection {dZ_res * geoFactor * LR_factor};
        PRINT_VERBOSE(__func__<<"() signed residual: " << res.residual << " -> Apply LR correction: " << LRcorrection);
        res.residual = std::min(std::abs(res.residual-LRcorrection), std::abs(res.residual+LRcorrection));
    } else {
        res.residual = std::abs(res.residual);
    }
 
    PRINT_VERBOSE(__func__<<"() "<< brief(*this) << "\nUse beamspot: " << useBeamspot << ", Slope: " << lineSlope 
                                    << ", Residual: " << res.residual << ", Window: " << res.accWindow << ", Geometrical Factor: " 
                                    << std::sqrt(geoFactor) << ", Propagation Factor: " << std::sqrt(propFactor));
    return res;
}

finalizePatternEta()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::finalizePatternEta

(

)

Finalize the pattern building in eta and update its state.

This method is called at the end of pattern building in eta, so we don't have phi-only hits yet

Definition at line 1089 of file GlobalPatternFinder.cxx.

                                                         {
    theta = 0.; 
    for (const std::vector<CandidateHit>&  hits : hitsPerStation) {
        for (const auto& hit : hits) {
            theta += atan2(hit.R, hit.Z);
        }
    }
    theta /= nBendingHits();
}

finalizePatternPhi()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::finalizePatternPhi

(

)

Finalize the pattern building in phi and update its state.

If there are no phi hits, we just use the central phi of the sector/overlap region

Definition at line 1099 of file GlobalPatternFinder.cxx.

                                                         {
    if (!nPhiLayers) {
        phi = sectorMap.sectorOverlapPhi(expSect.msSector(), expSect.adjacentMsSector());
        return;
    }
    double deltaPhiAcc {0.};
    std::optional<double> centralPhi {};
    auto processPhiHit = [&deltaPhiAcc, &centralPhi](const HitPayload& hit){
        if (!hit->measuresPhi()) {
            return;
        }
        if (!centralPhi) {
            centralPhi = hit.phi;
        }
        deltaPhiAcc += CxxUtils::deltaPhi(static_cast<double>(hit.phi), *centralPhi);
    };
    for (const std::vector<CandidateHit>&  hits : hitsPerStation) {
        for (const auto& hit : hits) {
            processPhiHit(*hit);
        }
    }
    for (const HitPayload& hit : phiOnlyHits) {
        processPhiHit(hit);
    }
    phi = CxxUtils::wrapToPi(centralPhi.value_or(0.) + deltaPhiAcc / nPhiLayers);
}

getMeanResidual2()

double MuonR4::FastReco::GlobalPatternFinder::PatternState::getMeanResidual2

(

)

const

Return the mean normalized residual squared.

Definition at line 1143 of file GlobalPatternFinder.cxx.

                                                               {
    if (isFinalized) {
        return meanNormResidual2;
    }
    return meanNormResidual2 / nBendingLayers();
}

getParentBuckets()

std::vector< const SpacePointBucket * > MuonR4::FastReco::GlobalPatternFinder::PatternState::getParentBuckets

(

)

const

Get the buckets associated with the pattern.

Definition at line 1160 of file GlobalPatternFinder.cxx.

                                                                                           {
    std::vector<const SpacePointBucket*> buckets{};
    for (const std::vector<CandidateHit>&  hits : hitsPerStation) {
        for (const auto& hit : hits) {
            if (std::ranges::find(buckets, hit->bucket) == buckets.end()) {
                buckets.push_back(hit->bucket);
            }
        }
    }
    return buckets;
}

isInLastLayer()

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::isInLastLayer

(

const CandidateHit &

hit

)

const

Check whether a given hit is in the last layer.

Definition at line 1171 of file GlobalPatternFinder.cxx.

                                                                                 {
    if (lastInsertedHit.globLayer != hit.globLayer) {
        return false;
    }
    if (hit.isStraw) {
        const auto& stationHits {hitsPerStation[Acts::toUnderlying(hit.station)]};
        for (auto it = stationHits.rbegin(); it != stationHits.rend(); ++it) {
            if (it->globLayer != hit.globLayer) {
                return false;
            }
            if (*it == hit) {
                return true;
            }
        }
        return false;
    }
    return lastInsertedHit == hit;
}

isInPattern()

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::isInPattern

(

const HitPayload &

hit

)

const

Check wheter a hit is present in the pattern.

Parameters

hit	hit to be checked

Returns

: boolean indicating if the hit is in the pattern

Definition at line 1084 of file GlobalPatternFinder.cxx.

                                                                             {
    const auto& hits {hitsPerStation[Acts::toUnderlying(hit.station)]};
    return std::ranges::find_if(hits, 
        [&hit](const CandidateHit& c){ return *c == hit; }) != hits.end();                                           
}

isPhiCompatible()

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::isPhiCompatible

(

const double

testPhi

)

const

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

Parameters

testPhi

test global phi

Returns

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

We check that the test hit is compatible with the pattern phi, if available, which is given by the first phi measurement in the pattern. If the pattern doesn't have a phi yet, we check that the test hit is in the same pattern sector(s)

Definition at line 980 of file GlobalPatternFinder.cxx.

                                                                                {
    if (nPhiLayers) {
        if (std::abs(CxxUtils::deltaPhi(phi, testPhi)) > cfg->phiTolerance) {
            PRINT_VERBOSE(__func__<<"() The pattern with phi = "<<inDegrees(phi)
                <<" is not compatible with the test hit with phi "<<inDegrees(testPhi));
            return false;
        }
    } else {
        const unsigned sector1 {expSect.msSector()};
        const unsigned sector2 {expSect.adjacentMsSector()};
        const bool isCompatible {sector1 == sector2 
            ? sectorMap.insideSector(sector1, testPhi)
            : sectorMap.insideSector(sector1, testPhi) && sectorMap.insideSector(sector2, testPhi)};
        if (!isCompatible) {
            PRINT_VERBOSE(__func__<<"() The test hit with phi = "<<inDegrees(testPhi)
                <<" is not inside the pattern sectors: "<<sector1<<" and "<<sector2);
            return false;
        }            
    }
    return true;
}

moveLineAnchorHit()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::moveLineAnchorHit

(

const CandidateHit &

refHit

)

Move the line anchor hit given a reference hit.

The anchor is defined as the closest hit in the closest station to the referece hit,

Definition at line 867 of file GlobalPatternFinder.cxx.

                                                                                  {
    // Treat first the special case where we have only one station
    if (nStations(/*onlyGoodStations=*/ false) < 2) {
        // If we call this method with only one station, it means that we inverted the hit search direction without
        // finding any hit in other stations beside the initial one. So the anchor is the last added hit.
        lineAnchorHit = lastInsertedHit;
        return;
    }
    // Find first the closest station to the reference station among the pattern stations
    const auto& closestStIt = std::ranges::min_element(hitsPerStation, std::ranges::less{},
        [&refHit](const auto& hits){
            if (hits.empty() || hits.front().station == refHit.station) {
                return std::numeric_limits<int>::max();
            }
            return std::abs(hits.front().globLayer - refHit.globLayer);
        });
 
    // Then find the closest hit in that station to the reference hit
    const auto& hits {*closestStIt};
    auto it {std::ranges::min_element(hits, std::ranges::less{},
        [&refHit](const CandidateHit& hit){
            return std::abs(hit.globLayer - refHit.globLayer); })};
    
    // Find how many hits in the same layer we have, to be able to set the line anchor at the central hit
    uint8_t nSameLayer {1u};
    for (auto jt = std::next(it); jt != hits.end() && jt->globLayer == it->globLayer; ++jt) {
        ++nSameLayer;
    }
    lineAnchorHit = *std::next(it, (nSameLayer - 1u) / 2u);
}

nBendingHits()

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nBendingHits

(

)

const

Return the number of hits in bending coordinate.

Definition at line 1135 of file GlobalPatternFinder.cxx.

                                                            {
    return std::accumulate(hitsPerStation.begin(), hitsPerStation.end(), uint8_t{0u}, 
        [](uint8_t acc, const auto& hits){
            return acc + hits.size(); });
}

nBendingLayers()

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nBendingLayers

(

)

const

Return the number of layers in bending coordinate.

Definition at line 1140 of file GlobalPatternFinder.cxx.

                                                              {
    return nPrecisionLayers + nTriggerLayers;
}

nMDTLastLayer()

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nMDTLastLayer

(

)

const

Gives the number of MDT hits on the last layer.

Definition at line 1149 of file GlobalPatternFinder.cxx.

                                                             {
    const auto& stationHits {hitsPerStation[Acts::toUnderlying(lastInsertedHit.station)]};
    uint8_t nMdtLastayer {0u};
    for (auto it = stationHits.rbegin(); it != stationHits.rend(); ++it) {
        if (it->globLayer != lastInsertedHit.globLayer) {
            break;
        }
        nMdtLastayer++;
    }
    return nMdtLastayer;
}

nStations()

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nStations

(

const bool

onlyGoodStations

)

const

Method returning the number of stations.

Parameters

onlyGoodStations

flag to indicate if only good stations should be counted, i.e. having a minimum number of hits

Definition at line 1126 of file GlobalPatternFinder.cxx.

                                                                                    {
    uint8_t nStations {0u};
    for (uint8_t st{0u}; st < s_nStations; ++st) {
        if (!hitsPerStation[st].empty() && (!onlyGoodStations || nMeasurementLayers[st] >= cfg->minStationLayers)) {
            nStations++;
        }
    }
    return nStations;
}

operator=() [1/2]

PatternState & MuonR4::FastReco::GlobalPatternFinder::PatternState::operator= ( const PatternState & other )

default

Copy assignment operator.

Parameters

other

other pattern state to copy from

operator=() [2/2]

PatternState & MuonR4::FastReco::GlobalPatternFinder::PatternState::operator= ( PatternState && other )

defaultnoexcept

Move assignment operator.

Parameters

other

other pattern state to move from

operator==()

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::operator== ( const PatternState & other ) const

delete

Patterns are considered identical if they have the same hit content.

However, map comparison is very expensive

overWriteHit()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::overWriteHit	(	const CandidateHit &	newHit,
		const double	newResidual,
		const double	newAcceptWindow )

Overwrite the hits on the last layer with the new one.

Parameters

newHit	new hit to replace with
newResidual	residual of the new hit
newAcceptWindow	acceptance window of the new hit
beamSpot	needed to update line parameters

Update the phi counts

Update the residual

Add now the new hit

Definition at line 1038 of file GlobalPatternFinder.cxx.

                                                                                   {
    const StIndex st {newHit.station};
    if (st != lastInsertedHit.station || lastInsertedHit.globLayer != newHit.globLayer) {
        throw std::runtime_error(std::format(
            "Trying to overwrite a hit in station/layer {}/{} with another one from station/layer {}/{}", 
                stName(lastInsertedHit.station), lastInsertedHit.globLayer, stName(st), newHit.globLayer));
    }
    /* We expect to overwrite hits of the same type (precision/trigger), since we only branch when we have 
     * compatible hits in the same layer, except for sTGC hits, where we have pad and strips in the same layer */
    if (lastInsertedHit->isPrecision != newHit->isPrecision) {
        if (/*lastInsertedHit->isPrecision ||*/ newHit.sp()->type() != xAOD::UncalibMeasType::sTgcStripType) {
            std::stringstream ss {};
            ss << "Trying to overwrite a hit with incompatible type\n";
            ss << "Old hit: " << **lastInsertedHit << ", isPrecision: " << lastInsertedHit->isPrecision << ", measuresEta: " << lastInsertedHit.sp()->measuresEta() << "\n";
            ss << "New hit: " << **newHit << ", isPrecision: " << newHit->isPrecision << ", measuresEta: " << newHit.sp()->measuresEta();
            throw std::runtime_error(ss.str());
        }
        nTriggerLayers--;
        nPrecisionLayers++;
    }
    if (lastInsertedHit.sp()->measuresPhi()) nPhiLayers--;
    if (newHit.sp()->measuresPhi()) {
        if (nPhiLayers == 0) phi = newHit->phi;
        nPhiLayers++;
    }
    meanNormResidual2 += Acts::square(newResidual / newAcceptWindow) - Acts::square(lastResidual / lastAcceptWindow);
    lastAcceptWindow = newAcceptWindow;
    lastResidual = newResidual;
 
    auto& stHits {hitsPerStation[Acts::toUnderlying(st)]};
    /* Remove ALL hits in the same layer */
    while (!stHits.empty()) {
        if (stHits.back().globLayer != lastInsertedHit.globLayer) {
            break;
        }
        stHits.pop_back();
    }
    hitsPerStation[Acts::toUnderlying(st)].push_back(newHit);
    lastInsertedHit = newHit;
    needLineUpdate = true;
}

print()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::print	(	std::ostream &	ostr,
		bool	detailed ) const

Print the pattern candidate.

Definition at line 1292 of file GlobalPatternFinder.cxx.

                                                                                 {
    ostr<<"Pattern state, Exp Sector: "<<(int)expSect.sector()<<", Theta: "<<inDegrees(theta) << ", Phi: "<<inDegrees(phi);
    ostr<<", nPrec: "<<(int)nPrecisionLayers<<", nEtaNonPrec: "<<(int)nTriggerLayers<<", nPhi: "<<(int)nPhiLayers;
    ostr<<", mean norma res sq: "<<getMeanResidual2();
    ostr<<", Hit per station: \n";
    for (uint8_t st{0u}; st < s_nStations; ++st) {
        const auto& hits {hitsPerStation[st]};
        if (hits.empty()) continue;
 
        ostr<<"  Station "<<Muon::MuonStationIndex::stName(static_cast<StIndex>(st))<<" has "<<hits.size()<<" hits ";
        if (detailed) {
            ostr<<"\n";
            for (const auto& hit : hits) {
                ostr<<"    "<<**hit<<", R: "<<hit.R<<", Z: "<<hit.Z<<", Phi: "<<inDegrees(hit->phi)<<", loc/glob lay: "<<(int)hit->locLayer<<"/"<<(int)hit.globLayer<<"\n";
            }
        }
    }
    if (!detailed) {
        ostr <<"\n    Last hit: "<<**lastInsertedHit<<"\n    prevLayerHit: "<<**prevLayerHit << "\n    lineAnchorHit: "<<**lineAnchorHit;
    }
}

updateLineParameters()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::updateLineParameters

(

const Amg::Vector3D &

beamSpot

)

Update the line parameters based on the current hits.

Parameters

beamSpot

position of the beam spot, needed when there are not enough hits

Definition at line 897 of file GlobalPatternFinder.cxx.

                                                                                      {
    if (!needLineUpdate) {
        return;
    }
    const StIndex lastSt {lastInsertedHit.station};
    auto& hitsLastSt {hitsPerStation[Acts::toUnderlying(lastSt)]};
    // Check whether we have to use the beamspot instead of the last pattern hit to draw the line with the line anchor.
    const bool new_useBeamspot {lastSt == lineAnchorHit.station && 
            (isBarrel(lastSt) ? std::abs(lastInsertedHit.R - lineAnchorHit.R)
                              : std::abs(lastInsertedHit.Z - lineAnchorHit.Z)) <= cfg->minLayerSeparation};
 
    const double new_anchorR {new_useBeamspot ? beamSpot.perp() : lineAnchorHit.R};
    const double new_anchorZ {new_useBeamspot ? beamSpot.z()    : lineAnchorHit.Z};
 
    /* Determine the (average) coordinates of the last added hit(s). If it is a straw, find  
     * the consecutive (MDT) hits on the same layer and return use average position
     * for next computations — gives a more central reference for the line direction */
    double refR {0.}, refZ {0.};
    uint8_t nSameLayer {0u};
    for (const auto& hit : hitsLastSt) {
        if (hit.globLayer != lastInsertedHit.globLayer) continue;
        refR += hit.R;
        refZ += hit.Z;
        ++nSameLayer;
    }
    refR /= nSameLayer;
    refZ /= nSameLayer;
 
    const double new_dZ_slope {refZ - new_anchorZ};
    if (std::abs(new_dZ_slope) < 1.) {
        PRINT_VERBOSE("updateLineParameters() Couldn't update the line parameters.");
        return;
    }
    const double dR_slope {refR - new_anchorR};
    PRINT_VERBOSE("updateLineParameters() Update line parameters dZ/slope: "<<dZ_slope<<", " << lineSlope
            << " --> " << new_dZ_slope << ", " << dR_slope / new_dZ_slope);
    
    lineSlope = dR_slope / new_dZ_slope;
    dZ_slope = new_dZ_slope;
    anchorR = new_anchorR;
    anchorZ = new_anchorZ;
    useBeamspot = new_useBeamspot;
    // If we have only one hit and it is a straw, store the LR correction factor
    LR_factor = (nSameLayer == 1u && lastInsertedHit.isStraw) ? 
        lastInsertedHit.sp()->driftRadius()/ Acts::fastHypot(dZ_slope, dR_slope) : -1.;
    needLineUpdate = false;
}

Member Data Documentation

anchorR

double MuonR4::FastReco::GlobalPatternFinder::PatternState::anchorR {0.}

Definition at line 303 of file GlobalPatternFinder.h.

{0.};

anchorZ

double MuonR4::FastReco::GlobalPatternFinder::PatternState::anchorZ {0.}

Simple line model: anchor Z and R.

Same as lineAnchorHit, except when using beamspot

Definition at line 302 of file GlobalPatternFinder.h.

{0.};

cfg

const Config* MuonR4::FastReco::GlobalPatternFinder::PatternState::cfg {nullptr}

Pointer to cfg option.

Definition at line 277 of file GlobalPatternFinder.h.

{nullptr};

dZ_slope

double MuonR4::FastReco::GlobalPatternFinder::PatternState::dZ_slope {0.}

Definition at line 298 of file GlobalPatternFinder.h.

{0.};

expSect

ExpandedSector MuonR4::FastReco::GlobalPatternFinder::PatternState::expSect {static_cast<int8_t>(0)}

expanded MS sector

Definition at line 305 of file GlobalPatternFinder.h.

{static_cast<int8_t>(0)};

hitsPerStation

std::array<std::vector<CandidateHit>, s_nStations> MuonR4::FastReco::GlobalPatternFinder::PatternState::hitsPerStation {}

Map collection of hits per station.

A pattern is determined by the hits belonging to it.

Definition at line 322 of file GlobalPatternFinder.h.

{};

isFinalized

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::isFinalized {false}

Flag to indicate if the pattern has been finalized.

Definition at line 311 of file GlobalPatternFinder.h.

{false};

isOverlap

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::isOverlap {false}

Flag to indicate if the pattern is overlapping with another one, used during overlap removal.

Definition at line 313 of file GlobalPatternFinder.h.

{false};

lastAcceptWindow

double MuonR4::FastReco::GlobalPatternFinder::PatternState::lastAcceptWindow {0.}

Definition at line 295 of file GlobalPatternFinder.h.

{0.};

lastInsertedHit

CandidateHit MuonR4::FastReco::GlobalPatternFinder::PatternState::lastInsertedHit {}

Pointer to the last inserted hit.

Needed to speed-up lookup

Definition at line 283 of file GlobalPatternFinder.h.

{};

lastResidual

double MuonR4::FastReco::GlobalPatternFinder::PatternState::lastResidual {0.}

Residual & acceptance window of the last inserted hit (needed when replacing a hit).

Definition at line 294 of file GlobalPatternFinder.h.

{0.};

lineAnchorHit

CandidateHit MuonR4::FastReco::GlobalPatternFinder::PatternState::lineAnchorHit {}

Pointer to the line anchor hit.

Definition at line 287 of file GlobalPatternFinder.h.

{};

lineSlope

double MuonR4::FastReco::GlobalPatternFinder::PatternState::lineSlope {0.}

Simple line model: slope and associated delta Z, i.e.

the distance in Z between the two points defining the line

Definition at line 297 of file GlobalPatternFinder.h.

{0.};

logger

const AthMessaging* MuonR4::FastReco::GlobalPatternFinder::PatternState::logger {nullptr}

Logger.

Definition at line 279 of file GlobalPatternFinder.h.

{nullptr};

LR_factor

double MuonR4::FastReco::GlobalPatternFinder::PatternState::LR_factor {-1.}

Simple line model: factor for LR correction to be applied.

Definition at line 300 of file GlobalPatternFinder.h.

{-1.};

meanNormResidual2

double MuonR4::FastReco::GlobalPatternFinder::PatternState::meanNormResidual2 {0.}

Mean over eta hits of the square of their residual divided by acceptance window.

Definition at line 292 of file GlobalPatternFinder.h.

{0.};

needLineUpdate

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::needLineUpdate {false}

Whether we need to update the pattern line the next time we find a hit in a new layer.

Definition at line 317 of file GlobalPatternFinder.h.

{false};

nMeasurementLayers

std::array<uint8_t, s_nStations> MuonR4::FastReco::GlobalPatternFinder::PatternState::nMeasurementLayers {}

Counts of measurement layers per station.

Definition at line 320 of file GlobalPatternFinder.h.

{};

nPhiLayers

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nPhiLayers {0u}

Definition at line 309 of file GlobalPatternFinder.h.

{0u};

nPrecisionLayers

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nPrecisionLayers {0u}

Counts of precision / non-precision / phi layers.

Definition at line 307 of file GlobalPatternFinder.h.

{0u};

nTriggerLayers

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nTriggerLayers {0u}

Definition at line 308 of file GlobalPatternFinder.h.

{0u};

phi

double MuonR4::FastReco::GlobalPatternFinder::PatternState::phi {0.}

Definition at line 290 of file GlobalPatternFinder.h.

{0.};

phiOnlyHits

std::vector<HitPayload> MuonR4::FastReco::GlobalPatternFinder::PatternState::phiOnlyHits {}

Array holding phi-only hits.

Definition at line 324 of file GlobalPatternFinder.h.

{};

prevLayerHit

CandidateHit MuonR4::FastReco::GlobalPatternFinder::PatternState::prevLayerHit {}

Pointer to the last hit in the second-to-last layer.

Definition at line 285 of file GlobalPatternFinder.h.

{};

theta

double MuonR4::FastReco::GlobalPatternFinder::PatternState::theta {0.}

Average theta & average phi of the pattern.

Definition at line 289 of file GlobalPatternFinder.h.

{0.};

useBeamspot

bool MuonR4::FastReco::GlobalPatternFinder::PatternState::useBeamspot {false}

Whether we used the beamspot to compute the line parameters.

Definition at line 315 of file GlobalPatternFinder.h.

{false};

visualInfo

Acts::CloneablePtr<PatternHitVisualInfo> MuonR4::FastReco::GlobalPatternFinder::PatternState::visualInfo {nullptr}

Pointer to Visual Information for pattern visualization.

Definition at line 281 of file GlobalPatternFinder.h.

{nullptr};

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx