MuonR4::FastReco::FastMuonSABuilder Class Reference

Standalone module to handle fast segment fitting and momentum estimation starting from global patterns. More...

#include <FastMuonSABuilder.h>

Inheritance diagram for MuonR4::FastReco::FastMuonSABuilder:

Collaboration diagram for MuonR4::FastReco::FastMuonSABuilder:

Classes
struct	Config
	Configuration object. More...

Public Types
using	StIndex = Muon::MuonStationIndex::StIndex
	Type alias for the station index.
using	Parameters = SegmentFit::Parameters
	Type alias for the segment fitting parameters.
using	LineFitter = MuonR4::SegmentFit::SegmentLineFitter
	Type alias for the line fitter.
using	MdtSegmentSeeder = MuonR4::SegmentFit::MdtSegmentSeedGenerator
	Type alias for the L-R segment seeder.
using	MuonCont_t = xAOD::FillContainer<xAOD::MuonContainer, xAOD::MuonAuxContainerR4>
	Define the muon container type.

Public Member Functions
	FastMuonSABuilder (const std::string &name, Config &&config)
	Standard constructor.
xAOD::Muon *	buildMuonCandidate (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const GlobalPattern &pattern, MuonCont_t &outMuons) const
	Main methods steering the muon candidate building.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
using	Hit_t = const SpacePoint*
	Type alias for the hit type & associated vector.
using	HitVec_t = std::vector<Hit_t>
using	Bucket_t = const SpacePointBucket*
	Type alias for the bucket type.
using	Segment_t = std::unique_ptr<Segment>
	Type alias for the segment type.

Private Member Functions
Segment_t	fitSegment (const EventContext &ctx, const Amg::Transform3D &localToGlobal, Bucket_t parentBucket, std::vector< Hit_t > &&hits) const
	Fit a segment using the provided seed.
HitVec_t	estimateBendingPars (HitVec_t &&hits, Parameters &pars) const
	Estimate the bending parameters of a segment through a weighted linear regression.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
Config	m_cfg
	Global Pattern Recognition configuration.
SpacePointPerLayerSorter	m_spSorter {}
	Spacepoint sorter per logical measurement layer.
std::unique_ptr< LineFitter >	m_fitter {}
	Pointer to the actual segment fitter.
std::unique_ptr< LineFitter >	m_nswFitter {}
	Pointer to the NSW segment fitter.
std::unique_ptr< MdtSegmentSeeder >	m_mdtSeeder {}
	Pointer to the L-R segment seeder.
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

Standalone module to handle fast segment fitting and momentum estimation starting from global patterns.

This tool consists of the final stage of the Phase-2 fast reconstruction, processing the global patterns found in previous steps to build muon candidates. It performs a straight line segment fit using the pattern hits in each station and use the fitted segments to estimate the momentum of the muon candidate. The main method consumes the global patterns and produces the output muon candidates as ****to be defined FastReco::MuonSA objects****.

Definition at line 36 of file FastMuonSABuilder.h.

Member Typedef Documentation

Bucket_t

using MuonR4::FastReco::FastMuonSABuilder::Bucket_t = const SpacePointBucket*

private

Type alias for the bucket type.

Definition at line 108 of file FastMuonSABuilder.h.

Hit_t

using MuonR4::FastReco::FastMuonSABuilder::Hit_t = const SpacePoint*

private

Type alias for the hit type & associated vector.

Definition at line 105 of file FastMuonSABuilder.h.

HitVec_t

using MuonR4::FastReco::FastMuonSABuilder::HitVec_t = std::vector<Hit_t>

private

Definition at line 106 of file FastMuonSABuilder.h.

LineFitter

using MuonR4::FastReco::FastMuonSABuilder::LineFitter = MuonR4::SegmentFit::SegmentLineFitter

Type alias for the line fitter.

Definition at line 43 of file FastMuonSABuilder.h.

MdtSegmentSeeder

using MuonR4::FastReco::FastMuonSABuilder::MdtSegmentSeeder = MuonR4::SegmentFit::MdtSegmentSeedGenerator

Type alias for the L-R segment seeder.

Definition at line 45 of file FastMuonSABuilder.h.

MuonCont_t

using MuonR4::FastReco::FastMuonSABuilder::MuonCont_t = xAOD::FillContainer<xAOD::MuonContainer, xAOD::MuonAuxContainerR4>

Define the muon container type.

Definition at line 47 of file FastMuonSABuilder.h.

Parameters

using MuonR4::FastReco::FastMuonSABuilder::Parameters = SegmentFit::Parameters

Type alias for the segment fitting parameters.

Definition at line 41 of file FastMuonSABuilder.h.

Segment_t

using MuonR4::FastReco::FastMuonSABuilder::Segment_t = std::unique_ptr<Segment>

private

Type alias for the segment type.

Definition at line 110 of file FastMuonSABuilder.h.

StIndex

using MuonR4::FastReco::FastMuonSABuilder::StIndex = Muon::MuonStationIndex::StIndex

Type alias for the station index.

Definition at line 39 of file FastMuonSABuilder.h.

Constructor & Destructor Documentation

FastMuonSABuilder()

MuonR4::FastReco::FastMuonSABuilder::FastMuonSABuilder	(	const std::string &	name,
		Config &&	config )

Standard constructor.

Parameters

name	Name to be printed in the messaging
config	Configuration parameters

Initialize the segment line fitter

Initialize the NSW segment fitter

Initialize the L-R segment seeder

Definition at line 59 of file FastMuonSABuilder.cxx.

                                                                           :
    AthMessaging{name}, m_cfg{std::move(config)} {
        SegmentLineFitter::Config fitCfg{};
        fitCfg.calibrator = m_cfg.calibrator;
        fitCfg.visionTool = m_cfg.visionTool;
        fitCfg.idHelperSvc = m_cfg.idHelperSvc;
        fitCfg.fitT0 = false;
        fitCfg.calcAlongStrip = false;
        fitCfg.recalibrate = m_cfg.recalibInFit;
        fitCfg.useFastFitter = m_cfg.useFastFitter;
        fitCfg.fastPreFitter = m_cfg.fastPreFitter;
        fitCfg.ignoreFailedPreFit = m_cfg.ignoreFailedPreFit;
        fitCfg.useHessian = m_cfg.useHessianResidual;
        fitCfg.doBeamSpot = false;
        fitCfg.outlierRemovalCut = m_cfg.outlierRemovalCut;
        fitCfg.recoveryPull = m_cfg.recoveryPull;
        fitCfg.nPrecHitCut = m_cfg.precHitCut;
        fitCfg.maxIter = m_cfg.maxIter;
        fitCfg.parsToUse = {ParamDefs::y0, ParamDefs::theta};

        SegmentLineFitter::Config nswFitCfg{fitCfg};
        nswFitCfg.parsToUse = {ParamDefs::x0, ParamDefs::y0, ParamDefs::theta, ParamDefs::phi};
 
        m_fitter = std::make_unique<LineFitter>(name, std::move(fitCfg));
        m_nswFitter = std::make_unique<LineFitter>(name, std::move(nswFitCfg));

        MdtSegmentSeeder::Config genCfg{};
        genCfg.hitPullCut = m_cfg.seedHitChi2;
        genCfg.busyLayerLimit = 3.;
        genCfg.startWithPattern = false;
        m_mdtSeeder = std::make_unique<MdtSegmentSeeder>(std::move(genCfg), makeActsAthenaLogger(this, name));
  
    }

Member Function Documentation

buildMuonCandidate()

xAOD::Muon * MuonR4::FastReco::FastMuonSABuilder::buildMuonCandidate	(	const EventContext &	ctx,
		const ActsTrk::GeometryContext &	gctx,
		const GlobalPattern &	pattern,
		MuonCont_t &	outMuons ) const

Main methods steering the muon candidate building.

Given the global pattern, it fits segments in each station and use them to estimate the muon momentum.

Parameters

ctx	Event context
gctx	Geometry context
pattern	Global pattern
outMuons	Output muon container to be filled

Returns

: Pointer to the built muon candidate if successful, otherwise nullptr

If we already have 3 segments, we don't try to fit more segments in other stations. Same if we are at the last station and haven't found any segments yet

Retrieve the pattern hits & parent buckets in the station

Since we can have multiple sectors in a station, we need to group hits by sector

We collect & sort the sectors by the number of hits, so we'll process first the sectors with more hits.

Try to fit a segment using the first sector. If it fails or the segment has poor quality, try other sectors if any

Find the parent bucket, needed for holes recovery in segment fitting. We expect one parent bucket per sector; if we have multiple ones, take the one containing the most hits

Definition at line 97 of file FastMuonSABuilder.cxx.

                                                                  {
    ATH_MSG_VERBOSE(__func__<<"() Start processing " << pattern);
 
    std::vector<StIndex> stations {pattern.getStations()};
    std::ranges::sort(stations, [](StIndex s1, StIndex s2) {
        LayerIndex l1 {toLayerIndex(s1)}, l2 {toLayerIndex(s2)};
        if (l1 == l2) {
            return isBarrel(s1);
        }
        return layerRank(l1) < layerRank(l2);
    });
 
    std::vector<Segment_t> muonSegments{};
    muonSegments.reserve(3u);
    for (const StIndex st : stations) {
        if (muonSegments.size() > 2 || (st == stations.back() && muonSegments.size() == 0.)) {
            break;
        }
        // If we already have a segment in the layer, we don't try to fit another one
        const LayerIndex layer {toLayerIndex(st)};
        if (std::ranges::any_of(muonSegments, [&layer](const Segment_t& seg) {
                return toLayerIndex(
                    seg->measurements().back()->spacePoint()->msSector()->chamberIndex()) == layer; })) {
            ATH_MSG_VERBOSE(__func__<<"() Already found a segment in layer " << layer 
                << " - skip station " << st);
            continue;
        }
        const HitVec_t& hits {pattern.hitsInStation(st)};
        const std::vector<Bucket_t>& buckets {pattern.bucketsInStation(st)};

        std::unordered_map<const MuonGMR4::SpectrometerSector*, HitVec_t> hitsPerSector{};
        std::ranges::for_each(hits, [&hitsPerSector](Hit_t hit) {
            hitsPerSector[hit->msSector()].push_back(hit);
        });
        std::vector<const MuonGMR4::SpectrometerSector*> sectorsInStation{};
        sectorsInStation.reserve(hitsPerSector.size());
        std::ranges::transform(hitsPerSector, std::back_inserter(sectorsInStation), 
            [](const auto& pair) { return pair.first; });
        std::ranges::sort(sectorsInStation, std::ranges::greater{}, 
            [&hitsPerSector](const MuonGMR4::SpectrometerSector* s) { 
                return hitsPerSector[s].size(); });
 
        std::vector<Segment_t> stSegments{};
        stSegments.reserve(sectorsInStation.size());
        for (const MuonGMR4::SpectrometerSector* sector : sectorsInStation) {
            ATH_MSG_VERBOSE(__func__<<"() Start segment fitting in sector " << sector->identString() 
                <<" station " << st << " with " << hitsPerSector[sector].size() << " hits.");
            const HitVec_t& sectorHits {hitsPerSector[sector]};

            std::vector<Bucket_t> bucketsInSector {};
            std::ranges::copy_if(buckets, std::back_inserter(bucketsInSector), 
                [&sector](Bucket_t bucket) { return bucket->msSector() == sector;
            });
            if (bucketsInSector.empty()) {
                throw std::runtime_error(std::format("No parent bucket found for sector {} in station {}", sector->identString(), stName(st)));
            }
            Bucket_t parentBucket {bucketsInSector.size() < 2u ? bucketsInSector.back() 
                : *std::ranges::max_element(bucketsInSector, std::ranges::less{}, [&sectorHits](const Bucket_t& b) {
                    return std::ranges::count_if(sectorHits, [&b](const Hit_t& hit) {
                        return std::ranges::any_of(*b, [&hit](const auto& h) {
                            return h.get() == hit; });
                    });
                })};
 
            Segment_t segment {fitSegment(ctx, sector->localToGlobalTransform(gctx), parentBucket, std::move(hitsPerSector[sector]))};
            if (segment) {
                //coverity[RW.NO_MATCHING_FUNCTION:FALSE]
                ATH_MSG_VERBOSE(__func__<<"() Successfully fitted segment in station "<< st <<": Pos: "
                    << Amg::toString(segment->position())<< ", dir: "<< Amg::toString(segment->direction()) 
                    << ", chi2: "<< segment->chi2()<<", nDoF: "<<segment->nDoF()<<std::endl << print(segment->measurements()));
                stSegments.push_back(std::move(segment));
                // If we found a good segment, we don't try to fit segments in other sectors of the same station.
                if (calcRedChi2(*stSegments.back()) <= m_cfg.goodSegmentCut) {
                    break;
                }
                continue;
            }
            ATH_MSG_VERBOSE(__func__<<"() No segment could be fitted. Try next sector, if any.");
        }
        if (stSegments.empty()) {
            ATH_MSG_DEBUG("No segment could be fitted in station " << st << " for pattern" << pattern);
            continue;
        }
        Segment_t& bestStSegment {stSegments.size() > 1 
            ? *std::ranges::max_element(stSegments, [](const Segment_t& s1, const Segment_t& s2) {
                    return betterSegment(*s2, *s1); }) 
            : stSegments.back()};
        ATH_MSG_VERBOSE(__func__<<"() Best segment in station " << st << ": Pos: " << Amg::toString(bestStSegment->position()) 
            << ", dir: " << Amg::toString(bestStSegment->direction()) << ", chi2: " << bestStSegment->chi2() << ", nDoF: " << bestStSegment->nDoF());
 
        muonSegments.push_back(std::move(bestStSegment));
    }
 
    ATH_MSG_VERBOSE(__func__<<"() Found "<< muonSegments.size()<<" muon segments to construct a candidate.");
    if (muonSegments.size() < 2) {
        ATH_MSG_DEBUG(__func__<<"() Not enough muon segments to construct a candidate - abort.");
        return nullptr;
    }
    /* Sort station points by radial distance. Needed when we have segments in Extended layers */
    std::ranges::sort(muonSegments, std::ranges::less{}, 
        [](const Segment_t& seg) { return seg->position().perp(); });
    
    const Amg::Vector3D planeNorm {Acts::makeDirectionFromPhiTheta(pattern.phi() + 90._degree, 90._degree)};
 
    std::vector<ITrackSeedingTool::PosMomPair_t> circlePoints{};
    for (const Segment_t& seg : muonSegments) {
        if (!seg){
            continue;
        }
        int sector {seg->measurements().back()->spacePoint()->msSector()->sector()};
        Amg::Vector3D projDir {ExpandedSector{static_cast<unsigned>(sector), 
                                ExpandedSector::SectorProjector::center}.normalDir()};
                                
        Amg::Vector3D projPos {Acts::PlanarHelper::intersectPlane(seg->position(), projDir, 
            planeNorm, Amg::Vector3D::Zero()).position()};
 
        circlePoints.emplace_back(std::move(projPos), Amg::projectDirOntoPlane(seg->direction(), planeNorm));
    }
    assert(muonSegments.size() <= 3);
    const double qtimesP = m_cfg.trackSeeder->estimateQtimesP(ctx, planeNorm, circlePoints);
   
    const double eta   {muonSegments[0]->position().eta()};
    const double pt    {std::abs(qtimesP) / std::cosh(eta)};
 
    xAOD::Muon* newMuon = outMuons->push_back(std::make_unique<xAOD::Muon>());
    newMuon->setAuthor(xAOD::Muon::Author::MuidSA);
    newMuon->setP4(pt, eta, pattern.phi());
    newMuon->setCharge(qtimesP > 0. ? 1 : -1);
    newMuon->setMuonType(xAOD::Muon::MuonType::MuonStandAlone);
    return newMuon;
}

estimateBendingPars()

FastMuonSABuilder::HitVec_t MuonR4::FastReco::FastMuonSABuilder::estimateBendingPars ( HitVec_t && hits, Parameters & pars ) const

private

Estimate the bending parameters of a segment through a weighted linear regression.

This method is used to estimate initial parameters when no straw measurements are available and the MDTseeder cannot be used, e.g. NSW.

Parameters

hits	Vector of hits
pars	Parameters to be estimated

Returns

: Vector of valid hits during the linear regression

Definition at line 325 of file FastMuonSABuilder.cxx.

                                                               {
    // Estimate line parameters in the bending plane using a weighted linear regression.
    double S {0.}, Sy {0.}, Sz {0.}, Szz {0.}, Syz {0.};
    HitVec_t validHits{};
    for (const auto& hit : hits) {
        const Amg::Vector3D& locPos {hit->localPosition()};
        const double z {locPos.z()};
        const double y {locPos.y()};
        const double sigma2 {hit->covariance()[etaCovIdx]};
        if (sigma2 < 1e-4) {
            ATH_MSG_WARNING(__func__<<"() Hit"<< *hit<<" with very small eta covariance: " << sigma2 << ". Skipping the measurement.");
            continue;
        }
        validHits.push_back(hit);
        const double w {1./sigma2};
        
        S += w;
        Sy += w * y;
        Sz += w * z;
        Szz += w * z * z;
        Syz += w * z * y;
    }
    const double det {S * Szz - Sz * Sz};
 
    if (std::abs(det) < 1e-6) {
        ATH_MSG_VERBOSE(__func__<<"() Degenerate weighted regression, using furthest hits...");
        const auto [minZHit, maxZHit] = std::ranges::minmax_element(hits, std::ranges::less{}, 
            [](const Hit_t& h) { return h->localPosition().z(); });
        const Amg::Vector3D& minLocPos {(*minZHit)->localPosition()};
        const Amg::Vector3D& maxLocPos {(*maxZHit)->localPosition()};
        const double deltaZ {maxLocPos.z() - minLocPos.z()};
        // This should not happen since we required at least 2 different layers.
        assert(std::abs(deltaZ) > 1e-3);
 
        pars[thetaIdx] = std::atan2(maxLocPos.y() - minLocPos.y(), deltaZ);
        pars[y0Idx] = minLocPos.y() - std::tan(pars[thetaIdx]) * minLocPos.z();
        return validHits;
    }
    //coverity[DIVIDE_BY_ZERO:FALSE]
    const double slope { (S * Syz - Sz * Sy) / det };
    //coverity[DIVIDE_BY_ZERO:FALSE]
    const double intercept { (Szz * Sy - Sz * Syz) / det };
 
    pars[thetaIdx] = std::atan(slope);
    pars[y0Idx] = intercept;
    return validHits;
}

fitSegment()

FastMuonSABuilder::Segment_t MuonR4::FastReco::FastMuonSABuilder::fitSegment ( const EventContext & ctx, const Amg::Transform3D & localToGlobal, Bucket_t parentBucket, std::vector< Hit_t > && hits ) const

private

Fit a segment using the provided seed.

Parameters

ctx	Event context
localToGlobal	Transformation from local to global coordinates
patternSeed	Seed for the segment fit

Returns

: Unique pointer to the fitted segment

Check that we have at least 2 measurement layers

Initialize initial parameters in the centeral phi plane of the chamber

Handle the case of NSW. In principle it can happen to have mixed hit types, NSW and e.g. EIL hits. In such a case, we check if NSW hits represent the majority

If we have straws, use the MDT segment seeder to estimate initial parameters. Segments are fitted into the chamber center phi plane.

Definition at line 243 of file FastMuonSABuilder.cxx.

                                                             { 
    const unsigned firstLayer {m_spSorter.sectorLayerNum(*hits.front())};
    if (hits.size() < 2 ||
        std::ranges::none_of(hits, [&](Hit_t hit) { 
            return m_spSorter.sectorLayerNum(*hit) != firstLayer; })) {
        ATH_MSG_DEBUG(__func__<<"() Not enough layers with hits to fit a segment, skipping!");
        return nullptr;
    }
    Acts::CalibrationContext cctx {ActsTrk::getCalibrationContext(ctx)};

    Parameters initialPars{};
    initialPars[phiIdx] = 90._degree;
    initialPars[x0Idx] = 0;
 
    if (const unsigned nNSWhits {countNSWHits(hits, parentBucket)}; nNSWhits > 0) {
 
        if (nNSWhits < hits.size()) {
            ATH_MSG_DEBUG(__func__<<"() Mixed hit types: "<<nNSWhits<<" NSW over "
                <<hits.size()<<" total hits in the segment seed.");
            
            std::vector<Hit_t> selHits{};
            const bool useNSW {nNSWhits > (hits.size() - nNSWhits)};
            std::ranges::copy_if(hits, std::back_inserter(selHits), [useNSW](Hit_t hit) { 
                return xAOD::isNSW(hit->type()) == useNSW; });
            std::swap(hits, selHits);
        }
        /* Estimate initial parameters in bending direction with a linear regression */
        auto validHits = estimateBendingPars(std::move(hits), initialPars);
        const auto [locPos, locDir] {makeLine(initialPars)};
        ATH_MSG_VERBOSE(__func__<<"() Initial parameters: "<<toString(initialPars)
            << ", hits: "<<print(validHits));
 
        auto houghSeed {std::make_unique<SegmentSeed>(0., 0., 0., 0., 0., std::move(validHits), parentBucket)};
 
        using CalibSpacePointVec = ISpacePointCalibrator::CalibSpacePointVec;
        CalibSpacePointVec calibHits{m_cfg.calibrator->calibrate(ctx, houghSeed->getHitsInMax(), locPos, locDir, 0.)};
        return m_nswFitter->fitSegment(ctx, houghSeed.get(), initialPars, localToGlobal, std::move(calibHits));
    }

    auto houghSeed {std::make_unique<SegmentSeed>(0., 0., 0., 0., 0., std::move(hits), parentBucket)};
    std::vector<Segment_t> segments{};
    MdtSegmentSeeder::State_t seedState{initialPars, houghSeed.get(), m_cfg.calibrator, m_cfg.recalibSeed};
 
    ATH_MSG_VERBOSE(__func__<<"() Start segment seed search");
    //coverity[routine_not_emitted:FALSE]
    while (auto seed = m_mdtSeeder->nextSeed(cctx, seedState)) {
        ATH_MSG_VERBOSE(__func__<<"() Found a seed. Try to fit the segment...");
 
        Segment_t segment {m_fitter->fitSegment(ctx, houghSeed.get(), seed->parameters,
            localToGlobal, std::move(seed->hits))};
        if (segment) {
            segments.push_back(std::move(segment));
        }
    }
 
    if (!segments.empty()) {
        ATH_MSG_VERBOSE(__func__<<"() In total "<<segments.size()<<" segment were constructed. Keep the best one.");
        if (msgLvl(MSG::VERBOSE) && segments.size() > 1) {
            for (const Segment_t& seg : segments) {
                //coverity[RW.NO_MATCHING_FUNCTION:FALSE]
                ATH_MSG_VERBOSE(__func__<<"() Segment: Pos: "<<Amg::toString(seg->position())
                    <<", dir: "<<Amg::toString(seg->direction())<<", chi2: "<<seg->chi2()
                    <<", nDoF: "<<seg->nDoF()<<std::endl<<print(seg->measurements()));
            }
        }
        return std::move(*std::ranges::max_element(segments, [&](const Segment_t& s1, const Segment_t& s2) {
            return betterSegment(*s2, *s1);
        }));
    }
    ATH_MSG_VERBOSE(__func__<<"() No segment seeds could be fitted.");
    return nullptr;
}

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();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

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 167 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 182 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 user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

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;
}

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::FastReco::FastMuonSABuilder::m_cfg

private

Global Pattern Recognition configuration.

Definition at line 130 of file FastMuonSABuilder.h.

m_fitter

std::unique_ptr<LineFitter> MuonR4::FastReco::FastMuonSABuilder::m_fitter {}

private

Pointer to the actual segment fitter.

Definition at line 134 of file FastMuonSABuilder.h.

{};

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_mdtSeeder

std::unique_ptr<MdtSegmentSeeder> MuonR4::FastReco::FastMuonSABuilder::m_mdtSeeder {}

private

Pointer to the L-R segment seeder.

Definition at line 138 of file FastMuonSABuilder.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_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_nswFitter

std::unique_ptr<LineFitter> MuonR4::FastReco::FastMuonSABuilder::m_nswFitter {}

private

Pointer to the NSW segment fitter.

Definition at line 136 of file FastMuonSABuilder.h.

{};

m_spSorter

SpacePointPerLayerSorter MuonR4::FastReco::FastMuonSABuilder::m_spSorter {}

private

Spacepoint sorter per logical measurement layer.

Definition at line 132 of file FastMuonSABuilder.h.

{};

---

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

• FastMuonSABuilder.h
• FastMuonSABuilder.cxx