Muon::MuPatCandidateTool Class Reference

class to manipulate MuPatCandidateBase objects More...

#include <MuPatCandidateTool.h>

Inheritance diagram for Muon::MuPatCandidateTool:

Collaboration diagram for Muon::MuPatCandidateTool:

Public Types
using	MeasVec = std::vector< const Trk::MeasurementBase * >
typedef MeasVec::iterator	MeasIt
typedef MeasVec::const_iterator	MeasCit

Public Member Functions
	MuPatCandidateTool (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor More...
virtual	~MuPatCandidateTool ()=default
	destructor More...
virtual StatusCode	initialize () override
	initialize method, method taken from bass-class AlgTool More...
bool	extendWithSegment (MuPatTrack &can, MuPatSegment &segInfo, std::unique_ptr< Trk::Track > &track) const
	extend a track candidate with a segment More...
std::unique_ptr< MuPatTrack >	createCandidate (MuPatSegment &segInfo, std::unique_ptr< Trk::Track > &track) const
	create a track candidate from one segment More...
std::unique_ptr< MuPatTrack >	createCandidate (MuPatSegment &segInfo1, MuPatSegment &segInfo2, std::unique_ptr< Trk::Track > &track) const
	create a track candidate from two segments More...
std::unique_ptr< MuPatTrack >	createCandidate (std::unique_ptr< Trk::Track > &track) const
	create a track candidate from a track More...
bool	updateTrack (MuPatTrack &candidate, std::unique_ptr< Trk::Track > &track) const
	set the new track in the candidate, and update candidate contents. More...
bool	recalculateCandidateSegmentContent (MuPatTrack &candidate) const
	recalculate the chamber indices on the candidate and reset them. More...
std::unique_ptr< MuPatSegment >	createSegInfo (const EventContext &ctx, const MuonSegment &segment) const
	create a MuPatSegment object from a segment More...
std::set< const MuonGM::MuonReadoutElement * >	readoutElements (const MuPatCandidateBase &entry) const
	get list of the readout elements of the hits on the entry More...
std::string	print (const MuPatSegment &segment, int level=0) const
	print the measurements on the track to string More...
std::string	print (const std::vector< MuPatSegment * > &segments, int level=0) const
std::string	print (const MuPatCandidateBase &candidate, int level=0) const
std::string	print (const MuPatTrack &track, int level=0) const
std::string	print (const std::vector< std::unique_ptr< MuPatTrack > > &tracks, int level=0) 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	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, V, H > &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 ()
	access to tool interface More...
static std::unique_ptr< MuPatTrack >	copyCandidate (MuPatTrack *canIn)
	copy a candidate without copying the track (lazy pointer copy) More...

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
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	updateHits (MuPatCandidateBase &entry, const MeasVec &measurements, bool recreateMDT=false, bool recreateCSC=false, bool createComp=false) const
	update hits for a MuPatCandidateBase More...
void	addCluster (const Trk::MeasurementBase &meas, std::vector< const MuonClusterOnTrack * > &rots) const
	extract MuonClusterOnTrack('s) from measurement More...
void	createAndAddCompetingROTs (const std::vector< const MuonClusterOnTrack * > &rots, MeasVec &hits, MeasVec &allHits, MuPatCandidateBase &entry) const
	create CompetingMuonClustersOnTracks from ROTs and add them to the MeasVec. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
ToolHandle< IMuonClusterOnTrackCreator >	m_cscRotCreator
ToolHandle< IMuonCompetingClustersOnTrackCreator >	m_compClusterCreator
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
PublicToolHandle< MuonEDMPrinterTool >	m_printer {this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ToolHandle< MuPatHitTool >	m_hitHandler {this, "HitTool", "Muon::MuPatHitTool/MuPatHitTool", "Tool to manipulate hit lists"}
ToolHandle< Muon::IMuonSegmentSelectionTool >	m_segmentSelector
Gaudi::Property< bool >	m_createCompetingROTsPhi {this, "CreateCompetingROTsPhi", false}
Gaudi::Property< bool >	m_createCompetingROTsEta {this, "CreateCompetingROTsEta", true}
Gaudi::Property< bool >	m_doMdtRecreation {this, "DoMdtRecreation", false}
Gaudi::Property< bool >	m_doCscRecreation {this, "DoCscRecreation", true}
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

class to manipulate MuPatCandidateBase objects

Definition at line 49 of file MuPatCandidateTool.h.

Member Typedef Documentation

MeasCit

typedef MeasVec::const_iterator Muon::MuPatCandidateTool::MeasCit

Definition at line 53 of file MuPatCandidateTool.h.

MeasIt

typedef MeasVec::iterator Muon::MuPatCandidateTool::MeasIt

Definition at line 52 of file MuPatCandidateTool.h.

MeasVec

using Muon::MuPatCandidateTool::MeasVec = std::vector<const Trk::MeasurementBase*>

Definition at line 51 of file MuPatCandidateTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuPatCandidateTool()

Muon::MuPatCandidateTool::MuPatCandidateTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

default AlgTool constructor

Definition at line 34 of file MuPatCandidateTool.cxx.

                                                                                                      : 
        AthAlgTool(t, n, p) {
        declareInterface<MuPatCandidateTool>(this);
    }

~MuPatCandidateTool()

virtual Muon::MuPatCandidateTool::~MuPatCandidateTool ( )

virtualdefault

destructor

Member Function Documentation

addCluster()

void Muon::MuPatCandidateTool::addCluster ( const Trk::MeasurementBase &  meas, std::vector< const MuonClusterOnTrack * > &  rots  ) const

private

extract MuonClusterOnTrack('s) from measurement

Definition at line 283 of file MuPatCandidateTool.cxx.

                                                                                                                        {
        const MuonClusterOnTrack* clus = dynamic_cast<const MuonClusterOnTrack*>(&meas);
        if (clus)
            rots.push_back(clus);
        else {
            const CompetingMuonClustersOnTrack* compclus = dynamic_cast<const CompetingMuonClustersOnTrack*>(&meas);
            if (compclus) {
                rots.insert(rots.end(), compclus->containedROTs().begin(), compclus->containedROTs().end());
            } else {
                Identifier id = m_edmHelperSvc->getIdentifier(meas);
                ATH_MSG_WARNING(" Trigger Measurement is not a MuonClusterOnTrack or CompetingMuonClustersOnTrack!!  "
                                << m_idHelperSvc->toString(id));
            }
        }
    }

copyCandidate()

std::unique_ptr< MuPatTrack > Muon::MuPatCandidateTool::copyCandidate ( MuPatTrack *  canIn )

static

copy a candidate without copying the track (lazy pointer copy)

Parameters

[in]	can	the MuPatTrack to be copied
[out]	the	new candidate, ownership is passed to caller. The new candidate will not own the track (lazy pointer copy)

Definition at line 95 of file MuPatCandidateTool.cxx.

                                                                                 {
        // copy and update hits
        std::unique_ptr<MuPatTrack> can = std::make_unique<MuPatTrack>(*canIn);
        return can;
    }

createAndAddCompetingROTs()

void Muon::MuPatCandidateTool::createAndAddCompetingROTs ( const std::vector< const MuonClusterOnTrack * > &  rots, MuPatCandidateTool::MeasVec &  hits, MuPatCandidateTool::MeasVec &  allHits, MuPatCandidateBase &  entry  ) const

private

create CompetingMuonClustersOnTracks from ROTs and add them to the MeasVec.

NEVER pass mixed eta/phi hits!!

Definition at line 299 of file MuPatCandidateTool.cxx.

                                                                                            {
        typedef std::map<Identifier, std::vector<const MuonClusterOnTrack*> > IdClusMap;
        typedef IdClusMap::iterator IdClusIt;
        IdClusMap idClusters;
 
        // loop over hits and sort by detector element
        for (const MuonClusterOnTrack* clus : rots) {
            Identifier id = clus->identify();
            Identifier detId = m_idHelperSvc->detElId(id);
            idClusters[detId].push_back(clus);
        }
 
        ATH_MSG_DEBUG(" creating CompetingMuonClustersOnTrack for " << idClusters.size() << " chambers ");
 
        IdClusIt chit = idClusters.begin();
        IdClusIt chit_end = idClusters.end();
        for (; chit != chit_end; ++chit) {
            if (msgLvl(MSG::VERBOSE)) {
                msg(MSG::VERBOSE )<<__FILE__<<":"<<__LINE__ << " in " << m_idHelperSvc->toStringDetEl(chit->first) << "  clusters: " << chit->second.size()
                                  << std::endl;
                for (const MuonClusterOnTrack* cl_it : chit->second) {
                    msg(MSG::VERBOSE) << "   " << m_idHelperSvc->toString(cl_it->identify());
 
                    // hack to get correct print-out
                    if (cl_it == chit->second.back())
                        msg(MSG::VERBOSE) << endmsg;
                    else
                        msg(MSG::VERBOSE) << std::endl;
                }
            }
 
            if (chit->second.empty()) {
                ATH_MSG_WARNING(" empty list, could not create CompetingMuonClustersOnTrack in chamber   "
                                << m_idHelperSvc->toString(chit->first));
                continue;
            }
 
            // only create competing ROT if there is more than one PRD
            if (chit->second.size() == 1) {
                hits.push_back(chit->second.front());
                allHits.push_back(chit->second.front());
                continue;
            }
 
            // create list of PRDs
            std::list<const Trk::PrepRawData*> prds;
            std::vector<const MuonClusterOnTrack*>::iterator cl_it = chit->second.begin();
            std::vector<const MuonClusterOnTrack*>::iterator cl_it_end = chit->second.end();
            for (; cl_it != cl_it_end; ++cl_it) {
                const Trk::PrepRawData* prd = (*cl_it)->prepRawData();
                if (prd) {
                    prds.push_back(prd);
                } else {
                    ATH_MSG_WARNING("MuonClusterOnTrack has no PRD.");
                }
            }
 
            std::unique_ptr<const CompetingMuonClustersOnTrack> comprot = m_compClusterCreator->createBroadCluster(prds, 0);
            if (!comprot) {
                ATH_MSG_WARNING(" could not create CompetingMuonClustersOnTrack in chamber   " << m_idHelperSvc->toString(chit->first));
                continue;
            }
            hits.push_back(comprot.get());
            allHits.push_back(comprot.get());
 
            // add to garbage collection
            trash_bin.addToTrash(std::move(comprot));
        }
    }

createCandidate() [1/3]

std::unique_ptr< MuPatTrack > Muon::MuPatCandidateTool::createCandidate	(	MuPatSegment &	segInfo,
		std::unique_ptr< Trk::Track > &	track
	)		const

create a track candidate from one segment

Parameters

[in]	seg1	the first MuPatSegment to be added, ownership is NOT passed!
[in]	seg2	the second MuPatSegment to be added, ownership is NOT passed!
[in]	track	the new track, ownership is passed to the candidate
[out]	the	new candidate, ownership is passed to caller

Definition at line 101 of file MuPatCandidateTool.cxx.

                                                                                                                             {
        // create the new candidate
        std::unique_ptr<MuPatTrack> candidate = std::make_unique< MuPatTrack>(&segInfo, track);
        recalculateCandidateSegmentContent(*candidate);
        return candidate;
    }

createCandidate() [2/3]

std::unique_ptr< MuPatTrack > Muon::MuPatCandidateTool::createCandidate	(	MuPatSegment &	segInfo1,
		MuPatSegment &	segInfo2,
		std::unique_ptr< Trk::Track > &	track
	)		const

create a track candidate from two segments

Parameters

[in]	seg1	the first MuPatSegment to be added, ownership is NOT passed!
[in]	seg2	the second MuPatSegment to be added, ownership is NOT passed!
[in]	track	the new track, ownership is passed to the candidate
[out]	the	new candidate, ownership is passed to caller

Definition at line 113 of file MuPatCandidateTool.cxx.

                                                                                                          {
        // create the new candidate
        std::unique_ptr<MuPatTrack> candidate = std::make_unique<MuPatTrack>(&segInfo1, &segInfo2, track);
        recalculateCandidateSegmentContent(*candidate);
        return candidate;
    }

createCandidate() [3/3]

std::unique_ptr< MuPatTrack > Muon::MuPatCandidateTool::createCandidate

(

std::unique_ptr< Trk::Track > &

track

)

const

create a track candidate from a track

Parameters

[in]	track	the new track, ownership is passed to the candidate
[out]	the	new candidate, ownership is passed to caller

Definition at line 121 of file MuPatCandidateTool.cxx.

                                                                                                      {
        // create a dummy segment vector
        std::vector<MuPatSegment*> segments;
 
        // create the new candidate
        std::unique_ptr<MuPatTrack> candidate = std::make_unique<MuPatTrack>(segments, track);
        recalculateCandidateSegmentContent(*candidate);
        return candidate;
    }

createSegInfo()

std::unique_ptr< MuPatSegment > Muon::MuPatCandidateTool::createSegInfo	(	const EventContext &	ctx,
		const MuonSegment &	segment
	)		const

create a MuPatSegment object from a segment

Parameters

[in]	segment	input segment
[out]	the	MuPatSegment object, ownership is passed to caller

Definition at line 53 of file MuPatCandidateTool.cxx.

                                                                                                                           {
        Identifier chid = m_edmHelperSvc->chamberId(segment);
        if (m_idHelperSvc->isTrigger(chid)) {
            ATH_MSG_WARNING("Trigger hit only segments not supported " << m_idHelperSvc->toStringChamber(chid));
            return nullptr;
        }
        std::unique_ptr<MuPatSegment> info = std::make_unique<MuPatSegment>();
        info->segment = &segment;
        info->chid = chid;
        info->chIndex = m_idHelperSvc->chamberIndex(info->chid);
        std::set<Identifier> chIds = m_edmHelperSvc->chamberIds(segment);
        for (const Identifier& id : chIds) {
            MuonStationIndex::ChIndex chIdx = m_idHelperSvc->chamberIndex(id);
            info->addChamber(chIdx);
            // set default name
            if (!info->name.empty()) info->name += "+";
            // stationname_eta_phi
            std::ostringstream oss;
            oss << MuonStationIndex::chName(chIdx) << "_" << m_idHelperSvc->stationEta(id) << "_" << m_idHelperSvc->stationPhi(id);
            info->name += oss.str();
        }
        info->stIndex = m_idHelperSvc->stationIndex(info->chid);
        info->isEndcap = m_idHelperSvc->isEndcap(info->chid);
        info->isMdt = m_idHelperSvc->isMdt(info->chid);
        info->usedInFit = 0;
        info->quality = m_segmentSelector->quality(segment);
        info->segQuality = dynamic_cast<const MuonSegmentQuality*>(segment.fitQuality());
 
        info->segPars.reset(m_edmHelperSvc->createTrackParameters(segment, 5000., 0.));
        if (!info->segPars) { ATH_MSG_WARNING(" failed to create track parameter for segment "); }
 
        updateHits(*info, info->segment->containedMeasurements(), m_doMdtRecreation, m_doCscRecreation, true);
        m_hitHandler->create(ctx, segment, info->hitList());
        return info;
    }

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [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.

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

{ return m_evtStore; }

extendWithSegment()

bool Muon::MuPatCandidateTool::extendWithSegment	(	MuPatTrack &	can,
		MuPatSegment &	segInfo,
		std::unique_ptr< Trk::Track > &	track
	)		const

extend a track candidate with a segment

Parameters

[in]	can	the MuPatTrack to be extended
[in]	track	the new track, ownership is passed to the candidate
[in]	seg	the MuPatSegment to be added, ownership is NOT passed!
[out]	true	if any segment was removed from the track, false if not

Definition at line 89 of file MuPatCandidateTool.cxx.

                                                                                                                           {
        // add segment to candidate
        can.addSegment(&segInfo, track);
        return recalculateCandidateSegmentContent(can);
    }

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

initialize()

StatusCode Muon::MuPatCandidateTool::initialize ( )

overridevirtual

initialize method, method taken from bass-class AlgTool

Definition at line 39 of file MuPatCandidateTool.cxx.

                                              {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_mdtRotCreator.retrieve());
        ATH_CHECK(m_cscRotCreator.retrieve(EnableTool{m_idHelperSvc->hasCSC()}));
 
        ATH_CHECK(m_compClusterCreator.retrieve());
        ATH_CHECK(m_hitHandler.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_segmentSelector.retrieve());
 
        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& Muon::MuPatCandidateTool::interfaceID ( )

inlinestatic

access to tool interface

Definition at line 66 of file MuPatCandidateTool.h.

                                                {
             static const InterfaceID IID_MuPatCandidateTool("Muon::MuPatCandidateTool", 1, 0);
             return IID_MuPatCandidateTool; 
        }

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.

print() [1/5]

std::string Muon::MuPatCandidateTool::print	(	const MuPatCandidateBase &	candidate,
		int	level = 0
	)		const

Definition at line 492 of file MuPatCandidateTool.cxx.

                                                                                            {
        const MuPatSegment* seg = dynamic_cast<const MuPatSegment*>(&candidate);
        if (seg) return print(*seg, level);
 
        const MuPatTrack* track = dynamic_cast<const MuPatTrack*>(&candidate);
        if (track) return print(*track, level);
 
        return "Unknown candidate type";
    }

print() [2/5]

std::string Muon::MuPatCandidateTool::print	(	const MuPatSegment &	segment,
		int	level = 0
	)		const

print the measurements on the track to string

This really belongs in MuonEDMPrinterTool in package MuonRecHelperTools. However, due to the tight tag collecting policy for release 15.5.0, this change is not likely to get accepted there. To be moved there as soon as release 16 is open

Definition at line 447 of file MuPatCandidateTool.cxx.

                                                                                    {
        std::ostringstream oss;
        oss << segment.name << ": " << m_printer->print(*segment.segment) << " q " << segment.quality;
        if (level == 0) return oss.str();
 
        if (segment.hitList().size() >= 2) {
            DistanceAlongParameters distCal{};
            oss << " length " << distCal(segment.hitList().front(), segment.hitList().back());
        }
        oss << std::endl << m_hitHandler->print(segment.hitList(), true, false, false);
        return oss.str();
    }

print() [3/5]

std::string Muon::MuPatCandidateTool::print	(	const MuPatTrack &	track,
		int	level = 0
	)		const

Definition at line 470 of file MuPatCandidateTool.cxx.

                                                                                {
        std::ostringstream oss;
        oss << m_printer->print(track.track()) << std::endl << m_printer->printStations(track.track());
 
        if (level == 0) return oss.str();
 
        const std::vector<MuPatSegment*>& segs = track.segments();
        oss << std::endl << print(segs, 0);
 
        return oss.str();
    }

print() [4/5]

std::string Muon::MuPatCandidateTool::print	(	const std::vector< MuPatSegment * > &	segments,
		int	level = 0
	)		const

Definition at line 460 of file MuPatCandidateTool.cxx.

                                                                                                 {
        std::vector<MuPatSegment*>::const_iterator it = segments.begin();
        std::vector<MuPatSegment*>::const_iterator it_end = segments.end();
        std::ostringstream oss;
        oss << " Segment candidate vector: " << segments.size();
        for (; it != it_end; ++it) oss << std::endl << print(**it, level);
 
        return oss.str();
    }

print() [5/5]

std::string Muon::MuPatCandidateTool::print	(	const std::vector< std::unique_ptr< MuPatTrack > > &	tracks,
		int	level = 0
	)		const

Definition at line 482 of file MuPatCandidateTool.cxx.

                                                                                                            {
        std::ostringstream oss;
        oss << "MuPatTracks " << tracks.size() << std::endl;
        std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit = tracks.begin();
        std::vector<std::unique_ptr<MuPatTrack> >::const_iterator tit_end = tracks.end();
        for (; tit != tit_end; ++tit) oss << " " << print(**tit, level) << std::endl;
 
        return oss.str();
    }

readoutElements()

std::set< const MuonGM::MuonReadoutElement * > Muon::MuPatCandidateTool::readoutElements

(

const MuPatCandidateBase &

entry

)

const

get list of the readout elements of the hits on the entry

Definition at line 420 of file MuPatCandidateTool.cxx.

                                                                                                                     {
        std::set<const MuonGM::MuonReadoutElement*> roEls;
 
        MuPatHitCit it = entry.hitList().begin();
        MuPatHitCit it_end = entry.hitList().end();
        for (; it != it_end; ++it) {
            if (!(*it)->info().id.is_valid()) continue;
            // only want MDT or CSC detEls
            if (!m_idHelperSvc->isMdt((*it)->info().id) && !m_idHelperSvc->isCsc((*it)->info().id)) continue;
 
            const Trk::MeasurementBase& meas = (*it)->measurement();
            const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(&meas);
            if (!rot) {
                const CompetingMuonClustersOnTrack* crot = dynamic_cast<const CompetingMuonClustersOnTrack*>(&meas);
                if (crot) {
                    const std::vector<const MuonClusterOnTrack*>& rots = crot->containedROTs();
                    if (!rots.empty()) rot = rots.front();
                }
            }
            if (rot) {
                const MuonGM::MuonReadoutElement* roEl = dynamic_cast<const MuonGM::MuonReadoutElement*>(rot->detectorElement());
                if (roEl) roEls.insert(roEl);
            }
        }
        return roEls;
    }

recalculateCandidateSegmentContent()

bool Muon::MuPatCandidateTool::recalculateCandidateSegmentContent

(

MuPatTrack &

candidate

)

const

recalculate the chamber indices on the candidate and reset them.

Return whether segment has been removed.

Definition at line 371 of file MuPatCandidateTool.cxx.

                                                                                           {
        // loop over track and get the chambers on the track
        const Trk::TrackStates* states = candidate.track().trackStateOnSurfaces();
        if (!states) return false;
 
        std::set<MuonStationIndex::ChIndex> chambers;
 
        // loop over TSOSs
        for (const Trk::TrackStateOnSurface* tsos : *states) {
            // only look at measurements
            if (!tsos->type(Trk::TrackStateOnSurface::Measurement) || tsos->type(Trk::TrackStateOnSurface::Outlier)) continue;
 
            // check whether state is a measurement
            const Trk::MeasurementBase* meas = tsos->measurementOnTrack();
            if (!meas) continue;
 
            // get chamber index
            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
            if (!id.is_valid() || !m_idHelperSvc->isMuon(id)) continue;
 
            // don't include trigger hits
            if (m_idHelperSvc->isTrigger(id)) continue;
 
            chambers.insert(m_idHelperSvc->chamberIndex(id));
 
            ATH_MSG_VERBOSE(" in recal " << m_idHelperSvc->toString(id));
        }
        if (msgLvl(MSG::VERBOSE)) {
            ATH_MSG_VERBOSE(" recalculateCandidateSegmentContent, old chambers " << candidate.chambers().size() << " new chambers "
                              << chambers.size());
            for (const MuonStationIndex::ChIndex& chit : candidate.chambers()) {
                if (!chambers.count(chit)) { ATH_MSG_VERBOSE(" removing chamber index from candidate " << MuonStationIndex::chName(chit)); }
            }
        }
 
        // reset chamber content
        bool bRemovedSegments = candidate.resetChambersOnCandidate(chambers);
 
        // recalculate hit list
        candidate.hitList().clear();
        m_hitHandler->create(candidate.track(), candidate.hitList());
        // update the hit summary
        updateHits(candidate, candidate.track().measurementsOnTrack()->stdcont());
 
        ATH_MSG_VERBOSE("Print content after recalculateCandidateSegmentContent() -- "<<m_hitHandler->print(candidate.hitList()));
 
        return bRemovedSegments;
    }

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.

updateHits()

void Muon::MuPatCandidateTool::updateHits ( MuPatCandidateBase &  entry, const MeasVec &  measurements, bool  recreateMDT = false, bool  recreateCSC = false, bool  createComp = false  ) const

private

update hits for a MuPatCandidateBase

Definition at line 131 of file MuPatCandidateTool.cxx.

                                                                                                   {
        MeasVec etaHits{}, phiHits{}, fakePhiHits{}, allHits{};
 
        unsigned int nmdtHitsMl1{0}, nmdtHitsMl2{0}, ncscHitsEta{0}, ncscHitsPhi{0}, nrpcHitsEta{0}, nrpcHitsPhi{0}, ntgcHitsEta{0},
            ntgcHitsPhi{0};
 
        entry.clearChambers();  // also clears stations and chamberIds
 
        bool hasEndcap{false}, hasSmall{false}, hasLarge{false}, hassloverlap{false}, previssmall{false};
        MuonStationIndex::StIndex prevstIndex = MuonStationIndex::StIndex::StUnknown;
 
        Trk::MagneticFieldProperties magProps;
 
        // vector to store trigger hits in case we have special treatment for them
        std::vector<const MuonClusterOnTrack*> triggerHitsPhi{}, triggerHitsEta{};
 
        // loop over hits
        bool is_first_meas = true;
        for (const Trk::MeasurementBase* meas : measurements) {
            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
            if (!id.is_valid()) {
                fakePhiHits.push_back(meas);
                continue;
            }
 
            // skip ID hits
            if (!m_idHelperSvc->isMuon(id)) continue;
 
            Identifier chId = m_idHelperSvc->chamberId(id);
            MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
            MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
            if (!hasEndcap) hasEndcap = m_idHelperSvc->isEndcap(id);
 
            bool measuresPhi = false;
 
            bool isMdt = m_idHelperSvc->isMdt(id);
            bool isCsc = m_idHelperSvc->isCsc(id);
            bool isNSW = m_idHelperSvc->isMM(id) || m_idHelperSvc->issTgc(id);
            // only add precision hits
            if (isMdt || isCsc || isNSW) {
                entry.addChamber(chIndex);  // will also add stationIndex
                entry.chamberIds().insert(chId);
            }
            if (isMdt) {
                // if in MDT recreation mode, recreate MDT using ROT creator. Store the pointer as we have to delete it ourselfs.
                if (recreateMDT) {
                    if (!m_doMdtRecreation) {
                        ATH_MSG_WARNING(
                            " recreation of MDTs requiered although not configured via jobO, ignoring request. Please check jobO ");
                    } else {
                        const auto* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(meas);
                        if (!mdt) {
                            ATH_MSG_WARNING(" found MdtDriftCircleOnTrack without MDT identifier " << m_idHelperSvc->toString(id));
                            continue;
                        }
                        ATH_MSG_DEBUG(" recreating MdtDriftCircleOnTrack ");
                        meas = entry.addToTrash
                          (std::unique_ptr<const MdtDriftCircleOnTrack>
                           (m_mdtRotCreator->createRIO_OnTrack(*mdt->prepRawData(), mdt->globalPosition())));
                    }
                }
 
                const bool isSmall = m_idHelperSvc->isSmallChamber(id);
                hasSmall |= isSmall;
                hasLarge |= !isSmall;
 
                if (isSmall != previssmall && !is_first_meas && stIndex == prevstIndex) hassloverlap = true;
 
                is_first_meas = false;
                previssmall = isSmall;
                prevstIndex = stIndex;
 
                unsigned int ml = m_idHelperSvc->mdtIdHelper().multilayer(id);
                nmdtHitsMl1 += (ml ==1);
                nmdtHitsMl2 += (ml ==2);
            } else {
                measuresPhi = m_idHelperSvc->measuresPhi(id);
 
                const bool isRpc = m_idHelperSvc->isRpc(id);
                const bool isTgc = m_idHelperSvc->isTgc(id);
                nrpcHitsPhi += (measuresPhi && isRpc);
                nrpcHitsEta += (!measuresPhi && isRpc);
                
                ntgcHitsPhi += (measuresPhi && isTgc);
                ntgcHitsEta += (!measuresPhi && isTgc);
 
                ncscHitsPhi+= (measuresPhi && isCsc);
                ncscHitsEta+= (!measuresPhi && isCsc);             
                if (isCsc && recreateCSC) {
                    const auto* csc = dynamic_cast<const CscClusterOnTrack*>(meas);
                    if (!csc) {
                        ATH_MSG_WARNING(" found CscClusterOnTrack without CSC identifier " << m_idHelperSvc->toString(id));
                        continue;
                    }
                    ATH_MSG_DEBUG(" recreating CscClusterOnTrack ");
                    meas = entry.addToTrash
                      (std::unique_ptr<const MuonClusterOnTrack>
                       (m_cscRotCreator->createRIO_OnTrack(*csc->prepRawData(), csc->globalPosition())));
                }  
                
 
                // if selected create competing ROTs for trigger hits
                if (createComp && (isRpc || isTgc)) {
                    if (measuresPhi && m_createCompetingROTsPhi) {
                        addCluster(*meas, triggerHitsPhi);
                        continue;
                    } else if (!measuresPhi && m_createCompetingROTsEta) {
                        addCluster(*meas, triggerHitsEta);
                        continue;
                    }
                }
            }
 
            allHits.push_back(meas);
 
            if (measuresPhi) {
                phiHits.push_back(meas);
            } else {
                etaHits.push_back(meas);
            }
        }
 
        if (createComp) {
            if (m_createCompetingROTsEta && !triggerHitsEta.empty()) createAndAddCompetingROTs(triggerHitsEta, etaHits, allHits, entry);
            if (m_createCompetingROTsPhi && !triggerHitsPhi.empty()) createAndAddCompetingROTs(triggerHitsPhi, phiHits, allHits, entry);
        }
 
        entry.nmdtHitsMl1 = nmdtHitsMl1;
        entry.nmdtHitsMl2 = nmdtHitsMl2;
        entry.ncscHitsEta = ncscHitsEta;
        entry.ncscHitsPhi = ncscHitsPhi;
        entry.nrpcHitsEta = nrpcHitsEta;
        entry.nrpcHitsPhi = nrpcHitsPhi;
        entry.ntgcHitsEta = ntgcHitsEta;
        entry.ntgcHitsPhi = ntgcHitsPhi;
        if (!triggerHitsEta.empty() && etaHits.empty()) {
            ATH_MSG_WARNING("did not find any eta hits");
        }
        entry.setEtaHits(etaHits);
        if (!triggerHitsPhi.empty() && phiHits.empty()) {
            ATH_MSG_WARNING("did not find any phi hits");
        }
        entry.setPhiHits(phiHits);
        entry.setFakePhiHits(fakePhiHits);
        entry.setAllHits(allHits);
        entry.hasEndcap(hasEndcap);
        entry.hasSmallChamber(hasSmall);
        entry.hasLargeChamber(hasLarge);
        entry.hasSLOverlap(hassloverlap);       
    }

updateTrack()

bool Muon::MuPatCandidateTool::updateTrack	(	MuPatTrack &	candidate,
		std::unique_ptr< Trk::Track > &	track
	)		const

set the new track in the candidate, and update candidate contents.

Candidate takes ownership of track. Returns whether segments have been removed compared to the pre-existing list of segments.

Definition at line 108 of file MuPatCandidateTool.cxx.

                                                                                                    {
        candidate.updateTrack(track);
        return recalculateCandidateSegmentContent(candidate);
    }

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

m_compClusterCreator

ToolHandle<IMuonCompetingClustersOnTrackCreator> Muon::MuPatCandidateTool::m_compClusterCreator

private

Initial value:

{
            this, "CompetingClustersCreator", "Muon::TriggerChamberClusterOnTrackCreator/TriggerChamberClusterOnTrackCreator",
            "tool to create competing clusters on track"}

Definition at line 157 of file MuPatCandidateTool.h.

m_createCompetingROTsEta

Gaudi::Property<bool> Muon::MuPatCandidateTool::m_createCompetingROTsEta {this, "CreateCompetingROTsEta", true}

private

Definition at line 169 of file MuPatCandidateTool.h.

m_createCompetingROTsPhi

Gaudi::Property<bool> Muon::MuPatCandidateTool::m_createCompetingROTsPhi {this, "CreateCompetingROTsPhi", false}

private

Definition at line 168 of file MuPatCandidateTool.h.

m_cscRotCreator

ToolHandle<IMuonClusterOnTrackCreator> Muon::MuPatCandidateTool::m_cscRotCreator

private

Initial value:

{
            this, "CscRotCreator", "Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator", "tool to calibrate CSC hits"}

Definition at line 155 of file MuPatCandidateTool.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_doCscRecreation

Gaudi::Property<bool> Muon::MuPatCandidateTool::m_doCscRecreation {this, "DoCscRecreation", true}

private

Definition at line 171 of file MuPatCandidateTool.h.

m_doMdtRecreation

Gaudi::Property<bool> Muon::MuPatCandidateTool::m_doMdtRecreation {this, "DoMdtRecreation", false}

private

Definition at line 170 of file MuPatCandidateTool.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuPatCandidateTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 161 of file MuPatCandidateTool.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_hitHandler

ToolHandle<MuPatHitTool> Muon::MuPatCandidateTool::m_hitHandler {this, "HitTool", "Muon::MuPatHitTool/MuPatHitTool", "Tool to manipulate hit lists"}

private

Definition at line 164 of file MuPatCandidateTool.h.

m_idHelperSvc

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

private

Definition at line 160 of file MuPatCandidateTool.h.

m_mdtRotCreator

ToolHandle<IMdtDriftCircleOnTrackCreator> Muon::MuPatCandidateTool::m_mdtRotCreator

private

Initial value:

{
            this, "MdtRotCreator", "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator", "tool to calibrate MDT hits"}

Definition at line 153 of file MuPatCandidateTool.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuPatCandidateTool::m_printer {this, "MuonPrinterTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

private

Definition at line 163 of file MuPatCandidateTool.h.

m_segmentSelector

ToolHandle<Muon::IMuonSegmentSelectionTool> Muon::MuPatCandidateTool::m_segmentSelector

private

Initial value:

{
            this, "SegmentSelector", "Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool", "Tool to resolve track ambiguities"}

Definition at line 165 of file MuPatCandidateTool.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:

• MuPatCandidateTool.h
• MuPatCandidateTool.cxx