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 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.
Amg::Vector3D	projToPhiPlane (const HitPayload &hit) const
	Project a certain hit position onto the bending plane where the pattern is defined.
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	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.
void	updatePatternPhi (const double newPhi)
	Helper method to update the pattern phi and bending plane normal.
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.
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 {}
	Last inserted hit.
CandidateHit	prevLayerHit {}
	Last hit in the second-to-last layer.
CandidateHit	lineAnchorHit {}
	Line anchor hit.
CandidateHit	seedHit {}
	Seed hit.
Amg::Vector3D	bendPlaneNorm {Amg::Vector3D::Zero()}
	Normal vector to the bending plane where the pattern lies.
Amg::Vector3D	linePos {Amg::Vector3D::Zero()}
	Position and direction of the pattern line.
Amg::Vector3D	lineDir {Amg::Vector3D::Zero()}
double	leverArm {0.}
	Distance between the two points defining the pattern line.
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	patPhi {0.}
	Pattern phi, which is the phi of the bending plane where the pattern lies.
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 194 of file GlobalPatternFinder.h.

Constructor & Destructor Documentation

PatternState() [1/4]

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

Constructor taking the seed information.

Parameters

seed	seed hit
expSector	expanded sector coordinate
cfg	pointer to configuration object
logger	pointer to messaging object

Update the hit counts in bending direction

Add now the new hit

Definition at line 747 of file GlobalPatternFinder.cxx.

        : cfg{cfg},
          logger{logger},
          lastInsertedHit{seed},
          prevLayerHit{seed},
          lineAnchorHit{seed},
          seedHit{seed},
          expSect{ExpandedSector{expSector}} {
          
    nMeasurementLayers[Acts::toUnderlying(seed.station)]++;
    if (seed->isPrecision) nPrecisionLayers++;
    else nTriggerLayers++;
    if (seed->sp()->measuresPhi()) nPhiLayers++;
 
    updatePatternPhi(seed->position.phi());

    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 981 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) {\
                updatePatternPhi(hit->position.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 compatible 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 772 of file GlobalPatternFinder.cxx.

                                                                              {
    // We test hits in same **expanded** sector, so we need just to compare hit's phi with pattern's phi, if available
    const double phiHit {testHit->position.phi()};
    if (nPhiLayers) {
        const double maxPhiDiff {testHit.sp()->measuresPhi() ? 
            cfg->phiTolerance : sectorMap.sectorWidth(testHit.sector)};
        if (std::abs(P4Helpers::deltaPhi(patPhi, phiHit)) > maxPhiDiff) {
            PRINT_VERBOSE(__func__<<"() The pattern with phi = "<<inDeg(patPhi)
                <<" is not compatible with the test hit with phi "<<inDeg(phiHit) << " - 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(std::tan(lineDir.theta()), 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 makeResult(LineTestDecision::eConsecutiveMdt);
    }
    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(P4Helpers::deltaPhi(patPhi, phiHit)) < 
                          std::abs(P4Helpers::deltaPhi(patPhi, lastInsertedHit->position.phi()))) {
            return makeResult(LineTestDecision::eOverwriteLastHit);
        }
        return LineTestRes{};
    }
    if (testHit->isPrecision != lastInsertedHit->isPrecision) {
        if (lastInsertedHit->isPrecision) {
            PRINT_VERBOSE(__func__<<"() Test hit is trigger hit and last inserted hit is precision, on the same layer - keep 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.

Dynamic acceptance window derived from the propagation of the measurement variance to the residual. In this simple model, the measurement variance is assumed isotropic. The residual variance increases
with the normalized extrapolation distance alpha = s / L, where s is the projection of the hit onto the pattern direction and L is the pattern lever arm.

Loosen the window when using the beamspot as reference, as the line slope is less well defined, and when we are looking for hits in a new station.

Definition at line 922 of file GlobalPatternFinder.cxx.

                                                                                      {
    LineTestRes res{};
 
    // Compute the residual
    const Amg::Vector3D pos {projToPhiPlane(*testHit)};
    const Amg::Vector3D K {pos - linePos};
    res.residual = (K.cross(lineDir)).mag();

    const double alpha {K.dot(lineDir) / leverArm};
    const double varianceScale {2. * (1. - alpha + Acts::square(alpha))};
    res.accWindow = cfg->baseResidualSigma * std::sqrt(varianceScale);
    if (useBeamspot || testHit->station != lastInsertedHit.station ||
        (testHit->station != prevLayerHit.station && testHit.globLayer == lastInsertedHit.globLayer)) {
        res.accWindow *= 2.;
    }
    PRINT_VERBOSE(__func__<<"() "<< brief(*this)<<"\nUse beamspot: "<<useBeamspot<<", Slope: "
        <<std::tan(lineDir.theta())<<", Residual: "<<res.residual<<", Window: "<<res.accWindow
        <<", alpha: "<<alpha<<", Scale Factor: "<<std::sqrt(varianceScale));
    return res;
}

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

                                                         {
    if (!nPhiLayers) {
        patPhi = 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;
        }
        const double hitPhi {hit.position.phi()};
        if (!centralPhi) {
            centralPhi = hitPhi;
        }
        deltaPhiAcc += P4Helpers::deltaPhi(hitPhi, *centralPhi);
    };
    for (const std::vector<CandidateHit>&  hits : hitsPerStation) {
        for (const auto& hit : hits) {
            processPhiHit(*hit);
        }
    }
    for (const HitPayload& hit : phiOnlyHits) {
        processPhiHit(hit);
    }
    patPhi = P4Helpers::deltaPhi(centralPhi.value_or(0.) + deltaPhiAcc / nPhiLayers, 0.);
}

getMeanResidual2()

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

(

)

const

Return the mean normalized residual squared.

Definition at line 1118 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 1124 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 1135 of file GlobalPatternFinder.cxx.

                                                                                 {
    if (lastInsertedHit.globLayer != hit.globLayer) {
        return false;
    }
    if (hit.isStraw && lastInsertedHit.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 1068 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 957 of file GlobalPatternFinder.cxx.

                                                                                {
    if (nPhiLayers) {
        if (std::abs(P4Helpers::deltaPhi(patPhi, testPhi)) > cfg->phiTolerance) {
            PRINT_VERBOSE(__func__<<"() The pattern with phi = "<<inDeg(patPhi)
                <<" is not compatible with the test hit with phi "<<inDeg(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 = "<<inDeg(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 848 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 1110 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 1115 of file GlobalPatternFinder.cxx.

                                                              {
    return nPrecisionLayers + nTriggerLayers;
}

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 1101 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 1017 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 (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) {
            updatePatternPhi(newHit->position.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;
        }
        if (visualInfo) {
            visualInfo->replacedHits.push_back(stHits.back().sp());
        }
        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 1267 of file GlobalPatternFinder.cxx.

                                                                                 {
    ostr<<"PatternState Exp Sector: "<<static_cast<int>(expSect.sector())
    <<", Theta: "<<inDeg(seedHit->position.theta()) << ", Phi: "<<inDeg(patPhi);
    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 "<<static_cast<StIndex>(st)<<" has "<<hits.size()<<" hits ";
        if (detailed) {
            ostr<<"\n";
            for (const auto& hit : hits) {
                ostr<<"    "<<hit<<"\n";
            }
        }
    }
    if (!detailed) {
        ostr <<"\n    Last hit: "<<lastInsertedHit<<"\n    prevLayerHit: "
            <<prevLayerHit << "\n    lineAnchorHit: "<<lineAnchorHit;
    }
}

projToPhiPlane()

Amg::Vector3D MuonR4::FastReco::GlobalPatternFinder::PatternState::projToPhiPlane

(

const HitPayload &

hit

)

const

Project a certain hit position onto the bending plane where the pattern is defined.

The hit is moved along the sensor direction if it does not measure phi, or is rotated around the Z axis if it does.

Parameters

hit	hit whose position is to be projected

Returns

: projected position

Definition at line 948 of file GlobalPatternFinder.cxx.

                                                                                       {
    const Amg::Vector3D& toProject {hit.position};
    if (hit->measuresPhi()) {
        const double R {toProject.perp()};
        return Amg::Vector3D{R * std::cos(patPhi), R * std::sin(patPhi), toProject.z()};
    }
    return Acts::PlanarHelper::intersectPlane(toProject, hit.sensorDir,
        bendPlaneNorm, Amg::Vector3D::Zero()).position();        
}

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

                                                                                      {
    if (!needLineUpdate) {
        return;
    }
    const StIndex lastSt {lastInsertedHit.station};
    Amg::Vector3D pos1 {projToPhiPlane(*lineAnchorHit)};
    Amg::Vector3D pos2 {projToPhiPlane(*lastInsertedHit)};
    
    // Check whether we have to use the beamspot instead of the last pattern hit to draw the line with the line anchor.
    useBeamspot = (lastSt == lineAnchorHit.station) && 
        (pos1 - pos2).mag() < cfg->minHitDistance4Line;
 
    if (useBeamspot) {
        pos1 = beamSpot;
    }
 
    /* 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 */
    std::vector<CandidateHit>& hitsLastSt {hitsPerStation[Acts::toUnderlying(lastSt)]};
    uint8_t nSameLayer {1u};
    for (const CandidateHit& hit : hitsLastSt) {
        if (hit == lastInsertedHit || 
            hit.globLayer != lastInsertedHit.globLayer) {
            continue;
        }
        pos2 += projToPhiPlane(*hit);
        ++nSameLayer;
    }
    if (nSameLayer > 1u) {
        pos2 = pos2 / nSameLayer;
    }
 
    const Amg::Vector3D d {pos2 - pos1};
    linePos = pos1;
    leverArm = d.mag();
    lineDir = d / leverArm;
    needLineUpdate = false;
 
    PRINT_VERBOSE(__func__<<"() Update line parameters --> Pos: "<<Amg::toString(linePos)
        <<" R/Z: "<<linePos.perp()<<"/"<<linePos.z()<<", Dir: " << Amg::toString(lineDir) 
        <<", slope: "<<std::tan(lineDir.theta())<<", LeverArm: " << leverArm);
}

updatePatternPhi()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::updatePatternPhi

(

const double

newPhi

)

Helper method to update the pattern phi and bending plane normal.

Definition at line 1153 of file GlobalPatternFinder.cxx.

                                                                          {
    patPhi = newPhi;
    bendPlaneNorm = Acts::makeDirectionFromPhiTheta(newPhi + 90._degree, 90._degree);
}

Member Data Documentation

bendPlaneNorm

Amg::Vector3D MuonR4::FastReco::GlobalPatternFinder::PatternState::bendPlaneNorm {Amg::Vector3D::Zero()}

Normal vector to the bending plane where the pattern lies.

Definition at line 299 of file GlobalPatternFinder.h.

{Amg::Vector3D::Zero()};

cfg

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

Pointer to cfg option.

Definition at line 285 of file GlobalPatternFinder.h.

{nullptr};

expSect

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

expanded MS sector

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

{};

isFinalized

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

Flag to indicate if the pattern has been finalized.

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

{false};

lastAcceptWindow

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

Definition at line 310 of file GlobalPatternFinder.h.

{0.};

lastInsertedHit

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

Last inserted hit.

Needed to speed-up lookup

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

{0.};

leverArm

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

Distance between the two points defining the pattern line.

Definition at line 305 of file GlobalPatternFinder.h.

{0.};

lineAnchorHit

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

Line anchor hit.

Definition at line 295 of file GlobalPatternFinder.h.

{};

lineDir

Amg::Vector3D MuonR4::FastReco::GlobalPatternFinder::PatternState::lineDir {Amg::Vector3D::Zero()}

Definition at line 303 of file GlobalPatternFinder.h.

{Amg::Vector3D::Zero()};

linePos

Amg::Vector3D MuonR4::FastReco::GlobalPatternFinder::PatternState::linePos {Amg::Vector3D::Zero()}

Position and direction of the pattern line.

Both are constructed to be within the bending plane of the pattern

Definition at line 302 of file GlobalPatternFinder.h.

{Amg::Vector3D::Zero()};

logger

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

Logger.

Definition at line 287 of file GlobalPatternFinder.h.

{nullptr};

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 307 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 326 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 329 of file GlobalPatternFinder.h.

{};

nPhiLayers

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

Definition at line 318 of file GlobalPatternFinder.h.

{0u};

nPrecisionLayers

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

Counts of precision / non-precision / phi layers.

Definition at line 316 of file GlobalPatternFinder.h.

{0u};

nTriggerLayers

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

Definition at line 317 of file GlobalPatternFinder.h.

{0u};

patPhi

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

Pattern phi, which is the phi of the bending plane where the pattern lies.

Definition at line 312 of file GlobalPatternFinder.h.

{0.};

phiOnlyHits

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

Array holding phi-only hits.

Definition at line 333 of file GlobalPatternFinder.h.

{};

prevLayerHit

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

Last hit in the second-to-last layer.

Definition at line 293 of file GlobalPatternFinder.h.

{};

seedHit

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

Seed hit.

Definition at line 297 of file GlobalPatternFinder.h.

{};

useBeamspot

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

Whether we used the beamspot to compute the line parameters.

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

{nullptr};

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx