MuonR4::SegmentFit::SegmentAmbiSolver Class Reference

The SegmentAmbiSolver removes ambiguities between segment candidates from the fit. More...

#include <SegmentAmbiSolver.h>

Inheritance diagram for MuonR4::SegmentFit::SegmentAmbiSolver:

Collaboration diagram for MuonR4::SegmentFit::SegmentAmbiSolver:

Classes
struct	Config
	Configuration object to stree the ambiguties. More...

Public Types
using	SegmentVec = std::vector<std::unique_ptr<Segment>>
	Abrivation of the temporary segment container.

Public Member Functions
	SegmentAmbiSolver (const std::string &name, Config &&config)
	Constructor.
SegmentVec	resolveAmbiguity (const ActsTrk::GeometryContext &gctx, SegmentVec &&toResolve) const
	Launches the ambiguity resoltuion and returns a new temporary contained containing the good candidates only.
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
enum class	Resolution : std::uint8_t { noOverlap , superSet , subSet }
	Auxiliary enum to indicate the ambiguity status of the segment candidates. More...
using	MeasurementSet = std::unordered_set<const xAOD::UncalibratedMeasurement*>
	List of measurements out of which the segment is made of.

Private Member Functions
std::vector< int >	driftSigns (const ActsTrk::GeometryContext &gctx, const Segment &segment, const Segment::MeasVec &measurements) const
	Calculates the left-right ambiguities of the segment w.r.t each measurement.
MeasurementSet	extractPrds (const Segment &segment) const
	Extract the Uncalibrated measurements used to build the segment.
unsigned int	countShared (const MeasurementSet &measSet1, const MeasurementSet &measSet2) const
	Counts the number of measurements that're in both sets.
double	redChi2 (const Segment &segment) const
	Returns the reduced chi2 of the segment.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
const Config	m_cfg {}
	Configuration object.
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

The SegmentAmbiSolver removes ambiguities between segment candidates from the fit.

They typically arise from the sharing of hits between two candidates. The resolution happens in the following steps 1) The passed segment candidates are sorted by the reduced chi2 in increasing order Candidates which already have a sufficiently good chi2 are internally sorted by the degress of freedom in decreasing order 2) The first segment in the list has the most degrees of freedom with an acceptable chi2. Is is added to the list of good candidates. 3) The other segments are compared with the good candidates. If the segment shares at minimum 3 hits with a good candidate and has a worse chi2 and fewer hits it is marked for removal. If the good candidate has worse chi2 the segment takes over the place of the good candidate

Definition at line 27 of file SegmentAmbiSolver.h.

Member Typedef Documentation

MeasurementSet

using MuonR4::SegmentFit::SegmentAmbiSolver::MeasurementSet = std::unordered_set<const xAOD::UncalibratedMeasurement*>

private

List of measurements out of which the segment is made of.

Definition at line 72 of file SegmentAmbiSolver.h.

SegmentVec

using MuonR4::SegmentFit::SegmentAmbiSolver::SegmentVec = std::vector<std::unique_ptr<Segment>>

Abrivation of the temporary segment container.

Definition at line 47 of file SegmentAmbiSolver.h.

Member Enumeration Documentation

Resolution

enum class MuonR4::SegmentFit::SegmentAmbiSolver::Resolution : std::uint8_t

strongprivate

Auxiliary enum to indicate the ambiguity status of the segment candidates.

Enumerator
noOverlap
superSet	No ambiguity with other candidates detected.
subSet	Ambiguity detected and the candidate is of better quality. Ambiguity detected but the candidate is of poorer quality

Definition at line 58 of file SegmentAmbiSolver.h.

                                 : std::uint8_t{
                noOverlap, 
                superSet,  
                subSet     
            };

Constructor & Destructor Documentation

SegmentAmbiSolver()

MuonR4::SegmentFit::SegmentAmbiSolver::SegmentAmbiSolver	(	const std::string &	name,
		Config &&	config )

Constructor.

Parameters

name	Name of the algorithm to synchronize the msg output
config	Ambiguity resolver configuration object

Definition at line 10 of file SegmentAmbiSolver.cxx.

                                                                           :
        AthMessaging{name},
        m_cfg{std::move(cfg)} {}

Member Function Documentation

countShared()

unsigned MuonR4::SegmentFit::SegmentAmbiSolver::countShared ( const MeasurementSet & measSet1, const MeasurementSet & measSet2 ) const

private

Counts the number of measurements that're in both sets.

Parameters

measSet1	First set of measurements to compare
measSet2	Second set of measurements to compare

Definition at line 121 of file SegmentAmbiSolver.cxx.

                                                                                  {
        if (measSet1.size() > measSet2.size()) {
            return std::count_if(measSet2.begin(),measSet2.end(),[&measSet1](const xAOD::UncalibratedMeasurement* meas){
                return measSet1.count(meas);
            });
        }
        return std::count_if(measSet1.begin(),measSet1.end(),[&measSet2](const xAOD::UncalibratedMeasurement* meas){
                return measSet2.count(meas);
            }); 
    }

driftSigns()

std::vector< int > MuonR4::SegmentFit::SegmentAmbiSolver::driftSigns ( const ActsTrk::GeometryContext & gctx, const Segment & segment, const Segment::MeasVec & measurements ) const

private

Calculates the left-right ambiguities of the segment w.r.t each measurement.

Parameters

gctx	Geometry context to construct the local segment parameters
segment	The segment from which the line parameters are extracted
measurements	List of segment measurments w.r. the left-right signs need to be evaluated

Definition at line 97 of file SegmentAmbiSolver.cxx.

                                                                                             {
        const auto [pos, dir] = makeLine(localSegmentPars(gctx, segment));
     
        ATH_MSG_VERBOSE("Fetch drift signs for segment "<<segment.msSector()->identString()
                      <<" -- "<<Amg::toString(pos)<<" + " <<Amg::toString(dir));
        return SeedingAux::strawSigns(pos, dir, measurements);
    }

extractPrds()

SegmentAmbiSolver::MeasurementSet MuonR4::SegmentFit::SegmentAmbiSolver::extractPrds ( const Segment & segment ) const

private

Extract the Uncalibrated measurements used to build the segment.

Parameters

segment

The segment from which the raw measurements should be fetched

Definition at line 107 of file SegmentAmbiSolver.cxx.

                                                                   {
        
        MeasurementSet meas{};
        for (const Segment::MeasVec::value_type& hit : segment.measurements()) {
            if (!hit->spacePoint() || hit->fitState() != CalibratedSpacePoint::State::Valid || !hit->measuresEta()) {
                continue;
            }
            meas.insert(hit->spacePoint()->primaryMeasurement());
            if (hit->spacePoint()->secondaryMeasurement()) {
                 meas.insert(hit->spacePoint()->secondaryMeasurement());
            }
        }
        return meas;
    }

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 163 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 178 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_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

redChi2()

double MuonR4::SegmentFit::SegmentAmbiSolver::redChi2 ( const Segment & segment ) const

private

Returns the reduced chi2 of the segment.

Parameters

segment

Segment of interest

Definition at line 14 of file SegmentAmbiSolver.cxx.

                                                                  {
        return segment.chi2() / std::max(segment.nDoF(), 1u);
    }

resolveAmbiguity()

SegmentVec MuonR4::SegmentFit::SegmentAmbiSolver::resolveAmbiguity	(	const ActsTrk::GeometryContext &	gctx,
		SegmentVec &&	toResolve ) const

Launches the ambiguity resoltuion and returns a new temporary contained containing the good candidates only.

Parameters

gctx	Geometry context to construct the local segment parameters
toResolve	Collection of segments which need to be ambiguity resolved

Sort segments with a reduced chi2 better than 5 (normmaly) by the degrees of freedom, otherwise by the reduced chi2 itself

Mark the first object as resolved

Fetch first the Prds

Check whether the two segments share hits at all

Re-evaluate the drift signs of the accepted measurement w.r.t. good one

Left-right solutions differ & the two segments have the same nDOF

Segments below that threshold are not considered for outlier removal Take the one which has more degrees of freedom

No overlap detected thus far

Definition at line 17 of file SegmentAmbiSolver.cxx.

                                                                                 {
        
        std::ranges::stable_sort(toResolve,[this](const SegmentVec::value_type& a,
                                                  const SegmentVec::value_type& b){
            const double redChi2A = redChi2(*a);
            const double redChi2B = redChi2(*b);
            if (redChi2A < m_cfg.selectByNDoFChi2 && redChi2B < m_cfg.selectByNDoFChi2){
                return a->nDoF() > b->nDoF();
            }
            return redChi2A < redChi2B;
        });
        SegmentVec resolved{};

        resolved.push_back(std::move(toResolve[0]));
        toResolve.erase(toResolve.begin());
        std::vector<std::vector<int>> segmentSigns{driftSigns(gctx, *resolved.front(), resolved.front()->measurements())};
        std::vector<MeasurementSet> segMeasurements{extractPrds(*resolved.front())};
 
        for (SegmentVec::value_type& resolveMe : toResolve) {
            ATH_MSG_VERBOSE("Try to resolve new segment "<<toString(localSegmentPars(gctx, *resolveMe))
                          <<" redChi2: "<<redChi2(*resolveMe)<<" nDoF: "<<resolveMe->nDoF());
            MeasurementSet testMeas{extractPrds(*resolveMe)};
            Resolution reso{Resolution::noOverlap};
            unsigned resolvedIdx{0};
            for (SegmentVec::value_type& goodSeg : resolved) {
                ATH_MSG_VERBOSE("Test against segment "<<toString(localSegmentPars(gctx, *goodSeg))
                        <<" redChi2: "<<redChi2(*goodSeg)<<" nDoF: "<<goodSeg->nDoF());
                MeasurementSet& resolvedM = segMeasurements[resolvedIdx];
                std::vector<int>& existSigns{segmentSigns[resolvedIdx++]};
                unsigned shared = countShared(resolvedM, testMeas);
                if (shared < m_cfg.sharedPrecHits) {
                    ATH_MSG_VERBOSE("Too few shared measurements "<<shared<<" (Required: "<<m_cfg.sharedPrecHits<<").");
                    continue;
                }
                const std::vector<int> reEvaluatedSigns{driftSigns(gctx, *resolveMe, goodSeg->measurements())};
 
                unsigned sameSides{0};
                for (unsigned s =0 ; s < existSigns.size(); ++s) {
                    sameSides += (reEvaluatedSigns[s] == existSigns[s]);
                }
                if (!m_cfg.remLeftRightAmbi && sameSides != existSigns.size() && resolveMe->nDoF() == goodSeg->nDoF()) {
                    ATH_MSG_VERBOSE("Reference signs: "<<existSigns<<" / re-evaluated: "<<reEvaluatedSigns);
                    continue;
                }
                const double resolvedChi2  = redChi2(*goodSeg);
                const double resolveMeChi2 = redChi2(*resolveMe);
                reso = resolveMeChi2 < resolvedChi2 ? Resolution::superSet : Resolution::subSet;
 
                ATH_MSG_VERBOSE("Chi2 good "<<resolvedChi2<<", candidate chi2: "<<resolveMeChi2);
                if (resolveMeChi2 < m_cfg.selectByNDoFChi2 && resolvedChi2 < m_cfg.selectByNDoFChi2) {
                    reso =  goodSeg->nDoF() > resolveMe->nDoF() ? Resolution::subSet : Resolution::superSet;
                }
                if (reso == Resolution::superSet) {
                    std::swap(goodSeg, resolveMe);
                    std::swap(resolvedM, testMeas);
                    existSigns = driftSigns(gctx, *resolveMe, resolveMe->measurements());
                    break;
                } else if (reso == Resolution::subSet) {
                    break;
                }
            }
            if (reso == Resolution::noOverlap) {
                segMeasurements.push_back(std::move(testMeas));
                segmentSigns.push_back(driftSigns(gctx, *resolveMe, resolveMe->measurements()));
                resolved.push_back(std::move(resolveMe));
            }
        }
        return resolved;
    }

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

const Config MuonR4::SegmentFit::SegmentAmbiSolver::m_cfg {}

private

Configuration object.

Definition at line 56 of file SegmentAmbiSolver.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_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.

---

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

• SegmentAmbiSolver.h
• SegmentAmbiSolver.cxx