Muon::MuPatHitTool Class Reference

#include <MuPatHitTool.h>

Inheritance diagram for Muon::MuPatHitTool:

Collaboration diagram for Muon::MuPatHitTool:

Public Member Functions
	MuPatHitTool (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor
	~MuPatHitTool ()
	destructor
StatusCode	initialize () override
	initialize method, method taken from bass-class AlgTool
bool	create (const EventContext &ctx, const MuonSegment &seg, MuPatHitList &hitList) const
	create a MCTBList from a MuonSegment
bool	create (const Trk::Track &track, MuPatHitList &hitList) const
	create a MuPatHitList from a Track
bool	create (const EventContext &ctx, const Trk::TrackParameters &pars, const std::vector< const Trk::MeasurementBase * > &measVec, MuPatHitList &hitList) const
	create a MuPatHitList from a Track
std::string	print (const MuPatHitList &hitList, bool printPos=true, bool printDir=true, bool printMom=true) const
	print the list of hits, with optional parts of the printout (position,direction,momentum)
bool	remove (const Trk::MeasurementBase &meas, MuPatHitList &hitList) const
	remove hit containing give measurement (uses pointer comparison)
bool	update (const Trk::Track &track, MuPatHitList &hitList) const
	update hit list for a give track
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	access to tool interface
static MuPatHitList	merge (const MuPatHitList &hitList1, const MuPatHitList &hitList2)
	merge two MuPatHitLists into a new one
static bool	extract (const MuPatHitList &hitList, std::vector< const Trk::MeasurementBase * > &measVec, bool usePreciseHits=true, bool getReducedTrack=false)
	merge two MuPatHitLists into a new one.
static bool	isSorted (const MuPatHitList &hitList)
	check whether the list is correctly sorted
static bool	remove (const Identifier &id, MuPatHitList &hitList)
	remove hit with a give Identifier

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
MuPatHit::Type	getHitType (const Identifier &id) const
	get hit type
MuPatHit::Info	getHitInfo (const Trk::MeasurementBase &meas) const
	get hit info
std::unique_ptr< const Trk::MeasurementBase >	createBroadMeasurement (const Trk::MeasurementBase &preciseMeas, const MuPatHit::Info &hitInfo) const
	calculate broad measurement for a give precise measurement
void	calculateResiduals (const Trk::TrackStateOnSurface *tsos, Trk::ResidualPull::ResidualType type, double &residual, double &residualPull) const
	calculate the residuals
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Trk::IPropagator >	m_propagator
ToolHandle< IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
ToolHandle< IMuonClusterOnTrackCreator >	m_cscRotCreator
ToolHandle< Trk::IResidualPullCalculator >	m_pullCalculator
PublicToolHandle< MuonEDMPrinterTool >	m_printer
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
Trk::MagneticFieldProperties	m_magFieldProperties {Trk::NoField}
	magnetic field properties
Gaudi::Property< bool >	m_isCosmic
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 27 of file MuPatHitTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuPatHitTool()

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

default AlgTool constructor

Definition at line 26 of file MuPatHitTool.cxx.

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

~MuPatHitTool()

Muon::MuPatHitTool::~MuPatHitTool ( )

default

destructor

Member Function Documentation

calculateResiduals()

void Muon::MuPatHitTool::calculateResiduals ( const Trk::TrackStateOnSurface * tsos, Trk::ResidualPull::ResidualType type, double & residual, double & residualPull ) const

inlineprivate

calculate the residuals

Definition at line 397 of file MuPatHitTool.cxx.

                                                                        {
        std::optional<Trk::ResidualPull> resPull(
            m_pullCalculator->residualPull(tsos->measurementOnTrack(), tsos->trackParameters(), type));
        if (resPull) {
            residual = resPull->residual().front();
            residualPull = resPull->pull().front();
        } else {
            residual = residualPull = -999;
        }
    }

create() [1/3]

bool Muon::MuPatHitTool::create	(	const EventContext &	ctx,
		const MuonSegment &	seg,
		MuPatHitList &	hitList ) const

create a MCTBList from a MuonSegment

Parameters

seg	the MuonSegment
hitList	the list to be filled

Returns

true if creation succeded

Definition at line 44 of file MuPatHitTool.cxx.

                                                                                                          {
        ATH_MSG_DEBUG(" creating hit list from segment " << std::endl << m_printer->print(seg));
 
        // create parameters with very large momentum and no charge
        double momentum{1.e8}, charge{0.};
        std::unique_ptr<const Trk::TrackParameters> pars{m_edmHelperSvc->createTrackParameters(seg, momentum, charge)};
        if (!pars) {
            ATH_MSG_WARNING(" could not create track parameters for segment ");
            return false;
        }
 
        return create(ctx, *pars, seg.containedMeasurements(), hitList);
    }

create() [2/3]

bool Muon::MuPatHitTool::create	(	const EventContext &	ctx,
		const Trk::TrackParameters &	pars,
		const std::vector< const Trk::MeasurementBase * > &	measVec,
		MuPatHitList &	hitList ) const

create a MuPatHitList from a Track

Parameters

pars	the input parameters
measVec	the list of measurements
hitList	the list to be filled

Returns

true if creation succeded

Definition at line 58 of file MuPatHitTool.cxx.

                                                                                                                {
        // loop over hits
        for (const Trk::MeasurementBase* meas : measVec) {
            // create hit info
            MuPatHit::Info hitInfo = getHitInfo(*meas);
 
            const Identifier& id = hitInfo.id;
            if (hitInfo.type == MuPatHit::UnknownType) {
                ATH_MSG_WARNING(" unknown hit type " << m_idHelperSvc->toString(id));
                continue;
            }
 
            // create broad measurement
            std::unique_ptr<const Trk::MeasurementBase> broadMeas = createBroadMeasurement(*meas, hitInfo);
            if (!broadMeas) {
                ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperSvc->toString(id));
                continue;
            }
            // extrapolate
            std::unique_ptr<const Trk::TrackParameters> exPars;
            if (pars.associatedSurface() == broadMeas->associatedSurface()) {
                exPars = pars.uniqueClone();
                ATH_MSG_VERBOSE(" start parameters and measurement expressed at same surface, cloning parameters ");
            } else {
                exPars = m_propagator->propagate(ctx, pars, broadMeas->associatedSurface(), Trk::anyDirection, false, m_magFieldProperties);
                if (!exPars) { continue; }  // !exPars
            }
 
            // create hit and insert it into list
            ATH_MSG_VERBOSE(" inserting hit " << m_idHelperSvc->toString(id) << " " << m_printer->print(*exPars));
            std::unique_ptr<MuPatHit> hit = std::make_unique<MuPatHit>(std::move(exPars), meas->uniqueClone(), std::move(broadMeas), hitInfo);
            hitList.push_back(std::move(hit));
        }
 
        const SortByDirectionMuPatHits isLargerCal{pars};
        std::stable_sort(hitList.begin(), hitList.end(), isLargerCal);
        return true;
    }

create() [3/3]

bool Muon::MuPatHitTool::create	(	const Trk::Track &	track,
		MuPatHitList &	hitList ) const

create a MuPatHitList from a Track

Parameters

track	the input track
hitList	the list to be filled

Returns

true if creation succeded

Definition at line 98 of file MuPatHitTool.cxx.

                                                                                {
        // loop over hits
        for (const Trk::TrackStateOnSurface* tsit : *track.trackStateOnSurfaces()) {
            // do not take into account scatteres and holes for now
            if (tsit->type(Trk::TrackStateOnSurface::Scatterer) ||
                tsit->type(Trk::TrackStateOnSurface::Hole)) continue;
 
            const Trk::MeasurementBase* meas = tsit->measurementOnTrack();
            if (!meas) continue;
 
            const Trk::TrackParameters* pars = tsit->trackParameters();
            if (!pars) continue;
 
            // create hit info
            MuPatHit::Info hitInfo = getHitInfo(*meas);
 
            if (tsit->type(Trk::TrackStateOnSurface::Outlier)) hitInfo.status = MuPatHit::Outlier;
 
            const Identifier& id = hitInfo.id;
 
            if (!m_idHelperSvc->isMuon(id)) continue;
 
            if (hitInfo.type == MuPatHit::UnknownType) {
                ATH_MSG_WARNING(" unknown hit type " << m_idHelperSvc->toString(id));
                continue;
            }
 
            // create broad measurement
            std::unique_ptr<const Trk::MeasurementBase> broadMeas = createBroadMeasurement(*meas, hitInfo);
            if (!broadMeas) {
                ATH_MSG_WARNING(" could not create broad measurement " << m_idHelperSvc->toString(id));
                continue;
            }
 
            // create hit and insert it into list
            std::unique_ptr<MuPatHit> hit = std::make_unique<MuPatHit>(pars->uniqueClone(), meas->uniqueClone(), std::move(broadMeas), hitInfo);
            ATH_MSG_VERBOSE(" inserting hit " << m_printer->print(*meas) << (hitInfo.status == MuPatHit::Outlier ? " Outlier" : ""));
            double residual{0.}, pull{0.};
            calculateResiduals(tsit, Trk::ResidualPull::Unbiased, residual, pull);
            hit->setResidual(residual,pull);
            hitList.push_back(std::move(hit));
        }
 
        const Trk::TrackParameters* pars = track.perigeeParameters();
        const SortByDirectionMuPatHits isLargerCal{*pars};
        std::stable_sort(hitList.begin(), hitList.end(), isLargerCal);
 
        return true;
    }

createBroadMeasurement()

std::unique_ptr< const Trk::MeasurementBase > Muon::MuPatHitTool::createBroadMeasurement ( const Trk::MeasurementBase & preciseMeas, const MuPatHit::Info & hitInfo ) const

private

calculate broad measurement for a give precise measurement

Definition at line 251 of file MuPatHitTool.cxx.

                                                                                                                        {
        // don't change errors for Pseudo measurements
        if (hitInfo.type == MuPatHit::MDT) {
            const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(&meas);
            if (!mdt) {
                ATH_MSG_WARNING(" found hit with a MDT Identifier that is not a MdtDriftCircleOnTrack "
                                << m_idHelperSvc->toString(hitInfo.id));
                return nullptr;
            }
            ATH_MSG_DEBUG(" creating broad MdtDriftCircleOnTrack ");
 
            return std::unique_ptr<const Trk::MeasurementBase>(m_mdtRotCreator->updateError(*mdt));
 
        } else if (hitInfo.type == MuPatHit::CSC && !hitInfo.measuresPhi) {
            if (m_cscRotCreator.empty()) {
                // Configured to not use CSC's
                return nullptr;
            }
            const CscClusterOnTrack* csc = dynamic_cast<const CscClusterOnTrack*>(&meas);
            if (!csc) {
                ATH_MSG_WARNING(" found hit with CSC identifier that is not a CscClusterOnTrack " << m_idHelperSvc->toString(hitInfo.id));
                return nullptr;
            }
            ATH_MSG_DEBUG(" creating broad CscClusterOnTrack ");
 
            return std::unique_ptr<const Trk::MeasurementBase>(
                m_cscRotCreator->createRIO_OnTrack(*csc->prepRawData(), csc->globalPosition()));
        }
 
        // don't change errors for CSC phi hits, TGC, RPC and Pseudo measurements
        return meas.uniqueClone();
    }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extract()

bool Muon::MuPatHitTool::extract ( const MuPatHitList & hitList, std::vector< const Trk::MeasurementBase * > & measVec, bool usePreciseHits = true, bool getReducedTrack = false )

static

merge two MuPatHitLists into a new one.

The first list will be added to the second

Parameters

hitList1	the first list
hitList2	the second list

Returns

true if merge succeded

Definition at line 171 of file MuPatHitTool.cxx.

                                       {
        // make sure the vector is sufficiently large
        measVec.reserve(hitList.size());
 
        // loop over hit list
        for (const MuPatHitPtr& hit : hitList) {
            if (hit->info().status != MuPatHit::OnTrack) { continue; }
            const Trk::MeasurementBase* meas = usePreciseHits ? &hit->preciseMeasurement() : &hit->broadMeasurement();
            measVec.push_back(meas);
        }
        return true;
    }

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

getHitInfo()

MuPatHit::Info Muon::MuPatHitTool::getHitInfo ( const Trk::MeasurementBase & meas ) const

private

get hit info

Definition at line 233 of file MuPatHitTool.cxx.

                                                                              {
        MuPatHit::Info hitInfo{};
        hitInfo.id = m_edmHelperSvc->getIdentifier(meas);
        // for clusters store layer id instead of channel id
        hitInfo.measuresPhi = true;  // assume that all PseudoMeasurements measure phi!!
        hitInfo.type = MuPatHit::Pseudo;
        hitInfo.status = MuPatHit::OnTrack;
        if (hitInfo.id.is_valid() && m_idHelperSvc->isMuon(hitInfo.id)) {
            hitInfo.type = getHitType(hitInfo.id);
            hitInfo.measuresPhi = m_idHelperSvc->measuresPhi(hitInfo.id);
            hitInfo.isSmall = m_idHelperSvc->isSmallChamber(hitInfo.id);
            hitInfo.stIdx = m_idHelperSvc->stationIndex(hitInfo.id);
            hitInfo.isEndcap = m_idHelperSvc->isEndcap(hitInfo.id);
            if (hitInfo.type != MuPatHit::MDT && hitInfo.type != MuPatHit::MM) hitInfo.id = m_idHelperSvc->layerId(hitInfo.id);
        }
        return hitInfo;
    }

getHitType()

MuPatHit::Type Muon::MuPatHitTool::getHitType ( const Identifier & id ) const

private

get hit type

Definition at line 215 of file MuPatHitTool.cxx.

                                                                    {
        if (m_idHelperSvc->isMdt(id))
            return MuPatHit::MDT;
        else if (m_idHelperSvc->isTgc(id))
            return MuPatHit::TGC;
        else if (m_idHelperSvc->isCsc(id))
            return MuPatHit::CSC;
        else if (m_idHelperSvc->isRpc(id))
            return MuPatHit::RPC;
        else if (m_idHelperSvc->isMM(id))
            return MuPatHit::MM;
        else if (m_idHelperSvc->issTgc(id))
            return MuPatHit::sTGC;
        else if (m_idHelperSvc->isMuon(id))
            return MuPatHit::PREC;
        return MuPatHit::UnknownType;
    }

initialize()

StatusCode Muon::MuPatHitTool::initialize ( )

override

initialize method, method taken from bass-class AlgTool

Definition at line 32 of file MuPatHitTool.cxx.

                                        {
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_mdtRotCreator.retrieve());
        ATH_CHECK(m_cscRotCreator.retrieve(DisableTool{m_cscRotCreator.empty()}));
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_pullCalculator.retrieve());
        ATH_CHECK(m_propagator.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()

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

inlinestatic

access to tool interface

Definition at line 39 of file MuPatHitTool.h.

                                                {
            static const InterfaceID IID_MuPatHitTool("Muon::MuPatHitTool", 1, 0);
            return IID_MuPatHitTool;
        }

isSorted()

bool Muon::MuPatHitTool::isSorted ( const MuPatHitList & hitList )

static

check whether the list is correctly sorted

Definition at line 381 of file MuPatHitTool.cxx.

                                                           {
        MuPatHitCit it = hitList.begin();
        MuPatHitCit it_end = hitList.end();
        MuPatHitCit itNext = it;
        if (itNext != it_end) ++itNext;
        bool isLarger = true;
        const Trk::TrackParameters& pars{hitList.front()->parameters()};
        const SortByDirectionMuPatHits isLargerCal{pars};
        for (; itNext != it_end; ++it, ++itNext) {
            isLarger = isLargerCal(*it, *itNext);
            bool sameSurface = (isLarger == isLargerCal(*it, *itNext));  // same surface
            if (!isLarger && !sameSurface) return false;
            if (sameSurface) return false;
        }
        return true;
    }

merge()

MuPatHitList Muon::MuPatHitTool::merge ( const MuPatHitList & hitList1, const MuPatHitList & hitList2 )

static

merge two MuPatHitLists into a new one

Parameters

hitList1	the first list
hitList2	the second list
outList	the resulting list

Returns

true if merge succeded

Loop another time to ensure that duplicate hits are removed

Definition at line 148 of file MuPatHitTool.cxx.

                                                                                               {
        // copy first list into outList
        MuPatHitList tmpList{};
        tmpList.reserve(hitList1.size() + hitList2.size());
 
        if (!hitList1.empty()) {
            const Trk::TrackParameters& pars{hitList1.front()->parameters()};
            const SortByDirectionMuPatHits isLargerCal{pars};
            std::merge(hitList1.begin(), hitList1.end(), hitList2.begin(), hitList2.end(),
                            std::back_inserter(tmpList), isLargerCal);
        } else {
            return hitList2;
        }
        MuPatHitList outList{};
        outList.reserve(tmpList.size());
        std::set<Identifier> used_hits{};
        std::copy_if(std::make_move_iterator(tmpList.begin()), std::make_move_iterator(tmpList.end()), std::back_inserter(outList),
                     [&used_hits](const MuPatHitPtr& pathit) { return used_hits.insert(pathit->info().id).second; });
 
        return outList;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

print()

std::string Muon::MuPatHitTool::print	(	const MuPatHitList &	hitList,
		bool	printPos = true,
		bool	printDir = true,
		bool	printMom = true ) const

print the list of hits, with optional parts of the printout (position,direction,momentum)

Definition at line 314 of file MuPatHitTool.cxx.

                                                                                                                {
        std::ostringstream sout;
        DistanceAlongParameters distCal{};
 
        // for nicely aligned printout, get max width of Id printout
        std::vector<std::string> idStrings;
        std::vector<std::string> dataStrings;
        idStrings.reserve(hitList.size());
        unsigned int idWidth = 0;
        std::string result = "first  ";
        bool isLarger = true;
        double distance = 0;
        MuPatHitCit it = hitList.begin();
        MuPatHitCit it_end = hitList.end();
        MuPatHitCit itNext = hitList.begin();
 
        const Trk::TrackParameters& pars{hitList.front()->parameters()};
        const SortByDirectionMuPatHits isLargerCal{pars};
 
        if (itNext != it_end) ++itNext;
        for (; it != it_end; ++it, ++itNext) {
 
            Identifier id = m_edmHelperSvc->getIdentifier((*it)->measurement());
            std::string idStr = id.is_valid() ? m_idHelperSvc->toString(id) : "pseudo-measurement";
            idStrings.push_back(idStr);
            if (idStr.length() > idWidth) idWidth = idStr.length();
            const Trk::TrackParameters& pars = (*it)->parameters();
            std::ostringstream dataOss;
            if (printPos) {
                dataOss << "r " << std::fixed << std::setprecision(0) << std::setw(5) << pars.position().perp() << " z " << std::fixed
                        << std::setprecision(0) << std::setw(6) << pars.position().z();
            }
            if (printDir) {
                dataOss << " theta " << std::fixed << std::setprecision(5) << std::setw(7) << pars.momentum().theta() << " phi "
                        << std::fixed << std::setprecision(3) << std::setw(6) << pars.momentum().phi();
            }
            if (printMom) {
                dataOss << " q*p(GeV) " << std::scientific << std::setprecision(3) << std::setw(10)
                        << pars.momentum().mag() * pars.charge() / 1000.;
            }
 
 
            dataOss << "  " << result << " dist " << distance;
            dataStrings.push_back(dataOss.str());
            if (itNext != it_end) {
                isLarger = isLargerCal(*it, *itNext);
 
                distance = distCal(*it, *itNext);
                result = isLarger ? "larger " : "smaller";
 
                if (isLarger == isLargerCal(*itNext, *it)) {
                    result = "duplicate";
                } else if (!isLarger) {
                    result += "   sorting problem ";
                }
            }
        }
 
        // second loop to print out aligned strings
        unsigned int n = idStrings.size();
        for (unsigned int i = 0; i < n; ++i) {
            sout << "  " << std::left << std::setw(idWidth) << idStrings[i] << std::right << " " << dataStrings[i];
            if (i != n - 1) sout << std::endl;
        }
 
        return sout.str();
    }

remove() [1/2]

bool Muon::MuPatHitTool::remove ( const Identifier & id, MuPatHitList & hitList )

static

remove hit with a give Identifier

Definition at line 185 of file MuPatHitTool.cxx.

                                                                         {
        // loop over hit list
        MuPatHitIt lit = hitList.begin(), lit_end = hitList.end();
        for (; lit != lit_end; ++lit) {
            const MuPatHit& hit = **lit;
            if (hit.info().id == id) {
                hitList.erase(lit);
                return true;
            }
        }
        // if we get here the hit was not found
        return false;
    }

remove() [2/2]

bool Muon::MuPatHitTool::remove	(	const Trk::MeasurementBase &	meas,
		MuPatHitList &	hitList ) const

remove hit containing give measurement (uses pointer comparison)

Definition at line 199 of file MuPatHitTool.cxx.

                                                                                         {
        // loop over hit list
        const Identifier meas_id = m_edmHelperSvc->getIdentifier(meas);
        MuPatHitIt lit = hitList.begin(), lit_end = hitList.end();
        for (; lit != lit_end; ++lit) {
            const MuPatHit& hit = **lit;
            if (m_edmHelperSvc->getIdentifier(hit.preciseMeasurement()) == meas_id ||
                m_edmHelperSvc->getIdentifier(hit.broadMeasurement()) == meas_id) {
                hitList.erase(lit);
                return true;
            }
        }
        // if we get here the hit was not found
        return false;
    }

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

update()

bool Muon::MuPatHitTool::update	(	const Trk::Track &	track,
		MuPatHitList &	hitList ) const

update hit list for a give track

Definition at line 285 of file MuPatHitTool.cxx.

                                                                                {
        const DataVector<const Trk::MeasurementBase>* measurements = track.measurementsOnTrack();
        if (!measurements) return false;
 
        std::set<Identifier> ids;
 
        DataVector<const Trk::MeasurementBase>::const_iterator mit = measurements->begin();
        DataVector<const Trk::MeasurementBase>::const_iterator mit_end = measurements->end();
        for (; mit != mit_end; ++mit) {
            Identifier id = m_edmHelperSvc->getIdentifier(**mit);
            if (!id.is_valid()) continue;
 
            if (!m_idHelperSvc->isMdt(id)) id = m_idHelperSvc->layerId(id);
 
            ids.insert(id);
        }
 
        // loop over hit list
        MuPatHitIt lit = hitList.begin(), lit_end = hitList.end();
        for (; lit != lit_end; ++lit) {
            MuPatHit& hit = **lit;
            if (!ids.count(hit.info().id)) {
                hit.info().status = MuPatHit::Outlier;
                continue;
            }
        }
        return true;
    }

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_cscRotCreator

ToolHandle<IMuonClusterOnTrackCreator> Muon::MuPatHitTool::m_cscRotCreator

private

Initial value:

{
            this,
            "CscRotCreator",
            "Muon::CscClusterOnTrackCreator/CscClusterOnTrackCreator",
        }

Definition at line 123 of file MuPatHitTool.h.

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

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuPatHitTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 145 of file MuPatHitTool.h.

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

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Muon::MuPatHitTool::m_idHelperSvc

private

Initial value:

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

Definition at line 140 of file MuPatHitTool.h.

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

m_isCosmic

Gaudi::Property<bool> Muon::MuPatHitTool::m_isCosmic

private

Initial value:

{this, "isCosmic", false,
                                         "Toggle whether the job runs on cosmic data. That influences the hit sorting on track"}

Definition at line 154 of file MuPatHitTool.h.

                                      {this, "isCosmic", false,
                                         "Toggle whether the job runs on cosmic data. That influences the hit sorting on track"};

m_magFieldProperties

Trk::MagneticFieldProperties Muon::MuPatHitTool::m_magFieldProperties {Trk::NoField}

private

magnetic field properties

Definition at line 152 of file MuPatHitTool.h.

{Trk::NoField};  

m_mdtRotCreator

ToolHandle<IMdtDriftCircleOnTrackCreator> Muon::MuPatHitTool::m_mdtRotCreator

private

Initial value:

{
            this,
            "MdtRotCreator",
            "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator",
        }

Definition at line 118 of file MuPatHitTool.h.

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

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuPatHitTool::m_printer

private

Initial value:

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

Definition at line 134 of file MuPatHitTool.h.

                                                      {
            this,
            "Printer",
            "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
        };  //<! tool to print EDM objects

m_propagator

ToolHandle<Trk::IPropagator> Muon::MuPatHitTool::m_propagator

private

Initial value:

{
            this,
            "AtlasRungeKuttaPropagator",
            "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator",
        }

Definition at line 113 of file MuPatHitTool.h.

                                               {
            this,
            "AtlasRungeKuttaPropagator",
            "Trk::RungeKuttaPropagator/AtlasRungeKuttaPropagator",
        };

m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> Muon::MuPatHitTool::m_pullCalculator

private

Initial value:

{
            this,
            "ResidualPullCalculator",
            "Trk::ResidualPullCalculator/ResidualPullCalculator",
        }

Definition at line 129 of file MuPatHitTool.h.

                                                               {
            this,
            "ResidualPullCalculator",
            "Trk::ResidualPullCalculator/ResidualPullCalculator",
        };  //<! tool to calculate residuals and pulls

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:

• MuPatHitTool.h
• MuPatHitTool.cxx