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

#include <GlobalPatternFinderDefs.h>

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

Public Member Functions
	PatternState (const CandidateHit &seed, const std::int8_t expSector, const Config cfg, const Acts::Logger logger)
	Constructor taking the seed information.
	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 resSigma)
	Add a hit to the pattern and update the internal state.
void	overWriteHit (const CandidateHit &newHit, const double newResidual, const double newResSigma)
	Overwrite the hits on the last layer with the new one.
LineTestRes	checkLineComp (const Acts::GeometryContext &gctx, const CandidateHit &testHit, const Amg::Vector3D &beamSpot)
	Method checking line compatibility of a test hit against the pattern.
LineTestRes	computeLineResidual (const Acts::GeometryContext &gctx, const CandidateHit &testHit) const
	Method to compute the residual of a test hit against the pattern line.
Amg::Vector3D	projToPhiPlane (const Acts::GeometryContext &gctx, const HitPayload &hit) const
	Project a certain hit position onto the bending plane where the pattern is defined.
bool	isPhiCompatible (const HitPayload &hit) 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	moveLineAnchorHit (const CandidateHit &refHit)
	Move the line anchor hit given a reference hit.
void	updateLineParameters (const Acts::GeometryContext &gctx, const Amg::Vector3D &beamSpot)
	Update the line parameters based on the current hits.
void	updatePatternPhi ()
	Helper method to update the pattern phi and bending plane normal.
double	getMeanResidual2 () const
	Return the mean normalized residual squared.
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.
const Acts::Logger &	logger () const
	Return the logger.
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 Acts::Logger *	m_logger {nullptr}
	Logger.
Acts::CloneablePtr< PatHitVisual >	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.
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 residual uncertainty.
double	lastResidual {0.}
	Residual & residual uncertainty of the last inserted hit (needed when replacing a hit).
double	lastResSigma {0.}
double	patPhi {0.}
	Pattern phi, which is the phi of the bending plane where the pattern lies.
double	patTheta {0.}
	Pattern theta, which is the value of the seed hit.
double	patPhiCov {0.}
	Covariance of the pattern phi.
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< 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 114 of file GlobalPatternFinderDefs.h.

Constructor & Destructor Documentation

◆ PatternState() [1/3]

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

explicit

Constructor taking the seed information.

Parameters

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

Add the new hit

Update the hit counts

Definition at line 152 of file GlobalPatternFinderDefs.cxx.

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

◆ PatternState() [2/3]

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

defaultnoexcept

Move constructor.

Parameters

other other pattern state to move from

◆ PatternState() [3/3]

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	resSigma )

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

Parameters

hit	hit to be added
residual	residual of the hit
resSigma	residual uncertainty of the hit

Add the new hit

Update the hit counts

Update the pointers to previous layer hit

If the new compatible hit is in a different station, update the line anchor

Definition at line 442 of file GlobalPatternFinderDefs.cxx.

                                                                          {
        hitsPerStation[Acts::toUnderlying(hit->station)].push_back(hit);
        if (hit->isPrecision) nPrecisionLayers++;
        else nTriggerLayers++;
 
        if (hit.sp()->measuresPhi()) {
            nPhiLayers++;
            updatePatternPhi();
        }
        const bool isNewStation {hit->station != lastInsertedHit->station};
        prevLayerHit = lastInsertedHit;
        lastInsertedHit = hit;
 
        meanNormResidual2 += Acts::square(residual / resSigma);
        lastResSigma = resSigma;
        lastResidual = residual;
        if (isNewStation) {
            moveLineAnchorHit(hit);
        }
        needLineUpdate = true;
    }

◆ checkLineComp()

LineTestRes MuonR4::FastReco::GlobalPatternFinder::PatternState::checkLineComp	(	const Acts::GeometryContext &	gctx,
		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

Loosen the window when we use the beamspot or when we are looking for hits in a new station, as the straight line approximation becomes less accurate on large distances. TO DO: investigate this further

Definition at line 176 of file GlobalPatternFinderDefs.cxx.

                                                                                              {
 
        if (testHit.sp()->measuresPhi() && !isPhiCompatible(*testHit)) {
            ACTS_VERBOSE(__func__<<"() Test hit phi "<<testHit->position.phi()
                <<" not compatible with "<<brief(*this));
            return LineTestRes{};
        }
        
        auto makeResult = [&](const LineTestDecision decision) -> LineTestRes {
            LineTestRes res{computeLineResidual(gctx, testHit)};
            double accWindow {cfg->nResidualSigma * res.sigma};
            if (useBeamspot || testHit->station != lastInsertedHit->station ||
                (testHit->station != prevLayerHit->station && testHit.globLayer == lastInsertedHit.globLayer)) {
                accWindow *= 2.;
            }
            if (res.residual < accWindow) {
                res.result = decision;
            }
            if (visualInfo) {
                visualInfo->hitLineInfo[testHit.sp()] =
                    std::make_pair(std::tan(lineDir.theta()), accWindow);
            }
            return res;
        };
 
        if(testHit.globLayer != lastInsertedHit.globLayer) {
            updateLineParameters(gctx, beamSpot);
            return makeResult(LineTestDecision::eAddHit);
        }
        if (testHit == lastInsertedHit) {
            ACTS_VERBOSE(__func__<<"() Test hit is the same as last inserted hit - reject.");
            return LineTestRes{};
        }
        if (lineAnchorHit.globLayer == lastInsertedHit.globLayer) {
            ACTS_VERBOSE(__func__<<"() Test hit on same layer as seed with no prior hits - reject.");
            return LineTestRes{};
        }
        return makeResult(LineTestDecision::eBranchPattern);
    }

◆ computeLineResidual()

LineTestRes MuonR4::FastReco::GlobalPatternFinder::PatternState::computeLineResidual	(	const Acts::GeometryContext &	gctx,
		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.

We project the test hit onto the phi plane only when the test hit does not measure phi or when we have no phi layers, otherwise we do not project so the residual include the error in the phi direction.

If the residual is very small, it's likely due to bad topology, reject it.

Alpha represents the extrapolation distance along the pattern line

Accumulate the derivatives of the scalar residual with respect to the common phi-plane angle.

Accumulate the covariance contributions of the hits to the residual

Accumulate the covariance contributions of one hit to the residual. Each hit contributes with its intrinsic covariance and, if projected,
with the uncertainty in the common phi-plane angle of the pattern.

Intrinsic covariance: for a projected hit, the residual direction is
transformed with the projection jacobian J^T * dir. dir^T * J * cov * J^T * dir = (J^T * dir)^T * cov * (J^T * dir)

Phi plane uncertainty: for a projected hit, the derivative of the scalar
residual with respect to the common phi-plane angle for the projected hits.

Parameters

hit	the hit for which to compute the covariance
isProjected	flag indicating if the hit is projected
pos	projected position (needed for the phi-plane derivative of projected hits)
preFactor	factor, function of alpha, to scale the covariance contributions

Compute the covariance contributions of the first line point

Compute the covariance contributions of the second line point

Compute the covariance contributions of the test hit

Definition at line 272 of file GlobalPatternFinderDefs.cxx.

                                                                                                          {
        LineTestRes res{};
        const bool projectTestHit {!testHit.sp()->measuresPhi() || nPhiLayers == 0u};
        const Amg::Vector3D testPos {projectTestHit ? projToPhiPlane(gctx,*testHit) 
                                                    : testHit->position};
        const Amg::Vector3D K {testPos - linePos};
        const double KdotD {K.dot(lineDir)};
        
        const Amg::Vector3D R {K - KdotD * lineDir}; // Residual vector
        res.residual = R.mag();
        if (res.residual < Acts::s_epsilon) {
            res.residual = std::numeric_limits<double>::max();
            res.sigma = 0.;
            return res;
        }
        const Amg::Vector3D resDir {R / res.residual}; // Residual direction
        const double alpha {KdotD / leverArm};
        
        double phiPlaneDerivativeAcc {0.};
        double residualCovAcc {0.};
        auto covarianceTerm = [&](const HitPayload& hit,
                                  const Amg::Vector3D& pos,
                                  const double preFactor,
                                  bool isProjected) -> void {
                    
            if (!isProjected) {
                residualCovAcc += Acts::square(preFactor) * 
                    hit.residualVariance(gctx, resDir, /*isProjected=*/false);
                return;
            }
            const Amg::Vector3D sensorDir {hit.sensorDir(gctx)};
            const double projFactor {sensorDir.dot(resDir) / 
                                     sensorDir.dot(bendPlaneNorm)};
            const Amg::Vector3D trfDir {resDir - projFactor * bendPlaneNorm};
            
            residualCovAcc += Acts::square(preFactor) 
                * hit.residualVariance(gctx, trfDir, /*isProjected=*/true);  
            phiPlaneDerivativeAcc += preFactor * pos.perp() * projFactor;
        };
        if (useBeamspot) {
            const double covS1 = cfg->beamSpotLength * Acts::square(resDir.z()) + 
                                 cfg->beamSpotRadius * (1 - Acts::square(resDir.z()));
            residualCovAcc += Acts::square(alpha - 1) * covS1;
        } else {
            covarianceTerm(*lineAnchorHit, linePos, alpha - 1, /*isProjected=*/true);
        }
        const Amg::Vector3D pos2 {linePos + leverArm * lineDir};
        covarianceTerm(*lastInsertedHit, pos2, -alpha, /*isProjected=*/true);
        covarianceTerm(*testHit, testPos, 1., projectTestHit);
      
        res.sigma = std::sqrt(residualCovAcc + Acts::square(phiPlaneDerivativeAcc) * patPhiCov);
 
        ACTS_VERBOSE(__func__<<"() "<< brief(*this)<<"\nUse beamspot: "<<useBeamspot
            <<", alpha: "<<alpha<<", Residual: "<<res.residual<<" +- "<<res.sigma
            <<", linePos R/theta: "<<linePos.perp()<<" / "<<inDeg(linePos.theta())
            <<", lineDir theta: "<<inDeg(lineDir.theta())
            <<", testPos R/theta/phi: "<<testPos.perp()<<" / "<<inDeg(testPos.theta())<<" / "<<inDeg(testPos.phi())
            <<", resDir theta/phi: "<<inDeg(resDir.theta())<<" / "<<inDeg(resDir.phi())
            <<", hit pos sigma: "<<std::sqrt(residualCovAcc)
            <<", phi plane sigma: "<<std::abs(phiPlaneDerivativeAcc)*std::sqrt(patPhiCov));
        return res;
    }

◆ getMeanResidual2()

double MuonR4::FastReco::GlobalPatternFinder::PatternState::getMeanResidual2 ( ) const

Return the mean normalized residual squared.

Definition at line 558 of file GlobalPatternFinderDefs.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 565 of file GlobalPatternFinderDefs.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;
    }

◆ 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 539 of file GlobalPatternFinderDefs.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 HitPayload & hit ) const

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

Parameters

hit	hit to be checked

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 415 of file GlobalPatternFinderDefs.cxx.

                                                                                     {
        const double testPhi {hit.position.phi()};
        if (nPhiLayers) {
            const double deltaPhiSigma {std::sqrt(patPhiCov + hit.phiCov)};
            const double deltaPhi {P4Helpers::deltaPhi(patPhi, testPhi)};
            if (std::abs(deltaPhi) > cfg->nPhiSigma * deltaPhiSigma) {
                ACTS_VERBOSE(__func__<<"() The pattern with phi = "<<inDeg(patPhi)<<" +- "<<inDeg(std::sqrt(patPhiCov))
                    <<" is not compatible with the test hit with phi "<<inDeg(testPhi) <<" +- "<<inDeg(std::sqrt(hit.phiCov)));
                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) {
                ACTS_VERBOSE(__func__<<"() The test hit with phi = "<<inDeg(testPhi)
                    <<" is not inside the pattern sectors: "<<sector1<<" and "<<sector2);
                return false;
            }            
        }
        return true;
    }

◆ logger()

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

inline

Return the logger.

Definition at line 200 of file GlobalPatternFinderDefs.h.

                                         {
            return *m_logger;
        }

◆ 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 222 of file GlobalPatternFinderDefs.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};
        lineAnchorHit = *std::ranges::min_element(hits, std::ranges::less{},
            [&refHit](const CandidateHit& hit){
                return std::abs(hit.globLayer - refHit.globLayer); });
    }

◆ nBendingLayers()

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::nBendingLayers ( ) const

Return the number of layers in bending coordinate.

Definition at line 555 of file GlobalPatternFinderDefs.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 544 of file GlobalPatternFinderDefs.cxx.

                                                                                        {
        uint8_t nStations {0u};
        for (uint8_t st{0u}; st < s_nStations; ++st) {
            const auto& hits {hitsPerStation[st]};
            if (!hits.empty() && 
                    (!onlyGoodStations || hits.size() >= 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	newResSigma )

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

Parameters

newHit	new hit to replace with
newResidual	residual of the new hit
newResSigma	residual uncertainty of the new hit
beamSpot	needed to update line parameters

Update the phi counts

Update the residual

Remove the last inserted hit

Add the new hit

Definition at line 472 of file GlobalPatternFinderDefs.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());
            }
            if (newHit->isPrecision) {
                nPrecisionLayers++;
                nTriggerLayers--;
            } else {
                nPrecisionLayers--;
                nTriggerLayers++;
            }
        }
        bool updatePhi {false};
        if (lastInsertedHit.sp()->measuresPhi()) {
            nPhiLayers--;
            updatePhi = true;
        }
        if (newHit.sp()->measuresPhi()) {
            nPhiLayers++;
            updatePhi = true;
        }
        meanNormResidual2 += Acts::square(newResidual / newResSigma) - 
                            Acts::square(lastResidual / lastResSigma);
        lastResSigma = newResSigma;
        lastResidual = newResidual;
        if (visualInfo) {
            visualInfo->replacedHits.push_back(lastInsertedHit.sp());
        }
        auto& stHits {hitsPerStation[Acts::toUnderlying(st)]};
        if (stHits.back() != lastInsertedHit) {
            std::stringstream ss {};
            ss << "Trying to overwrite a hit that is not the last inserted hit in station/layer " 
            << stName(st) << "/" << lastInsertedHit.globLayer << "\n";
            ss << "Last inserted hit: " << **lastInsertedHit << "\n";
            ss << "Last hit in station: " << **stHits.back();
            throw std::runtime_error(ss.str());
        }
        stHits.pop_back();
        stHits.push_back(newHit);
        lastInsertedHit = newHit;
 
        if (updatePhi) {
            updatePatternPhi();
        }
        needLineUpdate = true;
    }

◆ print()

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

Print the pattern candidate.

Definition at line 576 of file GlobalPatternFinderDefs.cxx.

                                                                                     {
        ostr<<"PatternState Exp Sector: "<<static_cast<int>(expSect.sector())
        <<", Theta: "<<inDeg(patTheta) << ", Phi: "<<inDeg(patPhi)<<" +- "<<inDeg(std::sqrt(patPhiCov));
        ostr<<", nPrec: "<<static_cast<int>(nPrecisionLayers)<<", nEtaNonPrec: "
            <<static_cast<int>(nTriggerLayers)<<", nPhi: "<<static_cast<int>(nPhiLayers);
        ostr<<", mean norma res sq: "<<getMeanResidual2()<<", dirTheta: "<<inDeg(lineDir.theta());
        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 Acts::GeometryContext &	gctx,
		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 365 of file GlobalPatternFinderDefs.cxx.

                                                                                                 {
        return Acts::PlanarHelper::intersectPlane(hit.position, hit.sensorDir(gctx),
            bendPlaneNorm, Amg::Vector3D::Zero()).position();        
    }

◆ updateLineParameters()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::updateLineParameters	(	const Acts::GeometryContext &	gctx,
		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

Check whether we have to use the beamspot instead of the anchor hit to draw the line.

Definition at line 245 of file GlobalPatternFinderDefs.cxx.

                                                                                              {
        if (!needLineUpdate) {
            return;
        }
        Amg::Vector3D pos1 {projToPhiPlane(gctx, *lineAnchorHit)};
        Amg::Vector3D pos2 {projToPhiPlane(gctx, *lastInsertedHit)};
        Amg::Vector3D d {pos2 - pos1};
        leverArm = d.mag();
        
        useBeamspot = (lastInsertedHit->station == lineAnchorHit->station) && 
                    leverArm < cfg->minHitDistance4Line;
        if (useBeamspot) {
            linePos = beamSpot;
            d = pos2 - beamSpot;
            leverArm = d.mag();
        } else {
            linePos = pos1;
        }
        lineDir = d / leverArm;
        needLineUpdate = false;
 
        ACTS_VERBOSE(__func__<<"() Updated --> linePos R/z/theta: "<<linePos.perp()<<" / "<<linePos.z()
            <<" / "<<inDeg(linePos.theta())<<", lineDir theta: "<<inDeg(lineDir.theta())
            <<", LeverArm: "<<leverArm<<", Use beamspot: "<<useBeamspot);
    }

◆ updatePatternPhi()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::updatePatternPhi ( )

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

If there are no phi hits, we just use the central phi of the sector/overlap region, with a standard deviation based on the expanded sector size.

Definition at line 370 of file GlobalPatternFinderDefs.cxx.

                                                           {
        if (!nPhiLayers) {
            patPhi = sectorMap.sectorOverlapPhi(expSect.msSector(), 
                                                expSect.adjacentMsSector());
            patPhiCov = Acts::square(expSect.sectorSize()) / 3.;
            bendPlaneNorm = Acts::makeDirectionFromPhiTheta(patPhi + 90._degree, 90._degree);
            ACTS_VERBOSE(__func__<<"() No phi hits in the pattern, set pattern phi to "
                <<inDeg(patPhi)<<" +- "<<inDeg(std::sqrt(patPhiCov)));
            return;
        }
        double sumSin{0.}, sumCos{0.}, sumWeight{0.};
 
        auto processPhiHit = [&sumSin, &sumCos, &sumWeight](const HitPayload& hit){
            if (!hit->measuresPhi()) {
                return;
            }
            if (hit.phiCov < Acts::s_epsilon) {
                std::stringstream ss {};
                ss << "Unexpected to have a phi hit with zero variance in phi direction: " << *hit.spacePoint << "\n";
                throw std::runtime_error(ss.str());
            }
            const double w = 1./hit.phiCov;
 
            const double phi {hit.position.phi()};
            sumSin += w * std::sin(phi);
            sumCos += w * std::cos(phi);
            sumWeight += w;
        };
        for (const std::vector<CandidateHit>&  hits : hitsPerStation) {
            for (const auto& hit : hits) {
                processPhiHit(*hit);
            }
        }
        for (const HitPayload& hit : phiOnlyHits) {
            processPhiHit(hit);
        }
        
        patPhi = std::atan2(sumSin, sumCos);
        patPhiCov = 1./sumWeight;
        bendPlaneNorm = Acts::makeDirectionFromPhiTheta(patPhi + 90._degree, 90._degree);
        ACTS_VERBOSE(__func__<<"() Updated pattern phi to "
            <<inDeg(patPhi)<<" +- "<<inDeg(std::sqrt(patPhiCov)));
    }

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 217 of file GlobalPatternFinderDefs.h.

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

◆ cfg

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

Pointer to cfg option.

Definition at line 205 of file GlobalPatternFinderDefs.h.

205{nullptr};

◆ expSect

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

expanded MS sector

Definition at line 237 of file GlobalPatternFinderDefs.h.

237{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 252 of file GlobalPatternFinderDefs.h.

252{};

◆ isFinalized

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

Flag to indicate if the pattern has been finalized.

Definition at line 243 of file GlobalPatternFinderDefs.h.

243{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 245 of file GlobalPatternFinderDefs.h.

245{false};

◆ lastInsertedHit

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

Last inserted hit.

Needed to speed-up lookup

Definition at line 211 of file GlobalPatternFinderDefs.h.

211{};

◆ lastResidual

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

Residual & residual uncertainty of the last inserted hit (needed when replacing a hit).

Definition at line 228 of file GlobalPatternFinderDefs.h.

228{0.};

◆ lastResSigma

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

Definition at line 229 of file GlobalPatternFinderDefs.h.

229{0.};

◆ leverArm

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

Distance between the two points defining the pattern line.

Definition at line 224 of file GlobalPatternFinderDefs.h.

224{0.};

◆ lineAnchorHit

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

Line anchor hit.

Definition at line 215 of file GlobalPatternFinderDefs.h.

215{};

◆ lineDir

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

Definition at line 222 of file GlobalPatternFinderDefs.h.

222{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. We store them as vectors to facilitate vector operations and avoid constructing them repeatedly.

Definition at line 221 of file GlobalPatternFinderDefs.h.

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

◆ m_logger

const Acts::Logger* MuonR4::FastReco::GlobalPatternFinder::PatternState::m_logger {nullptr}

Logger.

Definition at line 207 of file GlobalPatternFinderDefs.h.

207{nullptr};

◆ meanNormResidual2

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

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

Definition at line 226 of file GlobalPatternFinderDefs.h.

226{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 249 of file GlobalPatternFinderDefs.h.

249{false};

◆ nPhiLayers

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

Definition at line 241 of file GlobalPatternFinderDefs.h.

241{0u};

◆ nPrecisionLayers

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

Counts of precision / non-precision / phi layers.

Definition at line 239 of file GlobalPatternFinderDefs.h.

239{0u};

◆ nTriggerLayers

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

Definition at line 240 of file GlobalPatternFinderDefs.h.

240{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 231 of file GlobalPatternFinderDefs.h.

231{0.};

◆ patPhiCov

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

Covariance of the pattern phi.

Definition at line 235 of file GlobalPatternFinderDefs.h.

235{0.};

◆ patTheta

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

Pattern theta, which is the value of the seed hit.

Definition at line 233 of file GlobalPatternFinderDefs.h.

233{0.};

◆ phiOnlyHits

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

Array holding phi-only hits.

Definition at line 254 of file GlobalPatternFinderDefs.h.

254{};

◆ prevLayerHit

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

Last hit in the second-to-last layer.

Definition at line 213 of file GlobalPatternFinderDefs.h.

213{};

◆ useBeamspot

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

Whether we used the beamspot to compute the line parameters.

Definition at line 247 of file GlobalPatternFinderDefs.h.

247{false};

◆ visualInfo

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

Pointer to Visual Information for pattern visualization.

Definition at line 209 of file GlobalPatternFinderDefs.h.

209{nullptr};

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

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PatternState() [1/3]

◆ PatternState() [2/3]

◆ PatternState() [3/3]

◆ ~PatternState()

Member Function Documentation

◆ addHit()

◆ checkLineComp()

◆ computeLineResidual()

◆ getMeanResidual2()

◆ getParentBuckets()

◆ isInPattern()

◆ isPhiCompatible()

◆ logger()

◆ moveLineAnchorHit()

◆ nBendingLayers()

◆ nStations()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ overWriteHit()

◆ print()

◆ projToPhiPlane()

◆ updateLineParameters()

◆ updatePatternPhi()

Member Data Documentation

◆ bendPlaneNorm

◆ cfg

◆ expSect

◆ hitsPerStation

◆ isFinalized

◆ isOverlap

◆ lastInsertedHit

◆ lastResidual

◆ lastResSigma

◆ leverArm

◆ lineAnchorHit

◆ lineDir

◆ linePos

◆ m_logger

◆ meanNormResidual2

◆ needLineUpdate

◆ nPhiLayers

◆ nPrecisionLayers

◆ nTriggerLayers

◆ patPhi

◆ patPhiCov

◆ patTheta

◆ phiOnlyHits

◆ prevLayerHit

◆ useBeamspot

◆ visualInfo