#include <MuonSegmentTagTool.h>

Inheritance diagram for MuonCombined::MuonSegmentTagTool:

Collaboration diagram for MuonCombined::MuonSegmentTagTool:

Public Member Functions
	MuonSegmentTagTool (const std::string &type, const std::string &name, const IInterface *parent)

	~MuonSegmentTagTool ()=default

StatusCode	initialize () override

StatusCode	finalize () override

void	tag (const EventContext &ctx, const InDetCandidateCollection &inDetCandidates, const std::vector< const Muon::MuonSegment * > &segments, InDetCandidateToTagMap *tagMap) const override
	IMuonSegmentTagTool interface: build muons from ID and MuonSegments. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
using	SegmentMap = std::map< const Muon::MuonSegment *, ElementLink< xAOD::MuonSegmentContainer > >

using	SurfDef = MuonCombined::MuonSegmentTagSurfaces::SurfDef

using	SortedSegmentMap = std::map< int, std::vector< const Muon::MuonSegment * > >
	The segment vector is sorted into a map where the key is the associated surface definition of each segment. More...

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	printTable (const std::vector< std::string > &didEx, const std::vector< std::string > &segStation, const std::vector< std::vector< std::string >> &segToSurf) const
	method for extra DEBUG More...

std::vector< const Muon::MuonSegment * >	getCandidateSegments (const std::vector< const Muon::MuonSegment * > &segments) const
	Filters the input segments based on the number of hits fit quality etc. More...

SortedSegmentMap	findPopulatedStations (const std::vector< const Muon::MuonSegment * > &filteredSegments) const
	Creates the sorted segment map. More...

SortedSegmentMap	findCandidateStations (const MuonCombined::InDetCandidate &Id_trk, const SortedSegmentMap &filteredSegments) const
	Returns an array encoding which muon segments are compatible with the IdCandidate. More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static double	getPropDistance (const Trk::TrackParameters &start_pars, const Trk::Surface &target_surf)
	Returns the straight line distance estimation of the parameters to the surface. More...

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc

ToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

ToolHandle< IMuTagMatchingTool >	m_MuTagMatchingTool {this, "MuTagMatchingTool", "MuTagMatchingTool/MuTagMatchingTool"}

ToolHandle< IMuTagAmbiguitySolverTool >	m_MuTagAmbiguitySolverTool

ToolHandle< Muon::IMuonSegmentSelectionTool >	m_segmentSelector

ToolHandle< Muon::IMuonSegmentHitSummaryTool >	m_hitSummaryTool

Gaudi::Property< bool >	m_doSegmentsFilter {this, "DoSegmentsFilter", true, "flag to switch segment filtering on/off (for trigger)"}

Gaudi::Property< bool >	m_doTable {this, "DoOverviewTable", false}

Gaudi::Property< bool >	m_doBidirectional

Gaudi::Property< bool >	m_doPtDependentPullCut {this, "DoPtDependentPullCut", false, "flag to enable the pT-dependent pull cut"}

Gaudi::Property< bool >	m_removeLowPLowFieldRegion

Gaudi::Property< int >	m_segmentQualityCut {this, "SegmentQualityCut", 1, "minimum segment quality"}

Gaudi::Property< unsigned int >	m_nmdtHits {this, "nmdtHits", 4}

Gaudi::Property< unsigned int >	m_nmdtHoles {this, "nmdtHoles", 3}

Gaudi::Property< unsigned int >	m_nmdtHitsML {this, "nmdtHitsML", 2}

Gaudi::Property< bool >	m_triggerHitCut {this, "TriggerHitCut", true, "apply Trigger hit cut if trigger hits are expected"}

Gaudi::Property< bool >	m_ignoreSiAssocated

const MuonCombined::MuonSegmentTagSurfaces	m_surfaces {}

const Muon::MuonSectorMapping	m_sectorMapping {}
	sector mapping helper More...

std::atomic_uint	m_ntotTracks {0}

std::atomic_uint	m_nangleMatch {0}

std::atomic_uint	m_npmatch {0}

std::atomic_uint	m_natMSEntrance {0}

std::atomic_uint	m_naccepted {0}

std::array< std::atomic_uint, SurfDef::NumSurf > m_extrapolated	ATLAS_THREAD_SAFE {0}

std::array< std::atomic_uint, SurfDef::NumSurf > m_goodExtrapolated	ATLAS_THREAD_SAFE {0}

std::array< std::atomic_uint, SurfDef::NumSurf > m_recycledIntersect	ATLAS_THREAD_SAFE {0}

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 38 of file MuonSegmentTagTool.h.

Member Typedef Documentation

◆ SegmentMap

using MuonCombined::MuonSegmentTagTool::SegmentMap = std::map<const Muon::MuonSegment*, ElementLink<xAOD::MuonSegmentContainer> >

private

Definition at line 39 of file MuonSegmentTagTool.h.

◆ SortedSegmentMap

using MuonCombined::MuonSegmentTagTool::SortedSegmentMap = std::map<int, std::vector<const Muon::MuonSegment*> >

private

The segment vector is sorted into a map where the key is the associated surface definition of each segment.

Definition at line 61 of file MuonSegmentTagTool.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ SurfDef

using MuonCombined::MuonSegmentTagTool::SurfDef = MuonCombined::MuonSegmentTagSurfaces::SurfDef

private

Definition at line 40 of file MuonSegmentTagTool.h.

Constructor & Destructor Documentation

◆ MuonSegmentTagTool()

MuonCombined::MuonSegmentTagTool::MuonSegmentTagTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 49 of file MuonSegmentTagTool.cxx.

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

◆ ~MuonSegmentTagTool()

MuonCombined::MuonSegmentTagTool::~MuonSegmentTagTool ( )

default

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ finalize()

StatusCode MuonCombined::MuonSegmentTagTool::finalize ( )

override

Definition at line 71 of file MuonSegmentTagTool.cxx.

                                             {
         ATH_MSG_INFO("Total number of considered ID tracks         " << m_ntotTracks);
         ATH_MSG_INFO("Total number of ID tracks with angular match " << m_nangleMatch);
         ATH_MSG_INFO("Total number of preselected ID tracks        " << m_npmatch);
         ATH_MSG_INFO("Total number of ID tracks at MS entry        " << m_natMSEntrance);
         ATH_MSG_INFO("Total number of accepted ID tracks           " << m_naccepted);
         for (unsigned int i = 0; i < SurfDef::NumSurf; ++i) {
             const double recyc_extr = m_recycledIntersect[i] + m_extrapolated[i];
             auto calc_ratio = [&recyc_extr](unsigned int N) -> double { return recyc_extr > 0. ? 100. * N / recyc_extr : 0; };
             ATH_MSG_INFO("Layer " << m_surfaces.stationType(i) << " processed  " << int(recyc_extr) << " extrapolated " << m_extrapolated[i]
                                   << " (" << calc_ratio(m_extrapolated[i]) << " %) "
                                   << " recycled " << m_recycledIntersect[i] << " (" << calc_ratio(m_recycledIntersect[i]) << "%) "
                                   << " good " << m_goodExtrapolated[i] << " (" << calc_ratio(m_goodExtrapolated[i]) << "%)");
         }
         return StatusCode::SUCCESS;
     }

◆ findCandidateStations()

MuonSegmentTagTool::SortedSegmentMap MuonCombined::MuonSegmentTagTool::findCandidateStations	(	const MuonCombined::InDetCandidate &	Id_trk,
		const SortedSegmentMap &	filteredSegments
	)		const

private

Returns an array encoding which muon segments are compatible with the IdCandidate.

Definition at line 566 of file MuonSegmentTagTool.cxx.

                                                                                                                      {
         SortedSegmentMap sortedSegments;
  
         bool hasAngleMatch{false}, hasMatch{false};
         const Trk::Track* track = id_cand.indetTrackParticle().track();
         const Amg::Vector3D id_mom = track->perigeeParameters()->momentum();
  
         const double qID = track->perigeeParameters()->charge();
         const double pID = id_mom.mag();
  
         if (pID <= 20000. * (qID * id_mom.eta() - 2)) { return sortedSegments; }
  
         const Trk::CaloExtension* extension = id_cand.getCaloExtension();
         const Trk::TrackParameters* ms_entry = extension ? extension->muonEntryLayerIntersection() : nullptr;
         const double ThetaID = (ms_entry ? ms_entry->position() : id_mom).theta();
  
         std::vector<int> id_sectors;
         if (ms_entry) m_sectorMapping.getSectors(ms_entry->position().phi(), id_sectors);
         auto sector_match = [&, this](const Amg::Vector3D& seg_pos) -> bool {
             if (!ms_entry) return std::abs(qID * seg_pos.deltaPhi(id_mom) - qID / pID) < 0.6;
             std::vector<int> seg_sectors;
             m_sectorMapping.getSectors(seg_pos.phi(), seg_sectors);
             return std::find_if(id_sectors.begin(), id_sectors.end(), [&seg_sectors](const int id_sec) {
                        return std::find(seg_sectors.begin(), seg_sectors.end(), id_sec) != seg_sectors.end();
                    }) != id_sectors.end();
         };
  
         for (const auto& key_pair : filteredSegments) {
             const int surf_def = key_pair.first;
             const std::vector<const Muon::MuonSegment*>& source_vec = key_pair.second;
             std::vector<const Muon::MuonSegment*> target_vec;
             target_vec.reserve(source_vec.size());
             for (const Muon::MuonSegment* itSeg : source_vec) {
                 const Amg::Vector3D& pos = itSeg->globalPosition();
                 const double dTheta = pos.theta() - ThetaID;
                 const bool theta_match = ms_entry ? std::abs(dTheta) < 0.2 : (qID * dTheta < 0.2 && qID * dTheta > -0.6);
                 if (!theta_match) {
                     ATH_MSG_VERBOSE("dTheta cut failed");
                     continue;
                 }
                 if (!sector_match(pos)) {
                     ATH_MSG_VERBOSE("dPhi cut failed");
                     continue;
                 }
                 hasAngleMatch = true;
                 const Identifier chId = m_edmHelperSvc->chamberId(*itSeg);
                 if (!m_idHelperSvc->isCsc(chId)) hasMatch = true;
                 target_vec.push_back(itSeg);
             }
             if (target_vec.empty()) continue;
             sortedSegments[surf_def] = std::move(target_vec);
         }
         if (hasAngleMatch) ++m_nangleMatch;
         if (hasMatch)
             ++m_npmatch;
         else
             sortedSegments.clear();
         return sortedSegments;
     }

◆ findPopulatedStations()

MuonSegmentTagTool::SortedSegmentMap MuonCombined::MuonSegmentTagTool::findPopulatedStations ( const std::vector< const Muon::MuonSegment * > & filteredSegments ) const

private

Creates the sorted segment map.

Definition at line 553 of file MuonSegmentTagTool.cxx.

                                                                          {
         SortedSegmentMap sortedSegments{};
         for (const Muon::MuonSegment* itSeg : filteredSegments) {
             const Identifier chId = m_edmHelperSvc->chamberId(*itSeg);
             const int surf_def = MuonCombined::MuonSegmentTagSurfaces::stIdxToSurfDef(m_idHelperSvc->stationIndex(chId),
                                                                                       m_idHelperSvc->stationEta(chId) > 0);
             std::vector<const Muon::MuonSegment*>& surf_vec = sortedSegments[surf_def];
             if (surf_vec.empty()) surf_vec.reserve(filteredSegments.size());
             surf_vec.push_back(itSeg);
         }
         return sortedSegments;
     }

◆ getCandidateSegments()

std::vector< const Muon::MuonSegment * > MuonCombined::MuonSegmentTagTool::getCandidateSegments ( const std::vector< const Muon::MuonSegment * > & segments ) const

private

Filters the input segments based on the number of hits fit quality etc.

Update ME: Need to think about cuts for the NSW!

Definition at line 504 of file MuonSegmentTagTool.cxx.

                                                                  {
         if (!m_doSegmentsFilter) {
             ATH_MSG_VERBOSE("No segment filtering required. ");
             return segments;
         }
         std::vector<const Muon::MuonSegment*> FilteredSegmentCollection;
         FilteredSegmentCollection.reserve(segments.size());
  
         for (const Muon::MuonSegment* itSeg : segments) {
             int quality = m_segmentSelector->quality(*itSeg);
             ATH_MSG_DEBUG(" Segment quality " << quality);
             if (quality < m_segmentQualityCut) continue;
             Muon::IMuonSegmentHitSummaryTool::HitCounts hitCounts = m_hitSummaryTool->getHitCounts(*itSeg);
             if (hitCounts.ncscHits() > 0)
                 ATH_MSG_DEBUG(" CSC segment ");
             else {
                 if (hitCounts.nmdtHoles >= m_nmdtHoles) continue;
                 if (hitCounts.nmdtHits() < m_nmdtHits) continue;  // precision hits
                 if (hitCounts.nmdtHitsMl1 > 0 && hitCounts.nmdtHitsMl1 < m_nmdtHitsML) continue;
                 if (hitCounts.nmdtHitsMl2 > 0 && hitCounts.nmdtHitsMl2 < m_nmdtHitsML) continue;
                 // If Trigger hits are expected one should at least find one
                 ATH_MSG_DEBUG(" expected TrigHits " << hitCounts.nexpectedTrigHitLayers << " TrigHits found "
                                                     << hitCounts.nphiTrigHitLayers + hitCounts.netaTrigHitLayers);
                 if (m_triggerHitCut && hitCounts.nexpectedTrigHitLayers > 1 && hitCounts.nphiTrigHitLayers == 0 &&
                     hitCounts.netaTrigHitLayers == 0)
                     continue;
             }
             if (m_segmentQualityCut > 0) {
                 Identifier chId = m_edmHelperSvc->chamberId(*itSeg);
                 StationIndex stIndex = m_idHelperSvc->stationIndex(chId);
                 if (!m_triggerHitCut && stIndex == Muon::MuonStationIndex::EM) {
                     // don't apply the TGC requirement for the first station as it sometimes has not trigger hits due to TGC acceptance
                     int stationEta = m_idHelperSvc->stationEta(chId);
                     if (std::abs(stationEta) != 1) {
                         // remove EM segments without trigger hits
                         if (hitCounts.nphiTrigHitLayers == 0 && hitCounts.netaTrigHitLayers == 0) continue;
                     }
                 }
                 if (stIndex == Muon::MuonStationIndex::EI) {
                     // remove CSC segment with hits in only one projection
                     if (m_idHelperSvc->isCsc(chId) && !hitCounts.ncscHits.hasEtaAndPhi()) continue;
                 }
             }
             FilteredSegmentCollection.emplace_back(itSeg);
         }
         return FilteredSegmentCollection;
     }

◆ getPropDistance()

double MuonCombined::MuonSegmentTagTool::getPropDistance	(	const Trk::TrackParameters &	start_pars,
		const Trk::Surface &	target_surf
	)

inlinestaticprivate

Returns the straight line distance estimation of the parameters to the surface.

Definition at line 626 of file MuonSegmentTagTool.cxx.

                                                                                                                   {
         Trk::DistanceSolution distSol = target_surf.straightLineDistanceEstimate(start_pars.position(), start_pars.momentum().normalized());
         if (distSol.numberOfSolutions() > 0) return distSol.first();
         return distSol.toPointOfClosestApproach();
     }

◆ initialize()

StatusCode MuonCombined::MuonSegmentTagTool::initialize ( )

override

Definition at line 54 of file MuonSegmentTagTool.cxx.

                                               {
         ATH_CHECK(m_printer.retrieve());
         ATH_CHECK(m_MuTagMatchingTool.retrieve());
         ATH_CHECK(m_MuTagAmbiguitySolverTool.retrieve());
         ATH_CHECK(m_idHelperSvc.retrieve());
         ATH_CHECK(m_edmHelperSvc.retrieve());
         ATH_CHECK(m_segmentSelector.retrieve());
  
         ATH_MSG_INFO("Initializing MuonSegmentTagTool");
  
         ATH_MSG_DEBUG("Initialisation started                     ");
         ATH_MSG_DEBUG("================================           ");
         ATH_MSG_DEBUG("=Proprieties are                           ");
         ATH_MSG_DEBUG("================================           ");
         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()

static const InterfaceID& MuonCombined::IMuonSegmentTagTool::interfaceID ( )

inlinestaticinherited

Definition at line 27 of file IMuonSegmentTagTool.h.

                                                 {
             static const InterfaceID IID_IMuonSegmentTagTool("MuonCombined::IMuonSegmentTagTool", 1, 0);
             return IID_IMuonSegmentTagTool;
         }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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.

◆ printTable()

void MuonCombined::MuonSegmentTagTool::printTable	(	const std::vector< std::string > &	didEx,
		const std::vector< std::string > &	segStation,
		const std::vector< std::vector< std::string >> &	segToSurf
	)		const

private

method for extra DEBUG

Definition at line 464 of file MuonSegmentTagTool.cxx.

                                                                                                 {
         ATH_MSG_DEBUG(std::setw(6) << ""
                                    << "EX? (o: no extrap, X: extrap failed, V: extrap OK)");
  
         if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Surface" << std::setw(2) << "";
         for (unsigned int segment_counter = 0; segment_counter < segStation.size(); ++segment_counter) {
             if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << std::setw(10) << segStation[segment_counter];
         }
         if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << endmsg;
  
         unsigned int extrapolation_counter(0);
         std::string signstr("");
         if (m_doBidirectional) signstr = "+";
  
         for (int counter = 0; counter < SurfDef::NumSurf; ++counter) {
             if (msgLvl(MSG::DEBUG))
                 msg(MSG::DEBUG) << std::setw(5) << m_surfaces.stationType(counter) << signstr << std::setw(3)
                                 << didEx[extrapolation_counter];
             for (unsigned int segment_counter = 0; segment_counter < segStation.size(); ++segment_counter) {
                 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << std::setw(10) << (segToSurf[extrapolation_counter])[segment_counter];
             }  // end loop segments
             if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << endmsg;
             ++extrapolation_counter;
         }  // end loop surfaces
  
         if (m_doBidirectional) {
             signstr = "-";
             for (unsigned int counter = 0; counter < SurfDef::NumSurf; ++counter) {
                 if (msgLvl(MSG::DEBUG))
                     msg(MSG::DEBUG) << std::setw(5) << m_surfaces.stationType(counter) << signstr << std::setw(3)
                                     << didEx[extrapolation_counter];
                 for (unsigned int segment_counter = 0; segment_counter < segStation.size(); ++segment_counter) {
                     if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << std::setw(10) << (segToSurf[extrapolation_counter])[segment_counter];
                 }  // end loop segments
                 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << endmsg;
                 ++extrapolation_counter;
             }  // end loop surfaces
         }
     }

◆ 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();
   }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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.

◆ tag()

void MuonCombined::MuonSegmentTagTool::tag	(	const EventContext &	ctx,
		const InDetCandidateCollection &	inDetCandidates,
		const std::vector< const Muon::MuonSegment * > &	segments,
		InDetCandidateToTagMap *	tagMap
	)		const

overridevirtual

IMuonSegmentTagTool interface: build muons from ID and MuonSegments.

Associate the segments to the Track

Start the extrapolations through the spectrometer

update the extensions

Do not use the intersections in the back extrapolations

Actually this should never happen for the forward extrapolation

Segments found here

Recylce the intersections to get as close as possible to the target surfaces. In this case switch off the extrapolations

Find the intersection matching at best to the target surface

There exist tracks in the transition region between the endcaps & the barrel which have associated segment candidates with Barrel & Endcap like surfaces. However, if the previous surface was on a barrel and we start to extrapolate from the Barrel to an endcap like surface. It is very likely to fail hence use as a fall back the MS entrance again

Next surface succesfully reached

Some debugging statements

m_dotable

Check if there exists already a segment on the same surface. No need to redo the extrapolations twice

Implements MuonCombined::IMuonSegmentTagTool.

Definition at line 87 of file MuonSegmentTagTool.cxx.

                                                                                                                           {
         if (inDetCandidates.empty()) return;
  
         std::vector<const Muon::MuonSegment*> FilteredSegmentCollection = getCandidateSegments(segments);
  
         ATH_MSG_DEBUG("Filtered segments... in: " << segments.size() << ", out: " << FilteredSegmentCollection.size());
  
         if (FilteredSegmentCollection.empty()) return;
  
         unsigned int trackCount{0};
         ATH_MSG_DEBUG("performing tag of " << inDetCandidates.size() << " tracks with " << FilteredSegmentCollection.size()
                                            << " segments. ");
         // Checking which surfaces have segments, to avoid useless extrapolations
  
         const SortedSegmentMap populStat = findPopulatedStations(FilteredSegmentCollection);
  
         std::vector<MuonCombined::MuonSegmentInfo> segmentsInfoSelected;
         segmentsInfoSelected.reserve(FilteredSegmentCollection.size());
         for (const MuonCombined::InDetCandidate* idTP : inDetCandidates) {
             // ensure that the id trackparticle has a track
             // Ignore if this is a siAssociated disk (and property set).
             if (m_ignoreSiAssocated && idTP->isSiliconAssociated()) continue;
  
             ++trackCount;
  
             bool matchedSegment{false};
             const xAOD::TrackParticle& track = idTP->indetTrackParticle();
  
             //
             // Remove low p and low Field region defined by p < 6 and eta between 1.4-1.7
             //
             if (m_removeLowPLowFieldRegion) {
                 const double eta = std::abs(track.eta());
                 const double p = std::abs(1.0 / track.qOverP());
                 if (eta > 1.4 && eta < 1.7 && p < 6000.) continue;
             }
             ATH_MSG_DEBUG("Treating track " << trackCount << " " << idTP->toString());
  
             uint8_t numSCTHits{0}, numPixelHits{0};
             if (!track.summaryValue(numSCTHits, xAOD::numberOfSCTHits)) ATH_MSG_DEBUG("TrackParticle missing numberOfSCTHits");
             if (!track.summaryValue(numPixelHits, xAOD::numberOfPixelHits)) ATH_MSG_DEBUG("TrackParticle missing numberOfPixelHits");
  
             unsigned int nrIDetaHits = numSCTHits + numPixelHits;
             const bool trkEtaInfo = nrIDetaHits >= 5;
             if (!trkEtaInfo) ATH_MSG_DEBUG("Track has no ID eta information! (" << nrIDetaHits << " etaHits)");
  
             ++m_ntotTracks;
  
             const SortedSegmentMap assocStat = m_doBidirectional ? populStat : findCandidateStations(*idTP, populStat);
             if (assocStat.empty()) continue;
  
             const unsigned int num_assoc_segs =
                 std::accumulate(populStat.begin(), populStat.end(), 0,
                                 [](unsigned int N, const std::pair<int, std::vector<const Muon::MuonSegment*>>& seg_stat) {
                                     return N + seg_stat.second.size();
                                 });
  
             std::vector<MuonCombined::MuonSegmentInfo> segmentsInfo;
             segmentsInfo.reserve(num_assoc_segs);
             const int multiply = 1 + m_doBidirectional;
  
             std::optional<std::vector<std::string>> didExtrapolate =
                 m_doTable ? std::make_optional<std::vector<std::string>>(SurfDef::NumSurf * multiply, "o") : std::nullopt;
             std::optional<std::vector<std::string>> segStation =
                 m_doTable ? std::make_optional<std::vector<std::string>>(num_assoc_segs, "XXX") : std::nullopt;
             std::optional<std::vector<std::vector<std::string>>> trkToSegment =
                 m_doTable ? std::make_optional<std::vector<std::vector<std::string>>>(SurfDef::NumSurf * multiply, *segStation)
                           : std::nullopt;
  
             const int numberOfExtrapolations = 1 + m_doBidirectional;
             std::array<std::shared_ptr<const Trk::TrackParameters>, 2> trackAtMSEntrance;
  
             for (int i_extrapolations = 0; i_extrapolations < numberOfExtrapolations; ++i_extrapolations) {
                 // in case of along momentum extrapolation, use pre-existing extrapolation if available
                 const Trk::CaloExtension* extension = idTP->getCaloExtension();
                 const Muon::MuonSystemExtension* msExtension = idTP->getExtension();
                 std::vector<Intersection> intersections;
                 if (i_extrapolations == 0) {
                     if (msExtension) intersections = msExtension->layerIntersections();
                     if (extension && extension->muonEntryLayerIntersection()) {
                         const Trk::TrackParameters& pars = *extension->muonEntryLayerIntersection();
                         trackAtMSEntrance[i_extrapolations] = pars.uniqueClone();
                         ATH_MSG_DEBUG("Got MS entry pos: r " << pars.position().perp() << " z " << pars.position().z() << " momentum "
                                                              << pars.momentum().perp() << " cov " << pars.covariance());
                     }
                 } else
                     intersections.clear();
                 if (!trackAtMSEntrance[i_extrapolations]) {
                     trackAtMSEntrance[i_extrapolations] =
                         m_MuTagMatchingTool->ExtrapolateTrktoMSEntrance(ctx, *track.track(), Trk::alongMomentum);
                 }
  
                 if (!trackAtMSEntrance[i_extrapolations]) {
                     ATH_MSG_DEBUG("there is no track at MS entrance... not tagging for direction " << i_extrapolations);
                     continue;
                 }
                 ++m_natMSEntrance;
  
                 std::shared_ptr<const Trk::TrackParameters> atSurface{trackAtMSEntrance[i_extrapolations]},
                     nextSurface{trackAtMSEntrance[i_extrapolations]};
                 bool barrel_extp{false}, endcap_extp{false};
  
                 ATH_MSG_DEBUG("Start extrapolation " << i_extrapolations << " found in total " << num_assoc_segs
                                                      << " associated segments.");
  
                 for (auto& stat_pair : assocStat) {
                     const int surface_counter = stat_pair.first;
                     const int extrapolation_counter = i_extrapolations * SurfDef::NumSurf + surface_counter;
                     const std::vector<const Muon::MuonSegment*>& targets = stat_pair.second;
  
                     ATH_MSG_DEBUG("Surface " << m_surfaces.stationType(surface_counter));
                     if (m_doTable) (*didExtrapolate)[extrapolation_counter] = "X";
  
                     std::optional<std::vector<std::string>> segVsSurf =
                         m_doTable ? std::make_optional<std::vector<std::string>>(num_assoc_segs, "xxx") : std::nullopt;
                     const Trk::Surface* surface = m_surfaces.getSurface(surface_counter);
  
                     const bool is_barrel = surface_counter < SurfDef::EIA;
                     bool extrapolate{true};
                     if (!intersections.empty()) {
                         const bool is_aside = surface_counter < SurfDef::EIC;
                         Intersection best_intersec;
                         for (const Intersection& intersect : intersections) {
                             if (m_surfaces.stIdxToSurfDef(intersect.layerSurface.stIndex(), is_aside) != surface_counter) continue;
                             if (!best_intersec.trackParameters || std::abs(getPropDistance(*intersect.trackParameters, *surface)) <
                                                                       std::abs(getPropDistance(*best_intersec.trackParameters, *surface)))
                                 best_intersec = intersect;
                         }
                         if (best_intersec.trackParameters) {
                             atSurface = best_intersec.trackParameters;
                             extrapolate = false;
                             barrel_extp |= is_barrel;
                             endcap_extp |= !is_barrel;
                             ++m_recycledIntersect[surface_counter];
                         }
                     }
  
                     if (extrapolate) {
                         if (m_doTable) (*didExtrapolate)[extrapolation_counter] = "V";
                         if (!is_barrel && barrel_extp && !endcap_extp) {
                             atSurface = trackAtMSEntrance[i_extrapolations];
                             endcap_extp = true;
                         }
                         const Trk::PropDirection surf_dir =
                             getPropDistance(*atSurface, *surface) > 0 ? Trk::alongMomentum : Trk::oppositeMomentum;
                         ATH_MSG_DEBUG("Extrapolate " << m_surfaces.stationType(surface_counter) << " from (" << atSurface->position().perp()
                                                      << ", " << atSurface->position().z() << "), to  surface "
                                                      << "(" << surface->globalReferencePoint().perp() << ","
                                                      << surface->globalReferencePoint().z() << ") "
                                                      << (surf_dir == Trk::alongMomentum ? "along" : "opposite") << " momentum");
  
                         nextSurface = m_MuTagMatchingTool->ExtrapolateTrktoMSSurface(ctx, *surface, *atSurface, surf_dir);
                         ++m_extrapolated[surface_counter];
                         if (nextSurface) {
                             atSurface = nextSurface;
                             barrel_extp |= is_barrel;
                             endcap_extp |= !is_barrel;
                             if (m_doTable) (*trkToSegment)[extrapolation_counter] = (*segVsSurf);
                         } else {
                             continue;
                         }
                     } else if (m_doTable)
                         (*didExtrapolate)[extrapolation_counter] = "S";
  
                     ++m_goodExtrapolated[surface_counter];
  
                     std::vector<SegmentExtrCache> seg_extps{};
                     seg_extps.reserve(targets.size());
                     ATH_MSG_VERBOSE("Perform segment matching");
                     int segmentCount{-1};  // Variable used for debugging
                     for (const Muon::MuonSegment* seg_ptr : targets) {
                         ++segmentCount;
                         if (m_doTable) { (*segStation)[segmentCount] = "   "; }
  
                         bool isMatched{false};
                         if (!m_doTable) {
                             isMatched = m_MuTagMatchingTool->match(*atSurface, *seg_ptr, surface_counter);
                         } else {
                             if (!m_MuTagMatchingTool->surfaceMatch(*seg_ptr, surface_counter)) {
                                 (*segVsSurf)[segmentCount] = "surface";
                                 continue;
                             }
                             ATH_MSG_VERBOSE("treating track " << trackCount << " (extrapolation = " << i_extrapolations << ") and Segment "
                                                               << (*segStation)[segmentCount] << " (segment " << segmentCount << ")");
  
                             if (!m_MuTagMatchingTool->phiMatch(*atSurface, *seg_ptr)) {
                                 (*segVsSurf)[segmentCount] = "RghPhi";
                                 continue;
                             }
                             if (trkEtaInfo) {
                                 if (is_barrel) {
                                     if (!m_MuTagMatchingTool->thetaMatch(*atSurface, *seg_ptr)) {
                                         (*segVsSurf)[segmentCount] = "RghTheta";
                                         continue;
                                     }
                                 } else {
                                     if (!m_MuTagMatchingTool->rMatch(*atSurface, *seg_ptr)) {
                                         (*segVsSurf)[segmentCount] = "RghR";
                                         continue;
                                     }
                                 }
                                 isMatched = true;
                             } else {  // trk has no eta info
                                 ATH_MSG_DEBUG("bypassed roughEta/roughR cut since ID has no eta info!");
                                 isMatched = true;
                             }
                         }  
  
                         if (!isMatched) {
                             if (m_doTable) {
                                 ATH_MSG_DEBUG("isMatched is " << isMatched << " at this point, incoherent!");
                                 if (!trkEtaInfo)
                                     (*segVsSurf)[segmentCount] = "posPhi";
                                 else
                                     (*segVsSurf)[segmentCount] = "pos";
                             }
                             continue;
                         }
  
                         std::shared_ptr<const Trk::AtaPlane> atSegSurface;
                         std::vector<SegmentExtrCache>::const_iterator cache_itr = std::find_if(
                             seg_extps.begin(), seg_extps.end(),
                             [seg_ptr](const SegmentExtrCache& cache) { return cache.segment_surface == &(seg_ptr->associatedSurface()); });
                         if (cache_itr != seg_extps.end()) {
                             atSegSurface = cache_itr->segment_pars;
                             ATH_MSG_DEBUG("Recycle extrapolation");
                         } else {
                             const Trk::PropDirection seg_dir =
                                 getPropDistance(*atSurface, seg_ptr->associatedSurface()) > 0 ? Trk::alongMomentum : Trk::oppositeMomentum;
                             ATH_MSG_DEBUG("Extrapolate "
                                           << m_surfaces.stationType(surface_counter) << " from (" << atSurface->position().perp() << ", "
                                           << atSurface->position().z() << "), to  segment "
                                           << "(" << seg_ptr->globalPosition().perp() << "," << seg_ptr->globalPosition().z() << ") "
                                           << (seg_dir == Trk::alongMomentum ? "along" : "opposite") << " momentum");
                             atSegSurface = m_MuTagMatchingTool->ExtrapolateTrktoSegmentSurface(ctx, *seg_ptr, *atSurface, seg_dir);
                             seg_extps.emplace_back(atSegSurface, seg_ptr->associatedSurface());
                         }
                         if (!atSegSurface || !atSegSurface->covariance() || !Amg::hasPositiveDiagElems(*atSegSurface->covariance()))
                             continue;
                         const AmgSymMatrix(5) invCov = atSegSurface->covariance()->inverse();
                         if (!Amg::hasPositiveDiagElems(invCov)) continue;
  
                         MuonCombined::MuonSegmentInfo info =
                             m_MuTagMatchingTool->muTagSegmentInfo(ctx, track.track(), *seg_ptr, atSegSurface);
                         isMatched = m_MuTagMatchingTool->matchSegmentPosition(info, trkEtaInfo);
                         if (!isMatched) {
                             if (m_doTable) {
                                 if (!trkEtaInfo)
                                     (*segVsSurf)[segmentCount] = "posPhi";
                                 else
                                     (*segVsSurf)[segmentCount] = "pos";
                             }
                             continue;
                         }
                         isMatched = m_MuTagMatchingTool->matchSegmentDirection(info, trkEtaInfo);
  
                         if (!isMatched) {
                             if (m_doTable) {
                                 if (!trkEtaInfo)
                                     (*segVsSurf)[segmentCount] = "dirPhi";
                                 else
                                     (*segVsSurf)[segmentCount] = "dir";
                             }
                             continue;
                         }
  
                         isMatched = m_MuTagMatchingTool->matchDistance(info);
  
                         if (!isMatched) {
                             if (m_doTable) { (*segVsSurf)[segmentCount] = "dist"; }
                             continue;
                         }
  
                         isMatched = m_MuTagMatchingTool->matchCombinedPull(info);
                         if (!isMatched) {
                             if (m_doTable) { (*segVsSurf)[segmentCount] = "cpull"; }
                             continue;
                         }
  
                         if (m_doPtDependentPullCut) {
                             isMatched = m_MuTagMatchingTool->matchPtDependentPull(info, *track.track());
                             if (!isMatched) {
                                 if (m_doTable) { (*segVsSurf)[segmentCount] = "ptpull"; }
                                 continue;
                             }
                         }
                         if (m_doTable) (*segVsSurf)[segmentCount] = "TAG";
                         matchedSegment = true;
                         ATH_MSG_DEBUG("Tagged the track with Segment " << segmentCount);
  
                         segmentsInfo.push_back(std::move(info));
  
                     }  // end loop over segments
  
                     if (m_doTable) (*trkToSegment)[extrapolation_counter] = (*segVsSurf);
                 }  // end loop over MS surfaces
  
             }  // end loop over nr Directions of extrapolation.
  
             if (m_doTable) { printTable(*didExtrapolate, *segStation, *trkToSegment); }
  
             if (!matchedSegment) {
                 ATH_MSG_DEBUG("ID " << std::setw(3) << trackCount << " could not be matched with any segment on any abstract surface");
                 continue;
             }
  
             // The loop over SM surfaces yielded matches for the extrapolated track.
             // Per match, a MuTagObject is created and added to the MuTagObjectContainer
             // A Track which has at least one match with the extrapolated track may be called a muon
             //----------------------------------------------------------------
             //----------------------------------------------------------------
             if (!segmentsInfo.empty()) {
                 ++m_naccepted;
                 ATH_MSG_DEBUG("number of accepted tracks " << m_naccepted << " segmentsInfo size " << segmentsInfo.size());
  
                 std::vector<MuonCombined::MuonSegmentInfo> segmentsInfoSolved =
                     m_MuTagAmbiguitySolverTool->selectBestMuTaggedSegments(ctx, segmentsInfo);
                 segmentsInfoSelected.insert(segmentsInfoSelected.end(), std::make_move_iterator(segmentsInfoSolved.begin()),
                                             std::make_move_iterator(segmentsInfoSolved.end()));
                 ATH_MSG_DEBUG("segmentsInfoSelected size " << segmentsInfoSelected.size());
             }
  
         }  // end loop over tracks
  
         ATH_MSG_DEBUG("segmentsInfoSelected size after track loop " << segmentsInfoSelected.size());
         std::vector<MuonCombined::MuonSegmentInfo> segmentsInfoFinal =
             m_MuTagAmbiguitySolverTool->solveAmbiguities(ctx, segmentsInfoSelected);
         ATH_MSG_DEBUG("segmentsInfoFinal size " << segmentsInfoFinal.size());
  
         if (msgLevel(MSG::DEBUG)) {
             for (unsigned int ns1 = 0; ns1 < segmentsInfoFinal.size(); ++ns1) {
                 if (ns1 == 0)
                     ATH_MSG_DEBUG(m_printer->print(*segmentsInfoFinal[ns1].track));
                 else if (segmentsInfoFinal[ns1].track != segmentsInfoFinal[ns1 - 1].track)
                     ATH_MSG_DEBUG(m_printer->print(*segmentsInfoFinal[ns1].track));
                 ATH_MSG_DEBUG(m_printer->print(*segmentsInfoFinal[ns1].segment));
             }
         }
  
         for (const InDetCandidate* idTP : inDetCandidates) {
             const Trk::Track* track = idTP->indetTrackParticle().track();
             std::vector<MuonCombined::MuonSegmentInfo> segmentsInfoTag;
             segmentsInfoTag.reserve(segmentsInfoFinal.size());
  
             for (unsigned int ns1 = 0; ns1 < segmentsInfoFinal.size(); ++ns1) {
                 if (segmentsInfoFinal[ns1].track == track && segmentsInfoFinal[ns1].nsegments > 0) {
                     segmentsInfoTag.push_back(segmentsInfoFinal[ns1]);
                 }
             }
             if (segmentsInfoTag.empty()) continue;
             ATH_MSG_DEBUG("make Segment Tag object for " << m_printer->print(*track) << " nr segments " << segmentsInfoTag.size());
             SegmentTag* tag = new SegmentTag(segmentsInfoTag);
             tagMap->addEntry(idTP, tag);
         }
     }

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

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/3]

std::array<std::atomic_uint, SurfDef::NumSurf> m_extrapolated MuonCombined::MuonSegmentTagTool::ATLAS_THREAD_SAFE {0}

mutableprivate

Definition at line 111 of file MuonSegmentTagTool.h.

◆ ATLAS_THREAD_SAFE [2/3]

std::array<std::atomic_uint, SurfDef::NumSurf> m_goodExtrapolated MuonCombined::MuonSegmentTagTool::ATLAS_THREAD_SAFE {0}

mutableprivate

Definition at line 112 of file MuonSegmentTagTool.h.

◆ ATLAS_THREAD_SAFE [3/3]

std::array<std::atomic_uint, SurfDef::NumSurf> m_recycledIntersect MuonCombined::MuonSegmentTagTool::ATLAS_THREAD_SAFE {0}

mutableprivate

Definition at line 113 of file MuonSegmentTagTool.h.

◆ 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_doBidirectional

Gaudi::Property<bool> MuonCombined::MuonSegmentTagTool::m_doBidirectional

private

Initial value:

{this, "DoBidirectionalExtrapolation", false,

"flag to toggle to bidirectional extrapolation"}

Definition at line 87 of file MuonSegmentTagTool.h.

◆ m_doPtDependentPullCut

Gaudi::Property<bool> MuonCombined::MuonSegmentTagTool::m_doPtDependentPullCut {this, "DoPtDependentPullCut", false, "flag to enable the pT-dependent pull cut"}

private

Definition at line 89 of file MuonSegmentTagTool.h.

◆ m_doSegmentsFilter

Gaudi::Property<bool> MuonCombined::MuonSegmentTagTool::m_doSegmentsFilter {this, "DoSegmentsFilter", true, "flag to switch segment filtering on/off (for trigger)"}

private

Definition at line 85 of file MuonSegmentTagTool.h.

◆ m_doTable

Gaudi::Property<bool> MuonCombined::MuonSegmentTagTool::m_doTable {this, "DoOverviewTable", false}

private

Definition at line 86 of file MuonSegmentTagTool.h.

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonCombined::MuonSegmentTagTool::m_edmHelperSvc

private

Initial value:

{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",

"Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 72 of file MuonSegmentTagTool.h.

◆ 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_hitSummaryTool

ToolHandle<Muon::IMuonSegmentHitSummaryTool> MuonCombined::MuonSegmentTagTool::m_hitSummaryTool

private

Initial value:

{this, "MuonSegmentHitSummaryTool",

"remove track with p < 6 GeV in eta 1.4-17 region (low p and low field)"}

Definition at line 90 of file MuonSegmentTagTool.h.

◆ m_sectorMapping

const Muon::MuonSectorMapping MuonCombined::MuonSegmentTagTool::m_sectorMapping {}

private

sector mapping helper

Definition at line 104 of file MuonSegmentTagTool.h.

◆ m_segmentQualityCut

Gaudi::Property<int> MuonCombined::MuonSegmentTagTool::m_segmentQualityCut {this, "SegmentQualityCut", 1, "minimum segment quality"}

private

Definition at line 93 of file MuonSegmentTagTool.h.

◆ m_segmentSelector

ToolHandle<Muon::IMuonSegmentSelectionTool> MuonCombined::MuonSegmentTagTool::m_segmentSelector

private

Initial value:

{this, "MuonSegmentSelectionTool",

"Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool"}

Definition at line 80 of file MuonSegmentTagTool.h.

◆ m_surfaces

const MuonCombined::MuonSegmentTagSurfaces MuonCombined::MuonSegmentTagTool::m_surfaces {}

private

Definition at line 102 of file MuonSegmentTagTool.h.

◆ m_triggerHitCut

Gaudi::Property<bool> MuonCombined::MuonSegmentTagTool::m_triggerHitCut {this, "TriggerHitCut", true, "apply Trigger hit cut if trigger hits are expected"}

private

Definition at line 98 of file MuonSegmentTagTool.h.

◆ 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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ SegmentMap

◆ SortedSegmentMap

◆ StoreGateSvc_t

◆ SurfDef

Constructor & Destructor Documentation

◆ MuonSegmentTagTool()

◆ ~MuonSegmentTagTool()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ findCandidateStations()

◆ findPopulatedStations()

◆ getCandidateSegments()

◆ getPropDistance()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ printTable()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ tag()

◆ updateVHKA()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/3]

◆ ATLAS_THREAD_SAFE [2/3]

◆ ATLAS_THREAD_SAFE [3/3]

◆ m_detStore

◆ m_doBidirectional

◆ m_doPtDependentPullCut

◆ m_doSegmentsFilter

◆ m_doTable

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_hitSummaryTool

◆ m_idHelperSvc

◆ m_ignoreSiAssocated

◆ m_MuTagAmbiguitySolverTool

◆ m_MuTagMatchingTool

◆ m_naccepted

◆ m_nangleMatch

◆ m_natMSEntrance

◆ m_nmdtHits

◆ m_nmdtHitsML

◆ m_nmdtHoles

◆ m_npmatch

◆ m_ntotTracks

◆ m_printer

◆ m_removeLowPLowFieldRegion

◆ m_sectorMapping

◆ m_segmentQualityCut

◆ m_segmentSelector

◆ m_surfaces