Algorithm handling fast segment fitting starting from global patterns. More...

#include <MuonFastSegmentFittingAlg.h>

Inheritance diagram for MuonR4::MuonFastSegmentFittingAlg:

Classes
struct	Beamspot
	Define simplified beamspot measurement in a selected plane. More...

Public Member Functions
virtual	~MuonFastSegmentFittingAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum class	CoordPlane : std::uint8_t { etaPlane = 0 , phiPlane = 1 }
	Define the coordinate planes. More...
enum class	ParamDefs2D : std::uint8_t { slope = 0 , intercept = 1 , nParams = 2 }
	Define the line parameters. More...
using	StIndex = Muon::MuonStationIndex::StIndex
	Type alias for the station index.
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	Seed_t = std::unique_ptr<SegmentSeed>
	Type alias for the segment seed type.
using	Segment_t = std::unique_ptr<Segment>
	Type alias for the segment type.
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	SegmentSeedPair_t = std::pair<Seed_t, Segment_t>
	Struct to hold the segment and the seed for the needed lifetime.
using	SegmentSeedOpt_t = std::optional<SegmentSeedPair_t>
	Type alias for the segment-seed optional.
using	Line2D_t = std::array<double, Acts::toUnderlying(ParamDefs2D::nParams)>
	Type alias for the line representation.
using	RegressionRes_t = std::pair<HitVec_t, std::optional<Line2D_t>>
	Type alias for the result of the linear regression, consisting of the valid hits and line parameters.
using	DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>
	Abrivation of the extra declared auxVariables.
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< SegmentSeedPair_t >	processPattern (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const GlobalPattern &pattern) const
	Main methods steering the segment fitting.
SegmentSeedOpt_t	fitSegment (const EventContext &ctx, const Amg::Transform3D &localToGlobal, Bucket_t parentBucket, HitVec_t &&hits) const
	Fit a segment in a station given the hits & their parent bucket.
std::pair< HitVec_t, Parameters >	initializePars (const Amg::Transform3D &localToGlobal, const HitVec_t &hits) const
	Estimate the initial parameters for the segment fitting.
RegressionRes_t	linearRegression (const CoordPlane Plane, const HitVec_t &hits, const std::optional< Beamspot > &beamspot=std::nullopt) const
	Estimate the segment parameters in the plane defined by the CoordPlane template parameter using a weighted linear regression.
const Segment *	findSegmentToAddPhi (std::vector< SegmentSeedPair_t > &segs) const
	Find the segment to which increase the phi measurement count.
double	beamspotCov (const CoordPlane Plane, const Amg::Transform3D &localToGlobal) const
	Helper method to compute the beamspot covariance in one local coordinate.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< GlobalPatternContainer >	m_inPatterns {this, "InPatterns", "MuonR4GlobalPatterns", "Global patterns to read"}
	Write handle key for the output global patterns.
SG::WriteHandleKey< xAOD::MuonSegmentContainer >	m_outSegments {this, "OutSegments", "FastMuonSegments", "Segments to write"}
	Write handle key for the output segments.
DecorKey_t	m_patternKey {this, "ParentPatternKey", m_outSegments, "GlobalPatternLink", "Parent global pattern for the segments"}
	Parent global pattern decoration of the segments.
DecorKey_t	m_localSegParKey {this, "LocalSegParKey", m_outSegments, "localSegPars"}
	Decoration of the local segment parameters.
DecorKey_t	m_localSegCovKey {this, "LocalCovParKey", m_outSegments, "localSegCov"}
	Decoration of the local fit covariance parameters.
DecorKey_t	m_prdLinkKey {this, "PrdLinkKey", m_outSegments, "prdLinks" }
	Decoration to the links to the associated Uncalibrated measurements.
DecorKey_t	m_prdStateKey {this, "PrdStateKey", m_outSegments, "prdState"}
	Decoration to the PrdLink state (I.e.
SG::WriteHandleKey< xAOD::CombinedMuonStripContainer >	m_combMeasKey {this, "combinedPrdKey", "FastCombinedPrdKey"}
	Auxiliary container to model two measurements in the same gas gap as a single track state.
ActsTrk::GeoContextReadKey_t	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
	Geometry context key.
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	Handle to the MuonIdHelper service.
ToolHandle< ISpacePointCalibrator >	m_calibTool {this, "Calibrator", "" }
	Handle to the space point calibrator tool.
ToolHandle< IxAODSegmentCnvTool >	m_segmentCnvTool {this, "SegmentCnvTool", ""}
	Segment converter tool.
ToolHandle< MuonValR4::IPatternVisualizationTool >	m_segVisionTool {this, "VisualizationTool", ""}
	Handle to the visualization tool for segments.
BooleanProperty	m_recalibInFit {this, "recalibInFit" , false}
	Toggle the recalibration of hits during the segment fit.
BooleanProperty	m_hessianResidual {this, "useHessianResidual", false}
	Use the expliciit Hessian in the residual calculation.
DoubleProperty	m_seedHitChi2 {this, "ResoSeedHitAssoc", 5. }
	Two mdt seeds are the same if their defining parameters match wihin.
BooleanProperty	m_recalibSeed {this, "SeedRecalibrate", false}
	Toggle seed recalibration.
DoubleProperty	m_goodSegmentCut {this, "GoodSegmentCut", 2.}
	Reduced chi2 defining a good segment, stopping the fit of other segments in the same station.
UnsignedIntegerProperty	m_goodSegmentDoF {this, "GoodSegmentDoF", 5}
	Number of degrees of freedom defining a good segment, stopping the fit of other segments in the same station.
DoubleProperty	m_outlierRemovalCut {this, "OutlierRemoval", 3.}
	Cut on the segment chi2 / nDoF to launch the outlier removal.
DoubleProperty	m_recoveryPull {this, "RecoveryPull", 3.}
	Pull value for hit recovery.
UnsignedIntegerProperty	m_precHitCut {this, "PrecHitCut" , 3}
	Minimum number of precision hits to accept the segment.
BooleanProperty	m_useFastFitter {this, "useFastFitter", false}
	Use the fast Mdt fitter where possible.
BooleanProperty	m_fastPreFitter {this, "useFastPreFitter", false}
	The fast fitter is treated as a pre fitter.
BooleanProperty	m_ignoreFailedPreFit {this, "ignoreFailedPreFit", false}
	Switch to try the full fit when the fast pre-fitter fails.
UnsignedIntegerProperty	m_maxIter {this, "maxIterations", 50}
	Tune the number of iterations.
BooleanProperty	m_beamSpotRadius {this, "BeamSpotRadius", 30.*Gaudi::Units::cm}
	Beam spot radius.
BooleanProperty	m_beamSpotLength {this, "BeamSpotLength", 2.*Gaudi::Units::m}
	Beam spot length.
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.
Acts::SquareMatrix< 3 >	m_beamspotCov {Acts::SquareMatrix<3>::Zero()}
	Covariance matrix of the beam spot.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Friends
std::ostream &	operator<< (std::ostream &os, MuonFastSegmentFittingAlg::CoordPlane plane)
std::ostream &	operator<< (std::ostream &os, MuonFastSegmentFittingAlg::ParamDefs2D pars)
std::ostream &	operator<< (std::ostream &os, const Line2D_t &line)
std::ostream &	operator<< (std::ostream &os, const Beamspot &bs)

Detailed Description

Algorithm handling fast segment fitting starting from global patterns.

This algorithm processes the global patterns found in previous steps to build segments, needed later to estimate the momentum. It performs a straight line segment fit using the pattern hits in each station. The main method consumes the global patterns and produces the xAOD::segment container decorated with links to the original patterns.

Definition at line 29 of file MuonFastSegmentFittingAlg.h.

Member Typedef Documentation

◆ Bucket_t

using MuonR4::MuonFastSegmentFittingAlg::Bucket_t = const SpacePointBucket*

private

Type alias for the bucket type.

Definition at line 45 of file MuonFastSegmentFittingAlg.h.

◆ DecorKey_t

using MuonR4::MuonFastSegmentFittingAlg::DecorKey_t = SG::WriteDecorHandleKey<xAOD::MuonSegmentContainer>

private

Abrivation of the extra declared auxVariables.

Definition at line 146 of file MuonFastSegmentFittingAlg.h.

◆ Hit_t

using MuonR4::MuonFastSegmentFittingAlg::Hit_t = const SpacePoint*

private

Type alias for the hit type & associated vector.

Definition at line 42 of file MuonFastSegmentFittingAlg.h.

◆ HitVec_t

using MuonR4::MuonFastSegmentFittingAlg::HitVec_t = std::vector<Hit_t>

private

Definition at line 43 of file MuonFastSegmentFittingAlg.h.

◆ Line2D_t

using MuonR4::MuonFastSegmentFittingAlg::Line2D_t = std::array<double, Acts::toUnderlying(ParamDefs2D::nParams)>

private

Type alias for the line representation.

Definition at line 114 of file MuonFastSegmentFittingAlg.h.

◆ LineFitter

using MuonR4::MuonFastSegmentFittingAlg::LineFitter = MuonR4::SegmentFit::SegmentLineFitter

private

Type alias for the line fitter.

Definition at line 53 of file MuonFastSegmentFittingAlg.h.

◆ MdtSegmentSeeder

using MuonR4::MuonFastSegmentFittingAlg::MdtSegmentSeeder = MuonR4::SegmentFit::MdtSegmentSeedGenerator

private

Type alias for the L-R segment seeder.

Definition at line 55 of file MuonFastSegmentFittingAlg.h.

◆ Parameters

using MuonR4::MuonFastSegmentFittingAlg::Parameters = SegmentFit::Parameters

private

Type alias for the segment fitting parameters.

Definition at line 51 of file MuonFastSegmentFittingAlg.h.

◆ RegressionRes_t

using MuonR4::MuonFastSegmentFittingAlg::RegressionRes_t = std::pair<HitVec_t, std::optional<Line2D_t>>

private

Type alias for the result of the linear regression, consisting of the valid hits and line parameters.

Definition at line 117 of file MuonFastSegmentFittingAlg.h.

◆ Seed_t

using MuonR4::MuonFastSegmentFittingAlg::Seed_t = std::unique_ptr<SegmentSeed>

private

Type alias for the segment seed type.

Definition at line 47 of file MuonFastSegmentFittingAlg.h.

◆ Segment_t

using MuonR4::MuonFastSegmentFittingAlg::Segment_t = std::unique_ptr<Segment>

private

Type alias for the segment type.

Definition at line 49 of file MuonFastSegmentFittingAlg.h.

◆ SegmentSeedOpt_t

using MuonR4::MuonFastSegmentFittingAlg::SegmentSeedOpt_t = std::optional<SegmentSeedPair_t>

private

Type alias for the segment-seed optional.

Definition at line 60 of file MuonFastSegmentFittingAlg.h.

◆ SegmentSeedPair_t

using MuonR4::MuonFastSegmentFittingAlg::SegmentSeedPair_t = std::pair<Seed_t, Segment_t>

private

Struct to hold the segment and the seed for the needed lifetime.

Definition at line 58 of file MuonFastSegmentFittingAlg.h.

◆ StIndex

using MuonR4::MuonFastSegmentFittingAlg::StIndex = Muon::MuonStationIndex::StIndex

private

Type alias for the station index.

Definition at line 40 of file MuonFastSegmentFittingAlg.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ CoordPlane

enum class MuonR4::MuonFastSegmentFittingAlg::CoordPlane : std::uint8_t

strongprivate

Define the coordinate planes.

Enumerator

etaPlane

Bending plane.

phiPlane

Phi, e.g.

non-bending, plane

Definition at line 89 of file MuonFastSegmentFittingAlg.h.

                                  : std::uint8_t {               
                etaPlane = 0,
                phiPlane = 1
            };

◆ ParamDefs2D

enum class MuonR4::MuonFastSegmentFittingAlg::ParamDefs2D : std::uint8_t

strongprivate

Define the line parameters.

Enumerator

slope

Tangent of the angle, defined as dy/dz or dx/dz according to the plane.

intercept

Intercept at z=0 (i.e.

y0 or x0, according to the plane)

nParams

Number of parameters.

Definition at line 96 of file MuonFastSegmentFittingAlg.h.

                                   : std::uint8_t {
                slope = 0,
                intercept = 1,
                nParams = 2
            };

Constructor & Destructor Documentation

◆ ~MuonFastSegmentFittingAlg()

virtual MuonR4::MuonFastSegmentFittingAlg::~MuonFastSegmentFittingAlg ( )

virtualdefault

Member Function Documentation

◆ beamspotCov()

double MuonR4::MuonFastSegmentFittingAlg::beamspotCov	(	const CoordPlane	Plane,
		const Amg::Transform3D &	localToGlobal ) const

private

Helper method to compute the beamspot covariance in one local coordinate.

Parameters

Plane	Coordinate plane to be used
localToGlobal	Transform from local to global coordinates

Returns: : The beamspot covariance in the specified local coordinate

Definition at line 530 of file MuonFastSegmentFittingAlg.cxx.

                                                                                         {
 
    const Amg::Vector3D localAxisDir {Amg::Vector3D::Unit(Plane == CoordPlane::etaPlane)};
    const Amg::Vector3D globalAxisDir {localToGlobal.rotation() * localAxisDir};
    
    return globalAxisDir.dot(m_beamspotCov * globalAxisDir);
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode MuonR4::MuonFastSegmentFittingAlg::execute ( const EventContext & ctx ) const

overridevirtual

If no phi measurements are found, we add a fake one, in order to prevent the segment selector during the candidate construction to discard the candidate.

We fill the segment container by preserving the ordering by parent pattern

Decorate with pattern link

Add the phi hit if needed

Definition at line 144 of file MuonFastSegmentFittingAlg.cxx.

                                                                           {
 
    const ActsTrk::GeometryContext* gctx{nullptr};
    ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
 
    const GlobalPatternContainer* inPatterns{nullptr};
    ATH_CHECK(SG::get(inPatterns, m_inPatterns, ctx));
 
    IxAODSegmentCnvTool::DataShip ship{};
    ATH_CHECK(ship.segmentContainer.record(m_outSegments, ctx));
    ATH_CHECK(ship.setupLocalParameters(m_localSegParKey, m_localSegCovKey, ctx));
    ATH_CHECK(ship.setupMeasurementLink(m_combMeasKey, m_prdLinkKey, m_prdStateKey, ctx));
 
    using PatLink_t = ElementLink<GlobalPatternContainer>;
    xAOD::ContainerDecorator<xAOD::MuonSegmentContainer, PatLink_t> dec_patternLink{m_patternKey, ctx};
 
    std::size_t patIdx{0};
    ATH_MSG_DEBUG(__func__<<"() Start fitting segments in " << inPatterns->size() << " global patterns");
    for (const GlobalPattern* pat : *inPatterns) {
 
        std::vector<SegmentSeedPair_t> seedSegPairs{processPattern(ctx, *gctx, *pat)};
 
        if (seedSegPairs.size() <= 1u) {
            ATH_MSG_DEBUG(__func__<<"() Not enough muon segments to construct a candidate - abort pattern"
                << std::endl << *pat);
            patIdx++;
            continue;
        }
        const bool hasPhi {std::ranges::any_of(seedSegPairs, [](const SegmentSeedPair_t& seg) {
            return std::ranges::any_of(seg.second->measurements(), [](const auto& meas) {
                return isGoodHit(*meas) && meas->measuresPhi(); });
            })};
        const Segment* toAddPhi{nullptr};
        if(!hasPhi) {
            toAddPhi = findSegmentToAddPhi(seedSegPairs);
        }
        ship.segmentContainer->reserve(ship.segmentContainer->size() + seedSegPairs.size());
        for (const SegmentSeedPair_t& seedSegPair : seedSegPairs) {
            const Segment_t& seg = seedSegPair.second;
            xAOD::MuonSegment* segXAOD = m_segmentCnvTool->convertSegment(ctx, *seg, ship);
            
            dec_patternLink(*segXAOD) = PatLink_t{*inPatterns, patIdx};
            if (toAddPhi && toAddPhi == seg.get()) {
                segXAOD->setNHits(segXAOD->nPrecisionHits(), 
                                  segXAOD->nPhiLayers() + 1u, 
                                  segXAOD->nTrigEtaLayers());
            }
 
            ATH_MSG_VERBOSE(__func__<<"() Converted segment " << printSegment(*segXAOD));
        }
        patIdx++;
    }
    ATH_MSG_DEBUG("Written "<<ship.segmentContainer->size()<<" xAOD::Segments into StoreGate.");
    return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

◆ findSegmentToAddPhi()

const Segment * MuonR4::MuonFastSegmentFittingAlg::findSegmentToAddPhi ( std::vector< SegmentSeedPair_t > & segs ) const

private

Find the segment to which increase the phi measurement count.

This is needed to avoid the segment selector to discard the candidate during the candidate building.

Parameters

segs	Vector of segment-seed pairs

Returns: : Pointer to the segment to add phi measurements to, if any

Find the first segment which is on the most favoured layer to be a seed in the muon bulding process. If there is none, continue to the next.

Definition at line 515 of file MuonFastSegmentFittingAlg.cxx.

                                                                                                      {
    using enum LayerIndex;
    for (const LayerIndex layer : {Middle, Inner, Outer, Extended, BarrelExtended}) {
 
        auto it = std::ranges::find_if(segs, [&layer](const SegmentSeedPair_t& seg) {
            return toLayerIndex(seg.second->msSector()->chamberIndex()) == layer; });
        if (it != segs.end()) {
            return it->second.get();
        }
    }
    return nullptr;
}

◆ fitSegment()

MuonFastSegmentFittingAlg::SegmentSeedOpt_t MuonR4::MuonFastSegmentFittingAlg::fitSegment	(	const EventContext &	ctx,
		const Amg::Transform3D &	localToGlobal,
		Bucket_t	parentBucket,
		HitVec_t &&	hits ) const

private

Fit a segment in a station given the hits & their parent bucket.

Parameters

ctx	Event context
localToGlobal	Transformation from local to global coordinates
parentBucket	Pointer to the parent bucket of the hits, needed for hole recovery
hits	Vector of hits to be fitted

Returns: : Unique pointer to the fitted segment

Reject segment candidates with insufficient precision hits

Initialize initial parameters

Handle the case of NSW.

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 328 of file MuonFastSegmentFittingAlg.cxx.

                                                                     {
    std::set<unsigned> layers{};
    std::ranges::for_each(hits, [this, &layers](Hit_t hit) {
        if (isPrecisionHit(*hit)) {
            layers.insert(m_spSorter.sectorLayerNum(*hit));
        }
    });
    if (layers.size() < m_precHitCut) {
        ATH_MSG_VERBOSE(__func__<<"() Not enough layers with hits to fit a segment, skipping!");
        return std::nullopt;
    }
    Acts::CalibrationContext cctx {ActsTrk::getCalibrationContext(ctx)};
    auto [ValidHits, initialPars] {initializePars(localToGlobal, hits)};
    if (ValidHits.empty()) {
        ATH_MSG_VERBOSE(__func__<<"() Failed to initialize initial parameters for segment fitting.");
        return std::nullopt;
    }
    ATH_MSG_VERBOSE(__func__<<"() Start segment fitting with initial parameters: "
        <<toString(initialPars)<<", hits: "<<print(ValidHits));
    
    const auto [locPos, locDir] {makeLine(initialPars)};
    auto houghSeed {std::make_unique<SegmentSeed>(houghTanBeta(locDir), locPos.y(), 
                                                  houghTanAlpha(locDir), locPos.x(), 
                                                  ValidHits.size(), std::move(ValidHits), parentBucket)};
    if (toStationIndex(parentBucket->msSector()->chamberIndex()) == StIndex::EI &&
        std::ranges::all_of(houghSeed->getHitsInMax(), [](const Hit_t& hit) { 
            return xAOD::isNSW(hit->type()); })) {
        
        ATH_MSG_VERBOSE(__func__<<"() Found NSW hits. Use the NSW fitter to fit the segment.");
        using CalibSpacePointVec = ISpacePointCalibrator::CalibSpacePointVec;
        CalibSpacePointVec calibHits{m_calibTool->calibrate(ctx, 
            houghSeed->getHitsInMax(), locPos, locDir, 0.)};
        Segment_t res {m_nswFitter->fitSegment(ctx, 
            houghSeed.get(), initialPars, localToGlobal, std::move(calibHits))};
        if (res) {
            return std::make_pair(std::move(houghSeed), std::move(res));
        }
        return std::nullopt;
    }
    std::vector<Segment_t> segments{};
    MdtSegmentSeeder::State_t seedState{initialPars, houghSeed.get(), m_calibTool.get(), m_recalibSeed.value()};
 
    ATH_MSG_VERBOSE(__func__<<"() Start segment seed search");
    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) {
                ATH_MSG_VERBOSE(__func__<<"() Segment: Pos: "<<Amg::toString(seg->position())
                    <<", dir: "<<Amg::toString(seg->direction())<<", chi2: "<<seg->chi2()
                    <<", nDoF: "<<NDoF(*seg)<<std::endl<<print(seg->measurements()));
            }
        }
        Segment_t& bestSegment {*std::ranges::max_element(segments, [&](const Segment_t& s1, const Segment_t& s2) {
            return betterSegment(*s2, *s1);
        })};
        return std::make_pair(std::move(houghSeed), std::move(bestSegment));
    }
    ATH_MSG_VERBOSE(__func__<<"() No segment seeds could be fitted.");
    return std::nullopt;
}

◆ initialize()

StatusCode MuonR4::MuonFastSegmentFittingAlg::initialize ( )

overridevirtual

Initialize the segment line fitter

Initialize the NSW segment fitter

Initialize the L-R segment seeder

Definition at line 73 of file MuonFastSegmentFittingAlg.cxx.

                                                 {
    ATH_CHECK(m_outSegments.initialize());
    ATH_CHECK(m_patternKey.initialize());
    ATH_CHECK(m_localSegParKey.initialize());
    ATH_CHECK(m_localSegCovKey.initialize());
    ATH_CHECK(m_prdLinkKey.initialize());
    ATH_CHECK(m_prdStateKey.initialize());
    ATH_CHECK(m_combMeasKey.initialize());
    ATH_CHECK(m_inPatterns.initialize());
    ATH_CHECK(m_geoCtxKey.initialize());
    ATH_CHECK(m_calibTool.retrieve());
    ATH_CHECK(m_segmentCnvTool.retrieve());
    ATH_CHECK(m_idHelperSvc.retrieve());
 
    ATH_CHECK(m_segVisionTool.retrieve(EnableTool(!m_segVisionTool.empty())));
    SegmentLineFitter::Config fitCfg{};
    fitCfg.calibrator = m_calibTool.get();
    fitCfg.visionTool = m_segVisionTool.get();
    fitCfg.idHelperSvc = m_idHelperSvc.get();
    fitCfg.fitT0 = false;
    fitCfg.calcAlongStrip = false;
    fitCfg.recalibrate = m_recalibInFit;
    fitCfg.useFastFitter = m_useFastFitter;
    fitCfg.fastPreFitter = m_fastPreFitter;
    fitCfg.ignoreFailedPreFit = m_ignoreFailedPreFit;
    fitCfg.useHessian = m_hessianResidual;
    fitCfg.doBeamSpot = false;
    fitCfg.outlierRemovalCut = m_outlierRemovalCut;
    fitCfg.recoveryPull = m_recoveryPull;
    fitCfg.nPrecHitCut = m_precHitCut;
    fitCfg.maxIter = m_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_seedHitChi2;
    genCfg.busyLayerLimit = 3;
    genCfg.startWithPattern = false;
    m_mdtSeeder = std::make_unique<MdtSegmentSeeder>(std::move(genCfg), 
        makeActsAthenaLogger(this, name()));
 
    ATH_MSG_DEBUG("FastMuonSABuilder Configuration:\n"
            << " Recalibrate in fit: " << m_recalibInFit << "\n"
            << " Use Hessian in residual: " << m_hessianResidual << "\n"
            << " Seed hit chi2: " << m_seedHitChi2 << "\n"
            << " Recalibrate seed: " << m_recalibSeed << "\n"
            << " Good segment cut (reduced chi2): " << m_goodSegmentCut << "\n"
            << " Outlier removal cut (chi2/nDoF): " << m_outlierRemovalCut << "\n"
            << " Recovery pull: " << m_recoveryPull << "\n"
            << " Precision hit cut: " << m_precHitCut << "\n"
            << " Use fast fitter: " << m_useFastFitter << "\n"
            << " Fast fitter as pre-fitter: " << m_fastPreFitter << "\n"
            << " Ignore failed pre-fits: " << m_ignoreFailedPreFit << "\n"
            << " Max iterations: " << m_maxIter);
    
    m_beamspotCov(Amg::x, Amg::x) = m_beamspotCov(Amg::y, Amg::y) = 
        Acts::square(m_beamSpotRadius);
    m_beamspotCov(Amg::z, Amg::z) = Acts::square(m_beamSpotLength);
 
    return StatusCode::SUCCESS;
}

◆ initializePars()

std::pair< MuonFastSegmentFittingAlg::HitVec_t, Parameters > MuonR4::MuonFastSegmentFittingAlg::initializePars	(	const Amg::Transform3D &	localToGlobal,
		const HitVec_t &	hits ) const

private

Estimate the initial parameters for the segment fitting.

Parameters

localToGlobal	Transformation from local to global coordinates
hits	Vector of hits

Returns: : Estimated initial parameters

No enough hits or bad topology, return empty result

Failed to initialize phi parameters, fit the segment in the chamber phi plane

Add phi-only hits to eta hits

Definition at line 410 of file MuonFastSegmentFittingAlg.cxx.

                                                                      { 
                                            
    auto [etaHits, etaPars] = linearRegression(CoordPlane::etaPlane, hits);
    if (!etaPars || etaHits.size() < m_precHitCut) {
        ATH_MSG_VERBOSE(__func__<<"() Failed to initialize eta parameters.");
        return std::pair<HitVec_t, Parameters>{};
    }
    const Amg::Vector3D beamspotPos {localToGlobal.inverse().translation()};
    const Beamspot beamspot{beamspotPos.x(), beamspotPos.z(), 
        beamspotCov(CoordPlane::phiPlane, localToGlobal)};
    ATH_MSG_VERBOSE(__func__<<"() Use: "<<beamspot<<" for regression in "<<CoordPlane::phiPlane);
    auto [phiHits, phiPars] = linearRegression(CoordPlane::phiPlane, hits, beamspot);
    
    if (!phiPars) {
        phiHits.clear();
        phiPars = std::make_optional(Line2D_t{0., 0.});
    }
    for (Hit_t hit : phiHits) {
        if (!hit->measuresEta()) {
            etaHits.push_back(hit);
        }
    }
    Parameters pars{};
    const auto [tanAlpha, x0] = *phiPars;
    const auto [tanBeta , y0] = *etaPars;
    pars[Acts::toUnderlying(ParamDefs::y0)] = y0;
    pars[Acts::toUnderlying(ParamDefs::x0)] = x0;
    const Amg::Vector3D dir {Acts::makeDirectionFromAxisTangents(tanAlpha, tanBeta)};
    pars[Acts::toUnderlying(ParamDefs::theta)] = dir.theta();
    pars[Acts::toUnderlying(ParamDefs::phi)] = dir.phi();
 
    return std::make_pair(std::move(etaHits), pars);
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

◆ linearRegression()

MuonFastSegmentFittingAlg::RegressionRes_t MuonR4::MuonFastSegmentFittingAlg::linearRegression	(	const CoordPlane	Plane,
		const HitVec_t &	hits,
		const std::optional< Beamspot > &	beamspot = std::nullopt ) const

private

Estimate the segment parameters in the plane defined by the CoordPlane template parameter using a weighted linear regression.

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

Parameters

Plane	Coordinate plane to be used for the regression
hits	Vector of hits

Returns: : Result of the linear regression

TO DO: The linear regression should be improved to handle the covariance in z, not only in the x and y directions. This is needed for both straws measurements and beamspot.

Helper function to accumulate the regression sums

Address the case of not enough valid hits

Handle invalid determinant: require a non-zero total weight and sufficient weighted variance in z of the hits (at least 1 mm)

Definition at line 449 of file MuonFastSegmentFittingAlg.cxx.

                                                                                         {
    ATH_MSG_VERBOSE(__func__<<"() Start linear regression in the "<<Plane
        <<" with "<<hits.size()<<" hits"<<(beamspot ? " & beamspot." : "."));
 
    const auto CovIdx {Plane == CoordPlane::etaPlane 
        ? Acts::toUnderlying(SpacePoint::CovIdx::etaCov) 
        : Acts::toUnderlying(SpacePoint::CovIdx::phiCov)};
 
    double S {0.}, Sy {0.}, Sz {0.}, Szz {0.}, Syz {0.};
    auto accumulate = [&](const double y, const double z, const double w) {
        S += w;
        Sy += w * y;
        Sz += w * z;
        Szz += w * z * z;
        Syz += w * z * y;
    };
 
    HitVec_t validHits {};
    for (Hit_t hit : hits) {
        if ((Plane == CoordPlane::etaPlane && !hit->measuresEta()) ||
            (Plane == CoordPlane::phiPlane && !hit->measuresPhi())) {
            continue;
        }
        const double sigma2 {(Plane == CoordPlane::etaPlane && hit->isStraw())
            ? hit->covariance()[CovIdx] + Acts::square(hit->driftRadius())
            : hit->covariance()[CovIdx]};
 
        validHits.push_back(hit);
        const Amg::Vector3D& locPos {hit->localPosition()};
 
        accumulate(Plane == CoordPlane::etaPlane ? locPos.y() : locPos.x(), 
                   locPos.z(), 
                   1./sigma2);
    }
    if (beamspot) {
        accumulate(beamspot->coord, beamspot->z, 1./beamspot->cov_coordCoord);
    }
    if (validHits.size() + beamspot.has_value() < 2u) {
        ATH_MSG_VERBOSE(__func__<<"() Not enough hits to do a linear regression in the "
            <<Plane<<". Valid hits: "<<print(validHits));
        return std::make_pair(std::move(validHits), std::nullopt);
    }
    const double det {S * Szz - Acts::square(Sz)};
    if (S <= Acts::s_epsilon || 
        (det / Acts::square(S)) < minZVariance) {
        ATH_MSG_WARNING(__func__<<"() Degenerate regression in the "
            <<Plane<<": total weight: "<<S<<", variance in z: "
            <<det/Acts::square(S)<<" valid hits: "<<print(validHits));
        return std::make_pair(std::move(validHits), std::nullopt);
    }
    Line2D_t pars{};
    pars[Acts::toUnderlying(ParamDefs2D::slope)] = (S * Syz - Sz * Sy) / det;
    pars[Acts::toUnderlying(ParamDefs2D::intercept)] = (Szz * Sy - Sz * Syz) / det;
    ATH_MSG_VERBOSE(__func__<<"() Linear regression in the "
        <<Plane<<" -> "<<pars<<", with "<<validHits.size()
        <<" valid hits"<<(beamspot ? " and beamspot." : "."));
    return std::make_pair(std::move(validHits), std::move(pars));
}

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ processPattern()

std::vector< MuonFastSegmentFittingAlg::SegmentSeedPair_t > MuonR4::MuonFastSegmentFittingAlg::processPattern	(	const EventContext &	ctx,
		const ActsTrk::GeometryContext &	gctx,
		const GlobalPattern &	pattern ) const

private

Main methods steering the segment fitting.

Given the global pattern, it fits segments in each station, computing just the minimum amount to allow muon candidate building, i.e. 3 segments.

Parameters

ctx	Event context
gctx	Geometry context
pattern	Global pattern

Returns: : Vector of fitted segments

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 the sectors with hits in the station. We can either have 1 or 2 sectors (in the overlap regions). If we have 2 sectors, we ensure one is small and the other is large

Ensure the small sector is processed first to maximize the lever arm

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 208 of file MuonFastSegmentFittingAlg.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<SegmentSeedPair_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 SegmentSeedPair_t& seg) {
                return toLayerIndex(seg.second->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; });
        assert(sectorsInStation.size() > 0 && sectorsInStation.size() <= 2u &&
               (sectorsInStation.size() == 1u || isSmall(sectorsInStation[0]->chamberIndex()) != isSmall(sectorsInStation[1]->chamberIndex())));
        if (sectorsInStation.size() == 2u && !isSmall(sectorsInStation[0]->chamberIndex())) {
            std::swap(sectorsInStation[0], sectorsInStation[1]);
        }
 
        std::vector<SegmentSeedPair_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.");
            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)));
            }
            if (bucketsInSector.size() > 1u) {
                Bucket_t primaryBucket {*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; });
                        });
                    })};
                bucketsInSector.clear();
                bucketsInSector.push_back(primaryBucket);
            }
            Bucket_t parentBucket {bucketsInSector.back()};
 
            SegmentSeedOpt_t segment{fitSegment(ctx, sector->localToGlobalTransform(gctx), 
                                                parentBucket, std::move(sectorHits))};
            if (segment) {
                ATH_MSG_VERBOSE(__func__<<"() Successfully fitted segment in station "<< st 
                    <<": Pos: "<< Amg::toString(segment->second->position())
                    << ", dir: "<< Amg::toString(segment->second->direction()) 
                    << ", chi2: "<< segment->second->chi2()<<", nDoF: "<<NDoF(*segment->second)<<std::endl 
                    << print(segment->second->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.
                const Segment_t& newSegment {stSegments.back().second};
                if (calcRedChi2(*newSegment) <= m_goodSegmentCut && 
                    NDoF(*newSegment) >= m_goodSegmentDoF) {
                    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);
            continue;
        }
        SegmentSeedPair_t& bestSeg {stSegments.size() > 1 
            ? *std::ranges::max_element(stSegments, [](const SegmentSeedPair_t& s1, const SegmentSeedPair_t& s2) {
                    return betterSegment(*s2.second, *s1.second); }) 
            : stSegments.back()};
        ATH_MSG_VERBOSE(__func__<<"() Best segment in station " << st << ": Pos: " << Amg::toString(bestSeg.second->position()) 
            << ", dir: " << Amg::toString(bestSeg.second->direction()) << ", chi2: " << bestSeg.second->chi2() << ", nDoF: " << NDoF(*bestSeg.second));
 
        muonSegments.push_back(std::move(bestSeg));
    }
    ATH_MSG_DEBUG(__func__<<"() Found "<< muonSegments.size()<<" muon segments to construct a candidate.");
    return muonSegments;
}

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

◆ operator<< [1/4]

std::ostream & operator<<	(	std::ostream &	os,
		const Beamspot &	bs )

friend

Definition at line 563 of file MuonFastSegmentFittingAlg.cxx.

                                                                                          {
    return os << "Beamspot [z, coord, sigmaCoord]: ["
        << beamspot.z<< ", "<<beamspot.coord<< ", "<< std::sqrt(beamspot.cov_coordCoord) << "]";
}

◆ operator<< [2/4]

std::ostream & operator<<	(	std::ostream &	os,
		const Line2D_t &	line )

friend

Definition at line 558 of file MuonFastSegmentFittingAlg.cxx.

                                                                                      {
    return os << "Line [slope, intercept]: [" 
        << line[Acts::toUnderlying(MuonFastSegmentFittingAlg::ParamDefs2D::slope)] << ", " 
        << line[Acts::toUnderlying(MuonFastSegmentFittingAlg::ParamDefs2D::intercept)] << "]";
}

◆ operator<< [3/4]

std::ostream & operator<<	(	std::ostream &	os,
		MuonFastSegmentFittingAlg::CoordPlane	plane )

friend

Definition at line 539 of file MuonFastSegmentFittingAlg.cxx.

                                                                                  {
    switch (plane) {
        case MuonFastSegmentFittingAlg::CoordPlane::etaPlane:
            return os << "etaPlane";
        case MuonFastSegmentFittingAlg::CoordPlane::phiPlane:
            return os << "phiPlane";
    }
    return os;
}

◆ operator<< [4/4]

std::ostream & operator<<	(	std::ostream &	os,
		MuonFastSegmentFittingAlg::ParamDefs2D	pars )

friend

Definition at line 548 of file MuonFastSegmentFittingAlg.cxx.

                                                                                  {
    switch (pars) {
        case MuonFastSegmentFittingAlg::ParamDefs2D::intercept:
            return os << "Intercept";
        case MuonFastSegmentFittingAlg::ParamDefs2D::slope:
            return os << "Slope";
        default:
            return os;
    }
}

Member Data Documentation

◆ m_beamspotCov

Acts::SquareMatrix<3> MuonR4::MuonFastSegmentFittingAlg::m_beamspotCov {Acts::SquareMatrix<3>::Zero()}

private

Covariance matrix of the beam spot.

Definition at line 212 of file MuonFastSegmentFittingAlg.h.

212{Acts::SquareMatrix<3>::Zero()};

◆ m_beamSpotLength

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_beamSpotLength {this, "BeamSpotLength", 2.*Gaudi::Units::m}

private

Beam spot length.

Definition at line 201 of file MuonFastSegmentFittingAlg.h.

201{this, "BeamSpotLength", 2.*Gaudi::Units::m};

◆ m_beamSpotRadius

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_beamSpotRadius {this, "BeamSpotRadius", 30.*Gaudi::Units::cm}

private

Beam spot radius.

Definition at line 199 of file MuonFastSegmentFittingAlg.h.

199{this, "BeamSpotRadius", 30.*Gaudi::Units::cm};

◆ m_calibTool

ToolHandle<ISpacePointCalibrator> MuonR4::MuonFastSegmentFittingAlg::m_calibTool {this, "Calibrator", "" }

private

Handle to the space point calibrator tool.

Definition at line 165 of file MuonFastSegmentFittingAlg.h.

165{this, "Calibrator", "" };

◆ m_combMeasKey

SG::WriteHandleKey<xAOD::CombinedMuonStripContainer> MuonR4::MuonFastSegmentFittingAlg::m_combMeasKey {this, "combinedPrdKey", "FastCombinedPrdKey"}

private

Auxiliary container to model two measurements in the same gas gap as a single track state.

Definition at line 158 of file MuonFastSegmentFittingAlg.h.

158{this, "combinedPrdKey", "FastCombinedPrdKey"};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_fastPreFitter

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_fastPreFitter {this, "useFastPreFitter", false}

private

The fast fitter is treated as a pre fitter.

Definition at line 193 of file MuonFastSegmentFittingAlg.h.

193{this, "useFastPreFitter", false};

◆ m_fitter

std::unique_ptr<LineFitter> MuonR4::MuonFastSegmentFittingAlg::m_fitter {}

private

Pointer to the actual segment fitter.

Definition at line 206 of file MuonFastSegmentFittingAlg.h.

206{};

◆ m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonR4::MuonFastSegmentFittingAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Geometry context key.

Definition at line 161 of file MuonFastSegmentFittingAlg.h.

161{this, "AlignmentKey", "ActsAlignment", "cond handle key"};

◆ m_goodSegmentCut

DoubleProperty MuonR4::MuonFastSegmentFittingAlg::m_goodSegmentCut {this, "GoodSegmentCut", 2.}

private

Reduced chi2 defining a good segment, stopping the fit of other segments in the same station.

Definition at line 181 of file MuonFastSegmentFittingAlg.h.

181{this, "GoodSegmentCut", 2.};

◆ m_goodSegmentDoF

UnsignedIntegerProperty MuonR4::MuonFastSegmentFittingAlg::m_goodSegmentDoF {this, "GoodSegmentDoF", 5}

private

Number of degrees of freedom defining a good segment, stopping the fit of other segments in the same station.

Definition at line 183 of file MuonFastSegmentFittingAlg.h.

183{this, "GoodSegmentDoF", 5};

◆ m_hessianResidual

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_hessianResidual {this, "useHessianResidual", false}

private

Use the expliciit Hessian in the residual calculation.

Definition at line 174 of file MuonFastSegmentFittingAlg.h.

174{this, "useHessianResidual", false};

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::MuonFastSegmentFittingAlg::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Handle to the MuonIdHelper service.

Definition at line 163 of file MuonFastSegmentFittingAlg.h.

163{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_ignoreFailedPreFit

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_ignoreFailedPreFit {this, "ignoreFailedPreFit", false}

private

Switch to try the full fit when the fast pre-fitter fails.

Definition at line 195 of file MuonFastSegmentFittingAlg.h.

195{this, "ignoreFailedPreFit", false};

◆ m_inPatterns

SG::ReadHandleKey<GlobalPatternContainer> MuonR4::MuonFastSegmentFittingAlg::m_inPatterns {this, "InPatterns", "MuonR4GlobalPatterns", "Global patterns to read"}

private

Write handle key for the output global patterns.

Definition at line 141 of file MuonFastSegmentFittingAlg.h.

141{this, "InPatterns", "MuonR4GlobalPatterns", "Global patterns to read"};

◆ m_localSegCovKey

DecorKey_t MuonR4::MuonFastSegmentFittingAlg::m_localSegCovKey {this, "LocalCovParKey", m_outSegments, "localSegCov"}

private

Decoration of the local fit covariance parameters.

Definition at line 152 of file MuonFastSegmentFittingAlg.h.

152{this, "LocalCovParKey", m_outSegments, "localSegCov"};

◆ m_localSegParKey

DecorKey_t MuonR4::MuonFastSegmentFittingAlg::m_localSegParKey {this, "LocalSegParKey", m_outSegments, "localSegPars"}

private

Decoration of the local segment parameters.

Definition at line 150 of file MuonFastSegmentFittingAlg.h.

150{this, "LocalSegParKey", m_outSegments, "localSegPars"};

◆ m_maxIter

UnsignedIntegerProperty MuonR4::MuonFastSegmentFittingAlg::m_maxIter {this, "maxIterations", 50}

private

Tune the number of iterations.

Definition at line 197 of file MuonFastSegmentFittingAlg.h.

197{this, "maxIterations", 50};

◆ m_mdtSeeder

std::unique_ptr<MdtSegmentSeeder> MuonR4::MuonFastSegmentFittingAlg::m_mdtSeeder {}

private

Pointer to the L-R segment seeder.

Definition at line 210 of file MuonFastSegmentFittingAlg.h.

210{};

◆ m_nswFitter

std::unique_ptr<LineFitter> MuonR4::MuonFastSegmentFittingAlg::m_nswFitter {}

private

Pointer to the NSW segment fitter.

Definition at line 208 of file MuonFastSegmentFittingAlg.h.

208{};

◆ m_outlierRemovalCut

DoubleProperty MuonR4::MuonFastSegmentFittingAlg::m_outlierRemovalCut {this, "OutlierRemoval", 3.}

private

Cut on the segment chi2 / nDoF to launch the outlier removal.

Definition at line 185 of file MuonFastSegmentFittingAlg.h.

185{this, "OutlierRemoval", 3.};

◆ m_outSegments

SG::WriteHandleKey<xAOD::MuonSegmentContainer> MuonR4::MuonFastSegmentFittingAlg::m_outSegments {this, "OutSegments", "FastMuonSegments", "Segments to write"}

private

Write handle key for the output segments.

Definition at line 143 of file MuonFastSegmentFittingAlg.h.

143{this, "OutSegments", "FastMuonSegments", "Segments to write"};

◆ m_patternKey

DecorKey_t MuonR4::MuonFastSegmentFittingAlg::m_patternKey {this, "ParentPatternKey", m_outSegments, "GlobalPatternLink", "Parent global pattern for the segments"}

private

Parent global pattern decoration of the segments.

Definition at line 148 of file MuonFastSegmentFittingAlg.h.

148{this, "ParentPatternKey", m_outSegments, "GlobalPatternLink", "Parent global pattern for the segments"};

◆ m_prdLinkKey

DecorKey_t MuonR4::MuonFastSegmentFittingAlg::m_prdLinkKey {this, "PrdLinkKey", m_outSegments, "prdLinks" }

private

Decoration to the links to the associated Uncalibrated measurements.

Definition at line 154 of file MuonFastSegmentFittingAlg.h.

154{this, "PrdLinkKey", m_outSegments, "prdLinks" };

◆ m_prdStateKey

DecorKey_t MuonR4::MuonFastSegmentFittingAlg::m_prdStateKey {this, "PrdStateKey", m_outSegments, "prdState"}

private

Decoration to the PrdLink state (I.e.

outlier or valid)

Definition at line 156 of file MuonFastSegmentFittingAlg.h.

156{this, "PrdStateKey", m_outSegments, "prdState"};

◆ m_precHitCut

UnsignedIntegerProperty MuonR4::MuonFastSegmentFittingAlg::m_precHitCut {this, "PrecHitCut" , 3}

private

Minimum number of precision hits to accept the segment.

Definition at line 189 of file MuonFastSegmentFittingAlg.h.

189{this, "PrecHitCut" , 3};

◆ m_recalibInFit

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_recalibInFit {this, "recalibInFit" , false}

private

Toggle the recalibration of hits during the segment fit.

Definition at line 172 of file MuonFastSegmentFittingAlg.h.

172{this, "recalibInFit" , false};

◆ m_recalibSeed

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_recalibSeed {this, "SeedRecalibrate", false}

private

Toggle seed recalibration.

The two seed circles are recalibrated using the initial seed

Definition at line 179 of file MuonFastSegmentFittingAlg.h.

179{this, "SeedRecalibrate", false};

◆ m_recoveryPull

DoubleProperty MuonR4::MuonFastSegmentFittingAlg::m_recoveryPull {this, "RecoveryPull", 3.}

private

Pull value for hit recovery.

Definition at line 187 of file MuonFastSegmentFittingAlg.h.

187{this, "RecoveryPull", 3.};

◆ m_seedHitChi2

DoubleProperty MuonR4::MuonFastSegmentFittingAlg::m_seedHitChi2 {this, "ResoSeedHitAssoc", 5. }

private

Two mdt seeds are the same if their defining parameters match wihin.

Definition at line 176 of file MuonFastSegmentFittingAlg.h.

176{this, "ResoSeedHitAssoc", 5. };

◆ m_segmentCnvTool

ToolHandle<IxAODSegmentCnvTool> MuonR4::MuonFastSegmentFittingAlg::m_segmentCnvTool {this, "SegmentCnvTool", ""}

private

Segment converter tool.

Definition at line 167 of file MuonFastSegmentFittingAlg.h.

167{this, "SegmentCnvTool", ""};

◆ m_segVisionTool

ToolHandle<MuonValR4::IPatternVisualizationTool> MuonR4::MuonFastSegmentFittingAlg::m_segVisionTool {this, "VisualizationTool", ""}

private

Handle to the visualization tool for segments.

Definition at line 169 of file MuonFastSegmentFittingAlg.h.

169{this, "VisualizationTool", ""};

◆ m_spSorter

SpacePointPerLayerSorter MuonR4::MuonFastSegmentFittingAlg::m_spSorter {}

private

Spacepoint sorter per logical measurement layer.

Definition at line 204 of file MuonFastSegmentFittingAlg.h.

204{};

◆ m_useFastFitter

BooleanProperty MuonR4::MuonFastSegmentFittingAlg::m_useFastFitter {this, "useFastFitter", false}

private

Use the fast Mdt fitter where possible.

Definition at line 191 of file MuonFastSegmentFittingAlg.h.

191{this, "useFastFitter", false};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Bucket_t

◆ DecorKey_t

◆ Hit_t

◆ HitVec_t

◆ Line2D_t

◆ LineFitter

◆ MdtSegmentSeeder

◆ Parameters

◆ RegressionRes_t

◆ Seed_t

◆ Segment_t

◆ SegmentSeedOpt_t

◆ SegmentSeedPair_t

◆ StIndex

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ CoordPlane

◆ ParamDefs2D

Constructor & Destructor Documentation

◆ ~MuonFastSegmentFittingAlg()

Member Function Documentation

◆ beamspotCov()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ findSegmentToAddPhi()

◆ fitSegment()

◆ initialize()

◆ initializePars()

◆ inputHandles()

◆ isClonable()

◆ linearRegression()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ processPattern()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Friends And Related Symbol Documentation

◆ operator<< [1/4]

◆ operator<< [2/4]

◆ operator<< [3/4]

◆ operator<< [4/4]

Member Data Documentation

◆ m_beamspotCov

◆ m_beamSpotLength

◆ m_beamSpotRadius

◆ m_calibTool

◆ m_combMeasKey

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fastPreFitter

◆ m_fitter

◆ m_geoCtxKey

◆ m_goodSegmentCut

◆ m_goodSegmentDoF

◆ m_hessianResidual

◆ m_idHelperSvc

◆ m_ignoreFailedPreFit

◆ m_inPatterns