MuonR4::SegmentFit::MdtSegmentSeedGenerator Class Reference

Helper class to generate valid seeds for the segment fit. More...

#include <MdtSegmentSeedGenerator.h>

Inheritance diagram for MuonR4::SegmentFit::MdtSegmentSeedGenerator:

Collaboration diagram for MuonR4::SegmentFit::MdtSegmentSeedGenerator:

Classes
struct	Config
	Configuration switches of the module More...
struct	DriftCircleSeed
	Helper struct from a generated Mdt seed. More...
struct	SeedSolution
	Cache of all solutions seen thus far. More...

Public Types
using	LineSeeder_t = Acts::Experimental::CompositeSpacePointLineSeeder
using	HitVec = SpacePointPerLayerSplitter::HitVec

Public Member Functions
	MdtSegmentSeedGenerator (const std::string &name, const SegmentSeed *segmentSeed, const Config &configuration)
	Standard constructor taking the segmentSeed to start with and then few configuration tunes. More...
	~MdtSegmentSeedGenerator ()
std::optional< DriftCircleSeed >	nextSeed (const EventContext &ctx)
	returns the next seed in the row More...
unsigned int	numGenerated () const
	Returns how many seeds have been generated. More...
const Config &	config () const
	Returns the current seed configuration. More...
bool	msgLvl (const MSG::Level lvl) const
	Test the output level. More...
MsgStream &	msg () const
	The standard message stream. More...
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream. More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Private Types
using	TangentLine = LineSeeder_t::TwoCircleTangentPars
using	TangentAmbi = LineSeeder_t::TangentAmbi

Private Member Functions
bool	isValidLine (const TangentLine &solution) const
	Checks whether the intercept and the angle are witihn the allowed ranges. More...
Line_t::ParamVector	constructLinePars (const double theta, const double y0) const
	Construct the 3D-Line parameters from the estimates theta & y0 from the tangent line. More...
std::optional< DriftCircleSeed >	buildSeed (const EventContext &ctx, const HoughHitType &topHit, const HoughHitType &bottomHit, const TangentAmbi ambi)
	Tries to build the seed from the two hits. More...
void	moveToNextCandidate ()
	Prepares the generator to generate the seed from the next pair of drift circles. More...
void	initMessaging () const
	Initialize our message level and MessageSvc. More...

Static Private Member Functions
static SeedingAux::Config	translate (const Config &cfg)
	Translate the SeedGenerator config to a Seed auxillary config. More...

Private Attributes
Config	m_cfg {}
Line_t	m_line {}
	Line to instantiate the seed parameters. More...
const SegmentSeed *	m_segmentSeed {nullptr}
SpacePointPerLayerSplitter	m_hitLayers {m_segmentSeed->getHitsInMax()}
std::size_t	m_upperLayer {0}
	Considered layer to pick the top drift circle from. More...
std::size_t	m_lowerLayer {0}
	Considered layer to pick the bottom drift circle from. More...
std::size_t	m_lowerHitIndex {0}
	Explicit hit to pick in the selected bottom layer. More...
std::size_t	m_upperHitIndex {0}
	Explicit hit to pick in the selected top layer. More...
std::size_t	m_signComboIndex {0}
	Index of the left-right ambiguity between the circles. More...
std::vector< SeedSolution >	m_seenSolutions {}
	Vector caching equivalent solutions to avoid double seeding. More...
unsigned int	m_nGenSeeds {0}
	Counter on how many seeds have been generated. More...
std::string	m_nm
	Message source name. More...
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels) More...
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer. More...
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level. More...
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging) More...

Static Private Attributes
static constexpr std::array< TangentAmbi, 4 >	s_signCombos

Detailed Description

Helper class to generate valid seeds for the segment fit.

The generator first returns a seed directly made from the patten recogntion. Afterwards it builds seeds by lying tangent lines to a pair of drift circles. The pairing starts from the innermost & outermost layers with tubes. A valid seed must have at least 4 associated hits which are within a chi2 of 5. If two seeds within the parameter resolution are generated, then the latter one is skipped.

Definition at line 27 of file MdtSegmentSeedGenerator.h.

Member Typedef Documentation

HitVec

using MuonR4::SegmentFit::MdtSegmentSeedGenerator::HitVec = SpacePointPerLayerSplitter::HitVec

Definition at line 30 of file MdtSegmentSeedGenerator.h.

LineSeeder_t

using MuonR4::SegmentFit::MdtSegmentSeedGenerator::LineSeeder_t = Acts::Experimental::CompositeSpacePointLineSeeder

Definition at line 29 of file MdtSegmentSeedGenerator.h.

TangentAmbi

using MuonR4::SegmentFit::MdtSegmentSeedGenerator::TangentAmbi = LineSeeder_t::TangentAmbi

private

Definition at line 97 of file MdtSegmentSeedGenerator.h.

TangentLine

using MuonR4::SegmentFit::MdtSegmentSeedGenerator::TangentLine = LineSeeder_t::TwoCircleTangentPars

private

Definition at line 96 of file MdtSegmentSeedGenerator.h.

Constructor & Destructor Documentation

MdtSegmentSeedGenerator()

MuonR4::SegmentFit::MdtSegmentSeedGenerator::MdtSegmentSeedGenerator	(	const std::string &	name,
		const SegmentSeed *	segmentSeed,
		const Config &	configuration
	)

Standard constructor taking the segmentSeed to start with and then few configuration tunes.

Parameters

name	Name of the Seed generator's logger
segmentSeed	Seed from which the seeds for the fit are built
configuration	Passed configuration settings of the generator

Check whether the first layer is too busy

Check whether the lower layer is too busy

Definition at line 63 of file MdtSegmentSeedGenerator.cxx.

                                                                                 :
            AthMessaging{name},
            m_cfg{configuration},
            m_segmentSeed{segmentSeed} {
 
        if (m_hitLayers.mdtHits().empty()) return;
        
        if (std::ranges::any_of(m_hitLayers.mdtHits(), [this](const HitVec& vec){
                return vec.size() > m_cfg.busyLayerLimit;
            })) {
            m_cfg.startWithPattern = false;
        }
        // Set the start for the upper layer
        m_upperLayer = m_hitLayers.mdtHits().size()-1; 
 
        while (m_lowerLayer < m_upperLayer){
            const HitVec& lower{m_hitLayers.mdtHits()[m_lowerLayer]};
            if (lower.size() > m_cfg.busyLayerLimit || !firstGoodHit(lower, m_lowerHitIndex)) {
                ++m_lowerLayer;
            } else {
                break;
            }
            
        }
        while (m_lowerLayer < m_upperLayer){
         const HitVec& upper{m_hitLayers.mdtHits()[m_upperLayer]};
            if (upper.size() > m_cfg.busyLayerLimit || !firstGoodHit(upper, m_upperHitIndex)) {
                --m_upperLayer;
            } else {
                break;
            }
 
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            std::stringstream sstr{};
            for (const auto [layCount, layer] : Acts::enumerate(m_hitLayers.mdtHits())) { 
                sstr<<"Mdt-hits in layer "<<layCount<<": "<<layer.size()<<std::endl;
                for (const HoughHitType& hit : layer) {
                    sstr<<"   **** "<<(*hit)<<std::endl;
                }
            }
            for (const auto [layCount, layer] : Acts::enumerate(m_hitLayers.stripHits())) { 
                sstr<<"Hits in layer "<<layCount<<": "<<layer.size()<<std::endl;
                for (const HoughHitType& hit : layer) {
                    sstr<<"   **** "<<(*hit)<<std::endl;
                }
            }
            ATH_MSG_VERBOSE("SeedGenerator - sorting of hits done. Mdt layers: "<<m_hitLayers.mdtHits().size()
                            <<", strip layers: "<<m_hitLayers.stripHits().size()<<std::endl<<sstr.str()<<std::endl<<std::endl);
        }
    }

~MdtSegmentSeedGenerator()

MuonR4::SegmentFit::MdtSegmentSeedGenerator::~MdtSegmentSeedGenerator ( )

default

Member Function Documentation

buildSeed()

std::optional< MdtSegmentSeedGenerator::DriftCircleSeed > MuonR4::SegmentFit::MdtSegmentSeedGenerator::buildSeed ( const EventContext &  ctx, const HoughHitType &  topHit, const HoughHitType &  bottomHit, const TangentAmbi  ambi  )

private

Tries to build the seed from the two hits.

Fails if the solution is invalid or if the seed has already been built before

Parameters

topHit	Hit candidate from the upper layer
bottomHit	Hit candidate from the lower layer
sign	Object encoding whether the tangent is left / right

If there's an estimate on the time of arrival use it

Create a new line position & direction which also takes the potential phi estimates into account

Collect all hits close to the seed line

what ever comes after is not matching onto the segment

Reject seeds with too litle Mdt hit association

Last check wheather another seed with the same left-right combination hasn't already been found

All seed hits are of the same size

Including the places where no seed hit was assigned. Both solutions match in terms of left-right solutions. It's very likely that they're converging to the same segment.

Calibrate the seed hits

Add the solution to the list. That we don't iterate twice over it

If we found a long Mdt seed, then ensure that all subsequent seeds have at least the same amount of Mdt hits.

Associate strip hits

Definition at line 269 of file MdtSegmentSeedGenerator.cxx.

                                                                   {
        
        const Muon::IMuonIdHelperSvc* idHelperSvc{topHit->msSector()->idHelperSvc()};
        if (!isGoodDC(*bottomHit) || !isGoodDC(*topHit)) {
            THROW_EXCEPTION("Bad hit detected, despite that should have been captured upstream "
                <<isGoodDC(*bottomHit)<<", "<<isGoodDC(*topHit)<<" - lowerLayer: "<<m_lowerLayer
                <<", upperLayer"<<m_upperLayer<<", "<<"upperHit: "<<m_upperHitIndex<<", lowerHit: "<<m_lowerHitIndex<<" - "
                <<m_hitLayers.mdtHits().at(m_lowerLayer).size()<<", "<<m_hitLayers.mdtHits().at(m_upperLayer).size());
        }
  
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Attempt to construct seed from "<<idHelperSvc->toString(bottomHit->identify())
                      <<" && top tube "<<idHelperSvc->toString(topHit->identify()));
        
        SeedSolution solCandidate{};
        static_cast<TangentLine&>(solCandidate) = LineSeeder_t::constructTangentLine(*topHit, *bottomHit, ambi);
 
        Amg::Vector3D flipedDir = Amg::AngleAxis3D{solCandidate.theta, topHit->sensorDirection()} * topHit->planeNormal();
        solCandidate.theta = flipedDir.theta();
 
        if (!isValidLine(solCandidate)) {
            return std::nullopt;
        }
        
        std::unique_ptr<CalibratedSpacePoint> calibBottom{}, calibTop{};
        const double t0 = m_segmentSeed->parameters()[Acts::toUnderlying(ParamDefs::t0)];
        if (m_cfg.recalibSeedCircles) {
            m_line.updateParameters(constructLinePars(solCandidate.theta, solCandidate.y0));
            calibBottom = m_cfg.calibrator->calibrate(ctx, bottomHit, m_line.position(), m_line.direction(), t0);
            calibTop = m_cfg.calibrator->calibrate(ctx, topHit, m_line.position(), m_line.direction(), t0);
            static_cast<TangentLine&>(solCandidate) = LineSeeder_t::constructTangentLine(*calibTop, *calibBottom, ambi);
            if (!isValidLine(solCandidate)) {
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Recalibrated segment seed is invalid");
                return std::nullopt;
            }
        }
 
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Test new "<<solCandidate<<". "<<m_seenSolutions.size());
 
        if (std::ranges::find_if(m_seenSolutions,
                        [&solCandidate, this] (const SeedSolution& seen) {
                            const double deltaY = std::abs(seen.y0 - solCandidate.y0);
                            const double limitY = std::hypot(seen.dY0, solCandidate.dY0);
                            const double dTheta = std::abs(seen.theta - solCandidate.theta);
                            const double limitTh = std::hypot(seen.dTheta, solCandidate.dTheta);
                            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": "<<seen
                                    <<std::format(" delta Y: {:.2f} {:} {:.2f}", deltaY, deltaY < limitY ? '<' : '>', limitY)
                                    <<std::format(" delta theta: {:.2f} {:} {:.2f}", dTheta, dTheta < limitTh ? '<' : '>', limitTh) );
                            return deltaY < limitY && dTheta < limitTh;;
                        }) != m_seenSolutions.end()){
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Reject due to similarity");
            return std::nullopt;
        }
 
        DriftCircleSeed candidateSeed{};
        candidateSeed.parentBucket = m_segmentSeed->parentBucket();
        
        const auto finalSeedPars = constructLinePars(solCandidate.theta,solCandidate.y0);
        m_line.updateParameters(finalSeedPars);          
        for (const auto [layerNr,  hitsInLayer] : Acts::enumerate(m_hitLayers.mdtHits())) {
            ATH_MSG_VERBOSE( __func__<<"() "<<__LINE__<<": "<<hitsInLayer.size()<<" hits in layer "<<(layerNr +1));
            bool hadGoodHit{false};
            for (const HoughHitType testMe : hitsInLayer) {
                using namespace Acts::detail::LineHelper;
                const double distance = Acts::abs(signedDistance(testMe->localPosition(), testMe->sensorDirection(),
                                                                 m_line.position(), m_line.direction()));
                const double pull = Acts::abs(distance - testMe->driftRadius()) / std::sqrt(testMe->covariance()[covIdx]);
 
                const auto* re = static_cast<const xAOD::MdtDriftCircle*>(testMe->primaryMeasurement())->readoutElement();
 
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Test hit "<<idHelperSvc->toString(testMe->identify())
                            <<" "<<Amg::toString(testMe->localPosition())<<", pull: "<<pull<<", distance: "<<distance);
                if (pull < m_cfg.hitPullCut && distance < re->tubeRadius()) {
                    hadGoodHit = true;
                    solCandidate.seedHits.emplace_back(testMe);
                    candidateSeed.nMdt += isGoodDC(*testMe);
                }
                else if (hadGoodHit) {
                    break;
                } 
            }
        }
        const unsigned hitCut = std::max(1.*m_cfg.nMdtHitCut, 
                                         m_cfg.nMdtLayHitCut * m_hitLayers.mdtHits().size()); 
 
        if (1.*candidateSeed.nMdt < hitCut) {
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Too few hits associated "<<candidateSeed.nMdt<<", expect: "<<hitCut<<" hits.");
            return std::nullopt;
        }
        /* Calculate the left-right signs of the used hits */
        if (m_cfg.overlapCorridor) {
           solCandidate.solutionSigns = SeedingAux::strawSigns(m_line, solCandidate.seedHits);
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Circle solutions for seed "
                          <<idHelperSvc->toStringChamber(bottomHit->identify())<<" - "<<solCandidate);
            for (unsigned int a = m_cfg.startWithPattern; a< m_seenSolutions.size() ;++a) { 
                const SeedSolution& accepted = m_seenSolutions[a];
                unsigned int nOverlap{0};
                std::vector<int> corridor = SeedingAux::strawSigns(m_line, accepted.seedHits);                
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Test seed against accepted "<<accepted<<", updated signs: "<<corridor);
                for (unsigned int l = 0; l < accepted.seedHits.size(); ++l){
                    nOverlap += (corridor[l] == accepted.solutionSigns[l]);
                }
                if (nOverlap == corridor.size() && accepted.seedHits.size() >= solCandidate.seedHits.size()) {
                    ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Same set of hits collected within the same corridor");
                    return std::nullopt;
                }
            }
        }
        candidateSeed.parameters[Acts::toUnderlying(ParamDefs::t0)] = t0;
        for (const auto p : { ParamDefs::x0, ParamDefs::theta, ParamDefs::phi, ParamDefs::y0}) {
            candidateSeed.parameters[Acts::toUnderlying(p)] = finalSeedPars[Acts::toUnderlying(p)];
        }      
        for (const HoughHitType& hit : solCandidate.seedHits){
            //calibBottom is nullptr after it has been moved, so...
            //cppcheck-suppress accessMoved
            if (hit == bottomHit && calibBottom) {
                candidateSeed.measurements.emplace_back(std::move(calibBottom));
            } 
            //calibTop is nullptr after it has been moved, so...
            //cppcheck-suppress accessMoved
            else if (hit == topHit && calibTop) {
                candidateSeed.measurements.emplace_back(std::move(calibTop));
            } else {
                candidateSeed.measurements.emplace_back(m_cfg.calibrator->calibrate(ctx, hit, m_line.position(), 
                                                                                    m_line.direction(), t0));
            }
        }
 
        m_seenSolutions.emplace_back(std::move(solCandidate));
        if (m_cfg.tightenHitCut) {
            m_cfg.nMdtHitCut = std::max(m_cfg.nMdtHitCut, candidateSeed.nMdt);
        }
        ++m_nGenSeeds;        
        ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": In event "<<ctx.eventID().event_number()<<" found new seed solution "<<toString(candidateSeed.parameters));
 
        for (const std::vector<HoughHitType>& hitsInLayer : m_hitLayers.stripHits()) {
            HoughHitType bestHitLoc0{nullptr}, bestHitLoc1{nullptr};
            double bestPullLoc0{m_cfg.hitPullCut}, bestPullLoc1{m_cfg.hitPullCut};
            for (const HoughHitType testMe : hitsInLayer) {
                const double pull = std::sqrt(SeedingAux::chi2Term(m_line, *testMe));
                ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": Test hit "<<idHelperSvc->toString(testMe->identify())
                            <<" "<<Amg::toString(testMe->localPosition())<<", pull: "<<pull<<".");
                if (testMe->measuresLoc0() &&  pull < bestPullLoc0) {
                    bestPullLoc0 = pull;
                    bestHitLoc0 = testMe;
                }
                if (testMe->measuresLoc1() &&  pull < bestPullLoc1) {
                    bestPullLoc1 = pull;
                    bestHitLoc1 = testMe;
                }                
            }
            if (bestHitLoc0) {
                candidateSeed.measurements.push_back(m_cfg.calibrator->calibrate(ctx, bestHitLoc0, m_line.position(),
                                                                                 m_line.direction(), t0));
            }
            if (bestHitLoc1 && bestHitLoc1 != bestHitLoc0) {
                candidateSeed.measurements.push_back(m_cfg.calibrator->calibrate(ctx, bestHitLoc1, m_line.position(),
                                                                                 m_line.direction(), t0));                
            }
           
        }
        return candidateSeed;
    }

config()

const MdtSegmentSeedGenerator::Config & MuonR4::SegmentFit::MdtSegmentSeedGenerator::config

(

)

const

Returns the current seed configuration.

Definition at line 58 of file MdtSegmentSeedGenerator.cxx.

                                                                               {
        return m_cfg;
    }

constructLinePars()

Line_t::ParamVector MuonR4::SegmentFit::MdtSegmentSeedGenerator::constructLinePars ( const double  theta, const double  y0  ) const

private

Construct the 3D-Line parameters from the estimates theta & y0 from the tangent line.

Parameters

theta	Tangent line theta in the y-z plane
y0	Y intercept at z=0

Definition at line 233 of file MdtSegmentSeedGenerator.cxx.

                                                                                                          {
        Line_t::ParamVector pars{};
        pars[Acts::toUnderlying(ParamDefs::y0)] = y0;
        pars[Acts::toUnderlying(ParamDefs::x0)] = m_segmentSeed->interceptX();     
        if (Acts::abs(m_segmentSeed->tanAlpha()) > std::numeric_limits<double>::epsilon()) {
            const Amg::Vector3D dirFromTan = Acts::makeDirectionFromAxisTangents(m_segmentSeed->tanAlpha(),
                                                                                 std::tan(theta));
            pars[Acts::toUnderlying(ParamDefs::phi)] = dirFromTan.phi();
            pars[Acts::toUnderlying(ParamDefs::theta)]  = dirFromTan.theta();
        } else {
            pars[Acts::toUnderlying(ParamDefs::phi)] = 90._degree;
            pars[Acts::toUnderlying(ParamDefs::theta)]  = theta;
        }
        return pars;
    }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

isValidLine()

bool MuonR4::SegmentFit::MdtSegmentSeedGenerator::isValidLine ( const TangentLine &  solution ) const

private

Checks whether the intercept and the angle are witihn the allowed ranges.

Parameters

solution

Reference to the tangent line solution to check

Definition at line 248 of file MdtSegmentSeedGenerator.cxx.

                                                                              {
        if (solution.theta < m_cfg.thetaRange[0] || 
            solution.theta > m_cfg.thetaRange[1]) {
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": The theta angle: "
                <<(solution.theta / 1._degree)
                <<" is out of the valid range ["<<(m_cfg.thetaRange[0] / 1._degree)
                <<"-"<<(m_cfg.thetaRange[1] / 1._degree)<<"].");
            return false;
        }
        if (solution.y0 < m_cfg.interceptRange[0] || 
            solution.y0 > m_cfg.interceptRange[1]) {
            ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<": The intercept: "
                <<solution.y0 
                <<" is out of the valid range ["<<m_cfg.interceptRange[0] 
                <<"-"<<m_cfg.interceptRange[1] <<"].");
            return false;
        }
        return true;
 
    }

moveToNextCandidate()

void MuonR4::SegmentFit::MdtSegmentSeedGenerator::moveToNextCandidate ( )

inlineprivate

Prepares the generator to generate the seed from the next pair of drift circles.

Vary the left-right solutions

Move to the next hit in the lower layer

Ensure that the first hit in the lower layer is good for seeding

--> So we can update to the next hit in the upper layer

All combinations of hits & lines in both layers are processed Switch to the next lowerLayer. But skip the busy ones according to the configuration

The layer has ineed a good hit

Abort the loop if we parsed the multi-layer boundary

Go to the first lower layer

But search at least the first valid hit there

The layer has ineed a good hit

Definition at line 123 of file MdtSegmentSeedGenerator.cxx.

                                                             {
        const HitVec& lower = m_hitLayers.mdtHits()[m_lowerLayer];
        const HitVec& upper = m_hitLayers.mdtHits()[m_upperLayer];
        if (++m_signComboIndex < s_signCombos.size()) {
            return;
        }
        m_signComboIndex = 0; 
        
        if (moveToNextHit(lower, m_lowerHitIndex)) {
            return;
        }
        if (firstGoodHit(lower, m_lowerHitIndex)) {
            if (moveToNextHit(upper, m_upperHitIndex)) {
                return;
            }
        }
        while (m_lowerLayer < m_upperLayer) {
            const HitVec& nextLower{m_hitLayers.mdtHits()[++m_lowerLayer]};
            if (nextLower.size() > m_cfg.busyLayerLimit) {
                continue;
            }
            if (firstGoodHit(nextLower, m_lowerHitIndex)) {
                break;
            }
        }
 
        if (m_lowerLayer < m_upperLayer) {
            firstGoodHit(upper, m_upperHitIndex);
            return;
        }
        if (m_lowerLayer >= m_hitLayers.firstLayerFrom2ndMl() && numGenerated()){
            m_lowerLayer = m_upperLayer;
            return;
        }
        m_lowerLayer = 0; 
        do {
            const HitVec& nextLower{m_hitLayers.mdtHits()[m_lowerLayer]};
            if (nextLower.size() > m_cfg.busyLayerLimit) {
                continue;
            }
            if (firstGoodHit(nextLower, m_lowerHitIndex)) {
                break;
            }
        } while (++m_lowerLayer < m_upperLayer);
 
        while (m_lowerLayer < m_upperLayer) {
            const HitVec& nextUpper{m_hitLayers.mdtHits()[--m_upperLayer]};
            if (nextUpper.size() > m_cfg.busyLayerLimit) {
                continue;
            }
            if (firstGoodHit(nextUpper, m_upperHitIndex)) {
                break;
            }
        }
    }

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 164 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level  lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 179 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (!m_initialized.test_and_set()) initMessaging();
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

nextSeed()

std::optional< MdtSegmentSeedGenerator::DriftCircleSeed > MuonR4::SegmentFit::MdtSegmentSeedGenerator::nextSeed

(

const EventContext &

ctx

)

returns the next seed in the row

Increment for the next candidate

If a candidate is built return it. Otherwise continue the process

Definition at line 190 of file MdtSegmentSeedGenerator.cxx.

                                                                 {
        std::optional<DriftCircleSeed> found = std::nullopt; 
        if (!m_nGenSeeds && m_cfg.startWithPattern) {
            ++m_nGenSeeds;
            found = std::make_optional<DriftCircleSeed>();
            found->parameters = m_segmentSeed->parameters();
            found->measurements = m_cfg.calibrator->calibrate(ctx,
                                                              m_segmentSeed->getHitsInMax(),
                                                              m_segmentSeed->localPosition(),
                                                              m_segmentSeed->localDirection(),0.);
            found->parentBucket = m_segmentSeed->parentBucket();
            found->nMdt = std::ranges::count_if(m_segmentSeed->getHitsInMax(),
                                                [](const SpacePoint* hit){
                                                    return hit->type() == xAOD::UncalibMeasType::MdtDriftCircleType;
                                                });
            SeedSolution patternSeed{};
            patternSeed.seedHits.resize(2*m_hitLayers.mdtHits().size());
            patternSeed.solutionSigns.resize(2*m_hitLayers.mdtHits().size());
            patternSeed.y0 = m_segmentSeed->interceptY();
            patternSeed.theta = m_segmentSeed->tanBeta();
            m_seenSolutions.push_back(std::move(patternSeed));
            return found;
        }
       
        while (m_lowerLayer < m_upperLayer) {
            const HitVec& lower = m_hitLayers.mdtHits().at(m_lowerLayer);
            const HitVec& upper = m_hitLayers.mdtHits().at(m_upperLayer);
            ATH_MSG_VERBOSE("Layers with hits: "<<m_hitLayers.mdtHits().size()
                            <<" -- next bottom hit: "<<m_lowerLayer<<", hit: "<<m_lowerHitIndex
                            <<" ("<<lower.size()<<"), top hit " <<m_upperLayer<<", "<<m_upperHitIndex
                            <<" ("<<upper.size()<<") - ambiguity "
                            <<LineSeeder_t::toString(s_signCombos[m_signComboIndex]));
 
            found = buildSeed(ctx, upper.at(m_upperHitIndex), lower.at(m_lowerHitIndex), s_signCombos.at(m_signComboIndex));
            moveToNextCandidate();
            if (found) {
                return found;
            }
        }
        return std::nullopt; 
    }

numGenerated()

unsigned int MuonR4::SegmentFit::MdtSegmentSeedGenerator::numGenerated

(

)

const

Returns how many seeds have been generated.

Definition at line 120 of file MdtSegmentSeedGenerator.cxx.

                                                             {
        return m_nGenSeeds;
    }

setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

translate()

static SeedingAux::Config MuonR4::SegmentFit::MdtSegmentSeedGenerator::translate ( const Config &  cfg )

staticprivate

Translate the SeedGenerator config to a Seed auxillary config.

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_cfg

Config MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_cfg {}

private

Definition at line 134 of file MdtSegmentSeedGenerator.h.

m_hitLayers

SpacePointPerLayerSplitter MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_hitLayers {m_segmentSeed->getHitsInMax()}

private

Definition at line 139 of file MdtSegmentSeedGenerator.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_line

Line_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_line {}

private

Line to instantiate the seed parameters.

Definition at line 137 of file MdtSegmentSeedGenerator.h.

m_lowerHitIndex

std::size_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_lowerHitIndex {0}

private

Explicit hit to pick in the selected bottom layer.

Definition at line 146 of file MdtSegmentSeedGenerator.h.

m_lowerLayer

std::size_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_lowerLayer {0}

private

Considered layer to pick the bottom drift circle from.

Definition at line 144 of file MdtSegmentSeedGenerator.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nGenSeeds

unsigned int MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_nGenSeeds {0}

private

Counter on how many seeds have been generated.

Definition at line 154 of file MdtSegmentSeedGenerator.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_seenSolutions

std::vector<SeedSolution> MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_seenSolutions {}

private

Vector caching equivalent solutions to avoid double seeding.

Definition at line 152 of file MdtSegmentSeedGenerator.h.

m_segmentSeed

const SegmentSeed* MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_segmentSeed {nullptr}

private

Definition at line 138 of file MdtSegmentSeedGenerator.h.

m_signComboIndex

std::size_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_signComboIndex {0}

private

Index of the left-right ambiguity between the circles.

Definition at line 150 of file MdtSegmentSeedGenerator.h.

m_upperHitIndex

std::size_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_upperHitIndex {0}

private

Explicit hit to pick in the selected top layer.

Definition at line 148 of file MdtSegmentSeedGenerator.h.

m_upperLayer

std::size_t MuonR4::SegmentFit::MdtSegmentSeedGenerator::m_upperLayer {0}

private

Considered layer to pick the top drift circle from.

Definition at line 142 of file MdtSegmentSeedGenerator.h.

s_signCombos

constexpr std::array<TangentAmbi, 4> MuonR4::SegmentFit::MdtSegmentSeedGenerator::s_signCombos

staticconstexprprivate

Initial value:

{TangentAmbi::LL, TangentAmbi::RR,
                                                                     TangentAmbi::LR, TangentAmbi::RL}

Definition at line 98 of file MdtSegmentSeedGenerator.h.

---

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

• MdtSegmentSeedGenerator.h
• MdtSegmentSeedGenerator.cxx