The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg. More...

#include <MuonInDetToMuonSystemExtensionAlg.h>

Inheritance diagram for MuonInDetToMuonSystemExtensionAlg:

Collaboration diagram for MuonInDetToMuonSystemExtensionAlg:

Classes
struct	InDetCandidateCache

struct	MuidCoCache
	Helper struct to cache the MuidCo track and it's associated segments while keeping the association InDetCandidate <– > muidCo Tag. More...

Public Member Functions
	MuonInDetToMuonSystemExtensionAlg (const std::string &name, ISvcLocator *pSvcLocator)

	~MuonInDetToMuonSystemExtensionAlg ()=default

StatusCode	initialize () override

StatusCode	execute (const EventContext &ctx) const override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. 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	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

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	MuidCoVector = std::vector< MuidCoCache >

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	selectCandidates (const EventContext &ctx, InDetCandidateCache &cache) const
	Select the MuidCo candidates and put the associated id tracks on a black list. More...

StatusCode	findHitSectors (const EventContext &ctx, InDetCandidateCache &output_cache) const
	Find the sectors in the MS with muon signals. More...

StatusCode	findSegments (const EventContext &ctx, InDetCandidateCache &output_cache) const
	Select good segments. More...

bool	hasMatchingSegment (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
	Searches for segments within theta < 0.2 && sharing the same sector. More...

bool	hasMatchingSeed (const MuonCombined::InDetCandidate &id_cand, const InDetCandidateCache &cache) const
	Searches for hough seeds within theta < 0.2 && sharing the same sector. More...

StatusCode	create (const EventContext &ctx, InDetCandidateCache &cache) const
	Create the InDetCandidaes with system extensions. More...

StatusCode	createStaus (const EventContext &ctx, const InDetCandidateCollection *ext_candidates, const MuidCoVector &tag_map) const

void	maskHits (const Muon::MuonSegment *muon_seg, InDetCandidateCache &output_cache) const
	Mask the hits of the corresponding muon segment as used. 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...

Private Attributes
SG::ReadHandleKey< InDetCandidateCollection >	m_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}

SG::WriteHandleKey< InDetCandidateCollection >	m_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}
	Collection of InDet candidates written for MuGirl and MuonSegmentTag. More...

SG::WriteHandleKey< InDetCandidateCollection >	m_stauInDetCandKey {this, "WriteStauCandidates", ""}
	Collection of InDet candidates written for MuGirlStau. More...

SG::ReadHandleKey< Muon::HoughDataPerSectorVec >	m_houghDataPerSectorVecKey
	Use the hough data to find sectors in the speectrometer traversed by a muon. More...

SG::ReadHandleKey< Trk::SegmentCollection >	m_segmentKey
	Let's exploit the segments to get rid of as much tracks as possible. More...

PublicToolHandle< Muon::IMuonSegmentSelectionTool >	m_segmentSelector

ToolHandle< Muon::IMuonSystemExtensionTool >	m_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}
	The system extension tool extrapolates the candidate through the spectrometer. More...

SG::ReadHandleKey< MuonCombined::InDetCandidateToTagMap >	m_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}
	That is the collection of MuidCo candidates. More...

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

ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc

Gaudi::Property< bool >	m_restrictExtension {this, "UseOnlyHitSectors", false}
	Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded. More...

Gaudi::Property< int >	m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}
	The hough maxima always contain at least 2 hits. More...

Gaudi::Property< int >	m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}

Gaudi::Property< bool >	m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}
	Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates. More...

Gaudi::Property< float >	m_extThreshold {this, "ExtensionPtThreshold", 2500}
	Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer. More...

Gaudi::Property< bool >	m_extendSAF {this, "ExtendSAF", false}
	Shall SAF tracks be equiped with a muon system extension used by MuGirl later. More...

Gaudi::Property< bool >	m_extendBulk {this, "ExtendBulk", true}
	Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later. More...

const Muon::MuonSectorMapping	m_sector_mapping {}

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

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

The MuonInDetToMuonSystemExtensionAlg processes further the InDetCandidates created by the MuonCombinedInDetCandidateAlg.

The idea is that the latter is only selecting the Id tracks based on the outcome of the Id selection tool and whether a CaloExtension could be successfully attached. This information is full sufficient to run the MuonCombinedAlg and the MuonCalo algorithms, but not the SegmentTagging or muGirl. InDetCandidates, not combined to a full muon track by MuidCo (STACO generates to much noise) are copied and then equipped with the muonSystem extension.

Definition at line 34 of file MuonInDetToMuonSystemExtensionAlg.h.

Member Typedef Documentation

◆ MuidCoVector

using MuonInDetToMuonSystemExtensionAlg::MuidCoVector = std::vector<MuidCoCache>

private

Definition at line 76 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonInDetToMuonSystemExtensionAlg()

MuonInDetToMuonSystemExtensionAlg::MuonInDetToMuonSystemExtensionAlg	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Definition at line 31 of file MuonInDetToMuonSystemExtensionAlg.cxx.

31 :

32 AthReentrantAlgorithm(name, pSvcLocator) {}

◆ ~MuonInDetToMuonSystemExtensionAlg()

MuonInDetToMuonSystemExtensionAlg::~MuonInDetToMuonSystemExtensionAlg ( )

default

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ create()

StatusCode MuonInDetToMuonSystemExtensionAlg::create	(	const EventContext &	ctx,
		InDetCandidateCache &	cache
	)		const

private

Create the InDetCandidaes with system extensions.

We want these tracks to be extrapolated through the spectrometer reject those no meeting the basic requirements

Prepare the system extension

The candidate already has somehow a system extension --> it's just a matter of copying it

The system extension does not own the MuonEntryLayerIntersection()-> it's fine

If the id candidate has a matching segment, then we know that this track can be potentially reconstructed by MuTagIMO

Definition at line 101 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                   {
     for (const MuonCombined::InDetCandidate* candidate : *out_cache.input_candidates) {
         if (out_cache.excluded_trks.count(candidate)) {
             ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " has already been used by MuidCo");
             continue;
         }
         if (candidate->indetTrackParticle().pt() < m_extThreshold || (!m_extendSAF && candidate->isSiliconAssociated()) ||
             (!m_extendBulk && !candidate->isSiliconAssociated())) {
             ATH_MSG_VERBOSE("Inner detector track " << candidate->toString() << " is too soft");
             continue;
         }
  
         Muon::IMuonSystemExtensionTool::SystemExtensionCache cache;
         cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(candidate->indetTrackParticleLink());
         cache.candidate->setSiliconAssociated(candidate->isSiliconAssociated());
         cache.candidate->setExtension(candidate->getCaloExtension());
  
         const Muon::MuonSystemExtension* extension = candidate->getExtension();
         if (extension) {
             std::vector<Muon::MuonSystemExtension::Intersection> intersects = extension->layerIntersections();
             cache.candidate->setExtension(
                 std::make_unique<Muon::MuonSystemExtension>(&extension->muonEntryLayerIntersection(), std::move(intersects)));
         } else {
             const bool seg_match = !m_restrictExtension || hasMatchingSegment(*candidate, out_cache);
  
             if (!seg_match && !hasMatchingSeed(*candidate, out_cache)) continue;
             cache.useHitSectors = !seg_match;
             cache.sectorsWithHits = &out_cache.hit_sectors;
             cache.createSystemExtension = true;
             cache.requireSystemExtension = true;
  
             if (!m_muonSystemExtensionTool->muonSystemExtension(ctx, cache)) {
                 ATH_MSG_VERBOSE("Extension failed");
                 continue;
             }
         }
         out_cache.outputContainer->push_back(std::move(cache.candidate));
     }
     if (msgLevel(MSG::DEBUG)) {
         std::stringstream sstr;
         for (const MuonCombined::InDetCandidate* extended : *out_cache.outputContainer) {
             sstr << "   * " << extended->toString() << std::endl;
         }
         if (!out_cache.excluded_trks.empty()) {
             sstr << std::endl << " ======== The following tracks were already successfully combined  ======== " << std::endl;
             for (const MuonCombined::InDetCandidate* combined : out_cache.excluded_trks) {
                 sstr << "   = " << combined->toString() << std::endl;
             }
         }
         if (out_cache.excluded_trks.size() + out_cache.outputContainer->size() != out_cache.input_candidates->size()) {
             sstr << std::endl << " ++++++++ The following candidates were not extrapolated  ++++++++  " << std::endl;
             const InDetCandidateCollection::const_iterator begin = out_cache.outputContainer->begin();
             const InDetCandidateCollection::const_iterator end = out_cache.outputContainer->end();
  
             for (const MuonCombined::InDetCandidate* rejected : *out_cache.input_candidates) {
                 if (out_cache.excluded_trks.count(rejected) ||
                     std::find_if(begin, end,
                                  [rejected](const MuonCombined::InDetCandidate* extended) { return (*rejected) == (*extended); }) != end)
                     continue;
                 sstr << "   + " << rejected->toString() << std::endl;
             }
         }
         ATH_MSG_DEBUG("Extrapolated " << out_cache.outputContainer->size() << " out of " << out_cache.input_candidates->size()
                                       << " tracks through the spectrometer" << std::endl
                                       << std::endl
                                       << sstr.str());
     }
     return StatusCode::SUCCESS;
 }

◆ createStaus()

StatusCode MuonInDetToMuonSystemExtensionAlg::createStaus	(	const EventContext &	ctx,
		const InDetCandidateCollection *	ext_candidates,
		const MuidCoVector &	tag_map
	)		const

private

This will copy the existing candidates to the new container without calling the system extension tool

For the staus it is quite unclear what is the overlap between MuidCo and MuGirlStau. So in order to be on the safe side we add the MuidCo candidate tracks as well, but we also try to avoid the extrapolator like a cat does for a bubble bath. By taking the perigee parameters of the associated muon segments, we have a much much shorter path to extrapolate the track to the MuonLayerInterSection surfaces.

Definition at line 337 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                              {
     if (m_stauInDetCandKey.empty()) {
         ATH_MSG_VERBOSE("No candidates for stau reconstruction will be written");
         return StatusCode::SUCCESS;
     }
     ATH_MSG_DEBUG("Now find the candidates to be considered for MuGirlStau");
     InDetCandidateCache stau_cache{};
     stau_cache.input_candidates = ext_candidates;
  
     ATH_CHECK(create(ctx, stau_cache));
     for (const MuidCoCache& idMuidCo : tag_map) {
         Muon::IMuonSystemExtensionTool::SystemExtensionCache cache;
         cache.candidate = std::make_unique<MuonCombined::InDetCandidate>(idMuidCo.id_trk->indetTrackParticleLink());
         cache.candidate->setSiliconAssociated(idMuidCo.id_trk->isSiliconAssociated());
         cache.candidate->setExtension(idMuidCo.id_trk->getCaloExtension());
         cache.useHitSectors = false;
         cache.createSystemExtension = true;
         cache.requireSystemExtension = true;
  
         if (!m_muonSystemExtensionTool->muonLayerInterSections(ctx, *idMuidCo.cmb_trk, cache)) {
             ATH_MSG_DEBUG("Could not determine the intersections. Although that should be possible");
             continue;
         }
         stau_cache.outputContainer->push_back(std::move(cache.candidate));
     }
  
     SG::WriteHandle<InDetCandidateCollection> indetCandidateCollection(m_stauInDetCandKey, ctx);
     ATH_CHECK(indetCandidateCollection.record(std::move(stau_cache.outputContainer)));
     return StatusCode::SUCCESS;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

◆ execute()

StatusCode MuonInDetToMuonSystemExtensionAlg::execute ( const EventContext & ctx ) const

override

Definition at line 49 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                    {
     InDetCandidateCache output_cache{};
  
     SG::ReadHandle<InDetCandidateCollection> input_container{m_inputCandidate, ctx};
     if (!input_container.isValid()) {
         ATH_MSG_FATAL("Failed to retrieve " << m_inputCandidate.fullKey());
         return StatusCode::FAILURE;
     }
     output_cache.input_candidates = input_container.cptr();
     ATH_CHECK(selectCandidates(ctx, output_cache));
  
     if (m_restrictExtension) {
         ATH_CHECK(findSegments(ctx, output_cache));
         ATH_CHECK(findHitSectors(ctx, output_cache));
     }
  
     ATH_MSG_DEBUG("Find the inner detector candidates to be used for MuGirl / Segment tagging");
     ATH_CHECK(create(ctx, output_cache));
     SG::WriteHandle<InDetCandidateCollection> indetCandidateCollection(m_bulkInDetCandKey, ctx);
     ATH_CHECK(indetCandidateCollection.record(std::move(output_cache.outputContainer)));
  
     ATH_CHECK(createStaus(ctx, indetCandidateCollection.ptr(), output_cache.tag_map));
  
     return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ findHitSectors()

StatusCode MuonInDetToMuonSystemExtensionAlg::findHitSectors	(	const EventContext &	ctx,
		InDetCandidateCache &	output_cache
	)		const

private

Find the sectors in the MS with muon signals.

Helper function to cound whether all three stations are actually complete

The phi-hit vector has a size of 3 representing the forward-backward and barrel sections

Hits built into a MuidCo track

Subtract the hits used by MuidCo from the hough seeds

Find the chamber with the largest number of hits

Average the theta

Loop over the maxima & find the hit sectors

Remove all hits from the seed that are built into a segment

If the seed has still more than the minimum. Then let's mark the sector as hit

Cache the eta value additionally

Definition at line 178 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                              {
     SG::ReadHandle<Muon::HoughDataPerSectorVec> readHandle{m_houghDataPerSectorVecKey, ctx};
     if (!readHandle.isValid()) {
         ATH_MSG_FATAL("Failed to retrieve the prep data container " << m_houghDataPerSectorVecKey.fullKey());
         return StatusCode::FAILURE;
     }
     const std::vector<Muon::HoughDataPerSec>& hough_data = readHandle->vec;
     auto count_finished = [&output_cache]() -> unsigned int {
         unsigned int n{0};
         for (const auto& sector_hits : output_cache.hit_sectors) { n += sector_hits.second.size() >= num_sectors; }
         return n;
     };
  
     for (int det_region = 0; det_region < Muon::MuonStationIndex::DetectorRegionIndexMax; ++det_region) {
         const RegionIndex region_index = static_cast<RegionIndex>(det_region);
         for (int layer = 0; layer < Muon::MuonStationIndex::LayerIndexMax; ++layer) {
             const LayerIndex layer_index = static_cast<LayerIndex>(layer);
             const unsigned int hash = Muon::MuonStationIndex::sectorLayerHash(region_index, layer_index);
             const std::set<Identifier>& masked_hits = output_cache.consumed_hits[hash];
  
             auto num_hough_hits = [&masked_hits, this](const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& hough_maximum) {
                 std::map<Identifier, hough_chamber> chamber_counts;
                 for (const std::shared_ptr<MuonHough::Hit>& hough_hit : hough_maximum->hits) {
                     const Trk::PrepRawData* prep = prepData(hough_hit);
                     const Identifier chId = prep->identify();
                     if (masked_hits.count(chId) || (m_excludeNSW && (m_idHelperSvc->isMM(chId) || m_idHelperSvc->issTgc(chId)))) {
                         ATH_MSG_VERBOSE("Do not reuse hit " << m_idHelperSvc->toString(chId));
                         continue;
                     }
                     ATH_MSG_VERBOSE("Count hough hit " << m_idHelperSvc->toString(chId));
                     // Split the seeds into the chambers
                     hough_chamber& chamber = chamber_counts[m_idHelperSvc->chamberId(chId)];
                     ++chamber.nhits;
                     const Amg::Vector3D glob_pos = prep->detectorElement()->center(chId);
                     chamber.eta += glob_pos.eta();
                     chamber.sectors.insert(m_sector_mapping.getSector(glob_pos.phi()));
                 }
                 hough_chamber N{};
                 for (auto& ch_it : chamber_counts) {
                     if (N.nhits < ch_it.second.nhits) { N = std::move(ch_it.second); }
                 }
                 N.eta /= std::max(N.nhits, 1);
                 return N;
             };
  
             for (const Muon::HoughDataPerSec& sector_data : hough_data) {
                 const Muon::HoughDataPerSec::MaximumVec& eta_hits = sector_data.maxVec[hash];
                 for (const std::shared_ptr<MuonHough::MuonLayerHough::Maximum>& maxima : eta_hits) {
                     const hough_chamber effect_hits = num_hough_hits(maxima);
                     if (m_houghMin > effect_hits.nhits) continue;
                     ATH_MSG_VERBOSE("Hough maximum in " << Muon::MuonStationIndex::regionName(region_index) << ", "
                                                         << Muon::MuonStationIndex::layerName(layer_index)
                                                         << ", hits: " << effect_hits.nhits);
  
                     for (const int sector : effect_hits.sectors) {
                         output_cache.hit_sectors[region_index].insert(sector);
                         output_cache.eta_seeds[sector].push_back(effect_hits.eta);
                     }
                 }
                 if (count_finished() >= RegionIndex::DetectorRegionIndexMax) {
                     ATH_MSG_VERBOSE("The MS is filled up with Hough seeds. We do not need to search for them any longer");
                     break;
                 }
             }
         }
         for (auto& theta_pair : output_cache.eta_seeds) { std::sort(theta_pair.second.begin(), theta_pair.second.end()); }
     }
     output_cache.consumed_hits.clear();
     return StatusCode::SUCCESS;
 }

◆ findSegments()

StatusCode MuonInDetToMuonSystemExtensionAlg::findSegments	(	const EventContext &	ctx,
		InDetCandidateCache &	output_cache
	)		const

private

Select good segments.

Check if the segment is part of a MuidCo muon

Mask all hits from the Hough seeds

Definition at line 259 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                            {
     SG::ReadHandle<Trk::SegmentCollection> segmentContainer{m_segmentKey, ctx};
     if (!segmentContainer.isValid()) {
         ATH_MSG_FATAL("Failed to retrieve the Muon segment container " << m_segmentKey.fullKey());
         return StatusCode::FAILURE;
     }
     for (const Trk::Segment* trk_segment : *segmentContainer) {
         // Which in reality is a Muon segment
         const Muon::MuonSegment* muon_segment = dynamic_cast<const Muon::MuonSegment*>(trk_segment);
         if (!muon_segment) {
             ATH_MSG_WARNING("How can it be that a Muon segment is not a muon segment?");
             continue;
         }
         // Check if the segment satisfies the quality criteria
         if (m_segmentSelector->quality(*muon_segment) < m_segmentQuality) continue;
         if (output_cache.combined_segs.count(muon_segment)) {
             ATH_MSG_VERBOSE("Segment was already used in combined fit");
             continue;
         }
         if (m_excludeNSW && std::find_if(muon_segment->containedMeasurements().begin(),muon_segment->containedMeasurements().end(),
                 [this](const Trk::MeasurementBase* meas ){
                     const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
                      return meas_id.is_valid() && (m_idHelperSvc->isMM(meas_id) || m_idHelperSvc->issTgc(meas_id));
                 })!= muon_segment->containedMeasurements().end()) continue;
         
         maskHits(muon_segment, output_cache);
         output_cache.candidate_segments.push_back(muon_segment);
     }
     output_cache.combined_segs.clear();
     return StatusCode::SUCCESS;
 }

◆ hasMatchingSeed()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSeed	(	const MuonCombined::InDetCandidate &	id_cand,
		const InDetCandidateCache &	cache
	)		const

private

Searches for hough seeds within theta < 0.2 && sharing the same sector.

Definition at line 321 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                 {
     const Trk::TrackParameters* ms_entry = id_cand.getCaloExtension()->muonEntryLayerIntersection();
     const double etaID = ms_entry->position().eta();
     std::vector<int> id_sectors;
     m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
     for (const int& sect : id_sectors) {
         std::map<int, std::vector<double>>::const_iterator theta_itr = cache.eta_seeds.find(sect);
         if (theta_itr == cache.eta_seeds.end()) continue;
         if (std::find_if(theta_itr->second.begin(), theta_itr->second.end(),
                          [&etaID](const double eta_seed) { return std::abs(etaID - eta_seed) < 0.1; }) != theta_itr->second.end())
             return true;
     }
     return false;
 }

◆ hasMatchingSegment()

bool MuonInDetToMuonSystemExtensionAlg::hasMatchingSegment	(	const MuonCombined::InDetCandidate &	id_cand,
		const InDetCandidateCache &	cache
	)		const

private

Searches for segments within theta < 0.2 && sharing the same sector.

Definition at line 292 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                    {
     const Trk::TrackParameters* ms_entry = id_cand.getCaloExtension()->muonEntryLayerIntersection();
     const double ThetaID = ms_entry->position().theta();
     std::vector<int> id_sectors;
     m_sector_mapping.getSectors(ms_entry->position().phi(), id_sectors);
     auto sector_match = [&id_sectors, this](const Amg::Vector3D& seg_pos) -> bool {
         std::vector<int> seg_sectors;
         m_sector_mapping.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 Muon::MuonSegment* itSeg : cache.candidate_segments) {
         const Amg::Vector3D pos = itSeg->globalPosition();
         const double dTheta = pos.theta() - ThetaID;
         const bool theta_match = std::abs(dTheta) < 0.2;
         if (!theta_match) {
             ATH_MSG_VERBOSE("dTheta cut failed");
             continue;
         }
         if (!sector_match(pos)) {
             ATH_MSG_VERBOSE("dPhi cut failed");
             continue;
         }
         return true;
     }
     return false;
 }

◆ initialize()

StatusCode MuonInDetToMuonSystemExtensionAlg::initialize ( )

override

Definition at line 34 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                          {
     ATH_CHECK(m_muonSystemExtensionTool.retrieve());
     ATH_CHECK(m_idHelperSvc.retrieve());
     ATH_CHECK(m_edmHelperSvc.retrieve());
     ATH_CHECK(m_combTagMap.initialize());
     ATH_CHECK(m_inputCandidate.initialize());
     ATH_CHECK(m_bulkInDetCandKey.initialize());
     ATH_CHECK(m_stauInDetCandKey.initialize(!m_stauInDetCandKey.empty()));
     if (m_restrictExtension) { ATH_MSG_INFO("Use the Hough seeds to determine the sectors in the MS worth for being extrapolated to"); }
     ATH_CHECK(m_houghDataPerSectorVecKey.initialize(m_restrictExtension));
     ATH_CHECK(m_segmentKey.initialize(m_restrictExtension));
     if (m_restrictExtension) { ATH_CHECK(m_segmentSelector.retrieve()); }
     return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

◆ maskHits()

void MuonInDetToMuonSystemExtensionAlg::maskHits	(	const Muon::MuonSegment *	muon_seg,
		InDetCandidateCache &	output_cache
	)		const

private

Mask the hits of the corresponding muon segment as used.

Definition at line 375 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                          {
     const Identifier seg_id = m_edmHelperSvc->chamberId(*muon_seg);
     const LayerIndex layer_index = m_idHelperSvc->layerIndex(seg_id);
     const RegionIndex region_index = m_idHelperSvc->regionIndex(seg_id);
     const unsigned int hash = Muon::MuonStationIndex::sectorLayerHash(region_index, layer_index);
     std::set<Identifier>& id_set = output_cache.consumed_hits[hash];
     for (const Trk::MeasurementBase* meas : muon_seg->containedMeasurements()) {
         const Identifier meas_id = m_edmHelperSvc->getIdentifier(*meas);
         id_set.insert(meas_id);
     }
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ selectCandidates()

StatusCode MuonInDetToMuonSystemExtensionAlg::selectCandidates	(	const EventContext &	ctx,
		InDetCandidateCache &	cache
	)		const

private

Select the MuidCo candidates and put the associated id tracks on a black list.

Definition at line 74 of file MuonInDetToMuonSystemExtensionAlg.cxx.

                                                                                                                             {
     SG::ReadHandle<MuonCombined::InDetCandidateToTagMap> tag_map{m_combTagMap, ctx};
     if (!tag_map.isValid()) {
         ATH_MSG_FATAL("Failed to retrieve the tag map from " << tag_map.fullKey());
         return StatusCode::FAILURE;
     }
     if (tag_map->empty()) {
         ATH_MSG_DEBUG("No combined candidates in this event");
         return StatusCode::SUCCESS;
     }
  
     for (const auto& combined_tags : *tag_map) {
         if (combined_tags.second->author() != xAOD::Muon::MuidCo) {
             ATH_MSG_WARNING("Found a non MuidCo tag.... Please check " << combined_tags.second->toString());
             continue;
         }
         const MuonCombined::CombinedFitTag* cmb_tag = dynamic_cast<const MuonCombined::CombinedFitTag*>(combined_tags.second.get());
         MuidCoCache cache{combined_tags.first, cmb_tag};
         out_cache.tag_map.push_back(std::move(cache));
         out_cache.excluded_trks.insert(combined_tags.first);
         for (const Muon::MuonSegment* muon_seg : cmb_tag->associatedSegments()) {
             out_cache.combined_segs.insert(muon_seg);
             maskHits(muon_seg, out_cache);
         }
     }
     return StatusCode::SUCCESS;
 }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_bulkInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_bulkInDetCandKey {this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"}

private

Collection of InDet candidates written for MuGirl and MuonSegmentTag.

Definition at line 46 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_combTagMap

SG::ReadHandleKey<MuonCombined::InDetCandidateToTagMap> MuonInDetToMuonSystemExtensionAlg::m_combTagMap {this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"}

private

That is the collection of MuidCo candidates.

Definition at line 63 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_edmHelperSvc

ServiceHandle<Muon::IMuonEDMHelperSvc> MuonInDetToMuonSystemExtensionAlg::m_edmHelperSvc

private

Initial value:

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

"Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 67 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_excludeNSW

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_excludeNSW {this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"}

private

Prelimnary studies have shown that the NSWs generate a massive amount of fake candidates.

Definition at line 113 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extendBulk

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendBulk {this, "ExtendBulk", true}

private

Shall ordinary ID tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 119 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_extendSAF

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_extendSAF {this, "ExtendSAF", false}

private

Shall SAF tracks be equiped with a muon system extension used by MuGirl later.

Definition at line 117 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_extThreshold

Gaudi::Property<float> MuonInDetToMuonSystemExtensionAlg::m_extThreshold {this, "ExtensionPtThreshold", 2500}

private

Minimum pt threshold of the IdCandidate to be extrapolated through the spectrometer.

Definition at line 115 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_houghDataPerSectorVecKey

SG::ReadHandleKey<Muon::HoughDataPerSectorVec> MuonInDetToMuonSystemExtensionAlg::m_houghDataPerSectorVecKey

private

Initial value:

{this, "LayerHoughKey", "HoughDataPerSectorVec",

"HoughDataPerSectorVec key"}

Use the hough data to find sectors in the speectrometer traversed by a muon.

Definition at line 51 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_houghMin

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_houghMin {this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"}

private

The hough maxima always contain at least 2 hits.

If a muon track passes through a chamber one expects more than that. Apply a minimum cuts on the hits in the hough maximum to reject background --> needs to be further tuned

Definition at line 109 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_idHelperSvc

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

private

Definition at line 65 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_inputCandidate

SG::ReadHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_inputCandidate {this, "InputInDetCandidates", "InDetCandidates"}

private

Definition at line 43 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_muonSystemExtensionTool

ToolHandle<Muon::IMuonSystemExtensionTool> MuonInDetToMuonSystemExtensionAlg::m_muonSystemExtensionTool {this, "MuonSystemExtensionTool", "", "Muon system extension tool"}

private

The system extension tool extrapolates the candidate through the spectrometer.

Definition at line 61 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_restrictExtension

Gaudi::Property<bool> MuonInDetToMuonSystemExtensionAlg::m_restrictExtension {this, "UseOnlyHitSectors", false}

private

Restrict the extrapolation of ID tracks to sectors in the MS where at least a hit is recorded.

Definition at line 106 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_sector_mapping

const Muon::MuonSectorMapping MuonInDetToMuonSystemExtensionAlg::m_sector_mapping {}

private

Definition at line 121 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentKey

SG::ReadHandleKey<Trk::SegmentCollection> MuonInDetToMuonSystemExtensionAlg::m_segmentKey

private

Initial value:

{this, "MuonSegmentLocation", "TrackMuonSegments",

"name of muon segment container"}

Let's exploit the segments to get rid of as much tracks as possible.

Definition at line 54 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentQuality

Gaudi::Property<int> MuonInDetToMuonSystemExtensionAlg::m_segmentQuality {this, "segQuality", 1, "Quality cut on the segment."}

private

Definition at line 111 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_segmentSelector

PublicToolHandle<Muon::IMuonSegmentSelectionTool> MuonInDetToMuonSystemExtensionAlg::m_segmentSelector

private

Initial value:

{this, "MuonSegmentSelectionTool",

"Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool"}

Definition at line 57 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_stauInDetCandKey

SG::WriteHandleKey<InDetCandidateCollection> MuonInDetToMuonSystemExtensionAlg::m_stauInDetCandKey {this, "WriteStauCandidates", ""}

private

Collection of InDet candidates written for MuGirlStau.

Definition at line 48 of file MuonInDetToMuonSystemExtensionAlg.h.

◆ m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MuidCoVector

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonInDetToMuonSystemExtensionAlg()

◆ ~MuonInDetToMuonSystemExtensionAlg()

Member Function Documentation

◆ cardinality()

◆ create()

◆ createStaus()

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

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ findHitSectors()

◆ findSegments()

◆ hasMatchingSeed()

◆ hasMatchingSegment()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ maskHits()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ selectCandidates()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_bulkInDetCandKey

◆ m_combTagMap

◆ m_detStore

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_excludeNSW

◆ m_extendBulk

◆ m_extendedExtraObjects

◆ m_extendSAF

◆ m_extThreshold

◆ m_houghDataPerSectorVecKey

◆ m_houghMin

◆ m_idHelperSvc

◆ m_inputCandidate

◆ m_muonSystemExtensionTool

◆ m_restrictExtension

◆ m_sector_mapping

◆ m_segmentKey

◆ m_segmentQuality

◆ m_segmentSelector

◆ m_stauInDetCandKey

◆ m_varHandleArraysDeclared

◆ m_vhka