Muon::MuonNSWSegmentFinderTool Class Reference

#include <MuonNSWSegmentFinderTool.h>

Inheritance diagram for Muon::MuonNSWSegmentFinderTool:

Collaboration diagram for Muon::MuonNSWSegmentFinderTool:

Public Types
using	SeedMeasurement = NSWSeed::SeedMeasurement
using	MeasVec = NSWSeed::MeasVec
using	LayerMeasVec = std::vector<MeasVec>
using	MuonClusterPtr = std::unique_ptr<const Muon::MuonClusterOnTrack>
using	MuonClusterVec = std::vector<MuonClusterPtr>

Public Member Functions
	MuonNSWSegmentFinderTool (const std::string &type, const std::string &name, const IInterface *parent)
	default constructor
virtual	~MuonNSWSegmentFinderTool ()=default
	destructor
virtual StatusCode	initialize () override
void	find (const EventContext &ctx, SegmentMakingCache &cache) const override
int	wedgeNumber (const Muon::MuonClusterOnTrack *cluster) const
int	layerNumber (const Muon::MuonClusterOnTrack *cluster) const
int	channel (const Muon::MuonClusterOnTrack *cluster) const
	Returns the channel of the measurement on the layer.
const IMuonIdHelperSvc *	idHelper () const
bool	isPad (const Muon::MuonClusterOnTrack *clust) const
bool	isStrip (const Muon::MuonClusterOnTrack *clust) const
bool	isWire (const Muon::MuonClusterOnTrack *clust) const
template<size_t N>
std::string	printSeed (const std::array< SeedMeasurement, N > &seed) const
std::string	print (const SeedMeasurement &meas) const
std::string	print (const MeasVec &clusters) const
std::string	print (const LayerMeasVec &sortedVec) 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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	access to tool interface

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	HitType { Eta = 1 , Phi = 1 << 1 , Wire = 1 << 2 , Pad = 1 << 3 }
enum class	ChannelConstraint { InWindow , TooNarrow , TooWide }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< std::unique_ptr< Muon::MuonSegment > >	findStereoSegments (const EventContext &ctx, const std::vector< const Muon::MuonClusterOnTrack * > &allClusts, int singleWedge=0) const
	Runs the NSW segment maker by combining 4 Micromega layers to a stereo seed.
std::vector< std::unique_ptr< Muon::MuonSegment > >	findStgcPrecisionSegments (const EventContext &ctx, const std::vector< const Muon::MuonClusterOnTrack * > &MuonClusters, int singleWedge=0) const
	Combines 2 sTgc strip layers to find 2D segments constraining the muon in the eta direction.
std::vector< std::unique_ptr< Muon::MuonSegment > >	find3DSegments (const EventContext &ctx, const std::vector< const Muon::MuonClusterOnTrack * > &MuonClusters, std::vector< std::unique_ptr< Muon::MuonSegment > > &etaSegs, int singleWedge=0) const
MeasVec	cleanClusters (const std::vector< const Muon::MuonClusterOnTrack * > &MuonClusters, int hit_sel, int singleWedge) const
LayerMeasVec	classifyByLayer (const MeasVec &clusters, int hit_sel) const
std::vector< NSWSeed >	segmentSeedFromStgc (const LayerMeasVec &orderedClusters, bool usePhi) const
std::vector< NSWSeed >	segmentSeedFromMM (const LayerMeasVec &orderedClusters) const
std::vector< NSWSeed >	segmentSeedFromMM (const LayerMeasVec &orderedClusters, std::array< unsigned int, 4 > selLayers, unsigned int &trial_counter) const
std::vector< NSWSeed >	segmentSeedFromPads (const LayerMeasVec &orderedClusters, const Muon::MuonSegment &etaSeg) const
std::vector< std::pair< double, double > >	getPadPhiOverlap (const std::vector< std::vector< const Muon::sTgcPrepData * > > &pads) const
int	getClustersOnSegment (const LayerMeasVec &orderedclusters, NSWSeed &seed, const std::set< unsigned int > &exclude, bool useStereo=true) const
MeasVec	getCalibratedClusters (NSWSeed &seed) const
bool	hitsToTrack (const EventContext &ctx, const MeasVec &etaHitVec, const MeasVec &phiHitVec, const Trk::TrackParameters &startpar, TrackCollection &segTrkColl) const
std::unique_ptr< Trk::PseudoMeasurementOnTrack >	ipConstraint (const EventContext &ctx) const
	creates the IP constraint
std::unique_ptr< Trk::PseudoMeasurementOnTrack >	caloConstraint (const Trk::TrackParameters &startpar) const
std::vector< NSWSeed >	resolveAmbiguities (std::vector< NSWSeed > &&unresolved) const
std::vector< std::unique_ptr< Muon::MuonSegment > >	resolveAmbiguities (const EventContext &ctx, const TrackCollection &segColl, const Trk::Segment::Author a) const
std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const std::vector< const Trk::MeasurementBase * > &fit_meas, const Trk::TrackParameters &perigee) const
ChannelConstraint	compatiblyFromIP (const SeedMeasurement &meas1, const SeedMeasurement &meas2) const
	Checks whether the two measurements are compatible within the IP constraint.
std::pair< double, double >	coveredRadii (const SeedMeasurement &meas) const
	Returns the minimal & maximal radial distance of a measurement.
MeasVec	vetoBursts (MeasVec &&clustInLay) const
	Removes clusters from high activity areas in the detector.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< IMuonIdHelperSvc >	m_idHelperSvc
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
ToolHandle< Trk::ITrackAmbiguityProcessorTool >	m_ambiTool
	Tool for ambiguity solving.
ToolHandle< Trk::ITrackFitter >	m_slTrackFitter
ToolHandle< IMuonTrackToSegmentTool >	m_trackToSegmentTool
PublicToolHandle< MuonEDMPrinterTool >	m_printer
ToolHandle< IMuonTrackCleaner >	m_trackCleaner
ToolHandle< Trk::ITrackSummaryTool >	m_trackSummary
ToolHandle< IMuonClusterOnTrackCreator >	m_muonClusterCreator {this, "MuonClusterCreator", ""}
Gaudi::Property< bool >	m_ipConstraint {this, "IPConstraint", true}
Gaudi::Property< bool >	m_caloConstraint {this, "CaloConstraint", false}
	Use a virtual point at the calorimeter exit with same Z as constraint...
Gaudi::Property< double >	m_maxClustDist {this, "ClusterDistance", 5.}
Gaudi::Property< int >	m_nOfSeedLayers {this, "NOfSeedLayers", 1}
Gaudi::Property< bool >	m_useStereoSeeding {this, "SeedMMStereos", true}
Gaudi::Property< bool >	m_usesTGCSeeding {this, "SeedWithsTGCS", true}
Gaudi::Property< unsigned int >	m_ocupMmBinWidth
	Protection against slobbering Micromega events.
Gaudi::Property< unsigned int >	m_ocupMmNumPerBin
Gaudi::Property< unsigned int >	m_ocupMmNumPerPair
Gaudi::Property< uint >	m_maxInputPads {this, "maxInputPads", 40, "Maximum number of pads per wedge layer."}
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 126 of file MuonNSWSegmentFinderTool.h.

Member Typedef Documentation

LayerMeasVec

using Muon::MuonNSWSegmentFinderTool::LayerMeasVec = std::vector<MeasVec>

Definition at line 204 of file MuonNSWSegmentFinderTool.h.

MeasVec

using Muon::MuonNSWSegmentFinderTool::MeasVec = NSWSeed::MeasVec

Definition at line 203 of file MuonNSWSegmentFinderTool.h.

MuonClusterPtr

using Muon::IMuonNSWSegmentFinderTool::MuonClusterPtr = std::unique_ptr<const Muon::MuonClusterOnTrack>

inherited

Definition at line 27 of file IMuonNSWSegmentFinderTool.h.

MuonClusterVec

using Muon::IMuonNSWSegmentFinderTool::MuonClusterVec = std::vector<MuonClusterPtr>

inherited

Definition at line 28 of file IMuonNSWSegmentFinderTool.h.

SeedMeasurement

using Muon::MuonNSWSegmentFinderTool::SeedMeasurement = NSWSeed::SeedMeasurement

Definition at line 202 of file MuonNSWSegmentFinderTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

ChannelConstraint

enum class Muon::MuonNSWSegmentFinderTool::ChannelConstraint

strongprivate

Enumerator
InWindow
TooNarrow
TooWide

Definition at line 298 of file MuonNSWSegmentFinderTool.h.

                                    {
            InWindow,
            TooNarrow,
            TooWide
 
        };

HitType

enum Muon::MuonNSWSegmentFinderTool::HitType

private

Enumerator
Eta
Phi
Wire
Pad

Definition at line 230 of file MuonNSWSegmentFinderTool.h.

{ Eta = 1, Phi = 1 << 1, Wire = 1 << 2, Pad = 1 << 3 };

Constructor & Destructor Documentation

MuonNSWSegmentFinderTool()

Muon::MuonNSWSegmentFinderTool::MuonNSWSegmentFinderTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

default constructor

Definition at line 256 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                                             :
        AthAlgTool(type, name, parent) {
        declareInterface<IMuonNSWSegmentFinderTool>(this);
    }

~MuonNSWSegmentFinderTool()

virtual Muon::MuonNSWSegmentFinderTool::~MuonNSWSegmentFinderTool ( )

virtualdefault

destructor

Member Function Documentation

caloConstraint()

std::unique_ptr< Trk::PseudoMeasurementOnTrack > Muon::MuonNSWSegmentFinderTool::caloConstraint ( const Trk::TrackParameters & startpar ) const

private

Definition at line 701 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                                                {
         if (!m_caloConstraint) return nullptr;
         constexpr double errVtx{1.*Gaudi::Units::m};
         Amg::MatrixX covVtx(2,2);
         covVtx.setIdentity();
         covVtx = errVtx * errVtx * covVtx;
         const Amg::Vector3D parPos{startpar.position()};
         Amg::Vector3D projection{parPos.x(), parPos.y(), 0};
        //  project
        Trk::PerigeeSurface perVtx(projection);
        return std::make_unique<Trk::PseudoMeasurementOnTrack>(Trk::LocalParameters(Trk::DefinedParameter(0, Trk::locX),
                                                                                    Trk::DefinedParameter(1, Trk::locY)), 
                                                               std::move(covVtx),
                                                               std::move(perVtx));
 
    }

channel()

int Muon::MuonNSWSegmentFinderTool::channel

(

const Muon::MuonClusterOnTrack *

cluster

)

const

Returns the channel of the measurement on the layer.

Definition at line 953 of file MuonNSWSegmentFinderTool.cxx.

                                                                                    {
        if (m_idHelperSvc->isMM(cluster->identify())) return m_idHelperSvc->mmIdHelper().channel(cluster->identify());
        if (m_idHelperSvc->issTgc(cluster->identify())) return m_idHelperSvc->stgcIdHelper().channel(cluster->identify());
        return -1;
    }

classifyByLayer()

MuonNSWSegmentFinderTool::LayerMeasVec Muon::MuonNSWSegmentFinderTool::classifyByLayer ( const MeasVec & clusters, int hit_sel ) const

private

Definition at line 819 of file MuonNSWSegmentFinderTool.cxx.

                                                    {
        // Classifies clusters by layer, starting from the layer closest to the IP and moving outwards.
        // "clusters" is expected to contain only eta (MM+sTGC strip) or only phi hits (sTGC pads XOR wires).
        // The returned vector contains only layers that have hits.
 
        LayerMeasVec orderedClusters(16);
        std::array<std::set<Identifier>,16> used_hits{};
        int nBad{0};
        for (const Muon::MuonClusterOnTrack* hit : clusters) {
            const int iorder = layerNumber(hit);
            if (iorder < 0) {
                ++nBad;
                continue;
            }
            const Identifier id = hit->identify();
            if (m_idHelperSvc->issTgc(id)) {
                const int channelType = m_idHelperSvc->stgcIdHelper().channelType(id);
                // skip sTGC pads if using wires, or skip wires if using pads
                if (!(hit_sel & HitType::Pad) && channelType == sTgcIdHelper::Pad) continue;
                if (!(hit_sel & HitType::Wire) && channelType == sTgcIdHelper::Wire) continue;
            }
            std::set<Identifier>& lay_hits = used_hits[iorder];
            if (lay_hits.count(id)) continue;
            lay_hits.insert(id);
            orderedClusters[iorder].emplace_back(hit);
        }
        if (nBad) ATH_MSG_WARNING("Unable to classify " << nBad << " clusters by their layer since they are neither MM nor sTGC");
 
        // Erase layers without hits
        orderedClusters.erase(std::remove_if(orderedClusters.begin(), orderedClusters.end(),
                                             [](const MeasVec& vec) { return vec.empty(); }),
                              orderedClusters.end());
 
 
        for( MeasVec& lays: orderedClusters){
            std::sort(lays.begin(),lays.end(), [this](const SeedMeasurement& a, const SeedMeasurement& b){
                return channel(a) < channel(b);
            });
            ATH_MSG_DEBUG("Found in layer "<<m_idHelperSvc->toStringDetEl(lays[0]->identify())<<" "<<lays.size()<<" clusters");
 
 
        }
        ATH_MSG_VERBOSE("Collected clusters "<<print(orderedClusters));
 
        return orderedClusters;
    }

cleanClusters()

MeasVec Muon::MuonNSWSegmentFinderTool::cleanClusters ( const std::vector< const Muon::MuonClusterOnTrack * > & MuonClusters, int hit_sel, int singleWedge ) const

private

Definition at line 799 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                            {
        // Keep only eta (MM && sTGC) or phi (sTGC) clusters
        // In single-wedge mode keep only clusters from the requested wedge
        MeasVec clusters;
        clusters.reserve(muonClusters.size());
        for (const Muon::MuonClusterOnTrack* cluster : muonClusters) {
            if (!cluster) continue;
            if (singleWedge && singleWedge != wedgeNumber(cluster)) continue;
            const Identifier id = cluster->identify();
            if (((hit_sel & HitType::Eta) && !m_idHelperSvc->measuresPhi(id)) ||
                ((hit_sel & HitType::Phi) && m_idHelperSvc->measuresPhi(id)))
                clusters.emplace_back(cluster);
        }
 
        ATH_MSG_VERBOSE(" After hit cleaning, there are " << clusters.size() );
        return clusters;
    }

compatiblyFromIP()

MuonNSWSegmentFinderTool::ChannelConstraint Muon::MuonNSWSegmentFinderTool::compatiblyFromIP ( const SeedMeasurement & meas1, const SeedMeasurement & meas2 ) const

inlineprivate

Checks whether the two measurements are compatible within the IP constraint.

direction of final segment is well compatible with the IP cut

Use the Identity that 1./sinh(eta) = tan(theta) https://www.wolframalpha.com/input?i=1.%2Fsinh%28-ln%28tan%28x%2F2%29%29%29+-+tan%28x%29 Add another 0.25 as safety margin

Calculate the transverse radii at the edges of the

Definition at line 1370 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                                   {
        if (!m_ipConstraint) return ChannelConstraint::InWindow;
 
        // For a given dZ the measurements can only be separated by a certain dR such that the
        const double dZ = std::abs(meas2->globalPosition().z()) -
                          std::abs(meas1->globalPosition().z());

        static const double minTanTheta = 0.75 / std::sinh(maxEtaNSW);
        static const double maxTanTheta = 1.25 / std::sinh(minEtaNSW);
 
        const double minDR = minTanTheta * std::abs(dZ);
        const double maxDR = maxTanTheta * std::abs(dZ);
 
        const std::pair<double, double> rad1 = coveredRadii(meas1);
        const std::pair<double, double> rad2 = coveredRadii(meas2);
        const double dlR = rad2.first - rad1.first;
        const double drR = rad2.second - rad1.second;
        ATH_MSG_VERBOSE("compatiblyFromIP() -- Measurements "<<std::endl
                        <<print(meas1)<<std::endl<<print(meas2)
                        <<std::endl<<". Separation in dR (left/right) "<<dlR<<"/"<<drR<<", dZ "<<dZ
                        <<" --> dR has to be in "<<minDR<<" "<<maxDR);
        if ((std::abs(dlR) < minDR && std::abs(drR) < minDR) ||
            (dZ > 0 &&  dlR <0 && drR <0) || (dZ < 0 &&  dlR >0 && drR > 0)) {
            return ChannelConstraint::TooNarrow;
        } if (std::abs(dlR) > maxDR && std::abs(drR) > maxDR && dlR * drR > 0.){
            return ChannelConstraint::TooWide;
        }
        return ChannelConstraint::InWindow;
    }

coveredRadii()

std::pair< double, double > Muon::MuonNSWSegmentFinderTool::coveredRadii ( const SeedMeasurement & meas ) const

inlineprivate

Returns the minimal & maximal radial distance of a measurement.

Definition at line 1404 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                           {
        const MuonGM::MuonChannelDesign* design = getDesign(meas);
        const int chNum = channel(meas);
        Amg::Vector2D left{Amg::Vector2D::Zero()}, right{Amg::Vector2D::Zero()};
        design->leftEdge(chNum, left);
        design->rightEdge(chNum, right);
        const double radLeft{meas->associatedSurface().localToGlobal(left).perp()};
        const double radRight{meas->associatedSurface().localToGlobal(right).perp()};
        return std::make_pair(radLeft, radRight);
    }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

find()

void Muon::MuonNSWSegmentFinderTool::find ( const EventContext & ctx, SegmentMakingCache & cache ) const

overridevirtual

Remove all stereo segment hits from further processing

All segments

Single wedge segments. Important for the alignment runs

Loop over the 4 quads to create the segment container

The micromegas need 4 hits on track

Create the perigee parameter

Create the segment

Implements Muon::IMuonNSWSegmentFinderTool.

Definition at line 283 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                {
 
        std::vector<const Muon::MuonClusterOnTrack*> muonClusters{};
        muonClusters.reserve(cache.inputClust.size());
        std::transform(cache.inputClust.begin(), cache.inputClust.end(), std::back_inserter(muonClusters),
                        [](const std::unique_ptr<const MuonClusterOnTrack>& cl){return cl.get();});
        ATH_MSG_DEBUG("Entering MuonNSWSegmentFinderTool with " << muonClusters.size() << " clusters to be fit");
 
        // Find segments using the MM strips as a seed
        MuonSegmentVec out_segments{};
        {
            MuonSegmentVec stereoSegs = findStereoSegments(ctx, muonClusters, 0);
            ATH_MSG_VERBOSE("Found " << stereoSegs.size() << " MMG stereo seeded segments");
            out_segments.insert(out_segments.end(), std::make_move_iterator(stereoSegs.begin()),
                                                    std::make_move_iterator(stereoSegs.end()));
        }
 
        // Push back mm seded segments and cache used hits
        auto dump_output = [&]() {
            cache.constructedSegs.reserve(cache.constructedSegs.size() + out_segments.size());
            for (std::unique_ptr<Muon::MuonSegment>& seg : out_segments) {
                for (const Trk::MeasurementBase* meas : seg->containedMeasurements()) {
                     const Muon::MuonClusterOnTrack* clus = dynamic_cast<const Muon::MuonClusterOnTrack*>(meas);
                     if (clus) cache.usedHits.insert(clus->identify());
                }
                cache.constructedSegs.push_back(std::move(seg));
            }
        };
 
        std::vector<const Muon::MuonClusterOnTrack*> clustPostStereo{};
        std::array<std::set<Identifier>, 16> masked_segs{};
        for (std::unique_ptr<Muon::MuonSegment>& seg : out_segments) {
            for (const Trk::MeasurementBase* meas : seg->containedMeasurements()) {
                const Muon::MuonClusterOnTrack* clus = dynamic_cast<const Muon::MuonClusterOnTrack*>(meas);
                if (clus) masked_segs[layerNumber(clus)].insert(clus->identify());
            }
        }
 
        // Create new vector of clusters excluding the ones used in the mm seeded segments
        if (!out_segments.empty()) {
            clustPostStereo.reserve(muonClusters.size());
            for (const Muon::MuonClusterOnTrack* clus : muonClusters) {
                if (!masked_segs[layerNumber(clus)].count(clus->identify())) clustPostStereo.push_back(clus);
            }
        }
 
        // If we did not find any mm seeded segments use the full hit vector to build stgc seeded segments
        // otherwise use the ones that did not make it onto a segment yet 
        const std::vector<const Muon::MuonClusterOnTrack*>& segmentInput = !out_segments.empty() ? clustPostStereo : muonClusters;

        {
            MuonSegmentVec etaSegs = findStgcPrecisionSegments(ctx, segmentInput);
            ATH_MSG_VERBOSE("Found " << etaSegs.size() << " stgc seeded eta segments");
            MuonSegmentVec precSegs = find3DSegments(ctx, segmentInput, etaSegs);
            ATH_MSG_VERBOSE("Found " << precSegs.size() << " 3D segments");
            out_segments.insert(out_segments.end(),
                                std::make_move_iterator(precSegs.begin()),
                                std::make_move_iterator(precSegs.end()));
        }
 
 
 
        if (!cache.buildQuads) {
            dump_output();
            return;
        }
        for (std::unique_ptr<Muon::MuonSegment>& seg : out_segments) {
            std::vector<const MuonClusterOnTrack*> seg_hits{};
            seg_hits.reserve(seg->containedMeasurements().size());
            for (const Trk::MeasurementBase* meas : seg->containedMeasurements()) {
                const Muon::MuonClusterOnTrack* clus = dynamic_cast<const Muon::MuonClusterOnTrack*>(meas);
                if (clus) seg_hits.push_back(clus);
            }
            for (int iWedge{1}; iWedge<=4 ; ++iWedge) {
                MeasVec quad_hits = cleanClusters(seg_hits, HitType::Eta | HitType::Phi, iWedge);
                if ( quad_hits.size () < 2 || ((iWedge == 2 || iWedge == 3) && quad_hits.size() < 4)) continue;
                std::vector<const Trk::MeasurementBase*> fit_meas{};
                std::unique_ptr<Trk::PseudoMeasurementOnTrack> pseudoVtx{ipConstraint(ctx)};
                if (pseudoVtx) fit_meas.push_back(pseudoVtx.get());
                std::copy(quad_hits.begin(), quad_hits.end(), std::back_inserter(fit_meas));
                const Trk::Surface& surf = quad_hits.front()->associatedSurface();
                Trk::Intersection intersect = surf.straightLineIntersection(seg->globalPosition(), seg->globalDirection(), false, false);
                const Amg::Vector3D& gpos_seg = intersect.position;
                Amg::Vector3D gdir_seg{seg->globalDirection()};
                Amg::Vector3D perpos = gpos_seg - 10 * gdir_seg.unit();
                if (perpos.dot(gdir_seg) < 0) gdir_seg *= -1;
                Trk::Perigee startpar{perpos, gdir_seg, 0, perpos};
                std::unique_ptr<Trk::Track> segtrack = fit(ctx, fit_meas, startpar);
                if (!segtrack) continue;
 
                std::unique_ptr<MuonSegment> seg{m_trackToSegmentTool->convert(ctx, *segtrack)};
                if (seg) {
                    ATH_MSG_VERBOSE(" adding new quad segment " << m_printer->print(*seg) << std::endl
                                            <<"position: "<<to_string(seg->globalPosition())<< std::endl
                                            <<"direction: "<<to_string(seg->globalDirection())<< std::endl
                                            << m_printer->print(seg->containedMeasurements()));
                    seg->setAuthor(Trk::Segment::NswQuadAlign);
                    cache.quadSegs.emplace_back(std::move(seg));
                }
            }
        }
        dump_output();
    }

find3DSegments()

MuonSegmentVec Muon::MuonNSWSegmentFinderTool::find3DSegments ( const EventContext & ctx, const std::vector< const Muon::MuonClusterOnTrack * > & MuonClusters, std::vector< std::unique_ptr< Muon::MuonSegment > > & etaSegs, int singleWedge = 0 ) const

private

1 - All micromega layers have ideally been consumed. Try the seeding from the phi wires.

Definition at line 581 of file MuonNSWSegmentFinderTool.cxx.

                                                                                   {
        MuonSegmentVec segments{};
        // cluster cleaning #1; select only phi hits (must be from all wedges, in order to phi-seed)
        
        ATH_MSG_DEBUG("Cleaning phi clusters in stgc seeded 3D segments ");
        MeasVec phiClusters = cleanClusters(muonClusters, HitType::Phi | HitType::Wire, singleWedge);
        ATH_MSG_DEBUG("After hit cleaning, there are " << phiClusters.size() << " phi clusters to be fit");
 
 
        // classify the phi clusters by layer
        LayerMeasVec orderedWireClusters = classifyByLayer(phiClusters, HitType::Wire);
        LayerMeasVec orderedPadClusters = classifyByLayer(phiClusters, HitType::Pad);  // pads only
        if (orderedWireClusters.size() + orderedPadClusters.size() < 2) {
            ATH_MSG_DEBUG("Not enough phi hits present, cannot perform the 3D fit!");
            segments.insert(segments.end(), std::make_move_iterator(etaSegs.begin()), std::make_move_iterator(etaSegs.end()));
            return segments;
        }
 
        // cluster cleaning #2; select only eta hits
        ATH_MSG_DEBUG("Cleaning eta clusters in stgc seeded 3D segments ");
        MeasVec etaClusters = cleanClusters(muonClusters, HitType::Eta, singleWedge);
        LayerMeasVec orderedEtaClusters = classifyByLayer(etaClusters, HitType::Eta);
 
        // loop on eta segments
        bool triedWireSeed{false};  // wire seeds need to be retrieved only once (the first time they are needed)
        std::vector<NSWSeed> seeds_WiresSTGC;
        TrackCollection segTrkColl{SG::OWN_ELEMENTS};
        // Loop on eta segments
        for (std::unique_ptr<Muon::MuonSegment>& etaSeg : etaSegs) {
            bool is3Dseg{false};
            NSWSeed seed2D{this, *etaSeg};
            getClustersOnSegment(orderedEtaClusters, seed2D, {});  // eta clusters
 
            std::vector<NSWSeed> seeds;
            if (std::abs(etaSeg->globalPosition().eta()) < 2.4) {
                if (!triedWireSeed) {
                    // wire seeds need to be retrieved only once (they don't depend on the eta segment)
                    triedWireSeed = true;
                    seeds_WiresSTGC = segmentSeedFromStgc(orderedWireClusters, true);
                }
 
                if (!seeds_WiresSTGC.empty()) {
                    seeds = seeds_WiresSTGC;
                    ATH_MSG_DEBUG(" Seeding from sTGC wires");
                }
            }
 
            // 3 - last resort, try sTGC pads
            if (seeds.empty() ) {
 
                // only perform seeding with layers that have less than m_maxInputPads hits
                LayerMeasVec orderedPadClustersForSeeding;
                std::ranges::copy_if(orderedPadClusters,
                             std::back_inserter(orderedPadClustersForSeeding),
                             [this](const MeasVec& vec) { return vec.size() < m_maxInputPads; });
 
                seeds = segmentSeedFromPads(orderedPadClustersForSeeding, *etaSeg);
                ATH_MSG_DEBUG(" Seeding from sTGC pads");
            }
 
            // Loop on phi seeds
            MeasVec phiHitVec;
            const Trk::PlaneSurface& etaSegSurf = etaSeg->associatedSurface();
            double etaSegLocX = etaSeg->localParameters()[Trk::locX];
            double etaSegLocXZ = etaSeg->localDirection().angleXZ();
 
            for (NSWSeed& seed : seeds) {
                // calculate start parameters for the fit
                // combine the local position and direction of the eta-seed (segment)
                // and local position and direction of the phi-seed to generate 3D starting parameters
                Trk::Intersection intersect = etaSegSurf.straightLineIntersection(seed.pos(), seed.dir(), false, false);
                Amg::Vector2D lpos_seed{Amg::Vector2D::Zero()};
                Trk::LocalDirection ldir_seed{};
                etaSegSurf.globalToLocal(intersect.position, intersect.position, lpos_seed);
                etaSegSurf.globalToLocalDirection(seed.dir(), ldir_seed);
 
                Amg::Vector2D lpos_seg(etaSegLocX, lpos_seed[Trk::locY]);
                Trk::LocalDirection ldir_seg(etaSegLocXZ, ldir_seed.angleYZ());
 
                Amg::Vector3D gpos_seg{Amg::Vector3D::Zero()}, gdir_seg{Amg::Vector3D::Zero()};
                etaSegSurf.localToGlobal(lpos_seg, gpos_seg, gpos_seg);
                etaSegSurf.localToGlobalDirection(ldir_seg, gdir_seg);
 
                Amg::Vector3D perpos = gpos_seg - 10 * gdir_seg.unit();
                if (perpos.dot(gdir_seg) < 0) gdir_seg *= -1;
                const Trk::Perigee startpar{perpos, gdir_seg, 0, perpos};
 
                NSWSeed seed3D{this, perpos, gdir_seg};
 
                // gather phi hits aligned with the segment
                int nPhiHits = getClustersOnSegment(orderedPadClusters, seed3D,{});  // add pad hits  (from the requested wedge if any)
                nPhiHits += getClustersOnSegment(orderedWireClusters, seed3D, {});    // add wire hits (from the requested wedge if any)
                if (nPhiHits < 2) continue;                                       // at least two phi hits
 
                MeasVec phiHitVec = seed3D.measurements();
                // calibrate the eta hits
                MeasVec etaHitsCalibrated = getCalibratedClusters(seed2D);
 
                // fit
                if (hitsToTrack(ctx, etaHitsCalibrated, phiHitVec, startpar, segTrkColl)) {
                    is3Dseg = true;
                    ATH_MSG_VERBOSE("Segment successfully fitted for wedge "<<singleWedge<<std::endl<<
                                   m_printer->print(*segTrkColl.back()));
                }
            }  // end loop on phi seeds
 
            // if we failed to combine the eta segment with phi measurements,
            // just add the eta segment to the collection.
            if (!is3Dseg) { segments.push_back(std::move(etaSeg)); }
        }  // end loop on precision plane segments
        MuonSegmentVec new_segs = resolveAmbiguities(ctx, segTrkColl, Trk::Segment::NswStgcSeeded);
        segments.insert(segments.end(), std::make_move_iterator(new_segs.begin()), std::make_move_iterator(new_segs.end()));
        return segments;
    }

findStereoSegments()

MuonSegmentVec Muon::MuonNSWSegmentFinderTool::findStereoSegments ( const EventContext & ctx, const std::vector< const Muon::MuonClusterOnTrack * > & allClusts, int singleWedge = 0 ) const

private

Runs the NSW segment maker by combining 4 Micromega layers to a stereo seed.

Subsequentally, the hits on the hit road are added to the seeed and the segment is fitted

Parameters

ctx	EventContext
allClusts	Collection of all EventContext objects
singleWedge	0 (use all 4 multiplets) 2/3

Returns

Order any parsed hit into the layer structure

Loop over the seeds

Require that the seed has at least one extra hit, if we're not restricting ourselves to a single wedge

Craete the perigee parameter

Create the segment

Definition at line 393 of file MuonNSWSegmentFinderTool.cxx.

                                                                                       {
 
       if (!m_useStereoSeeding){
          ATH_MSG_VERBOSE("MMStereoSeeding disabled!"); 
          return {};
       }
 
       ATH_MSG_VERBOSE("Running MMStereoSeeding"); 
        LayerMeasVec orderedClust =
            classifyByLayer(cleanClusters(allClusts, HitType::Eta | HitType::Phi, singleWedge), HitType::Wire | HitType::Pad);
 
        for (MeasVec& hitsInLayer : orderedClust) hitsInLayer = vetoBursts(std::move(hitsInLayer));
        orderedClust.erase(std::remove_if(orderedClust.begin(), orderedClust.end(),
                                             [](const MeasVec& vec) { return vec.empty(); }),
                              orderedClust.end());
        if (orderedClust.empty()) return {};
 
 
        std::vector<NSWSeed> seeds = segmentSeedFromMM(orderedClust);
        ATH_MSG_DEBUG("Retrieved " << seeds.size() << " seeds in the MMStereoAlg after the ambiguity resolution" );
 
        if (seeds.empty()) return {};
        TrackCollection trackSegs{SG::OWN_ELEMENTS};
        for (NSWSeed& seed : seeds) {
            std::vector<const Trk::MeasurementBase*> fit_meas{};
 
            std::unique_ptr<Trk::PseudoMeasurementOnTrack> pseudoVtx{ipConstraint(ctx)};
            if (pseudoVtx) fit_meas.push_back(pseudoVtx.get());
            MeasVec calib_clust = getCalibratedClusters(seed);
            std::copy(calib_clust.begin(), calib_clust.end(), std::back_inserter(fit_meas));
            const Trk::Surface& surf = calib_clust.front()->associatedSurface();
 
            Trk::Intersection intersect = surf.straightLineIntersection(seed.pos(), seed.dir(), false, false);
            const Amg::Vector3D& gpos_seg = intersect.position;
            Amg::Vector3D gdir_seg{seed.dir()};
            Amg::Vector3D perpos = gpos_seg - 10 * gdir_seg.unit();
            if (perpos.dot(gdir_seg) < 0) gdir_seg *= -1;
 
            Trk::Perigee startpar{perpos, gdir_seg, 0, perpos};

            std::unique_ptr<Trk::Track> segtrack = fit(ctx, fit_meas, startpar);
            if (segtrack) trackSegs.push_back(std::move(segtrack));
        }
        return resolveAmbiguities(ctx, trackSegs, Trk::Segment::Author::NswStereoSeeded);
    }

findStgcPrecisionSegments()

MuonSegmentVec Muon::MuonNSWSegmentFinderTool::findStgcPrecisionSegments ( const EventContext & ctx, const std::vector< const Muon::MuonClusterOnTrack * > & MuonClusters, int singleWedge = 0 ) const

private

Combines 2 sTgc strip layers to find 2D segments constraining the muon in the eta direction.

Resolve the ambiguities amongsty the tracks and convert the result

Definition at line 478 of file MuonNSWSegmentFinderTool.cxx.

                                                                                              {
 
       if (!m_usesTGCSeeding){
          ATH_MSG_VERBOSE("2D sTGC seeding disabled!"); 
          return {};
       }
 
       ATH_MSG_VERBOSE("Running 2D sTGC seeding"); 
 
 
        // clean the muon clusters; select only the eta hits.
        // in single-wedge mode the eta seeds are retrieved from the specific wedge
        
        ATH_MSG_DEBUG("Cleaning eta clusters in stgc seeded 2D segments ");
        MeasVec clusters = cleanClusters(muonClusters, HitType::Eta, singleWedge);  // eta hits only
        ATH_MSG_VERBOSE("  After hit cleaning, there are " << clusters.size() << " precision 2D clusters");
 
        // classify eta clusters by layer
        LayerMeasVec orderedClusters = classifyByLayer(clusters, 0);
 
        if (orderedClusters.size() < 4) return {};  // at least four layers with eta hits (MM and sTGC)
 
        // create segment seeds
        std::vector<NSWSeed> seeds = segmentSeedFromStgc(orderedClusters, false);
        ATH_MSG_DEBUG("  Found " << seeds.size() << " 2D seeds");
        // Loop on seeds: find all clusters near the seed and try to fit
        MeasVec etaHitVec, phiHitVec;
        TrackCollection segTrkColl{SG::OWN_ELEMENTS};
 
        for (NSWSeed& seed : seeds) {
            if (seed.size() < 4){
               ATH_MSG_VERBOSE(__func__<<" :"<<__LINE__<< " - Seed size: " << seed.size() << " is below the cut (4)");
               continue;
            }
 
            etaHitVec = seed.measurements();
            const Trk::PlaneSurface& surf = static_cast<const Trk::PlaneSurface&>(etaHitVec.front()->associatedSurface());
            // calculate start parameters for the fit
            // local position and direction of the eta-seed on the surface of the first cluster
            Trk::Intersection intersect = surf.straightLineIntersection(seed.pos(), seed.dir(), false, false);
            Amg::Vector2D lpos_seed{Amg::Vector2D::Zero()};
            Trk::LocalDirection ldir_seed{};
            surf.globalToLocal(intersect.position, intersect.position, lpos_seed);
            surf.globalToLocalDirection(seed.dir(), ldir_seed);
 
            // use the seed info to generate start parameters (dummy values for phi)
            Amg::Vector2D lpos(lpos_seed[Trk::locX], 0.);
            Trk::LocalDirection ldir(ldir_seed.angleXZ(), -M_PI_2);
            Amg::Vector3D gpos_seg{Amg::Vector3D::Zero()}, gdir_seg{Amg::Vector3D::Zero()};
            surf.localToGlobal(lpos, gpos_seg, gpos_seg);
            surf.localToGlobalDirection(ldir, gdir_seg);
 
            Amg::Vector3D perpos = gpos_seg - 10 * gdir_seg.unit();
            if (perpos.dot(gdir_seg) < 0) gdir_seg *= -1;
            const auto startpar = Trk::Perigee(perpos, gdir_seg, 0, perpos);
            ATH_MSG_VERBOSE(" start parameter " << perpos << " pp " << startpar.position() << " gd " << gdir_seg.unit() << " pp "
                                                << startpar.momentum().unit());
 
            // fit the hits
            hitsToTrack(ctx, etaHitVec, phiHitVec, startpar, segTrkColl);
        }
        return resolveAmbiguities(ctx, segTrkColl, Trk::Segment::Author::NswStgcSeeded);
    }

fit()

std::unique_ptr< Trk::Track > Muon::MuonNSWSegmentFinderTool::fit ( const EventContext & ctx, const std::vector< const Trk::MeasurementBase * > & fit_meas, const Trk::TrackParameters & perigee ) const

private

Definition at line 447 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                       {
        ATH_MSG_DEBUG("Fit segment from (" << to_string(perigee.position())<< "  pointing to " <<
                                            to_string(perigee.momentum())<<". Contained measurements in candidate: " << std::endl
                                            << m_printer->print(fit_meas));
        std::unique_ptr<Trk::Track> segtrack = m_slTrackFitter->fit(ctx, fit_meas, perigee, false, Trk::nonInteracting);
        if (!segtrack) {
            ATH_MSG_DEBUG("Fit failed");
            return nullptr;
        }
        ATH_MSG_VERBOSE("--> Fit succeeded");
        std::unique_ptr<Trk::Track> cleanedTrack = m_trackCleaner->clean(*segtrack, ctx);
        if (cleanedTrack && cleanedTrack->perigeeParameters() != segtrack->perigeeParameters()) { segtrack.swap(cleanedTrack); }
        // quality criteria
        if (!m_edmHelperSvc->goodTrack(*segtrack, 10)) {
            if (segtrack->fitQuality()) {
                ATH_MSG_DEBUG("Segment fit with chi^2/nDoF = " << segtrack->fitQuality()->chiSquared() << "/"
                                                               << segtrack->fitQuality()->numberDoF());
            }
            return nullptr;
        }
        // update the track summary and add the track to the collection
        m_trackSummary->updateTrack(ctx, *segtrack);
        ATH_MSG_DEBUG("Segment accepted with chi^2/nDoF = " << segtrack->fitQuality()->chiSquared() << "/"
                                                               << segtrack->fitQuality()->numberDoF());
        return segtrack;
    }

getCalibratedClusters()

MeasVec Muon::MuonNSWSegmentFinderTool::getCalibratedClusters ( NSWSeed & seed ) const

private

Definition at line 1540 of file MuonNSWSegmentFinderTool.cxx.

                                                                               {
 
        MeasVec calibratedClusters;
        MeasVec clusters = seed.measurements();
 
        // loop on the segment clusters and use the phi of the seed to correct them
        for (const SeedMeasurement& clus : clusters) {
            std::unique_ptr<const Muon::MuonClusterOnTrack> newClus;
 
            // get the intercept of the seed direction with the cluster surface
            const Identifier hitID = clus->identify();
            const Trk::Surface& surf = clus->associatedSurface();
            Trk::Intersection intersect = surf.straightLineIntersection(seed.pos(), seed.dir(), false, false);
 
            if (m_idHelperSvc->isMM(hitID)) {
                // build a  new MM cluster on track with correct position
                std::unique_ptr<const Muon::MuonClusterOnTrack> newClus {m_muonClusterCreator->correct(*clus->prepRawData(), intersect.position, seed.dir())};
                calibratedClusters.emplace_back(seed.newCalibClust(std::move(newClus)));
            } else if (m_idHelperSvc->issTgc(hitID)) {
                // build a  new sTGC cluster on track with correct position
                std::unique_ptr<const Muon::MuonClusterOnTrack> newClus {m_muonClusterCreator->correct(*clus->prepRawData(), intersect.position, seed.dir())};
                calibratedClusters.emplace_back(seed.newCalibClust(std::move(newClus)));
            }
        }
 
        return calibratedClusters;
    }

getClustersOnSegment()

int Muon::MuonNSWSegmentFinderTool::getClustersOnSegment ( const LayerMeasVec & orderedclusters, NSWSeed & seed, const std::set< unsigned int > & exclude, bool useStereo = true ) const

private

Definition at line 960 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                                                 {
        ATH_MSG_VERBOSE(" getClustersOnSegment: layers " << orderedclusters.size());
        int nHitsAdded{0};
 
        for (const MeasVec& surfHits : orderedclusters) {
            if (exclude.count(layerNumber(surfHits[0]))) continue;
            // get the best hit candidate on this layer
            
            for (const SeedMeasurement& hit : surfHits) { 
 
                  const Identifier id = hit->identify();
                  const MuonGM::MuonChannelDesign* design = getDesign(hit);
 
                  //In case of the 2D eta stgc seeding we don't want the MMG stereo hits on the segment
                  if ( !useStereo && m_idHelperSvc->isMM(id) && design->hasStereoAngle() ) continue;
 
                  nHitsAdded += seed.add(hit, m_maxClustDist); 
            }
        }
        ATH_MSG_VERBOSE(" getClustersOnSegment: returning " << nHitsAdded << " hits ");
        return nHitsAdded;
    }

getPadPhiOverlap()

std::vector< std::pair< double, double > > Muon::MuonNSWSegmentFinderTool::getPadPhiOverlap ( const std::vector< std::vector< const Muon::sTgcPrepData * > > & pads ) const

private

Definition at line 1440 of file MuonNSWSegmentFinderTool.cxx.

                                                                         {
        // 'pads' contains segment hit candidates, classified in four layers (IP or HO).
        // Layers are ordered; for IP, the layer with hits that is nearest to
        // the IP is first, while for HO, the one furthest from the IP is first.
 
        std::vector<std::vector<double>> padsPhiL, padsPhiR;
        std::vector<double> padsPhiC;
 
        // Loop on layers
        for (const std::vector<const Muon::sTgcPrepData*>& surfHits : pads) {
            // Loop on layer hits
            std::vector<double> surfPadsPhiL, surfPadsPhiR;
            for (const Muon::sTgcPrepData* prd : surfHits) {
                const Identifier id = prd->identify();
                const MuonGM::MuonPadDesign* design = prd->detectorElement()->getPadDesign(id);
                if (!design) {
                    ATH_MSG_WARNING("No design available for " << m_idHelperSvc->toString(id));
                    continue;
                }
 
                // Phi boundaries of this pad in local coordinates
                const double halfWidthX = 0.5 * design->channelWidth(prd->localPosition(), true);
                const double hitPadX = prd->localPosition().x();  // x is in the phi direction
 
                // Reject hit candidates on pads too close (in phi) to any pad kept so far
                // (pad fuzziness) to constrain the number of combinations.
                bool samePhi = std::find_if(padsPhiC.begin(), padsPhiC.end(), [&hitPadX, &halfWidthX](const double prevPadPhi) {
                                   return std::abs(hitPadX - prevPadPhi) < 0.9 * halfWidthX;
                               }) != padsPhiC.end();
 
                if (samePhi) continue;
 
                // Store the new pad candidate
                surfPadsPhiL.push_back(hitPadX - halfWidthX);
                surfPadsPhiR.push_back(hitPadX + halfWidthX);
                padsPhiC.push_back(hitPadX);
                ATH_MSG_DEBUG(" keep pad id " << m_idHelperSvc->toString(id) << " local x: " << hitPadX << " width: " << halfWidthX);
            }
 
            padsPhiL.push_back(std::move(surfPadsPhiL));
            padsPhiR.push_back(std::move(surfPadsPhiR));
        }
 
        unsigned int nSurf = padsPhiR.size();
 
        // number of combinations we can make out of pads in different layers
        // we want to keep combinations of overlapping pads.
        unsigned int nCombos{1};
        for (const std::vector<double>& surfPadsPhiR : padsPhiR) {
            if (!surfPadsPhiR.empty()) nCombos *= surfPadsPhiR.size();
        }
 
        std::vector<std::pair<double, double>> phiOverlap;
        phiOverlap.reserve(nCombos);
 
        if (nCombos <= 100) {
            unsigned int N{nCombos};
            for (unsigned int isurf{0}; isurf < nSurf; ++isurf) {
                if (padsPhiR[isurf].empty()) continue;
                unsigned int nSurfHits = padsPhiR[isurf].size();
                N /= nSurfHits;
 
                for (unsigned int icombo{0}; icombo < nCombos; ++icombo) {
                    // index of the pad that corresponds to this combination
                    unsigned int padIdx = (icombo / N) % nSurfHits;
                    if (isurf == 0) {
                        // first surface: just add the range of each hit pad
                        phiOverlap.emplace_back(padsPhiL[isurf][padIdx], padsPhiR[isurf][padIdx]);
                    } else {
                        // subsequent surfaces: use staggering to narrow the phi ranges
                        phiOverlap[icombo].first = std::max(padsPhiL[isurf][padIdx], phiOverlap[icombo].first);
                        phiOverlap[icombo].second = std::min(padsPhiR[isurf][padIdx], phiOverlap[icombo].second);
                    }
                }
            }
 
            // delete bad combinations with xmin > xmax (indicates non overlapping pads)
            phiOverlap.erase(std::remove_if(phiOverlap.begin(), phiOverlap.end(),
                                            [](std::pair<double, double>& range) { return range.first >= range.second; }),
                             phiOverlap.end());
            ATH_MSG_DEBUG("Pad seeding - #combinations initial: " << nCombos
                                                                  << ", after cleaning for non overlapping pads: " << phiOverlap.size());
 
        } else {
            // in case combinations are too many, store the phi ranges of individual pads
            for (unsigned int isurf{0}; isurf < nSurf; ++isurf) {
                unsigned int nSurfHits = padsPhiR[isurf].size();
                for (unsigned int ihit{0}; ihit < nSurfHits; ++ihit) {
                    phiOverlap.emplace_back(padsPhiL[isurf][ihit], padsPhiR[isurf][ihit]);
                }
            }
            ATH_MSG_DEBUG("Pad seeding - #combinations: " << nCombos << " is too large. Seeding from" << phiOverlap.size()
                                                          << " individual pads.");
        }
 
        return phiOverlap;
    }

hitsToTrack()

bool Muon::MuonNSWSegmentFinderTool::hitsToTrack ( const EventContext & ctx, const MeasVec & etaHitVec, const MeasVec & phiHitVec, const Trk::TrackParameters & startpar, TrackCollection & segTrkColl ) const

private

Definition at line 741 of file MuonNSWSegmentFinderTool.cxx.

                                                                                  {
        // vector of hits for the fit
        std::vector<const Trk::MeasurementBase*> vecFitPts;
        unsigned int nHitsEta = etaHitVec.size();
        unsigned int nHitsPhi = phiHitVec.size();
        vecFitPts.reserve(nHitsEta + nHitsPhi + 2 + m_ipConstraint + m_caloConstraint);
 
        std::unique_ptr<Trk::PseudoMeasurementOnTrack> pseudoVtx{ipConstraint(ctx)}, 
                                                       pseudoVtxCalo{caloConstraint(startpar)},
                                                       pseudoPhi1{nullptr}, pseudoPhi2{nullptr};
        // is chosen, add a pseudo measurement as vtx at the center of ATLAS
        if (pseudoVtx) { vecFitPts.push_back(pseudoVtx.get()); }
        if (pseudoVtxCalo) { vecFitPts.push_back(pseudoVtxCalo.get()); }
 
        if (!nHitsPhi) {
            // generate two pseudo phi measurements for the fit,
            // one on the first hit surface and one on the last hit surface.
 
            Amg::MatrixX cov(1, 1);
            constexpr double pseudoPrecision = 100 * Gaudi::Units::micrometer;
            cov(0, 0) = pseudoPrecision; 
            static const Trk::LocalParameters loc_pseudopars{Trk::DefinedParameter(0, Trk::locY)};
            pseudoPhi1 = std::make_unique<Trk::PseudoMeasurementOnTrack>(Trk::LocalParameters(loc_pseudopars),
                                                                         Amg::MatrixX(cov),
                                                                         etaHitVec.front()->associatedSurface());
            pseudoPhi2 = std::make_unique<Trk::PseudoMeasurementOnTrack>(Trk::LocalParameters(loc_pseudopars),
                                                                         Amg::MatrixX(cov),
                                                                         etaHitVec.back()->associatedSurface());
 
            // add the first pseudo phi hit, the hit vector, and the second pseudo phi hit
            vecFitPts.push_back(pseudoPhi1.get());
            std::copy(etaHitVec.begin(), etaHitVec.end(), std::back_inserter(vecFitPts));
            vecFitPts.push_back(pseudoPhi2.get());
            ATH_MSG_DEBUG("Fitting a 2D-segment track with " << nHitsEta << " Eta hits");
 
        } else {
            // sorted eta and sorted phi hits combined (sorted by their the z-coordinate)
            std::merge(phiHitVec.begin(), phiHitVec.end(), etaHitVec.begin(), etaHitVec.end(), std::back_inserter(vecFitPts),
                       [](const Muon::MuonClusterOnTrack* c1, const Muon::MuonClusterOnTrack* c2) {
                           double z1 = std::abs(c1->detectorElement()->center(c1->identify()).z());
                           double z2 = std::abs(c2->detectorElement()->center(c2->identify()).z());
                           return z1 < z2;
                       });
            ATH_MSG_DEBUG("Fitting a 3D-segment track with " << nHitsEta << " Eta hits and " << nHitsPhi << " Phi hits");
        }
 
        // fit the hits and generate the Trk::Track
        std::unique_ptr<Trk::Track> segtrack = fit(ctx, vecFitPts, startpar);
        if (!segtrack) return false;
        segTrkColl.push_back(std::move(segtrack));
        return true;
    }

idHelper()

const IMuonIdHelperSvc * Muon::MuonNSWSegmentFinderTool::idHelper

(

)

const

Definition at line 281 of file MuonNSWSegmentFinderTool.cxx.

{ return m_idHelperSvc.get(); }

initialize()

StatusCode Muon::MuonNSWSegmentFinderTool::initialize ( )

overridevirtual

Definition at line 262 of file MuonNSWSegmentFinderTool.cxx.

                                                    {
        ATH_CHECK(m_slTrackFitter.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_ambiTool.retrieve());
        ATH_CHECK(m_trackToSegmentTool.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_trackCleaner.retrieve());
        ATH_CHECK(m_trackSummary.retrieve());
        ATH_CHECK(m_muonClusterCreator.retrieve());
        if (m_ipConstraint && m_caloConstraint) {
            ATH_MSG_FATAL("The muon should come from the IP && horizontally from the Calo..."<<
            "We need to place a very good basball player at the calo exit to deflect the muon horizontally.");
            return StatusCode::FAILURE;
        }
        ATH_MSG_DEBUG(" Max cut " << m_maxClustDist);
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & Muon::IMuonNSWSegmentFinderTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 22 of file IMuonNSWSegmentFinderTool.h.

                                                {
            static const InterfaceID IID_IMuonNSWSegmentFinderTool("Muon::IMuonNSWSegmentFinderTool", 1, 0);
            return IID_IMuonNSWSegmentFinderTool;
        }

ipConstraint()

std::unique_ptr< Trk::PseudoMeasurementOnTrack > Muon::MuonNSWSegmentFinderTool::ipConstraint ( const EventContext & ctx ) const

private

creates the IP constraint

Beamspot constraint?

Definition at line 718 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                                 {
        if (!m_ipConstraint) return nullptr;
        constexpr double errVtx{10.*Gaudi::Units::cm};
        Amg::MatrixX covVtx(1, 1);
        covVtx(0, 0) = errVtx * errVtx;
        Trk::PerigeeSurface perVtx(Amg::Vector3D::Zero());
        return std::make_unique<Trk::PseudoMeasurementOnTrack>(Trk::LocalParameters(Trk::DefinedParameter(0, Trk::locX)), std::move(covVtx),
                                                               std::move(perVtx));
    }

isPad()

bool Muon::MuonNSWSegmentFinderTool::isPad

(

const Muon::MuonClusterOnTrack *

clust

)

const

Definition at line 728 of file MuonNSWSegmentFinderTool.cxx.

                                                                                  {
        const Identifier id = clust->identify();
        return m_idHelperSvc->issTgc(id) && m_idHelperSvc->stgcIdHelper().channelType(id) == sTgcIdHelper::Pad;
    }

isStrip()

bool Muon::MuonNSWSegmentFinderTool::isStrip

(

const Muon::MuonClusterOnTrack *

clust

)

const

Definition at line 732 of file MuonNSWSegmentFinderTool.cxx.

                                                                                    {
        const Identifier id = clust->identify();
        return m_idHelperSvc->issTgc(id) && m_idHelperSvc->stgcIdHelper().channelType(id) == sTgcIdHelper::Strip;
    }

isWire()

bool Muon::MuonNSWSegmentFinderTool::isWire

(

const Muon::MuonClusterOnTrack *

clust

)

const

Definition at line 736 of file MuonNSWSegmentFinderTool.cxx.

                                                                                   {
        const Identifier id = clust->identify();
        return m_idHelperSvc->issTgc(id) && m_idHelperSvc->stgcIdHelper().channelType(id) == sTgcIdHelper::Wire;
    }

layerNumber()

int Muon::MuonNSWSegmentFinderTool::layerNumber

(

const Muon::MuonClusterOnTrack *

cluster

)

const

Definition at line 943 of file MuonNSWSegmentFinderTool.cxx.

                                                                                         {
        // Internal logic. Initialize with 16 layers:
        // [0-3]   for the four sTGC IP layers
        // [4-11]  for the eight MM IP+HO layers (empty when phi hits are requested)
        // [12-15] for the four sTGC HO layers
        int layer{0};
        if (m_idHelperSvc->isMM(cluster->identify())) layer = m_idHelperSvc->mmIdHelper().gasGap(cluster->identify());
        if (m_idHelperSvc->issTgc(cluster->identify())) layer = m_idHelperSvc->stgcIdHelper().gasGap(cluster->identify());
        return 4 * (wedgeNumber(cluster) - 1) + layer - 1;
    }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

print() [1/3]

std::string Muon::MuonNSWSegmentFinderTool::print

(

const LayerMeasVec &

sortedVec

)

const

Definition at line 1592 of file MuonNSWSegmentFinderTool.cxx.

                                                                                 {
        std::stringstream sstr{};
        unsigned int lay{0};
        for (const MeasVec& clusts: sortedVec){
            sstr<<"Clusters in Layer: "<<(lay+1)<<std::endl;
            sstr<<"#################################################"<<std::endl;
            sstr<<print(clusts);
            ++lay;
        }
        return sstr.str();
    }

print() [2/3]

std::string Muon::MuonNSWSegmentFinderTool::print

(

const MeasVec &

clusters

)

const

Definition at line 1585 of file MuonNSWSegmentFinderTool.cxx.

                                                                               {
        std::stringstream sstr{};
        for (const SeedMeasurement& cl : measurements){
            sstr<<" *** "<<print(cl)<<std::endl;
        }
        return sstr.str();
    }

print() [3/3]

std::string Muon::MuonNSWSegmentFinderTool::print

(

const SeedMeasurement &

meas

)

const

Definition at line 1578 of file MuonNSWSegmentFinderTool.cxx.

                                                                             {
        std::stringstream sstr{};
        sstr << m_idHelperSvc->toString(cl->identify()) << " at " <<to_string(cl.pos())
            <<" pointing to (" <<to_string(cl.dir())<<" cluster size: "<<clusterSize(cl);
 
        return sstr.str();
    }

printSeed()

template<size_t N>

std::string Muon::MuonNSWSegmentFinderTool::printSeed

(

const std::array< SeedMeasurement, N > &

seed

)

const

Definition at line 1570 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                {
        std::stringstream sstr{};
        sstr << std::endl;
        for (const SeedMeasurement& cl : seed) sstr << " *** " << print(cl) << std::endl;
        return sstr.str();
    }

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resolveAmbiguities() [1/2]

MuonSegmentVec Muon::MuonNSWSegmentFinderTool::resolveAmbiguities ( const EventContext & ctx, const TrackCollection & segColl, const Trk::Segment::Author a ) const

private

Definition at line 544 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                {
        if (msgLvl(MSG::DEBUG)) {
            ATH_MSG_DEBUG("Tracks before ambi solving: ");
            for (const Trk::Track* trk : segTrkColl) {
                ATH_MSG_DEBUG(m_printer->print(*trk));
                const DataVector<const Trk::MeasurementBase>* meas = trk->measurementsOnTrack();
                if (meas) ATH_MSG_DEBUG(m_printer->print(meas->stdcont()));
            }
        }
 
        MuonSegmentVec segments{};
        std::unique_ptr<const TrackCollection> resolvedTracks(m_ambiTool->process(&segTrkColl));
        ATH_MSG_DEBUG("Resolved track candidates: old size " << segTrkColl.size() << " new size " << resolvedTracks->size());
 
        // store the resolved segments
        for (const Trk::Track* trk : *resolvedTracks) {
            const auto* measurements = trk->measurementsOnTrack();
            const bool has_eta = std::find_if(measurements->begin(), measurements->end(),
                                              [this](const Trk::MeasurementBase* meas) {
                                                  Identifier id = m_edmHelperSvc->getIdentifier(*meas);
                                                  return id.is_valid() && !m_idHelperSvc->measuresPhi(id);
                                              }) != trk->measurementsOnTrack()->end();
            if (!has_eta) continue;
            std::unique_ptr<MuonSegment> seg{m_trackToSegmentTool->convert(ctx, *trk)};
            if (seg) {
                ATH_MSG_DEBUG(" adding " << m_printer->print(*seg) << std::endl << m_printer->print(seg->containedMeasurements()));
                seg->setAuthor(a);
                segments.emplace_back(std::move(seg));
            } else {
                ATH_MSG_VERBOSE("Segment conversion failed, no segment created. ");
            }
        }
        return segments;
    }

resolveAmbiguities() [2/2]

std::vector< NSWSeed > Muon::MuonNSWSegmentFinderTool::resolveAmbiguities ( std::vector< NSWSeed > && unresolved ) const

private

Definition at line 1414 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                         {
        std::vector<NSWSeed> seeds;
        seeds.reserve(unresolved.size());
        std::sort(unresolved.begin(), unresolved.end(),[](const NSWSeed& a, const NSWSeed& b){
                                                            return a.chi2() < b.chi2();
                                                     });
        for (NSWSeed& seed : unresolved) {
            bool add_seed{true};
            for (NSWSeed& good : seeds) {
                NSWSeed::SeedOR ov = good.overlap(seed);
                if (ov == NSWSeed::SeedOR::SubSet) {
                    std::swap(seed, good);
                    add_seed = false;
                    break;
                } else if (ov == NSWSeed::SeedOR::Same || ov == NSWSeed::SeedOR::SuperSet) {
                    add_seed = false;
                    break;
                }
            }
            if (add_seed) seeds.push_back(std::move(seed));
        }
        ATH_MSG_VERBOSE(seeds.size()<<" out of "<<unresolved.size()<<" passed the overlap removal");
        return seeds;
    }

segmentSeedFromMM() [1/2]

std::vector< NSWSeed > Muon::MuonNSWSegmentFinderTool::segmentSeedFromMM ( const LayerMeasVec & orderedClusters ) const

private

layers 12-15 contain stgcs and are not of interest...

Combinatorics debugging stream

Definition at line 1122 of file MuonNSWSegmentFinderTool.cxx.

                                                   {
        std::vector<NSWSeed> seeds;
        std::array<unsigned int, 4> layers{};
        unsigned int trials{0}, used_layers{0};
        constexpr size_t lastMMLay = 11;
        std::vector<NSWSeed> laySeeds;

        std::stringstream sstr{};
        for (int e4  = std::min(lastMMLay, orderedClusters.size() -1); e4 >= 3 ; --e4) {
            layers[3] = e4;
            for (int e3 = e4 -1 ; e3 >= 2; --e3) {
                layers[2] = e3;
                for (int e2 = 1 ; e2 < e3; ++e2) {
                    layers[1] = e2;
                    for (int e1= 0; e1< e2; ++e1) {
                        layers[0] = e1;
                        const unsigned int old_trials = trials;
                        laySeeds = segmentSeedFromMM(orderedClusters,layers, trials);
                        if (old_trials == trials) continue;
 
                        used_layers += !laySeeds.empty();
                        seeds.insert(seeds.end(), std::make_move_iterator(laySeeds.begin()),
                                                  std::make_move_iterator(laySeeds.end()));
 
                        if (msgLvl(MSG::VERBOSE)) {
                            sstr<<" Attempts thus far "<<old_trials<<" attempts now "<<trials<<" --- "<<e1<<","<<e2<<","<<e3<<","<<e4<<std::endl;
                            for (int lay : layers) {
                                sstr<<"Layer: "<<lay<<" number of measurements "<<orderedClusters[lay].size()<<std::endl;
                                for (const SeedMeasurement& meas : orderedClusters[lay] ){
                                    sstr<<" **** "<< print(meas)<<std::endl;
                                }
                                sstr<<std::endl<<std::endl<<std::endl;
                            }
                        }
                    }
                }
            }
        }
        if (trials > 100000) {
            ATH_MSG_VERBOSE(sstr.str());
        }
        ATH_MSG_VERBOSE("Out of "<<trials<<" possible seeds, "<<seeds.size()<<" were finally built. Used in total "<<used_layers<<" layers");
        return resolveAmbiguities(std::move(seeds));
    }

segmentSeedFromMM() [2/2]

std::vector< NSWSeed > Muon::MuonNSWSegmentFinderTool::segmentSeedFromMM ( const LayerMeasVec & orderedClusters, std::array< unsigned int, 4 > selLayers, unsigned int & trial_counter ) const

inlineprivate

Determine whether the layer is X(1) / U(2) or V(3)

Order the strips such that the first and second pair consist each of crossing strips

The second pair is parallel

Assign the first measurement of each layer to calculate the linear transformation

Habemus valid strip quartett

Function to calculate the muon crossing

Reserve space for 200 seeds

The two channels are too narrow. Same conclusion holds for all previous hits from this layer combined with the next ones of layer 1

The opening angle of these two channels is just too wide

The first or the second one can cross with the third one

Reject combinations that consist only of 1 strip clusters

We will revise this requirement in the near future. Keep the block for the moment

Definition at line 1173 of file MuonNSWSegmentFinderTool.cxx.

                                                                                                               {
        std::vector<NSWSeed> seeds{};
 
        std::array<unsigned int, 4> lay_ord{};
        for (size_t s = 0; s < selLayers.size(); ++s) {
            unsigned int lay = selLayers[s];
            const SeedMeasurement& seed = orderedClusters[lay].front();
            const Identifier id = seed->identify();
            if (!m_idHelperSvc->isMM(id)) return seeds;
            const MuonGM::MuonChannelDesign* design = getDesign(seed);
            if (!design->hasStereoAngle())  lay_ord[s] = 1;
            else if (design->stereoAngle() >0.) lay_ord[s] = 2;
            else lay_ord[s] = 3;
        }
       auto swap_strips = [&selLayers, &lay_ord] (unsigned int i, unsigned j){
            std::swap(lay_ord[i], lay_ord[j]);
            std::swap(selLayers[i],selLayers[j]);
       };
        if (lay_ord[0] == lay_ord[1]){
            if (lay_ord[1] != lay_ord[2]) swap_strips(1,2);
             else if (lay_ord[1] != lay_ord[3]) swap_strips(1,3);
             else {
                ATH_MSG_VERBOSE("Strips are all parallel.");
                return seeds;
            }
        }
        if (lay_ord[2] == lay_ord[3]) {
            // Check if the last hit can be exchanged by the first one.
            // But also ensure that the second and fourth are not the same
            if (lay_ord[3] != lay_ord[0] && lay_ord[3] != lay_ord[1]) swap_strips(3,0);
            else {
               ATH_MSG_VERBOSE("No way to rearrange the strips such that the latter two strips cross.");
               return seeds;
            }
        }
        std::array<SeedMeasurement, 4> base_seed{};
        for (size_t s = 0; s < selLayers.size(); ++s) {
            unsigned int lay = selLayers[s];
            base_seed[s] = orderedClusters[lay].front();
        }
 
        const double A = (base_seed[1].pos().z() - base_seed[0].pos().z());
        const double G = (base_seed[2].pos().z() - base_seed[0].pos().z());
        const double K = (base_seed[3].pos().z() - base_seed[0].pos().z());
 
        AmgSymMatrix(2) diamond{AmgSymMatrix(2)::Zero()};
        diamond.block<2, 1>(0, 1) = ((A - G) * base_seed[3].dirDot(base_seed[1]) * base_seed[1].dir() + G * base_seed[3].dirDot(base_seed[0]) * base_seed[0].dir() - A * base_seed[3].dir()).block<2, 1>(0, 0);
        diamond.block<2, 1>(0, 0) = ((K - A) * base_seed[2].dirDot(base_seed[1]) * base_seed[1].dir() - K * base_seed[2].dirDot(base_seed[0]) * base_seed[0].dir() + A * base_seed[2].dir()).block<2, 1>(0, 0);
 
        if (std::abs(diamond.determinant()) < std::numeric_limits<float>::epsilon()) {
            ATH_MSG_VERBOSE(" The seed built from " << printSeed(base_seed) << " cannot constrain phi as " << std::endl
                                                    << diamond << std::endl
                                                    << " is singular " << diamond.determinant() << " with rank "
                                                    << (Eigen::FullPivLU<AmgSymMatrix(2)>{diamond}.rank()));
 
            return seeds;
        }
        ATH_MSG_VERBOSE("The combination of " << printSeed(base_seed) << " to " << std::endl
                                              << diamond << std::endl
                                              << "May give a couple of stereo seeds " << diamond.determinant());

        const AmgSymMatrix(2) seed_builder = diamond.inverse();
        const double KmG = K-G;
        const double KmA = K-A;
        const double AmG = A-G;
 
        const double TwoDotZero = base_seed[2].dirDot(base_seed[0]);
        const double ThreeDotZero = base_seed[3].dirDot(base_seed[0]);
        const double ThreeDotOne = base_seed[3].dirDot(base_seed[1]);
        const double TwoDotOne = base_seed[2].dirDot(base_seed[1]);
 
        auto estimate_muon = [&] () -> std::optional<std::array<double,2>> {
            const Amg::Vector3D Y0 = K * base_seed[2].pos() - G * base_seed[3].pos() - KmG * base_seed[0].pos();
            const Amg::Vector3D Y1 = AmG * base_seed[3].pos() - KmG * base_seed[1].pos() + KmA * base_seed[2].pos();
            const double Y0dotE0 = base_seed[0].dirDot(Y0);
            const double Y1dotE1 = base_seed[1].dirDot(Y1);
 
            const AmgVector(2) centers = (KmG * (base_seed[0].pos() - base_seed[1].pos()) +
                                           Y0dotE0 * base_seed[0].dir() +
                                           A * (base_seed[3].pos() - base_seed[2].pos()) -
                                          Y1dotE1 * base_seed[1].dir())
                                         .block<2, 1>(0, 0);
 
            const AmgVector(2) sol_pars = seed_builder * centers;
            const std::array<double, 4> lengths{(Y0dotE0 + K * sol_pars[0] * TwoDotZero - G * sol_pars[1] * ThreeDotZero) / KmG,
                                            (Y1dotE1 + AmG * sol_pars[1] *ThreeDotOne + KmA * sol_pars[0] * TwoDotOne) / KmG, sol_pars[0], sol_pars[1]};
            bool accept{true};
            ATH_MSG_VERBOSE("Check intersections of "<<printSeed(base_seed));
            constexpr double tolerance = 10.* Gaudi::Units::mm;
            std::optional<Amg::Vector3D> seg_pos{std::nullopt}, seg_dir{std::nullopt};
            for (unsigned int i = 0; i < base_seed.size(); ++i) {
                const MuonGM::MuonChannelDesign* design = getDesign(base_seed[i]);
                const double halfLength = design->channelHalfLength(channel(base_seed[i]), true);
                accept &= (halfLength  + tolerance > std::abs(lengths[i]));
                if (msgLvl(MSG::VERBOSE)) {
                    if (!seg_pos) {
                        seg_pos = std::make_optional<Amg::Vector3D>(base_seed[0].pos() +
                                                                    lengths[0] * base_seed[0].dir());
                        ATH_MSG_VERBOSE("Position "<<to_string(*seg_pos));
                    }
                    if (!seg_dir){
                            seg_dir = std::make_optional<Amg::Vector3D>((base_seed[1].pos() +
                                                                    lengths[1] *base_seed[1].dir() - (*seg_pos)).unit());
                        ATH_MSG_VERBOSE("Direction "<<to_string(*seg_dir));
                    }
                    std::optional<double> mu_crossing = Amg::intersect<3>(*seg_pos, *seg_dir, base_seed[i].pos(),base_seed[i].dir());
                    ATH_MSG_VERBOSE(" ----- "<<(i+1)<<" at "<<to_string(base_seed[i].pos() + lengths[i]*base_seed[i].dir())
                                << " ("<< std::string( halfLength > std::abs(lengths[i]) ? "inside" : "outside")<<" wedge) "
                                << halfLength <<" vs. "<<std::abs(lengths[i])<<" crossing point: "<<std::abs(*mu_crossing));
                } else if (!accept) return std::nullopt;
            }
            if (!accept) return std::nullopt;
            return std::make_optional<std::array<double,2>>({lengths[0], lengths[1]});
        };

        seeds.reserve(200);
        MeasVec::const_iterator begin2{orderedClusters[selLayers[1]].begin()};
        MeasVec::const_iterator begin3{orderedClusters[selLayers[2]].begin()};
        MeasVec::const_iterator begin4{orderedClusters[selLayers[3]].begin()};
 
        const MeasVec::const_iterator end2{orderedClusters[selLayers[1]].end()};
        const MeasVec::const_iterator end3{orderedClusters[selLayers[2]].end()};
        const MeasVec::const_iterator end4{orderedClusters[selLayers[3]].end()};
 
        for (const SeedMeasurement& lay1 : orderedClusters[selLayers[0]]) {
            base_seed[0] = lay1;
            for (MeasVec::const_iterator lay2 = begin2; lay2 != end2; ++lay2) {
 
                base_seed[1] = *lay2;
                ChannelConstraint chCheck = compatiblyFromIP(lay1, *lay2);
                if (chCheck == ChannelConstraint::TooNarrow) {
                    begin2 = lay2 + 1;
                    continue;
                }
                else if (chCheck == ChannelConstraint::TooWide) {
                    break;
                }
                for (MeasVec::const_iterator lay3 = begin3; lay3 != end3; ++lay3) {
                    chCheck = compatiblyFromIP(lay1, *lay3);
                    const ChannelConstraint chCheck1 = compatiblyFromIP(*lay2, *lay3);
                    if (chCheck == ChannelConstraint::TooNarrow && chCheck1 == ChannelConstraint::TooNarrow) {
                        begin3 = lay3 + 1;
                        continue;
                    } else if (chCheck == ChannelConstraint::TooWide && chCheck1 == ChannelConstraint::TooWide) {
                        break;
                    }
                    base_seed[2] = *lay3;
                    for (MeasVec::const_iterator lay4 = begin4 ; lay4 != end4; ++lay4) {
                        chCheck = compatiblyFromIP(*lay3, *lay4);
                        if (chCheck == ChannelConstraint::TooNarrow) {
                            begin4 = lay4 + 1;
                            continue;
                        }  else if (chCheck == ChannelConstraint::TooWide) {
                            break;
                        }
 
                        base_seed[3] = (*lay4);
                        std::optional<std::array<double, 2>> isects = estimate_muon();
                        ++trial_counter;
                        if (!isects) continue;
                        NSWSeed seed{this, base_seed, *isects};
 
                        if (seed.size() < 4) continue;
                        if (m_ipConstraint) {
                            const double eta = std::abs(seed.dir().eta());
                            if (eta < minEtaNSW || eta > maxEtaNSW) {
                                continue;
                            }
                            if (seed.dir().block<2,1>(0,0).dot(seed.pos().block<2,1>(0,0)) < 0.) continue;
                            static const Muon::MuonSectorMapping  sector_mapping{};
                            const double deltaPhi = std::abs(seed.dir().deltaPhi(seed.pos()));
                            if (deltaPhi > sector_mapping.sectorWidth(m_idHelperSvc->sector(base_seed[0]->identify()))) continue;
                        }
                        getClustersOnSegment(orderedClusters, seed, {selLayers[0], selLayers[1],selLayers[2], selLayers[3]});
                        seeds.emplace_back(std::move(seed));
                    }
                }
            }
        }
        return seeds;
    }

segmentSeedFromPads()

std::vector< NSWSeed > Muon::MuonNSWSegmentFinderTool::segmentSeedFromPads ( const LayerMeasVec & orderedClusters, const Muon::MuonSegment & etaSeg ) const

private

Do not run an empty container

Definition at line 985 of file MuonNSWSegmentFinderTool.cxx.

                                                                                  {
        std::vector<NSWSeed> seeds;
        if (orderedClusters.empty()) return seeds;
 
        std::vector<std::vector<const Muon::sTgcPrepData*>> sTgcIP(4);  // IP: layers nearest to the IP will be added first
        std::vector<std::vector<const Muon::sTgcPrepData*>> sTgcHO(4);  // HO: layers furthest from the IP will be added first
 
        // Process clusters separately for each multilayer
        for (int iml : {1, 2}) {
            int il = (iml == 1) ? 0 : orderedClusters.size() - 1;
            int iend = (iml == 1) ? orderedClusters.size() : -1;
            int idir = (iml == 1) ? 1 : -1;
            unsigned int nLayersWithHitMatch{0};
 
            // Loop on layers (reverse loop for HO)
            for (; il != iend; il += idir) {
                double lastDistance{1000.};
                if (nLayersWithHitMatch >= sTgcIP.size()) {
                    sTgcIP.resize(nLayersWithHitMatch + 1);
                    sTgcHO.resize(nLayersWithHitMatch + 1);
                }
                std::vector<const Muon::sTgcPrepData*>& matchedHits =
                    (iml == 1) ? sTgcIP.at(nLayersWithHitMatch) : sTgcHO.at(nLayersWithHitMatch);
 
                // Loop on the hits on this layer. Find the one closest (in eta) to the segment intersection.
                for (const Muon::MuonClusterOnTrack* rio : orderedClusters[il]) {
                    const sTgcPrepData* padHit = dynamic_cast<const sTgcPrepData*>(rio->prepRawData());
                    if (!padHit) continue;
 
                    // check the multilayer the hit is on
                    if (m_idHelperSvc->stgcIdHelper().multilayer(padHit->identify()) != iml) continue;
 
                    const MuonGM::MuonPadDesign* design = padHit->detectorElement()->getPadDesign(padHit->identify());
                    if (!design) continue;
 
                    // local position of the segment intersection with the plane
                    const Trk::Surface& surf = padHit->detectorElement()->surface(padHit->identify());
                    Trk::Intersection intersect =
                        surf.straightLineIntersection(etaSeg.globalPosition(), etaSeg.globalDirection(), false, false);
                    Amg::Vector2D segLocPosOnSurf{Amg::Vector2D::Zero()};
                    surf.globalToLocal(intersect.position, intersect.position, segLocPosOnSurf);
 
                    // eta distance between the hit and the segment intersection with the plane
                    // check that it's no more than half of the pad eta-pitch.
                    double chWidth = design->channelWidth(padHit->localPosition(), false);
                    double etaDistance = std::abs(padHit->localPosition().y() - segLocPosOnSurf[1]);
                    if (etaDistance > 0.5 * chWidth) continue;
                    ATH_MSG_DEBUG(" etaDistance " << etaDistance << " between pad center and position on the pad.");
 
                    if (matchedHits.empty()) {
                        // first hit
                        matchedHits.push_back(padHit);
                        ATH_MSG_DEBUG(" best etaDistance: " << etaDistance);
                    } else if (std::abs(etaDistance - lastDistance) < 0.001) {
                        // competing hit pad, keep both (all hit pads of the same eta row will be candidates)
                        matchedHits.push_back(padHit);
                        ATH_MSG_DEBUG(" added etaDistance: " << etaDistance << " size " << matchedHits.size());
                    } else if (etaDistance < lastDistance) {
                        // found a better hit; clear the old ones (possible only for clustered pad hits)
                        matchedHits.clear();
                        matchedHits.push_back(padHit);
                        ATH_MSG_DEBUG(" replacing best etaDistance with: " << etaDistance);
                    } else {
                        continue;
                    }
                    lastDistance = etaDistance;
                }  // end of loop on hits
 
                if (!matchedHits.empty()) ++nLayersWithHitMatch;
 
            }  // end of loop on layers
 
            // need at least one hit in each multilayer to create a seed
            if (!nLayersWithHitMatch) return seeds;
 
        }  // end of loop on multilayers
 
        // get refined phi ranges on each ml, by taking into account pad staggering
        std::vector<std::pair<double, double>> sTgcIP_phiRanges = getPadPhiOverlap(sTgcIP);
        std::vector<std::pair<double, double>> sTgcHO_phiRanges = getPadPhiOverlap(sTgcHO);
 
        // reference prds on the outermost hit surfaces
        const sTgcPrepData* prdL1 = sTgcIP.front().front();
        const sTgcPrepData* prdL2 = sTgcHO.front().front();
        const auto& surfPrdL1 = prdL1->detectorElement()->surface();
        const auto& surfPrdL2 = prdL2->detectorElement()->surface();
 
        // create a seed for each combination of IP and HO points
        for (const std::pair<double, double>& range1 : sTgcIP_phiRanges) {
            double midPhi1 = 0.5 * (range1.first + range1.second);
            Amg::Vector2D lp1(midPhi1, prdL1->localPosition().y());
            Amg::Vector3D gpL1{Amg::Vector3D::Zero()};
            surfPrdL1.localToGlobal(lp1, gpL1, gpL1);
 
            Amg::Vector2D lp1_lowPhi{range1.first, prdL1->localPosition().y()};
            Amg::Vector2D lp1_highPhi{range1.second, prdL1->localPosition().y()};
 
            Amg::Vector3D gp1_lowPhi{Amg::Vector3D::Zero()};
            Amg::Vector3D gp1_highPhi{Amg::Vector3D::Zero()};
 
            surfPrdL1.localToGlobal(lp1_lowPhi, gp1_lowPhi, gp1_lowPhi);
            surfPrdL1.localToGlobal(lp1_highPhi, gp1_highPhi, gp1_highPhi);
 
            Trk::Intersection intersect_lowPhi = surfPrdL2.straightLineIntersection(gp1_lowPhi, gp1_lowPhi, false, false);
            Trk::Intersection intersect_highPhi = surfPrdL2.straightLineIntersection(gp1_highPhi, gp1_highPhi, false, false);
 
            Amg::Vector2D lpIntersect_lowPhi{Amg::Vector2D::Zero()};
            Amg::Vector2D lpIntersect_highPhi{Amg::Vector2D::Zero()};
 
            surfPrdL2.globalToLocal(intersect_lowPhi.position, intersect_lowPhi.position, lpIntersect_lowPhi);
            surfPrdL2.globalToLocal(intersect_highPhi.position, intersect_highPhi.position, lpIntersect_highPhi);
 
            for (const std::pair<double, double>& range2 : sTgcHO_phiRanges) {
                double midPhi2 = 0.5 * (range2.first + range2.second);
                // let's check that the phi ranges in the two multilayer overlap 
                if( lpIntersect_highPhi.x() - range2.first < 0 ||   range2.second - lpIntersect_lowPhi.x() < 0) {
                    ATH_MSG_DEBUG(" segmentSeedFromPads: skipping seed with non-overlapping phi ranges");
                    continue;
                }
 
                Amg::Vector2D lp2(midPhi2, prdL2->localPosition().y());
                Amg::Vector3D gpL2{Amg::Vector3D::Zero()};
                surfPrdL2.localToGlobal(lp2, gpL2, gpL2);
                // create the seed taking the average position (w.r.t. IP)
                // as global direction (as for an infinite momentum track).
                Amg::Vector3D gDir = (gpL2 + gpL1).unit();
                seeds.emplace_back(this, gpL1, gDir);
            }
        }
 
        ATH_MSG_DEBUG(" segmentSeedFromPads: seeds.size() " << seeds.size());
        return seeds;
    }

segmentSeedFromStgc()

std::vector< NSWSeed > Muon::MuonNSWSegmentFinderTool::segmentSeedFromStgc ( const LayerMeasVec & orderedClusters, bool usePhi ) const

private

Reject

Definition at line 868 of file MuonNSWSegmentFinderTool.cxx.

                                                                                          {
        std::vector<NSWSeed> seeds;
 
        // oderedClusters should contain either eta clusters (MM and sTGC)
        // or sTGC phi hits. For MM phi, use the dedicated function.
        if (orderedClusters.size() < 4) return seeds;
 
        // Create seeds using each pair of hits on the two most distant layers (that containing hits).
        // m_nOfSeedLayers (default = 1) dictates whether we want to also use hits from inner layers.
 
        // Loop on layers to get the first seed point
        int seedingLayersL{0};
        for (unsigned int ilayerL{0}; (ilayerL < orderedClusters.size() && seedingLayersL < m_nOfSeedLayers); ++ilayerL) {
            bool usedLayerL{false};
            for (const SeedMeasurement& hitL : orderedClusters[ilayerL]) {
                if (usePhi != m_idHelperSvc->measuresPhi(hitL->identify())) continue;
                else if(m_idHelperSvc->isMM(hitL->identify())) break;
 
 
                // For the second point, loop on layers in reverse to be as far as possible from the first.
                int seedingLayersR{0};
                for (unsigned int ilayerR = orderedClusters.size() - 1; (ilayerR > ilayerL && seedingLayersR < m_nOfSeedLayers);
                     --ilayerR) {
                    bool usedLayerR{false};
                    for (const SeedMeasurement& hitR : orderedClusters[ilayerR]) {
                        if (usePhi != m_idHelperSvc->measuresPhi(hitR->identify())) continue;
                        else if (m_idHelperSvc->isMM(hitR->identify())) break;
                        NSWSeed seed{this,hitL, hitR};
                        if (!usePhi && m_ipConstraint) {
                            const double eta = seed.dir().perp() > std::numeric_limits<float>::epsilon() ? std::abs(seed.dir().eta()): FLT_MAX;
                            if (eta < minEtaNSW || eta > maxEtaNSW) {
                                continue;
                            }
                        } else if (usePhi && m_ipConstraint) {
                            // first make sure that the wires are in the same or neigbouring quads
                            if(std::abs(std::abs(m_idHelperSvc->stationEta(hitL->identify())) - std::abs(m_idHelperSvc->stationEta(hitR->identify()))) > 1) {
                                continue;
                            }
                            // project the hit in the first layer assuming the track comes from the IP
                            Trk::Intersection intersect = hitR->detectorElement()->surface(hitR->identify()).straightLineIntersection(hitL->globalPosition(),hitL->globalPosition().unit(), false, false);
                            Amg::Vector2D lpos_intersect{Amg::Vector2D::Zero()};
                            hitR->detectorElement()->surface(hitR->identify()).globalToLocal(intersect.position, intersect.position, lpos_intersect);
 
                            Amg::Vector2D lPosR;
                            hitR->detectorElement()->surface(hitR->identify()).globalToLocal(hitR->globalPosition(), hitR->globalPosition(), lPosR);
 
                            
                            if(std::abs(lpos_intersect.x() - lPosR.x()) > 87.5 ) continue; // reject seed if the projection is more than 2.5 wire groups away
                        }
 
                        usedLayerR = true;
                        usedLayerL = true;
                        getClustersOnSegment(orderedClusters, seed, {ilayerL, ilayerR}, false);
                        seeds.emplace_back(std::move(seed));
 
                    }
                    if (usedLayerR) ++seedingLayersR;
                }
            }
            if (usedLayerL) ++seedingLayersL;
        }
 
        return resolveAmbiguities(std::move(seeds));
    }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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);
      }
    }
  }

vetoBursts()

MeasVec Muon::MuonNSWSegmentFinderTool::vetoBursts ( MeasVec && clustInLay ) const

private

Removes clusters from high activity areas in the detector.

The micromegas are slobbering quite a lot in the 2023 data taking leading to uncopable comptuing times. The burst vetoing aims to mitigate this situation. A histogram with a bin width of m_ocupMmBinWidth is defined Hits are filled into the accoring bin using their channel number Bins with large activity are then cleared. In the second step, pairs of bins where their sum is too exhaustive are removed.

Define the number of bins

Fill the measurements into the histograms

Apply the single bin cleaning

Apply the pair wise bin cleaning

Copy the rest over

Definition at line 1604 of file MuonNSWSegmentFinderTool.cxx.

                                                                              {
        if (clustInLay.size() < m_ocupMmNumPerBin || m_idHelperSvc->issTgc(clustInLay[0]->identify())) return clustInLay;
        MeasVec prunedMeas{};
        prunedMeas.reserve(clustInLay.size());
        const unsigned int firstCh = channel(clustInLay[0]);
        const unsigned int lastCh = channel(clustInLay[clustInLay.size() -1]);
        const unsigned int deltaCh = lastCh - firstCh;
        const unsigned int nBins = deltaCh / m_ocupMmBinWidth + (deltaCh % m_ocupMmBinWidth > 0);
        ATH_MSG_VERBOSE("Clusters in layer "<<print(clustInLay)<<" lowest channel: "<<
                        firstCh<<", highest channel: "<<lastCh<<" bin width: "<<m_ocupMmBinWidth<<" number of bins"<<nBins);
 
        LayerMeasVec occupancyHisto{};
        occupancyHisto.resize(nBins);
        for (MeasVec& bin : occupancyHisto) {
            bin.reserve(clustInLay.size());
        }
        ATH_MSG_VERBOSE("Clusters sorted into bins "<<print(occupancyHisto));
        for (SeedMeasurement& meas : clustInLay){
            unsigned int bin = (channel(meas) - firstCh) % nBins;
            occupancyHisto[bin].push_back(std::move(meas));
        }
        for (MeasVec& bin : occupancyHisto) {
            if(bin.size() >= m_ocupMmNumPerBin){
                ATH_MSG_VERBOSE("The micromegas are slobbering. Detected too many clusters "<<bin.size()<<std::endl<<print(bin));
                bin.clear();
            }
        }
        for (unsigned int i = 0; i < occupancyHisto.size() -1; ++i) {
            if (occupancyHisto[i].size() + occupancyHisto[i+1].size() >= m_ocupMmNumPerPair){
                ATH_MSG_VERBOSE("The two neighbouring bins "<<i<<"&"<<(i+1)<<" have too many clusters "<<std::endl<<
                print(occupancyHisto[i])<<std::endl<<print(occupancyHisto[i+1]));
                occupancyHisto[i].clear();
                occupancyHisto[i+1].clear();
            }
        }
        for (MeasVec& bin : occupancyHisto){
            std::copy(std::make_move_iterator(bin.begin()),
                      std::make_move_iterator(bin.end()),
                      std::back_inserter(prunedMeas));
        }
 
        ATH_MSG_VERBOSE("Number of measurements before pruning "<<clustInLay.size()<<" number of measurments survived the pruning "<<prunedMeas.size());
        return prunedMeas;
 
    }

wedgeNumber()

int Muon::MuonNSWSegmentFinderTool::wedgeNumber

(

const Muon::MuonClusterOnTrack *

cluster

)

const

Definition at line 936 of file MuonNSWSegmentFinderTool.cxx.

                                                                                         {
        if (m_idHelperSvc->isMM(cluster->identify()))
            return m_idHelperSvc->mmIdHelper().multilayer(cluster->identify()) + 1;  // [IP:2, HO:3]
        if (m_idHelperSvc->issTgc(cluster->identify()))
            return 3 * (m_idHelperSvc->stgcIdHelper().multilayer(cluster->identify()) - 1) + 1;  // [IP:1, HO:4];
        return -1;
    }

Member Data Documentation

m_ambiTool

ToolHandle<Trk::ITrackAmbiguityProcessorTool> Muon::MuonNSWSegmentFinderTool::m_ambiTool

private

Initial value:

{
            this,
            "SegmentAmbiguityTool",
            "Trk::SimpleAmbiguityProcessorTool/MuonAmbiProcessor",
        }

Tool for ambiguity solving.

Definition at line 148 of file MuonNSWSegmentFinderTool.h.

                                                              {
            this,
            "SegmentAmbiguityTool",
            "Trk::SimpleAmbiguityProcessorTool/MuonAmbiProcessor",
        };  

m_caloConstraint

Gaudi::Property<bool> Muon::MuonNSWSegmentFinderTool::m_caloConstraint {this, "CaloConstraint", false}

private

Use a virtual point at the calorimeter exit with same Z as constraint...

Definition at line 184 of file MuonNSWSegmentFinderTool.h.

{this, "CaloConstraint", false};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuonNSWSegmentFinderTool::m_edmHelperSvc

private

Initial value:

{
            this,
            "edmHelper",
            "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
            "Handle to the service providing the IMuonEDMHelperSvc interface",
        }

Definition at line 141 of file MuonNSWSegmentFinderTool.h.

                                                       {
            this,
            "edmHelper",
            "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
            "Handle to the service providing the IMuonEDMHelperSvc interface",
        };  //<! Id helper tool

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idHelperSvc

ServiceHandle<IMuonIdHelperSvc> Muon::MuonNSWSegmentFinderTool::m_idHelperSvc

private

Initial value:

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

Definition at line 136 of file MuonNSWSegmentFinderTool.h.

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

m_ipConstraint

Gaudi::Property<bool> Muon::MuonNSWSegmentFinderTool::m_ipConstraint {this, "IPConstraint", true}

private

Definition at line 181 of file MuonNSWSegmentFinderTool.h.

{this, "IPConstraint", true};  // use a ip perigee(0,0) constraint in the segment fit

m_maxClustDist

Gaudi::Property<double> Muon::MuonNSWSegmentFinderTool::m_maxClustDist {this, "ClusterDistance", 5.}

private

Definition at line 185 of file MuonNSWSegmentFinderTool.h.

{this, "ClusterDistance", 5.};

m_maxInputPads

Gaudi::Property<uint> Muon::MuonNSWSegmentFinderTool::m_maxInputPads {this, "maxInputPads", 40, "Maximum number of pads per wedge layer."}

private

Definition at line 199 of file MuonNSWSegmentFinderTool.h.

{this, "maxInputPads", 40, "Maximum number of pads per wedge layer."};

m_muonClusterCreator

ToolHandle<IMuonClusterOnTrackCreator> Muon::MuonNSWSegmentFinderTool::m_muonClusterCreator {this, "MuonClusterCreator", ""}

private

Definition at line 179 of file MuonNSWSegmentFinderTool.h.

{this, "MuonClusterCreator", ""};

m_nOfSeedLayers

Gaudi::Property<int> Muon::MuonNSWSegmentFinderTool::m_nOfSeedLayers {this, "NOfSeedLayers", 1}

private

Definition at line 186 of file MuonNSWSegmentFinderTool.h.

{this, "NOfSeedLayers", 1};

m_ocupMmBinWidth

Gaudi::Property<unsigned int> Muon::MuonNSWSegmentFinderTool::m_ocupMmBinWidth

private

Initial value:

{this, "MmOccupancyBinWidth", 100, 
        "Size of the channel window to group the MicroMegaCluster"}

Protection against slobbering Micromega events.

Definition at line 193 of file MuonNSWSegmentFinderTool.h.

                                                    {this, "MmOccupancyBinWidth", 100, 
        "Size of the channel window to group the MicroMegaCluster"};

m_ocupMmNumPerBin

Gaudi::Property<unsigned int> Muon::MuonNSWSegmentFinderTool::m_ocupMmNumPerBin

private

Initial value:

{this, "MmOccupancySingleCut", 5, 
        "Cut on the number of MicroMega clusters in a particular occupancy bin"}

Definition at line 195 of file MuonNSWSegmentFinderTool.h.

                                                     {this, "MmOccupancySingleCut", 5, 
        "Cut on the number of MicroMega clusters in a particular occupancy bin"};

m_ocupMmNumPerPair

Gaudi::Property<unsigned int> Muon::MuonNSWSegmentFinderTool::m_ocupMmNumPerPair

private

Initial value:

{this, "MmOccupancyPairCut", 7,
        "Cut on the number of MicroMega clusters in two neighbouring occupancy bins"}

Definition at line 197 of file MuonNSWSegmentFinderTool.h.

                                                      {this, "MmOccupancyPairCut", 7,
        "Cut on the number of MicroMega clusters in two neighbouring occupancy bins"};

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonNSWSegmentFinderTool::m_printer

private

Initial value:

{
            this,
            "Printer",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        }

Definition at line 163 of file MuonNSWSegmentFinderTool.h.

                                                      {
            this,
            "Printer",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        };

m_slTrackFitter

ToolHandle<Trk::ITrackFitter> Muon::MuonNSWSegmentFinderTool::m_slTrackFitter

private

Initial value:

{
            this,
            "SLFitter",
            "Trk::GlobalChi2Fitter/MCTBSLFitter",
        }

Definition at line 153 of file MuonNSWSegmentFinderTool.h.

                                                   {
            this,
            "SLFitter",
            "Trk::GlobalChi2Fitter/MCTBSLFitter",
        };  //<! fitter, always use straightline

m_trackCleaner

ToolHandle<IMuonTrackCleaner> Muon::MuonNSWSegmentFinderTool::m_trackCleaner

private

Initial value:

{
            this,
            "TrackCleaner",
            "Muon::MuonTrackCleaner/MuonTrackCleaner",
        }

Definition at line 168 of file MuonNSWSegmentFinderTool.h.

                                                    {
            this,
            "TrackCleaner",
            "Muon::MuonTrackCleaner/MuonTrackCleaner",
        };

m_trackSummary

ToolHandle<Trk::ITrackSummaryTool> Muon::MuonNSWSegmentFinderTool::m_trackSummary

private

Initial value:

{
            this,
            "TrackSummaryTool",
            "Trk::TrackSummaryTool/MuidTrackSummaryTool",
        }

Definition at line 173 of file MuonNSWSegmentFinderTool.h.

                                                       {
            this,
            "TrackSummaryTool",
            "Trk::TrackSummaryTool/MuidTrackSummaryTool",
        };

m_trackToSegmentTool

ToolHandle<IMuonTrackToSegmentTool> Muon::MuonNSWSegmentFinderTool::m_trackToSegmentTool

private

Initial value:

{
            this,
            "TrackToSegmentTool",
            "Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool",
        }

Definition at line 158 of file MuonNSWSegmentFinderTool.h.

                                                                {
            this,
            "TrackToSegmentTool",
            "Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool",
        };  //<! track to segment converter

m_useStereoSeeding

Gaudi::Property<bool> Muon::MuonNSWSegmentFinderTool::m_useStereoSeeding {this, "SeedMMStereos", true}

private

Definition at line 189 of file MuonNSWSegmentFinderTool.h.

{this, "SeedMMStereos", true};

m_usesTGCSeeding

Gaudi::Property<bool> Muon::MuonNSWSegmentFinderTool::m_usesTGCSeeding {this, "SeedWithsTGCS", true}

private

Definition at line 190 of file MuonNSWSegmentFinderTool.h.

{this, "SeedWithsTGCS", true};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MuonNSWSegmentFinderTool.h
• MuonNSWSegmentFinderTool.cxx