MuonR4::NswSegmentFinderAlg Class Reference

#include <NswSegmentFinderAlg.h>

Inheritance diagram for MuonR4::NswSegmentFinderAlg:

Collaboration diagram for MuonR4::NswSegmentFinderAlg:

Classes
class	SeedStatistics
	Seed statistics per sector to be printed in the end. More...

Public Member Functions
virtual	~NswSegmentFinderAlg ()=default
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
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	StripOrient {   U , V , X , P ,   C , Unknown }
	Enumeration to classify the orientation of a NSW strip. More...
enum class	HitWindow { tooLow , inside , tooHigh }
	To fastly check whether a hit is roughly compatible with a muon trajectory a narrow corridor is opened from the estimated beamspot to the first tested hit in the seed finding. More...
using	HitVec = SpacePointPerLayerSplitter::HitVec
using	HitLayVec = SpacePointPerLayerSplitter::HitLayVec
using	HitLaySpan_t = std::vector<std::reference_wrapper<const HitVec>>
	Abbrivation of the space comprising multiple hit vectors without copy.
using	UsedHitMarker_t = std::vector<std::vector<unsigned int>>
	Abbrivation of the container book keeping whether a hit is used or not.
using	UsedHitSpan_t = std::vector<std::reference_wrapper<std::vector<unsigned int>>>
	Abbrivation of the container to pass a subset of markers wtihout copy.
using	InitialSeed_t = std::array<const SpacePoint*, 4>
	Abbrivation of the initial seed.
using	InitialSeedVec_t = std::vector<InitialSeed_t>
	Vector of initial seeds.
using	SegmentSeedVec_t = std::vector<std::unique_ptr<SegmentSeed>>
	Abbrivation of the seed vector.
using	SegmentVec_t = std::vector<std::unique_ptr<Segment>>
	Abbrivation of the final segment vector.
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StripOrient	classifyStrip (const SpacePoint &spacePoint) const
	Determines the orientation of the strip space point.
UsedHitMarker_t	emptyBookKeeper (const HitLayVec &sortedSp) const
	Constructs an empty HitMarker from the split space points.
HitWindow	hitFromIPCorridor (const SpacePoint &testHit, const Amg::Vector3D &beamSpotPos, const Amg::Vector3D &dirEstUp, const Amg::Vector3D &dirEstDn) const
	The hit is above the predefined corridor.
void	constructPreliminarySeeds (const Amg::Vector3D &beamSpot, const HitLaySpan_t &combinatoricLayers, const UsedHitSpan_t &usedHits, InitialSeedVec_t &outVec) const
	Construct a set of prelimnary seeds from the selected combinatoric layers.
std::unique_ptr< SegmentSeed >	constructCombinatorialSeed (const InitialSeed_t &initialSeed, const AmgSymMatrix(2)&bMatrix, const HoughMaximum &max, const HitLaySpan_t &extensionLayers, const UsedHitSpan_t &usedHits) const
	Construct a combinatorial seed from the initial 4-layer seed hits.
std::pair< SegmentSeedVec_t, SegmentVec_t >	buildSegmentsFromMM (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const HitLayVec &hitLayers, const HoughMaximum &max, const Amg::Vector3D &beamSpotPos, UsedHitMarker_t &usedHits, bool useOnlyMM) const
	Build the final segment seed from strip like measurements using the combinatorial seeding for MicroMegas (or strip measurements) logic.
std::pair< SegmentSeedVec_t, SegmentVec_t >	buildSegmentsFromSTGC (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const HitLayVec &hitLayers, const HoughMaximum &max, const Amg::Vector3D &beamSpotPos, UsedHitMarker_t &usedHits) const
	Build the segment for a seed from STGC 2D measurement layers directly and then attempt to append hits from the other layers.
std::unique_ptr< Segment >	fitSegmentSeed (const EventContext &ctx, const ActsTrk::GeometryContext &gctx, const SegmentSeed *patternSeed) const
	Fit the segment seeds.
void	processSegment (std::unique_ptr< Segment > segment, const HitVec &seedHits, const HitLayVec &hitLayers, UsedHitMarker_t &usedHits, SegmentVec_t &segments) const
	Process the segment and mark the hits if it is successfully built or not by differently mark the hits as used.
void	markHitsAsUsed (const HitVec &spacePoints, const HitLayVec &allSortHits, UsedHitMarker_t &usedHitMarker, unsigned int increase, bool markNeighborHits) const
	Hits that are used in a good seed/segment built should be flagged as used and not contribute to other seed.
HitVec	extendHits (const Amg::Vector3D &startPos, const Amg::Vector3D &direction, const HitLaySpan_t &extensionLayers, const UsedHitSpan_t &usedHits) const
	Extend the seed with the hits from the other layers.
std::pair< SegmentSeedVec_t, SegmentVec_t >	findSegmentsFromMaximum (const HoughMaximum &max, const ActsTrk::GeometryContext &gctx, const EventContext &ctx) const
	Find seed and segment from an eta hough maximum.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< EtaHoughMaxContainer >	m_etaKey {this, "CombinatorialReadKey", "MuonHoughNswMaxima"}
SG::WriteHandleKey< SegmentSeedContainer >	m_writeSegmentSeedKey {this, "MuonNswSegmentSeedWriteKey", "MuonNswSegmentSeeds"}
SG::WriteHandleKey< SegmentContainer >	m_writeSegmentKey {this, "MuonNswSegmentWriteKey", "MuonNswSegments"}
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< MuonValR4::IPatternVisualizationTool >	m_visionTool {this, "VisualizationTool", ""}
	Pattern visualization tool.
ToolHandle< ISpacePointCalibrator >	m_calibTool {this, "Calibrator", "" }
std::unique_ptr< SegmentFit::SegmentLineFitter >	m_lineFitter {}
DoubleProperty	m_windowTheta {this, "thetaWindow", 2.5 * Gaudi::Units::deg}
DoubleProperty	m_minPullThreshold {this, "maxPull", 5.}
UnsignedIntegerProperty	m_minSeedHits {this, "minSeedHits", 4}
UnsignedIntegerProperty	m_maxInvalidClusters {this, "maxInvalidClusters", 4}
BooleanProperty	m_markHitsFromSeed {this, "markHitsFromSeed", true}
BooleanProperty	m_doOnlyMMCombinatorics {this, "doOnlyMMCombinatorics", false}
UnsignedIntegerProperty	m_maxUsed {this, "maxHitIsUsed", 8}
UnsignedIntegerProperty	m_minClusSize {this, "minClusterSize", 1}
DoubleProperty	m_maxChi2 {this, "maxChi2", 5.}
UnsignedIntegerProperty	m_maxClustersInLayer {this, "maxClustersInLayer", 8}
DoubleProperty	m_maxdYWindow {this, "maxdYWindow", 4.*Gaudi::Units::cm}
BooleanProperty	m_dumpSeedStatistics {this, "dumpStatistics", true}
std::unique_ptr< SeedStatistics > m_seedCounter	ATLAS_THREAD_SAFE {}
const MuonGMR4::MuonDetectorManager *	m_detMgr {}
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

Detailed Description

Definition at line 33 of file NswSegmentFinderAlg.h.

Member Typedef Documentation

HitLaySpan_t

using MuonR4::NswSegmentFinderAlg::HitLaySpan_t = std::vector<std::reference_wrapper<const HitVec>>

private

Abbrivation of the space comprising multiple hit vectors without copy.

Definition at line 112 of file NswSegmentFinderAlg.h.

HitLayVec

using MuonR4::NswSegmentFinderAlg::HitLayVec = SpacePointPerLayerSplitter::HitLayVec

private

Definition at line 110 of file NswSegmentFinderAlg.h.

HitVec

using MuonR4::NswSegmentFinderAlg::HitVec = SpacePointPerLayerSplitter::HitVec

private

Definition at line 108 of file NswSegmentFinderAlg.h.

InitialSeed_t

using MuonR4::NswSegmentFinderAlg::InitialSeed_t = std::array<const SpacePoint*, 4>

private

Abbrivation of the initial seed.

Definition at line 118 of file NswSegmentFinderAlg.h.

InitialSeedVec_t

using MuonR4::NswSegmentFinderAlg::InitialSeedVec_t = std::vector<InitialSeed_t>

private

Vector of initial seeds.

Definition at line 120 of file NswSegmentFinderAlg.h.

SegmentSeedVec_t

using MuonR4::NswSegmentFinderAlg::SegmentSeedVec_t = std::vector<std::unique_ptr<SegmentSeed>>

private

Abbrivation of the seed vector.

Definition at line 125 of file NswSegmentFinderAlg.h.

SegmentVec_t

using MuonR4::NswSegmentFinderAlg::SegmentVec_t = std::vector<std::unique_ptr<Segment>>

private

Abbrivation of the final segment vector.

Definition at line 127 of file NswSegmentFinderAlg.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

UsedHitMarker_t

using MuonR4::NswSegmentFinderAlg::UsedHitMarker_t = std::vector<std::vector<unsigned int>>

private

Abbrivation of the container book keeping whether a hit is used or not.

Definition at line 114 of file NswSegmentFinderAlg.h.

UsedHitSpan_t

using MuonR4::NswSegmentFinderAlg::UsedHitSpan_t = std::vector<std::reference_wrapper<std::vector<unsigned int>>>

private

Abbrivation of the container to pass a subset of markers wtihout copy.

Definition at line 116 of file NswSegmentFinderAlg.h.

Member Enumeration Documentation

HitWindow

enum class MuonR4::NswSegmentFinderAlg::HitWindow

strongprivate

To fastly check whether a hit is roughly compatible with a muon trajectory a narrow corridor is opened from the estimated beamspot to the first tested hit in the seed finding.

Hits in subsequent layers need to be within this corridor in order to be considered for seed construction. The HitWindow is the output classification of such a corridor test.

Enumerator
tooLow
inside	The hit is below the predefined corridor.
tooHigh	The hit is inside the defined window and hence an initial candidate.

Definition at line 134 of file NswSegmentFinderAlg.h.

                            {tooLow, 
                             inside, 
                             tooHigh}; 

StripOrient

enum class MuonR4::NswSegmentFinderAlg::StripOrient

strongprivate

Enumeration to classify the orientation of a NSW strip.

Enumerator
U
V	Stereo strips with positive angle.
X	Stereo strips with negative angle.
P	Ordinary eta strips.
C	Single phi measurements.
Unknown	Combined 2D space point (sTGC wire + strip / sTgc pad)

Definition at line 45 of file NswSegmentFinderAlg.h.

                              {
          U, 
          V, 
          X, 
          P, 
          C, 
          Unknown
        };

Constructor & Destructor Documentation

~NswSegmentFinderAlg()

virtual MuonR4::NswSegmentFinderAlg::~NswSegmentFinderAlg ( )

virtualdefault

Member Function Documentation

buildSegmentsFromMM()

std::pair< NswSegmentFinderAlg::SegmentSeedVec_t, NswSegmentFinderAlg::SegmentVec_t > MuonR4::NswSegmentFinderAlg::buildSegmentsFromMM ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const HitLayVec & hitLayers, const HoughMaximum & max, const Amg::Vector3D & beamSpotPos, UsedHitMarker_t & usedHits, bool useOnlyMM ) const

private

Build the final segment seed from strip like measurements using the combinatorial seeding for MicroMegas (or strip measurements) logic.

Parameters

hitLayers	Reference to the hits of the strip layers
gctx	The geometry context
ctx	The event context
max	Refrence to the eta maximum from which the segment seed is constructed
beamSporPos	The beaspot position in the sector's frame to be used to constrain the hits selection
usedHits	Refrence to the book keeper of which of the hits on the extension was already used
useOnlyMM	: Boolean to use only MM hits for the initial 4layer seed from the combinatorics

Definition at line 527 of file NswSegmentFinderAlg.cxx.

                                                               {
    
    //go through the layers and build seeds from the combinations of hits
    SegmentSeedVec_t seeds{};
    SegmentVec_t segments{};
    std::size_t layerSize = hitLayers.size();
 
    if(layerSize < minLayers){
        ATH_MSG_VERBOSE("Not enough layers to build a seed");
        return {std::move(seeds), std::move(segments)};
    }
 
    //lamda helper to find the first unused strip hit on the layer
    auto unusedStripHit = [&](const HitVec& layerHits, unsigned int layIdx) -> const SpacePoint* {
        //in case of MM only combinatorial seeding - we consider only MM strip hits for seeding
        bool isMM = useOnlyMM ? layerHits.front()->type() == xAOD::UncalibMeasType::MMClusterType : true;
        for (auto [idx, hit] : Acts::enumerate(layerHits)) {
            auto spOrient = classifyStrip(*hit);
            bool isStrip = spOrient == StripOrient::X || spOrient == StripOrient::U || spOrient == StripOrient::V;
            bool isUnused = usedHits[layIdx].at(idx) <= m_maxUsed;           
            if (isStrip && isUnused && isMM) {
                return hit;
            }
        }
        return nullptr;       
    };
 
    std::array<const SpacePoint*, 4> seedHits{};
    InitialSeedVec_t preLimSeeds{};
 
    for (std::size_t i = 0; i < layerSize - 3; ++i) {
        seedHits[0] = unusedStripHit(hitLayers[i], i);
        if(!seedHits[0]) {
            continue;
        }
        for (std::size_t j = i + 1; j < layerSize - 2; ++j) {
            seedHits[1] = unusedStripHit(hitLayers[j], j);
            if(!seedHits[1]){
                continue;
            }
            for (std::size_t k = j + 1; k < layerSize - 1; ++k) {
                seedHits[2] = unusedStripHit(hitLayers[k], k);
                if(!seedHits[2]){
                    continue;
                }
                for (std::size_t l = k + 1; l < layerSize; ++l) {
                    seedHits[3] = unusedStripHit(hitLayers[l], l);
                    if(!seedHits[3]){
                        continue;
                    }
 
                    const HitLaySpan_t layers{hitLayers[i], hitLayers[j], hitLayers[k], hitLayers[l]};
                    //skip combination with at least one too busy layer
                    bool tooBusy = std::ranges::any_of(layers,
                                            [this](const auto& layer) {
                                                return layer.get().size() > m_maxClustersInLayer;
                                            });
                    if (tooBusy) {
                        continue; // skip this combination
                    }
                    
                    AmgSymMatrix(2) bMatrix = betaMatrix(seedHits);   
       
                    if (std::abs(bMatrix.determinant()) < 1.e-6) {
                        continue;
                    }
                    ATH_MSG_DEBUG("Space point positions for seed layers: \n"
                                 <<(*seedHits[0]) << ",\n"
                                 <<(*seedHits[1]) << ",\n"
                                 <<(*seedHits[2]) << ",\n"
                                 <<(*seedHits[3]));  
    
                  
                    UsedHitSpan_t usedHitsSpan{usedHits[i], usedHits[j], usedHits[k], usedHits[l]};    
                    // each layer may have more than one hit - take the hit combinations                    
                    constructPreliminarySeeds(beamSpotPos, layers, usedHitsSpan, preLimSeeds);
 
                     //the layers not participated in the seed build - gonna be used for the extension  
                    HitLaySpan_t extensionLayers{};
                    UsedHitSpan_t usedExtensionHits{};
                    usedExtensionHits.reserve(hitLayers.size());
                    extensionLayers.reserve(hitLayers.size());
                    for (std::size_t e = 0 ; e < hitLayers.size(); ++e) {
                        if (!(e == i || e == j || e == k || e == l)){
                            extensionLayers.emplace_back(hitLayers[e]);
                            usedExtensionHits.emplace_back(usedHits[e]);
                        }
                    }
                    // we have made sure to have hits from all the four layers -
                    // start by 4 hits for the seed and try to build the extended seed for the combinatorics found
                    for (auto &combinatoricHits : preLimSeeds) {
                        auto seed = constructCombinatorialSeed(combinatoricHits, bMatrix, max, extensionLayers, usedExtensionHits);
                        if (!seed) {                            
                            continue;
                        }
                                             
                        std::unique_ptr<Segment> segment = fitSegmentSeed(ctx, gctx, seed.get());
                        processSegment(std::move(segment), seed->getHitsInMax(), hitLayers, usedHits, segments);
                        seeds.push_back(std::move(seed));                                    
              
                    }
                }
            }
        }
    }
    return std::make_pair(std::move(seeds),std::move(segments));
}

buildSegmentsFromSTGC()

std::pair< NswSegmentFinderAlg::SegmentSeedVec_t, NswSegmentFinderAlg::SegmentVec_t > MuonR4::NswSegmentFinderAlg::buildSegmentsFromSTGC ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const HitLayVec & hitLayers, const HoughMaximum & max, const Amg::Vector3D & beamSpotPos, UsedHitMarker_t & usedHits ) const

private

Build the segment for a seed from STGC 2D measurement layers directly and then attempt to append hits from the other layers.

Parameters

hitLayers	: Reference to the hits of the layers
gctx	The reference to the geometry context
ctx	The reference to the event context
max	Refrence to the eta maximum from which the segment seed is constructed
beamSpotPos	The beamspot position in the sector's frame to be used to constrain the hits selection
usedHits	Refrence to the book keeper of which of the hits on the extension was already used

Definition at line 429 of file NswSegmentFinderAlg.cxx.

                                                                            {
 
    //go through the  layers and build seeds from the combinations of hits 
    //starting from the outermost layers with 2D measurements (excluding pads)
    SegmentSeedVec_t seeds{};
    SegmentVec_t segments{};
    std::size_t layerSize = hitLayers.size();
    double thetaWindowCut{std::cos(2*m_windowTheta)};
 
    // lamda helper to check if the spacepoint is combined (but not pad) and unused in an already constructed seed
    auto isUnusedCombined = [&](std::size_t layIdx, std::size_t hitIdx) -> bool {
        const SpacePoint* sp = hitLayers[layIdx][hitIdx];
        if (sp->type() != xAOD::UncalibMeasType::sTgcStripType) {
            THROW_EXCEPTION("Space point is not of sTgc type: "<<sp->msSector()->idHelperSvc()->toString(sp->identify()));
        }
        const auto* prd = static_cast<const xAOD::sTgcMeasurement*>(sp->primaryMeasurement());
        bool isCombined = sTgcChannelType(prd->channelType()) == "S" && sp->dimension() == 2;
        bool isUnused = usedHits[layIdx].at(hitIdx) <= m_maxUsed;
        return isCombined && isUnused;      
   
    };
 
    // find the 2D measurements from the outermost layers - even move one layer inside 
    for(std::size_t layIdx1 = 0; layIdx1 < 2; ++layIdx1){        
        for(std::size_t layIdx2 = layerSize-1; layIdx2 >= layerSize-2; --layIdx2){
            //in case of MM layers we stop - the layers are sorted in Z
            if(hitLayers[layIdx1].front()->type() == xAOD::UncalibMeasType::MMClusterType  || 
               hitLayers[layIdx2].front()->type() == xAOD::UncalibMeasType::MMClusterType){
                ATH_MSG_VERBOSE("Outermost layers are MM - stop searching for sTgc Measurements");
                return std::make_pair(std::move(seeds), std::move(segments));
            }
 
            //check if we have 2D measurements on these layers that are unused (excluding the pads)
            for(std::size_t hitIdx1 = 0; hitIdx1 < hitLayers[layIdx1].size(); ++hitIdx1) {
                const SpacePoint* hit1 = hitLayers[layIdx1][hitIdx1];
                if(!isUnusedCombined(layIdx1, hitIdx1)){
                    continue;
                }
                for(std::size_t hitIdx2 = 0; hitIdx2 < hitLayers[layIdx2].size(); ++hitIdx2) {
                    const SpacePoint* hit2 = hitLayers[layIdx2][hitIdx2];
                    if(!isUnusedCombined(layIdx2, hitIdx2)){
                        continue;
                    }
                     //test if this selection of the hits from the two layers is aligned with the beam spot 
                    const Amg::Vector3D beamSpotHitDir{(beamSpotPos - hit1->localPosition()).unit()};
                    const Amg::Vector3D seedDir{(hit2->localPosition() - hit1->localPosition()).unit()};                 
                    const double cosAngle = beamSpotHitDir.dot(seedDir);
                    //accept the deflection of direction with a tolerance of 1 deg                    
                    if(std::abs(cosAngle) < thetaWindowCut){                        
                        continue;                        
                    }                   
                    //found 2D hits on the outermost layers - build a seed
                    HitVec seedHits{hit1, hit2};
                    //get the seed direction and position from the two 2D hits
                    const Amg::Vector3D seedPos = hit1->localPosition();
                     //express position in z=0
                    const Amg::Vector3D seedPosZ0 = seedPos + Amg::intersect<3>(seedPos, seedDir, Amg::Vector3D::UnitZ(), 0.).value_or(0.)*seedDir;                 
                    // extend the seed to the other layers
                    HitLaySpan_t extensionLayers{};
                    UsedHitSpan_t usedExtensionHits{};
                    extensionLayers.reserve(hitLayers.size());
                    usedExtensionHits.reserve(hitLayers.size());
                    for (std::size_t e = 0 ; e < hitLayers.size(); ++e) {
                        if (!(e == layIdx1 || e == layIdx2)){                            
                            extensionLayers.emplace_back(hitLayers[e]);
                            usedExtensionHits.emplace_back(usedHits[e]);    
                        }
                    }
                    auto extendedHits = extendHits(seedPosZ0, seedDir, extensionLayers, usedExtensionHits);
                    std::ranges::move(extendedHits, std::back_inserter(seedHits));
 
                    if(seedHits.size() < minLayers){
                        continue;                    
                    }
 
                    //make seed 
                    auto seed = std::make_unique<SegmentSeed>(houghTanBeta(seedDir), seedPosZ0.y(),
                                                         houghTanAlpha(seedDir), seedPosZ0.x(),
                                                         seedHits.size(), std::move(seedHits),
                                                         max.parentBucket());
                    //fit the segment seed
                    std::unique_ptr<Segment> segment = fitSegmentSeed(ctx, gctx, seed.get());  
                    processSegment(std::move(segment), seed->getHitsInMax(), hitLayers, usedHits, segments);
                    seeds.push_back(std::move(seed));
 
                }               
            }
        }
    }
    return std::make_pair(std::move(seeds),std::move(segments));
}

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

classifyStrip()

NswSegmentFinderAlg::StripOrient MuonR4::NswSegmentFinderAlg::classifyStrip ( const SpacePoint & spacePoint ) const

private

Determines the orientation of the strip space point.

Definition at line 117 of file NswSegmentFinderAlg.cxx.

                                                                {
    
    if (sp.type() == xAOD::UncalibMeasType::MMClusterType) {
        const auto& design = getDesign(sp);
        if (!design.hasStereoAngle()) {
            return StripOrient::X;
        } 
        return design.stereoAngle() > 0. ? StripOrient::U : StripOrient::V;
    } else if (sp.type() == xAOD::UncalibMeasType::sTgcStripType) {
        const auto* prd = static_cast<const xAOD::sTgcMeasurement*>(sp.primaryMeasurement());
        if (sp.dimension() == 2) {
            return StripOrient::C;        
        }       
        //check if we have strip only or wire only measurements
        return prd->channelType() == sTgcIdHelper::Strip ? StripOrient::X : StripOrient::P;
         
    }
    ATH_MSG_WARNING("Cannot classify orientation of "<<m_idHelperSvc->toString(sp.identify()));
    return StripOrient::Unknown;
}

constructCombinatorialSeed()

std::unique_ptr< SegmentSeed > MuonR4::NswSegmentFinderAlg::constructCombinatorialSeed ( const InitialSeed_t & initialSeed, const AmgSymMatrix(2)& bMatrix, const HoughMaximum & max, const HitLaySpan_t & extensionLayers, const UsedHitSpan_t & usedHits ) const

private

Construct a combinatorial seed from the initial 4-layer seed hits.

Parameters

initialSeed	Reference to the hit quadruplet that may form a seed
bMatrix	Kernel matrix calculated from the layer configuration to construct the seed
max	Refrence to the eta maximum from which the segment seed is constructed
extensionLayers	Reference to the hits on the remaining layers of the detector
usedHits	Refrence to the book keeper of which of the hits on the extension was already used

Definition at line 315 of file NswSegmentFinderAlg.cxx.

                                                                                         {
    bool allValid = std::any_of(initialSeed.begin(), initialSeed.end(), 
                                [this](const auto& hit){
        if (hit->type() == xAOD::UncalibMeasType::MMClusterType) {
            const auto* mmClust = static_cast<const xAOD::MMCluster*>(hit->primaryMeasurement());
            return mmClust->stripNumbers().size() >= m_minClusSize;
        }
        return true;
    });
 
    if (!allValid) {
        ATH_MSG_VERBOSE("Seed rejection: Not all clusters meet minimum strip size");
        return nullptr; 
    }
    
 
    std::array<double, 4> params = defineParameters(bMatrix, initialSeed);
 
    const auto [segPos, direction] = seedSolution(initialSeed, params);
 
    // check the consistency of the parameters - expected to lay in the strip's
    // length
    for (std::size_t i = 0; i < 4; ++i) {
        const double halfLength = stripHalfLength(*initialSeed[i]);
        
        if (std::abs(params[i]) > halfLength) {
            ATH_MSG_VERBOSE("Seed Rejection: Invalid seed - outside of the strip's length "<< m_idHelperSvc->toString(initialSeed[i]->identify())
                          <<", param: "<<params[i]<<", halfLength: "<<halfLength);
            return nullptr;
        }
    }
    double tanAlpha = houghTanAlpha(direction);
    double tanBeta = houghTanBeta(direction);
 
    double interceptX = segPos.x();
    double interceptY = segPos.y();
 
 
    // extend the seed to the segment -- include hits from the other layers too
    auto extendedHits = extendHits(segPos, direction, extensionLayers, usedHits);
    HitVec hits{initialSeed.begin(),initialSeed.end()};
    std::ranges::move(extendedHits, std::back_inserter(hits));
 
    return std::make_unique<SegmentSeed>(tanBeta, interceptY, tanAlpha,
                                         interceptX, hits.size(),
                                         std::move(hits), max.parentBucket());
}

constructPreliminarySeeds()

void MuonR4::NswSegmentFinderAlg::constructPreliminarySeeds ( const Amg::Vector3D & beamSpot, const HitLaySpan_t & combinatoricLayers, const UsedHitSpan_t & usedHits, InitialSeedVec_t & outVec ) const

private

Construct a set of prelimnary seeds from the selected combinatoric layers.

Quadruplets of hits, one from each layer, are formed if they are all within the the corridor as described above

Parameters

beamSpot	Position of the beam spot in the sector's frame
combinatoricLayers	Quadruplet of four hit vectors from which the hits are retrieved
usedHits	Mask marking hits that were already successfully added to a seed
outVec	Reference to the output vector where the initial seeds are stored. The vector is cleared at the beginning and capacity is allocated accordingly

Assign enough memory to the vector

The hit is alrady in a good seed. Don't consider again

Construct the beamspot to first hit connection to guestimate the angle

Apply cut window on theta of the seed.

Definition at line 215 of file NswSegmentFinderAlg.cxx.

                                                                                               {
    seedHitsFromLayers.clear();
    std::size_t maxSize{1};
    for (const HitVec& hitVec : combinatoricLayers) {
        maxSize = maxSize * hitVec.size();
    }
    seedHitsFromLayers.reserve(maxSize);
 
    unsigned iterLay0{0}, iterLay1{0}, iterLay2{0}, iterLay3{0};    
    unsigned startLay1{0}, startLay2{0}, startLay3{0};
    
    for( ; iterLay0 <  combinatoricLayers[0].get().size() ; ++iterLay0){
        if (usedHits[0].get()[iterLay0] > m_maxUsed) {
            continue;
        }
        const SpacePoint* hit0 = combinatoricLayers[0].get()[iterLay0];
        const Amg::Vector3D initSeedDir{(beamSpot - hit0->localPosition()).unit()};
        const Amg::Vector3D dirEstUp = Amg::dirFromAngles(initSeedDir.phi(), initSeedDir.theta() - m_windowTheta); 
        const Amg::Vector3D dirEstDn = Amg::dirFromAngles(initSeedDir.phi(), initSeedDir.theta() + m_windowTheta); 
 
        ATH_MSG_VERBOSE("Reference hit: "<<m_idHelperSvc->toString(hit0->identify())
                      <<", position: "<<Amg::toString(hit0->localPosition())
                      <<", seed dir: "<<Amg::toString(initSeedDir)
                      <<", seed plane: "<<Amg::toString(SeedingAux::extrapolateToPlane(beamSpot, initSeedDir, *hit0)));
        for( iterLay1 = startLay1; iterLay1 <  combinatoricLayers[1].get().size() ; ++iterLay1){
            TEST_HIT_CORRIDOR(1, iterLay1, startLay1);
            for( iterLay2 = startLay2; iterLay2 < combinatoricLayers[2].get().size() ; ++iterLay2){
                TEST_HIT_CORRIDOR(2, iterLay2, startLay2);
                for( iterLay3 = startLay3; iterLay3 < combinatoricLayers[3].get().size(); ++iterLay3){
                    TEST_HIT_CORRIDOR(3, iterLay3, startLay3);
                    seedHitsFromLayers.emplace_back(std::array{hit0, combinatoricLayers[1].get()[iterLay1], 
                                                           combinatoricLayers[2].get()[iterLay2],
                                                           combinatoricLayers[3].get()[iterLay3]}); 
                }
            }
        }
    }
}

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.

{ return m_detStore; }

emptyBookKeeper()

NswSegmentFinderAlg::UsedHitMarker_t MuonR4::NswSegmentFinderAlg::emptyBookKeeper ( const HitLayVec & sortedSp ) const

private

Constructs an empty HitMarker from the split space points.

Parameters

sortedSp

List of space points sorted by layer

Definition at line 108 of file NswSegmentFinderAlg.cxx.

                                                                       {
        UsedHitMarker_t emptyKeeper(sortedSp.size());
        for (std::size_t l = 0; l < sortedSp.size(); ++l) {
            emptyKeeper[l].resize(sortedSp[l].size(), 0);
        }
        return emptyKeeper;
}

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.

{ return m_evtStore; }

execute()

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

overridevirtual

Definition at line 818 of file NswSegmentFinderAlg.cxx.

                                                                     {
    // read the inputs
    const EtaHoughMaxContainer *maxima{nullptr};
    ATH_CHECK(SG::get( maxima, m_etaKey, ctx));
 
    const ActsTrk::GeometryContext *gctx{nullptr};
    ATH_CHECK(SG::get(gctx, m_geoCtxKey, ctx));
 
    // prepare our output collection
    SG::WriteHandle writeSegments{m_writeSegmentKey, ctx};
    ATH_CHECK(writeSegments.record(std::make_unique<SegmentContainer>()));
 
    SG::WriteHandle writeSegmentSeeds{m_writeSegmentSeedKey, ctx};
    ATH_CHECK(writeSegmentSeeds.record(std::make_unique<SegmentSeedContainer>()));
 
    // we use the information from the previous eta-hough transform
    // to get the combined hits that belong in the same maxima
    for (const HoughMaximum *max : *maxima) {
 
        auto [seeds, segments] = findSegmentsFromMaximum(*max, *gctx, ctx);
       
        if (msgLvl(MSG::VERBOSE)) {
            for(const auto& hitMax : max->getHitsInMax()){
                ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hitMax->identify())<<", "
                                <<Amg::toString(hitMax->localPosition())<<", dir: "
                                <<Amg::toString(hitMax->sensorDirection()));
            }
        }
 
        for(auto& seed: seeds){
 
             if (msgLvl(MSG::VERBOSE)){
                std::stringstream sstr{};
                sstr<<"Seed tanBeta = "<<seed->tanBeta()<<", y0 = "<<seed->interceptY()
                         <<", tanAlpha = "<<seed->tanAlpha()<<", x0 = "<<seed->interceptX()<<", hits in the seed "
                         <<seed->getHitsInMax().size()<<std::endl;
        
                for(const auto& hit : seed->getHitsInMax()){
                    sstr<<" *** Hit "<<m_idHelperSvc->toString(hit->identify())<<", "
                        << Amg::toString(hit->localPosition())<<", dir: "<<Amg::toString(hit->sensorDirection())<<std::endl;
                }
                ATH_MSG_VERBOSE(sstr.str());
            }
            if (m_visionTool.isEnabled()) {          
                m_visionTool->visualizeSeed(ctx, *seed, "#phi-combinatorialSeed");
            }
 
            writeSegmentSeeds->push_back(std::move(seed));
 
        }
 
        for (auto &seg : segments) {
 
            const Parameters pars = localSegmentPars(*gctx, *seg);
 
            ATH_MSG_VERBOSE("Segment parameters : "<<toString(pars));
 
            if (m_visionTool.isEnabled()) {          
                m_visionTool->visualizeSegment(ctx, *seg, "#phi-segment");
            }
            
            writeSegments->push_back(std::move(seg));
            
        }
    }
    
    return StatusCode::SUCCESS;
}

extendHits()

NswSegmentFinderAlg::HitVec MuonR4::NswSegmentFinderAlg::extendHits ( const Amg::Vector3D & startPos, const Amg::Vector3D & direction, const HitLaySpan_t & extensionLayers, const UsedHitSpan_t & usedHits ) const

private

Extend the seed with the hits from the other layers.

Parameters

startPos	The seed position
direction	The seed direction
extensionLayers	The layers to which the seed is extended by extrapolation
usedHits	The book keeping of the used hits to be skipped

Definition at line 263 of file NswSegmentFinderAlg.cxx.

                                                                         {
    
    //the hits we need to return to extend the segment seed
    HitVec combinatoricHits;
 
    for (std::size_t i = 0; i < extensionLayers.size(); ++i) {
        const HitVec& layer{extensionLayers[i].get()};
        const Amg::Vector3D extrapPos = SeedingAux::extrapolateToPlane(startPos, direction, *layer.front());
 
        unsigned indexOfHit = layer.size() + 1;
        unsigned triedHit{0};
        double minPull{std::numeric_limits<double>::max()};
       
        // loop over the hits on the same layer
        for (unsigned j = 0; j < layer.size(); ++j) {
            if (usedHits[i].get().at(j) > m_maxUsed) {
                continue;
            }
            auto hit = layer.at(j);
            const double pull = std::sqrt(SeedingAux::chi2Term(extrapPos, direction, *hit));
            ATH_MSG_VERBOSE("Trying extension with hit " << m_idHelperSvc->toString(hit->identify()));
           
            //find the hit with the minimum pull (check at least one hit after we have increasing pulls)
            if (pull > minPull) {
                triedHit+=1;  
                continue;                 
            }
 
            if(triedHit>1){
                break;
            }
 
            indexOfHit = j;
            minPull = pull;
        }
 
        // complete the seed with the extended hits
        if (minPull < m_minPullThreshold) {
            const auto* bestCand = layer.at(indexOfHit);
            ATH_MSG_VERBOSE("Extension successfull - hit" << m_idHelperSvc->toString(bestCand->identify())
                          <<", pos: "<<Amg::toString(bestCand->localPosition())
                          <<", dir: "<<Amg::toString(bestCand->sensorDirection())<<" found with pull "<<minPull);
            combinatoricHits.push_back(bestCand);
        }
    }
    return combinatoricHits;
}

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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode MuonR4::NswSegmentFinderAlg::finalize ( )

overridevirtual

Definition at line 887 of file NswSegmentFinderAlg.cxx.

                                         {    
    if(m_seedCounter) {
        m_seedCounter->printTableSeedStats(msgStream());
    }
    return StatusCode::SUCCESS;
}

findSegmentsFromMaximum()

std::pair< NswSegmentFinderAlg::SegmentSeedVec_t, NswSegmentFinderAlg::SegmentVec_t > MuonR4::NswSegmentFinderAlg::findSegmentsFromMaximum ( const HoughMaximum & max, const ActsTrk::GeometryContext & gctx, const EventContext & ctx ) const

private

Find seed and segment from an eta hough maximum.

Parameters

max	The maximum from the eta hough transform
gctx	The geometry Context
ctx	The event context

Definition at line 642 of file NswSegmentFinderAlg.cxx.

                                                                            {
    // first sort the hits per layer from the maximum
    SpacePointPerLayerSplitter hitLayers{max.getHitsInMax()};
 
    const HitLayVec& stripHitsLayers{hitLayers.stripHits()};
    const std::size_t layerSize = stripHitsLayers.size();
    
    //seeds and segments containers
    SegmentSeedVec_t seeds{};
    SegmentVec_t segments{};
 
    const Amg::Transform3D globToLocal = max.msSector()->globalToLocalTransform(gctx);
    //counters for the number of seeds, extented seeds and segments
 
    if (layerSize < minLayers) {
        ATH_MSG_VERBOSE("Not enough layers to build a seed");
        return std::make_pair(std::move(seeds),std::move(segments));
    }
 
    if (m_visionTool.isEnabled()) {
        MuonValR4::IPatternVisualizationTool::PrimitiveVec primitives{};
        constexpr double legX{0.2};
        double legY{0.8};
        for (const SpacePoint* sp : max.getHitsInMax()) {
            const xAOD::MuonSimHit* simHit = getTruthMatchedHit(*sp->primaryMeasurement());
            if (!simHit) {
                continue;
            }
 
            const MuonGMR4::MuonReadoutElement* reEle = m_detMgr->getReadoutElement(simHit->identify());
            const Amg::Transform3D toChamb = reEle->msSector()->globalToLocalTransform(gctx) * 
                                             reEle->localToGlobalTransform(gctx, sp->identify());
 
            const Amg::Vector3D hitPos = toChamb * xAOD::toEigen(simHit->localPosition());
            const Amg::Vector3D hitDir = toChamb.linear() * xAOD::toEigen(simHit->localDirection());
            const double pull = std::sqrt(SeedingAux::chi2Term(hitPos, hitDir, *sp));
     
            if(sp->type() == xAOD::UncalibMeasType::MMClusterType) {
                const auto* mmClust = static_cast<const xAOD::MMCluster*>(sp->primaryMeasurement());
                const MuonGMR4::MmReadoutElement* mmEle = mmClust->readoutElement();
                const auto& design = mmEle->stripLayer(mmClust->measurementHash()).design();
                std::string stereoDesign{!design.hasStereoAngle() ? "X" : design.stereoAngle() >0 ? "U": "V"};
                primitives.push_back(MuonValR4::drawLabel(std::format("ml: {:1d}, gap: {:1d}, {:}, pull: {:.2f}", 
                                                                      mmEle->multilayer(), mmClust->gasGap(),
                                     stereoDesign, pull), legX, legY, 14));
            } else if(sp->type() == xAOD::UncalibMeasType::sTgcStripType) {
                const auto* sTgcMeas = static_cast<const xAOD::sTgcMeasurement*>(sp->primaryMeasurement());          
                std::string channelString = sp->secondaryMeasurement() == nullptr ?
                                            sTgcChannelType(sTgcMeas->channelType()) :
                                            std::format("{:}/{:}",  sTgcChannelType(sTgcMeas->channelType()),
                                                         sTgcChannelType(static_cast<const xAOD::sTgcMeasurement*>(sp->secondaryMeasurement())->channelType()));
                primitives.push_back(MuonValR4::drawLabel(std::format("ml: {:1d}, gap: {:1d}, type: {:}, pull: {:.2f}", 
                                            sTgcMeas->readoutElement()->multilayer(), sTgcMeas->gasGap(), 
                                            channelString, pull), legX, legY, 14));
            }
            legY-=0.05;           
        }
        m_visionTool->visualizeBucket(ctx, *max.parentBucket(),
                                      "truth", std::move(primitives));
    }
 
    UsedHitMarker_t allUsedHits = emptyBookKeeper(stripHitsLayers); 
    std::size_t nSeeds{0}, nExtSeeds{0}, nSegments{0}; //for the seed statistics
 
    // helper lamda function to increase counters and fill the seeds and segments we want to return after we construct them 
    // the extended seeds are returned even if they did not make it to a segment and the segments only if successfully fitted
    auto processSeedsAndSegments = [&](std::pair<SegmentSeedVec_t, SegmentVec_t>&& seedSegmentPairs, std::string_view source) {
        auto& [returnSeeds, returnSegments] = seedSegmentPairs;
        ATH_MSG_DEBUG("From " << source << ": built " << returnSeeds.size() << " seeds and " << returnSegments.size() << " segments.");
        for(auto& seed : returnSeeds) {            
            ++nSeeds;
            if(seed->getHitsInMax().size() < m_minSeedHits){
                continue;
            }                   
            ++nExtSeeds;
            seeds.push_back(std::move(seed));
        }
        //move all the segments to the output container
        std::ranges::move(returnSegments, std::back_inserter(segments));
        nSegments += returnSegments.size();
    };
 
    //Start from outermost sTgc layers with combined 2D measurements
    ATH_MSG_VERBOSE("Start building seed from sTgc outermost layers");
    processSeedsAndSegments(buildSegmentsFromSTGC(ctx, gctx, stripHitsLayers, max, globToLocal.translation(), allUsedHits), "sTgc segment seeds");    
 
    //continue with the combinatorial seeding for the strip measurements
    if(m_doOnlyMMCombinatorics){
 
        processSeedsAndSegments(buildSegmentsFromMM(ctx, gctx, stripHitsLayers, max, globToLocal.translation(), allUsedHits, true), "MM combinatoric segment seeds");
 
    }else{
 
        processSeedsAndSegments(buildSegmentsFromMM(ctx, gctx, stripHitsLayers, max, globToLocal.translation(), allUsedHits, true), "MM combinatoric segment seeds");
        processSeedsAndSegments(buildSegmentsFromMM(ctx, gctx, stripHitsLayers, max, globToLocal.translation(), allUsedHits, false), "MM and STGC combinatoric segment seeds");
 
    }   
    
     if(m_seedCounter) {
        m_seedCounter->addToStat(max.msSector(), nSeeds, nExtSeeds, nSegments);
    }
 
    return std::make_pair(std::move(seeds),std::move(segments));
}

fitSegmentSeed()

std::unique_ptr< Segment > MuonR4::NswSegmentFinderAlg::fitSegmentSeed ( const EventContext & ctx, const ActsTrk::GeometryContext & gctx, const SegmentSeed * patternSeed ) const

private

Fit the segment seeds.

Parameters

ctx	The reference to the event context
gctx	The reference to the Geometry Context
patternSeed	The pointer to the seed of which we fit the calibrated space points

Definition at line 368 of file NswSegmentFinderAlg.cxx.

                                                                                                  {
    
    if(patternSeed->getHitsInMax().size() < m_minSeedHits){
        ATH_MSG_VERBOSE("Not enough hits in the SegmentSeed to fit a segment");
        return nullptr;    
    }
 
    ATH_MSG_VERBOSE("Fit the SegmentSeed");
 
    //Calibration of the seed spacepoints
    CalibSpacePointVec calibratedHits = m_calibTool->calibrate(ctx, patternSeed->getHitsInMax(), 
                                                               patternSeed->localPosition(), 
                                                               patternSeed->localDirection(), 0.);
 
    const Amg::Transform3D& locToGlob{patternSeed->msSector()->localToGlobalTransform(gctx)};
 
    return m_lineFitter->fitSegment(ctx, patternSeed, patternSeed->parameters(),
                                                locToGlob, std::move(calibratedHits));
}

hitFromIPCorridor()

NswSegmentFinderAlg::HitWindow MuonR4::NswSegmentFinderAlg::hitFromIPCorridor ( const SpacePoint & testHit, const Amg::Vector3D & beamSpotPos, const Amg::Vector3D & dirEstUp, const Amg::Vector3D & dirEstDn ) const

inlineprivate

The hit is above the predefined corridor.

Tests whether a hit is inside the corridor defined by line connecting the centre of the first candidate hit in the seed and the beam spot. The theta angle is varied by m_windowTheta to define the lower & upper direction etimate. The function tests whether the strip then crosses the corridor.

Parameters

testHit	Reference to the hit to test
beamSpotPos	Position of the beam spot serving as starting point
dirEstUp	Direction vector defining the upper limit of the corridor
dirEstDn	Direction vector defining the lower limit of the corridor

Calculate the strip edges

Check whether the both edges are below the lower estimated muon arrival

Analogous check for the upper edge

No extrapolation needed

Analogous check for the upper edge

Definition at line 138 of file NswSegmentFinderAlg.cxx.

                                                                             {
 
    const Amg::Vector3D estPlaneArrivalUp = SeedingAux::extrapolateToPlane(beamSpotPos, dirEstUp, testHit);
    const Amg::Vector3D estPlaneArrivalDn = SeedingAux::extrapolateToPlane(beamSpotPos, dirEstDn, testHit); 
 
    bool below{true}, above{true};
    switch (classifyStrip(testHit)) {
        using enum StripOrient;
        case U:
        case V:{
            const double halfLength = 0.5* stripHalfLength(testHit);
            const Amg::Vector3D leftEdge  = testHit.localPosition() - halfLength * testHit.sensorDirection();
            const Amg::Vector3D rightEdge = testHit.localPosition() + halfLength * testHit.sensorDirection();

            below = estPlaneArrivalDn.y() > std::max(leftEdge.y(), rightEdge.y());
            above = estPlaneArrivalUp.y() < std::min(leftEdge.y(), rightEdge.y());
            break; 
        } case X:
          case C: {
            const double hY = testHit.localPosition().y();
            below = estPlaneArrivalDn.y() > hY;
            above = estPlaneArrivalUp.y() < hY;
            break;
        }
        case P:{
            break;
        }
        case Unknown:{
            break;
        }
 
    }
    ATH_MSG_VERBOSE("Hit " << m_idHelperSvc->toString(testHit.identify())
                << (below || above ? " is outside the window" : " is inside the window"));
    if(below) {
        return HitWindow::tooLow;
    }
    if(above) {
        return HitWindow::tooHigh;
    }
    return HitWindow::inside;
};

initialize()

StatusCode MuonR4::NswSegmentFinderAlg::initialize ( )

overridevirtual

Definition at line 76 of file NswSegmentFinderAlg.cxx.

                                           {
    ATH_CHECK(m_geoCtxKey.initialize());
    ATH_CHECK(m_etaKey.initialize());
    ATH_CHECK(m_writeSegmentKey.initialize());
    ATH_CHECK(m_writeSegmentSeedKey.initialize());
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_calibTool.retrieve());
    ATH_CHECK(m_visionTool.retrieve(DisableTool{m_visionTool.empty()}));
    ATH_CHECK(detStore()->retrieve(m_detMgr));
 
    if (!(m_idHelperSvc->hasMM() || m_idHelperSvc->hasSTGC())) {
        ATH_MSG_ERROR("MM or STGC not part of initialized detector layout");
        return StatusCode::FAILURE;
    }
 
    SegmentLineFitter::Config fitCfg{};
    fitCfg.calibrator = m_calibTool.get();
    fitCfg.visionTool = m_visionTool.get();
    fitCfg.calcAlongStrip = false;
    fitCfg.idHelperSvc = m_idHelperSvc.get();
    fitCfg.parsToUse = {ParamDefs::x0, ParamDefs::y0, ParamDefs::theta, ParamDefs::phi};
    
    m_lineFitter = std::make_unique<SegmentFit::SegmentLineFitter>(name(), std::move(fitCfg));
 
    if(m_dumpSeedStatistics){
        m_seedCounter = std::make_unique<SeedStatistics>();
    }
 
    return StatusCode::SUCCESS;
}

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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

markHitsAsUsed()

void MuonR4::NswSegmentFinderAlg::markHitsAsUsed ( const HitVec & spacePoints, const HitLayVec & allSortHits, UsedHitMarker_t & usedHitMarker, unsigned int increase, bool markNeighborHits ) const

private

Hits that are used in a good seed/segment built should be flagged as used and not contribute to other seed.

Parameters

spacePoints	The space points to be marked as used
allSortHits	All the available hits
usedHitMarker	The book keeping of the hits
increase	The hit counter increase
markNeighborHits	Flag wether to mark hits on the layer in the vicinity

Todo

use the localMeasurementPos of the measurement?

Todo

use the localMeasurementPos of the measurement?

Definition at line 749 of file NswSegmentFinderAlg.cxx.

                                                                     {
 
    SpacePointPerLayerSorter layerSorter{};
      
    for(const auto& sp : spacePoints){
        // Proection against the auxiliary measurement
        if(!sp){
            continue;
        }           
 
        unsigned measLayer = layerSorter.sectorLayerNum(*sp);
        
        Amg::Vector2D spPosX{Amg::Vector2D::Zero()};
        switch (sp->primaryMeasurement()->numDimensions()) {
            case 1:
                spPosX[Amg::x] = sp->primaryMeasurement()->localPosition<1>().x();
                break;
            case 2:
                spPosX = xAOD::toEigen(sp->primaryMeasurement()->localPosition<2>());
                break;
            default:
                THROW_EXCEPTION("Unsupported dimension");
        }
 
        for (std::size_t lIdx = 0; lIdx < allSortHits.size(); ++lIdx) {
            const HitVec& hVec{allSortHits[lIdx]}; 
            //check if they are not in the same layer
            unsigned hitLayer = layerSorter.sectorLayerNum(*hVec.front());
            if(hitLayer != measLayer) {
                ATH_MSG_VERBOSE("Not in the same layer since measLayer = "<< measLayer << " and "<<hitLayer);
                continue;
            }
            for (std::size_t hIdx = 0 ; hIdx < hVec.size(); ++hIdx) {
                //check the dY between the measurement and the hits                
                auto testHit = hVec[hIdx];
                if (testHit == sp) {
                    usedHitMarker[lIdx][hIdx] += incr;
                    if(!markNeighborHits){
                        break;
                    }                     
                } else if (markNeighborHits) {
                    Amg::Vector2D testPosX{Amg::Vector2D::Zero()};
                    switch (testHit->primaryMeasurement()->numDimensions()) {
                        case 1:
                            testPosX[Amg::x] = testHit->primaryMeasurement()->localPosition<1>().x();
                            break;
                        case 2:
                            testPosX = xAOD::toEigen(testHit->primaryMeasurement()->localPosition<2>());
                            break;
                        default:
                            THROW_EXCEPTION("Unsupported dimension");
                    }
                    //if the hit not found let's see if it is too close to the segment's measurement  
                    double deltaX = (testPosX - spPosX).mag();
                    if(deltaX < m_maxdYWindow){
                        usedHitMarker[lIdx][hIdx] += incr;
                    } 
                }
            }
        }
    }
}

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.

processSegment()

void MuonR4::NswSegmentFinderAlg::processSegment ( std::unique_ptr< Segment > segment, const HitVec & seedHits, const HitLayVec & hitLayers, UsedHitMarker_t & usedHits, SegmentVec_t & segments ) const

private

Process the segment and mark the hits if it is successfully built or not by differently mark the hits as used.

Parameters

segment	The segment to process
seedHits	The seed hits which the segments is constructed from
hitLayers	The layers contributed to the seed
usedHits	The reference of the book keeper for the hits to mark as used
segments	Reference to the segments otuput vector where the successfully built segments are stored

Definition at line 390 of file NswSegmentFinderAlg.cxx.

                                                                       {
    
    if (!segment) {
        ATH_MSG_VERBOSE("Seed Rejection: Segment fit failed");
       
        if (m_markHitsFromSeed && seedHits.size() > m_minSeedHits) {
            // Mark hits from extended seed (used increment by 1)
            markHitsAsUsed(seedHits, hitLayers, usedHits, 1, false);
        }
        return;
    }
 
    // -------- success path --------
    ATH_MSG_DEBUG("Segment built with "
                  << segment->measurements().size()
                  << " hits, chi2/ndof: "
                  << segment->chi2() / std::max(1u,segment->nDoF()));
 
    HitVec segMeasSP;
    segMeasSP.reserve(segment->measurements().size());
 
    std::ranges::transform(
        segment->measurements(),
        std::back_inserter(segMeasSP),
        [](const auto& m) { return m->spacePoint(); }
    );
 
    // Mark segment hits as fully used (used increment by 10,
    // hits are effectively removed)
    markHitsAsUsed(segMeasSP, hitLayers, usedHits, 10, true);
    segments.push_back(std::move(segment));
 
}

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE

std::unique_ptr<SeedStatistics> m_seedCounter MuonR4::NswSegmentFinderAlg::ATLAS_THREAD_SAFE {}

private

Definition at line 315 of file NswSegmentFinderAlg.h.

{};

m_calibTool

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

private

Definition at line 274 of file NswSegmentFinderAlg.h.

{this, "Calibrator", "" };

m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::NswSegmentFinderAlg::m_detMgr {}

private

Definition at line 317 of file NswSegmentFinderAlg.h.

{};

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_doOnlyMMCombinatorics

BooleanProperty MuonR4::NswSegmentFinderAlg::m_doOnlyMMCombinatorics {this, "doOnlyMMCombinatorics", false}

private

Definition at line 295 of file NswSegmentFinderAlg.h.

{this, "doOnlyMMCombinatorics", false};

m_dumpSeedStatistics

BooleanProperty MuonR4::NswSegmentFinderAlg::m_dumpSeedStatistics {this, "dumpStatistics", true}

private

Definition at line 313 of file NswSegmentFinderAlg.h.

{this, "dumpStatistics", true};

m_etaKey

SG::ReadHandleKey<EtaHoughMaxContainer> MuonR4::NswSegmentFinderAlg::m_etaKey {this, "CombinatorialReadKey", "MuonHoughNswMaxima"}

private

Definition at line 256 of file NswSegmentFinderAlg.h.

{this, "CombinatorialReadKey", "MuonHoughNswMaxima"};

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::NswSegmentFinderAlg::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}

private

Definition at line 265 of file NswSegmentFinderAlg.h.

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

m_idHelperSvc

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

private

Definition at line 268 of file NswSegmentFinderAlg.h.

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

m_lineFitter

std::unique_ptr<SegmentFit::SegmentLineFitter> MuonR4::NswSegmentFinderAlg::m_lineFitter {}

private

Definition at line 277 of file NswSegmentFinderAlg.h.

{};

m_markHitsFromSeed

BooleanProperty MuonR4::NswSegmentFinderAlg::m_markHitsFromSeed {this, "markHitsFromSeed", true}

private

Definition at line 292 of file NswSegmentFinderAlg.h.

{this, "markHitsFromSeed", true};

m_maxChi2

DoubleProperty MuonR4::NswSegmentFinderAlg::m_maxChi2 {this, "maxChi2", 5.}

private

Definition at line 304 of file NswSegmentFinderAlg.h.

{this, "maxChi2", 5.};

m_maxClustersInLayer

UnsignedIntegerProperty MuonR4::NswSegmentFinderAlg::m_maxClustersInLayer {this, "maxClustersInLayer", 8}

private

Definition at line 307 of file NswSegmentFinderAlg.h.

{this, "maxClustersInLayer", 8};

m_maxdYWindow

DoubleProperty MuonR4::NswSegmentFinderAlg::m_maxdYWindow {this, "maxdYWindow", 4.*Gaudi::Units::cm}

private

Definition at line 310 of file NswSegmentFinderAlg.h.

{this, "maxdYWindow", 4.*Gaudi::Units::cm};  

m_maxInvalidClusters

UnsignedIntegerProperty MuonR4::NswSegmentFinderAlg::m_maxInvalidClusters {this, "maxInvalidClusters", 4}

private

Definition at line 289 of file NswSegmentFinderAlg.h.

{this, "maxInvalidClusters", 4};

m_maxUsed

UnsignedIntegerProperty MuonR4::NswSegmentFinderAlg::m_maxUsed {this, "maxHitIsUsed", 8}

private

Definition at line 298 of file NswSegmentFinderAlg.h.

{this, "maxHitIsUsed", 8};

m_minClusSize

UnsignedIntegerProperty MuonR4::NswSegmentFinderAlg::m_minClusSize {this, "minClusterSize", 1}

private

Definition at line 301 of file NswSegmentFinderAlg.h.

{this, "minClusterSize", 1};

m_minPullThreshold

DoubleProperty MuonR4::NswSegmentFinderAlg::m_minPullThreshold {this, "maxPull", 5.}

private

Definition at line 283 of file NswSegmentFinderAlg.h.

{this, "maxPull", 5.};

m_minSeedHits

UnsignedIntegerProperty MuonR4::NswSegmentFinderAlg::m_minSeedHits {this, "minSeedHits", 4}

private

Definition at line 286 of file NswSegmentFinderAlg.h.

{this, "minSeedHits", 4};

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.

m_visionTool

ToolHandle<MuonValR4::IPatternVisualizationTool> MuonR4::NswSegmentFinderAlg::m_visionTool {this, "VisualizationTool", ""}

private

Pattern visualization tool.

Definition at line 271 of file NswSegmentFinderAlg.h.

{this, "VisualizationTool", ""};

m_windowTheta

DoubleProperty MuonR4::NswSegmentFinderAlg::m_windowTheta {this, "thetaWindow", 2.5 * Gaudi::Units::deg}

private

Definition at line 280 of file NswSegmentFinderAlg.h.

{this, "thetaWindow", 2.5 * Gaudi::Units::deg};

m_writeSegmentKey

SG::WriteHandleKey<SegmentContainer> MuonR4::NswSegmentFinderAlg::m_writeSegmentKey {this, "MuonNswSegmentWriteKey", "MuonNswSegments"}

private

Definition at line 262 of file NswSegmentFinderAlg.h.

{this, "MuonNswSegmentWriteKey", "MuonNswSegments"};

m_writeSegmentSeedKey

SG::WriteHandleKey<SegmentSeedContainer> MuonR4::NswSegmentFinderAlg::m_writeSegmentSeedKey {this, "MuonNswSegmentSeedWriteKey", "MuonNswSegmentSeeds"}

private

Definition at line 259 of file NswSegmentFinderAlg.h.

{this, "MuonNswSegmentSeedWriteKey", "MuonNswSegmentSeeds"};

---

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

• NswSegmentFinderAlg.h
• NswSegmentFinderAlg.cxx