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 HitPayload &seed, const uint8_t sectorCoord, const double seedTheta)
	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 HitPayload &hit, const double residual, const double acceptWindow)
	Add a hit to the pattern and update the internal state.
void	overWriteHit (const HitPayload &oldHit, const HitPayload &newHit, const double newResidual, const double newAcceptWindow)
	Overwrite a hit in the pattern and update the internal state.
const HitPayload &	getNthLastHit (const uint8_t n) const
	Get the n-th last inserted hit.
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.
bool	operator== (const PatternState &other) const =delete
	Patterns are considered identical if they have the same hit content.
void	print (std::ostream &ostr) const
	Print the pattern candidate and stream operator.

Public Attributes
Acts::CloneablePtr< PatternHitVisualInfo >	visualInfo {nullptr}
	Pointer to Visual Information for pattern visualization.
const SpacePoint *	lastInsertedHit {nullptr}
	Pointer to the last inserted hit.
const SpacePoint *	prevLayerHit {nullptr}
	Pointer to the last hit in the second-to-last layer.
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.}
uint8_t	nPrecisionHits {0u}
	Counts of precision measurements / non-precision in bending direction / phi measurements.
uint8_t	nBendingTriggerHits {0u}
uint8_t	nPhiHits {0u}
uint8_t	nMissedLayerHits {0u}
	Number of missed candidate hits in different measurement layers during pattern building.
uint8_t	sectorCoord {0}
	expanded sector coordinate & the two corresponding physical sectors
uint8_t	sector1 {0}
uint8_t	sector2 {0}
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.
std::unordered_map< StIndex, std::vector< HitPayload > >	hitsPerStation {}
	Map collection of hits per station.
std::vector< StIndex >	stations {}
	Pattern hit stations to save the filling order.
BucketPerContainer	bucketsPerContainer {}
	Map of spacepoint buckets per spacepoint container associated to the pattern.

Friends
std::ostream &	operator<< (std::ostream &ostr, const PatternState &candidate)

Detailed Description

Pattern state object storing pattern information during construction.

Definition at line 175 of file GlobalPatternFinder.h.

Constructor & Destructor Documentation

PatternState() [1/4]

MuonR4::FastReco::GlobalPatternFinder::PatternState::PatternState	(	const HitPayload &	seed,
		const uint8_t	sectorCoord,
		const double	seedTheta )

Constructor taking the seed information.

Parameters

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

Definition at line 900 of file GlobalPatternFinder.cxx.

        : lastInsertedHit{seed.hit},
          prevLayerHit{seed.hit},
          theta{seedTheta},
          sectorCoord{sectorCoord},
          sector1{static_cast<uint8_t>(MsTrackSeeder::ringSector((sectorCoord - sectorCoord % 2) / 2))},
          sector2{static_cast<uint8_t>(MsTrackSeeder::ringSector((sectorCoord + sectorCoord % 2) / 2))} {
          
    StIndex stationHit {seed.station}; 
    hitsPerStation[stationHit].push_back(seed);
    stations.push_back(stationHit);
 
    if (seed.isPrecision) nPrecisionHits++;
    else if (seed->measuresEta()) nBendingTriggerHits++;
 
    if (seed->measuresPhi()) {
        phi = seed.phi;
        nPhiHits++;
    }
}

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 HitPayload &	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 last hit and previous layer hit

Add now the new hit

Reset the number of missed layer hits

Update the hit counts in bending direction

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

Update the residual. Since we can also add phi-only hits without updating the residual, we need to check the accept window

Definition at line 922 of file GlobalPatternFinder.cxx.

                                                                          {
    lastInsertedHit = hit.hit;
    if (const HitPayload& previousHit {getNthLastHit(1u)}; 
        checkLayerOrdering(hit, previousHit) != eSameLayer) {
        prevLayerHit = previousHit.hit;
    }
    StIndex stationHit {hit.station}; 
    hitsPerStation[stationHit].push_back(hit);
    if (stations.empty() || stations.back() != stationHit) {
        stations.push_back(stationHit);
    }
    nMissedLayerHits = 0;
    if (hit.isPrecision) nPrecisionHits++;
    else if (hit->measuresEta()) nBendingTriggerHits++;
    if (hit->measuresPhi()) {
        if (nPhiHits == 0) phi = hit.phi;
        nPhiHits++;
    }
    if (acceptWindow > Acts::s_epsilon) {
        meanNormResidual2 += Acts::square(residual / acceptWindow);
        lastAcceptWindow = acceptWindow;
        lastResidual = residual;
    }
}

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

Update the bucket map

Update eta

Definition at line 1006 of file GlobalPatternFinder.cxx.

                                                         {
    theta = 0.; 
    for (const auto& [_, hits] : hitsPerStation) {
        for (const auto& hit : hits) {
            auto& bucketVec {bucketsPerContainer[hit.container]};
            if (std::ranges::find(bucketVec, hit.bucket) == bucketVec.end()){
                bucketVec.push_back(hit.bucket);
            }
            theta += atan2(hit.R, hit.Z);
        }
    }
    assert(nPrecisionHits + nBendingTriggerHits > Acts::s_epsilon);
    theta /= (nPrecisionHits + nBendingTriggerHits);
}

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

                                                         {
    if (!nPhiHits) {
        phi = sectorMap.sectorOverlapPhi(sector1, sector2);
        return;
    }
    double deltaPhiAcc {0.};
    std::optional<double> centralPhi {};
    for (const auto& [_, hits] : hitsPerStation) {
        for (const auto& hit : hits) {
            if (!hit->measuresPhi()) {
                continue;
            }
            if (!centralPhi) {
                centralPhi = hit.phi;
            }
            deltaPhiAcc += CxxUtils::deltaPhi(hit.phi, *centralPhi);
        }
    }
    phi = CxxUtils::wrapToPi(centralPhi.value_or(0.) + deltaPhiAcc / nPhiHits);
}

getNthLastHit()

const GlobalPatternFinder::HitPayload & MuonR4::FastReco::GlobalPatternFinder::PatternState::getNthLastHit

(

const uint8_t

n

)

const

Get the n-th last inserted hit.

Parameters

n	the index of the hit to retrieve

Returns

: reference to the n-th last inserted hit

Definition at line 1066 of file GlobalPatternFinder.cxx.

                                                                    {
    if (n >= nPrecisionHits + nBendingTriggerHits) {
        // If we have not yet inserted n hits, we return the seed hit
        return hitsPerStation.at(stations.front()).front();
    }
    std::size_t remaining {n};
    for (auto stIt = stations.rbegin(); stIt != stations.rend(); ++stIt) {
        const std::vector<HitPayload>& hits {hitsPerStation.at(*stIt)};
        const size_t nHits  {hits.size()};
        if (remaining <= nHits) {
            return hits.at(nHits - remaining);
        }
        remaining -= nHits;
    }
    // Fall-back return, should not happen if the input n is consistent with hit counts
    return hitsPerStation.at(stations.front()).front();
}

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

                                                                             {
    const auto seedStationIt {hitsPerStation.find(hit.station)};
    return seedStationIt != hitsPerStation.end() && 
           std::ranges::find(seedStationIt->second, hit) != seedStationIt->second.end();                                               
}

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 HitPayload &	oldHit,
		const HitPayload &	newHit,
		const double	newResidual,
		const double	newAcceptWindow )

Overwrite a hit in the pattern and update the internal state.

Parameters

oldHit	hit to be replaced
newHit	new hit to replace with
newResidual	residual of the new hit
accepWindow	acceptance window of the new hit

MDT hits in the same layer are added with the same residual

Update the phi count and the pattern phi if needed

Update the residual. When we replace a hit, we have always the new residual & accept window, so no checks are needed.

Update the pointers to last hit. Since we overwrite hits in the same layer, prevLayerHit remains unchanged

Definition at line 954 of file GlobalPatternFinder.cxx.

                                                                                   {
    if (oldHit.station != newHit.station) {
        throw std::runtime_error(std::format("Trying to overwrite a hit in station {} with another one from station {}", stName(oldHit.station), stName(newHit.station)));
    }
    // 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 ((oldHit.isPrecision != newHit.isPrecision || 
        oldHit->measuresEta() != newHit->measuresEta()) && newHit->type() != xAOD::UncalibMeasType::sTgcStripType) {
        std::stringstream ss {"Trying to overwrite a hit with incompatible type\n"};
        ss << "Old hit: " << *oldHit << ", isPrecision: " << oldHit.isPrecision << ", measuresEta: " << oldHit->measuresEta() << "\n";
        ss << "New hit: " << *newHit << ", isPrecision: " << newHit.isPrecision << ", measuresEta: " << newHit->measuresEta();
        throw std::runtime_error(ss.str());
    }
    assert(newAcceptWindow > Acts::s_epsilon && lastAcceptWindow > Acts::s_epsilon);
    StIndex lastStation {oldHit.station};
    auto it {hitsPerStation.find(lastStation)};
    if (it == hitsPerStation.end() || lastStation != stations.back()) {
        throw std::runtime_error("Trying to remove a hit from an invalid station");
    }
    std::vector<HitPayload>& hitsInStation {it->second};
    // Remove ALL hits in the same layer
    while (!hitsInStation.empty()) {
        HitPayload& lastHit {hitsInStation.back()};
        if (checkLayerOrdering(lastHit, oldHit) != eSameLayer) {
            break;
        }
        if (lastHit.isPrecision) nPrecisionHits--;
        else nBendingTriggerHits--; //This method is called only in pattern building in eta, so we don't have phi-only hits yet
        if (lastHit->measuresPhi()) nPhiHits--;
        hitsInStation.pop_back();
        meanNormResidual2 -= Acts::square(lastResidual / lastAcceptWindow);
    }
    // then insert the new hit
    hitsInStation.push_back(newHit);
    if (newHit.isPrecision) nPrecisionHits++;
    else nBendingTriggerHits++; //This method is called only in pattern building in eta, so we don't have phi-only hits yet
    if (newHit->measuresPhi()) {
        if (nPhiHits == 0) phi = newHit.phi;
        nPhiHits++;
    }
    meanNormResidual2 += Acts::square(newResidual / newAcceptWindow);
    lastResidual = newResidual;
    lastAcceptWindow = newAcceptWindow;
    lastInsertedHit = newHit.hit;
}

print()

void MuonR4::FastReco::GlobalPatternFinder::PatternState::print

(

std::ostream &

ostr

)

const

Print the pattern candidate and stream operator.

Definition at line 1106 of file GlobalPatternFinder.cxx.

                                                                  {
    ostr<<"Pattern state, Expanded Sector: "<<sectorCoord<<", Theta: "<<theta << ", Phi: "<<phi;
    ostr<<", nPrecisionHits: "<<nPrecisionHits<<", nEtaNonPrecisionHits: "<<nBendingTriggerHits<<", nPhiHits: "<<nPhiHits;
    ostr<<", mean normalized residual squared: "<<meanNormResidual2;
    ostr<<", Hit per station: \n";
    for (const auto& [station,hits] : hitsPerStation) {
        ostr<<"  Station "<<Muon::MuonStationIndex::stName(station)<<" has "<<hits.size()<<" hits\n";
        for (const auto& hit : hits) {
            ostr<<"    "<<*hit<<", R: "<<hit.R<<", Phi:"<<hit.phi<<"\n";
        }
    }
}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & ostr, const PatternState & candidate )

friend

Definition at line 269 of file GlobalPatternFinder.h.

                                                                                               {
                    candidate.print(ostr);
                    return ostr;
                }

Member Data Documentation

bucketsPerContainer

BucketPerContainer MuonR4::FastReco::GlobalPatternFinder::PatternState::bucketsPerContainer {}

Map of spacepoint buckets per spacepoint container associated to the pattern.

Definition at line 263 of file GlobalPatternFinder.h.

{};

hitsPerStation

std::unordered_map<StIndex, std::vector<HitPayload> > MuonR4::FastReco::GlobalPatternFinder::PatternState::hitsPerStation {}

Map collection of hits per station.

A pattern is determined by the hits belonging to it.

Definition at line 258 of file GlobalPatternFinder.h.

{};

isFinalized

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

Flag to indicate if the pattern has been finalized.

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

{false};

lastAcceptWindow

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

Definition at line 241 of file GlobalPatternFinder.h.

{0.};

lastInsertedHit

const SpacePoint* MuonR4::FastReco::GlobalPatternFinder::PatternState::lastInsertedHit {nullptr}

Pointer to the last inserted hit.

Needed to speed-up lookup

Definition at line 231 of file GlobalPatternFinder.h.

{nullptr};

lastResidual

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

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

Definition at line 240 of file GlobalPatternFinder.h.

{0.};

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

{0.};

nBendingTriggerHits

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

Definition at line 244 of file GlobalPatternFinder.h.

{0u};

nMissedLayerHits

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

Number of missed candidate hits in different measurement layers during pattern building.

Definition at line 247 of file GlobalPatternFinder.h.

{0u};

nPhiHits

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

Definition at line 245 of file GlobalPatternFinder.h.

{0u};

nPrecisionHits

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

Counts of precision measurements / non-precision in bending direction / phi measurements.

Definition at line 243 of file GlobalPatternFinder.h.

{0u};

phi

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

Definition at line 236 of file GlobalPatternFinder.h.

{0.};

prevLayerHit

const SpacePoint* MuonR4::FastReco::GlobalPatternFinder::PatternState::prevLayerHit {nullptr}

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

Definition at line 233 of file GlobalPatternFinder.h.

{nullptr};

sector1

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::sector1 {0}

Definition at line 250 of file GlobalPatternFinder.h.

{0};

sector2

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::sector2 {0}

Definition at line 251 of file GlobalPatternFinder.h.

{0};

sectorCoord

uint8_t MuonR4::FastReco::GlobalPatternFinder::PatternState::sectorCoord {0}

expanded sector coordinate & the two corresponding physical sectors

Definition at line 249 of file GlobalPatternFinder.h.

{0};

stations

std::vector<StIndex> MuonR4::FastReco::GlobalPatternFinder::PatternState::stations {}

Pattern hit stations to save the filling order.

Stations can be repeated when we invert the search direction (e.g. from seed ourward -> BM BO, then from seed inward BM BI)

Definition at line 261 of file GlobalPatternFinder.h.

{};

theta

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

Average theta & average phi of the pattern.

Definition at line 235 of file GlobalPatternFinder.h.

{0.};

visualInfo

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

Pointer to Visual Information for pattern visualization.

Definition at line 229 of file GlobalPatternFinder.h.

{nullptr};

---

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

• GlobalPatternFinder.h
• GlobalPatternFinder.cxx