#include <DataFormats/MuonReco/interface/Muon.h>

Inheritance diagram for reco::Muon:

Public Types
enum	ArbitrationType { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned }
	define arbitration schemes More...

typedef std::map < MuonTrackType, reco::TrackRef >	MuonTrackRefMap

enum	MuonTrackType { None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT }
	map for Global Muon refitters More...

typedef std::pair< TrackRef, Muon::MuonTrackType >	MuonTrackTypePair

Public Types inherited from reco::RecoCandidate
enum	TrackType { noTrackType, recoTrackType, gsfTrackType }
	track type More...

Public Types inherited from reco::LeafCandidate
typedef int	Charge
	electric charge type More...

typedef CandidateCollection	daughters
	collection of daughter candidates More...

typedef unsigned int	index

typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...

typedef math::XYZPoint	Point
	point in the space More...

typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...

typedef math::XYZVector	Vector
	point in the space More...

Public Types inherited from reco::Candidate
enum	{ dimension = 3 }

enum	{ size = dimension * (dimension + 1)/2 }
	matix size More...

typedef int	Charge
	electric charge type More...

typedef candidate::const_iterator	const_iterator

typedef math::Error< dimension > ::type	CovarianceMatrix
	covariance error matrix (3x3) More...

typedef unsigned int	index
	index type More...

typedef candidate::iterator	iterator

typedef math::XYZTLorentzVector	LorentzVector
	Lorentz vector. More...

typedef math::XYZPoint	Point
	point in the space More...

typedef math::PtEtaPhiMLorentzVector	PolarLorentzVector
	Lorentz vector. More...

typedef size_t	size_type

typedef math::XYZVector	Vector
	point in the space More...

Public Member Functions
virtual const Track *	bestTrack () const
	best track pointer More...

virtual TrackBaseRef	bestTrackRef () const
	best track RefToBase More...

MuonEnergy	calEnergy () const
	get energy deposition information More...

float	caloCompatibility () const

Muon *	clone () const
	create a clone More...

virtual TrackRef	combinedMuon () const
	reference to a stand-alone muon Track More...

MuonQuality	combinedQuality () const
	get energy deposition information More...

float	dDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	dDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	dX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	dY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

virtual TrackRef	dytTrack () const

virtual TrackRef	globalTrack () const
	reference to Track reconstructed in both tracked and muon detector More...

virtual TrackRef	innerTrack () const

bool	isAValidMuonTrack (const MuonTrackType &type) const

bool	isCaloCompatibilityValid () const

bool	isCaloMuon () const

bool	isEnergyValid () const

bool	isGlobalMuon () const

bool	isIsolationValid () const

bool	isMatchesValid () const

bool	isMuon () const

const MuonIsolation &	isolationR03 () const

const MuonIsolation &	isolationR05 () const

bool	isPFIsolationValid () const

bool	isPFMuon () const

bool	isQualityValid () const

bool	isRPCMuon () const

bool	isStandAloneMuon () const

bool	isTimeValid () const

bool	isTrackerMuon () const

std::vector< MuonChamberMatch > &	matches ()
	get muon matching information More...

const std::vector < MuonChamberMatch > &	matches () const

	Muon ()

	Muon (Charge, const LorentzVector &, const Point &=Point(0, 0, 0))
	constructor from values More...

virtual TrackRef	muonBestTrack () const

virtual MuonTrackType	muonBestTrackType () const

TrackRef	muonTrack (const MuonTrackType &) const

TrackRef	muonTrackFromMap (const MuonTrackType &type) const

int	numberOfChambers () const

int	numberOfChambersNoRPC () const
	number of chambers not including RPC matches (MuonChamberMatches include RPC rolls) More...

int	numberOfMatchedStations (ArbitrationType type=SegmentAndTrackArbitration) const

int	numberOfMatches (ArbitrationType type=SegmentAndTrackArbitration) const
	get number of chambers with matched segments More...

int	numberOfSegments (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const
	get number of segments More...

virtual TrackRef	outerTrack () const
	reference to Track reconstructed in the muon detector only More...

const MuonPFIsolation &	pfIsolationR03 () const

const MuonPFIsolation &	pfIsolationR04 () const

reco::Candidate::LorentzVector	pfP4 () const

virtual TrackRef	pickyTrack () const

float	pullDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const

float	pullDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const

float	pullX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const

float	pullY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration, bool includeSegmentError=true) const

float	segmentDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentDxDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentDyDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentXErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	segmentYErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

virtual void	setBestTrack (MuonTrackType muonType)

void	setCalEnergy (const MuonEnergy &calEnergy)
	set energy deposition information More...

void	setCaloCompatibility (float input)

virtual void	setCombined (const TrackRef &t)

void	setCombinedQuality (const MuonQuality &combinedQuality)
	set energy deposition information More...

virtual void	setGlobalTrack (const TrackRef &t)
	set reference to Track More...

virtual void	setInnerTrack (const TrackRef &t)
	set reference to Track More...

void	setIsolation (const MuonIsolation &isoR03, const MuonIsolation &isoR05)

void	setMatches (const std::vector< MuonChamberMatch > &matches)
	set muon matching information More...

void	setMuonTrack (const MuonTrackType &, const TrackRef &)

virtual void	setOuterTrack (const TrackRef &t)
	set reference to Track More...

void	setPFIsolation (const MuonPFIsolation &isoR03, const MuonPFIsolation &isoR04)

virtual void	setPFP4 (const reco::Candidate::LorentzVector &p4_)

virtual void	setStandAlone (const TrackRef &t)

void	setTime (const MuonTime &time)
	set timing information More...

virtual void	setTrack (const TrackRef &t)

void	setType (unsigned int type)

virtual TrackRef	standAloneMuon () const
	reference to a stand-alone muon Track More...

unsigned int	stationGapMaskDistance (float distanceCut=10.) const

unsigned int	stationGapMaskPull (float sigmaCut=3.) const
	same as above for given number of sigmas More...

unsigned int	stationMask (ArbitrationType type=SegmentAndTrackArbitration) const

float	t0 (int n=0)

MuonTime	time () const
	get timing information More...

virtual TrackRef	tpfmsTrack () const

virtual TrackRef	track () const
	reference to a Track More...

float	trackDist (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackDistErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackDxDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackDxDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackDyDz (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackDyDzErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackEdgeX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackEdgeY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackX (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackXErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackY (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

float	trackYErr (int station, int muonSubdetId, ArbitrationType type=SegmentAndTrackArbitration) const

unsigned int	type () const

Public Member Functions inherited from reco::RecoCandidate
virtual TrackType	bestTrackType () const
	track type More...

virtual CaloTowerRef	caloTower () const
	reference to a CaloTower More...

virtual reco::GsfTrackRef	gsfTrack () const
	reference to a GsfTrack More...

virtual size_t	numberOfTracks () const
	number of multiple Tracks More...

	RecoCandidate ()
	default constructor More...

	RecoCandidate (Charge q, const LorentzVector &p4, const Point &vtx=Point(0, 0, 0), int pdgId=0, int status=0)
	constructor from values More...

	RecoCandidate (Charge q, const PolarLorentzVector &p4, const Point &vtx=Point(0, 0, 0), int pdgId=0, int status=0)
	constructor from values More...

virtual reco::SuperClusterRef	superCluster () const
	reference to a SuperCluster More...

virtual reco::TrackRef	track (size_t) const
	reference to one of multiple Tracks More...

virtual	~RecoCandidate ()
	destructor More...

Public Member Functions inherited from reco::LeafCandidate
virtual const_iterator	begin () const
	first daughter const_iterator More...

virtual iterator	begin ()
	first daughter iterator More...

template<typename S >
daughter_iterator< S >::type	beginFilter (const S &s) const

virtual Vector	boostToCM () const

virtual int	charge () const
	electric charge More...

virtual const Candidate *	daughter (size_type) const
	return daughter at a given position (throws an exception) More...

virtual Candidate *	daughter (size_type)
	return daughter at a given position (throws an exception) More...

virtual Candidate *	daughter (const std::string &s)
	return daughter with a specified role name More...

virtual const Candidate *	daughter (const std::string &s) const
	return daughter with a specified role name More...

virtual const_iterator	end () const
	last daughter const_iterator More...

virtual iterator	end ()
	last daughter iterator More...

template<typename S >
daughter_iterator< S >::type	endFilter (const S &s) const

virtual double	energy () const
	energy More...

virtual double	et () const
	transverse energy More...

virtual double	eta () const
	momentum pseudorapidity More...

virtual void	fillVertexCovariance (CovarianceMatrix &v) const
	fill SMatrix More...

template<typename T >
T	get () const
	get a component More...

template<typename T , typename Tag >
T	get () const
	get a component More...

template<typename T >
T	get (size_type i) const
	get a component More...

template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...

virtual bool	hasMasterClone () const

virtual bool	hasMasterClonePtr () const

virtual bool	isConvertedPhoton () const

virtual bool	isElectron () const

virtual bool	isJet () const

virtual bool	isPhoton () const

	LeafCandidate ()
	default constructor More...

	LeafCandidate (const Candidate &c)

	LeafCandidate (Charge q, const LorentzVector &p4, const Point &vtx=Point(0, 0, 0), int pdgId=0, int status=0, bool integerCharge=true)
	constructor from values More...

	LeafCandidate (Charge q, const PolarLorentzVector &p4, const Point &vtx=Point(0, 0, 0), int pdgId=0, int status=0, bool integerCharge=true)
	constructor from values More...

virtual bool	longLived () const
	is long lived? More...

virtual double	mass () const
	mass More...

virtual bool	massConstraint () const
	do mass constraint? More...

virtual double	massSqr () const
	mass squared More...

virtual const CandidateBaseRef &	masterClone () const

virtual const CandidatePtr &	masterClonePtr () const

template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...

virtual Vector	momentum () const
	spatial momentum vector More...

virtual const Candidate *	mother (size_type) const
	return mother at a given position (throws an exception) More...

virtual double	mt () const
	transverse mass More...

virtual double	mtSqr () const
	transverse mass squared More...

template<typename T >
size_type	numberOf () const
	number of components More...

template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...

virtual size_t	numberOfDaughters () const
	number of daughters More...

virtual size_t	numberOfMothers () const
	number of mothers More...

virtual size_t	numberOfSourceCandidatePtrs () const

virtual double	p () const
	magnitude of momentum vector More...

virtual const LorentzVector &	p4 () const
	four-momentum Lorentz vector More...

virtual int	pdgId () const
	PDG identifier. More...

virtual double	phi () const
	momentum azimuthal angle More...

virtual const PolarLorentzVector &	polarP4 () const
	four-momentum Lorentz vector More...

virtual double	pt () const
	transverse momentum More...

virtual double	px () const
	x coordinate of momentum vector More...

virtual double	py () const
	y coordinate of momentum vector More...

virtual double	pz () const
	z coordinate of momentum vector More...

virtual double	rapidity () const
	rapidity More...

virtual void	setCharge (Charge q)
	set electric charge More...

virtual void	setLongLived ()
	set long lived flag More...

virtual void	setMass (double m)
	set particle mass More...

virtual void	setMassConstraint ()
	set mass constraint flag More...

virtual void	setP4 (const LorentzVector &p4)
	set 4-momentum More...

virtual void	setP4 (const PolarLorentzVector &p4)
	set 4-momentum More...

virtual void	setPdgId (int pdgId)

virtual void	setPz (double pz)

virtual void	setStatus (int status)
	set status word More...

virtual void	setThreeCharge (Charge qx3)
	set electric charge More...

virtual void	setVertex (const Point &vertex)
	set vertex More...

virtual CandidatePtr	sourceCandidatePtr (size_type i) const

virtual int	status () const
	status word More...

virtual double	theta () const
	momentum polar angle More...

virtual int	threeCharge () const
	electric charge More...

virtual const Point &	vertex () const
	vertex position More...

virtual double	vertexChi2 () const
	chi-squares More...

virtual double	vertexCovariance (int i, int j) const
	(i, j)-th element of error matrix, i, j = 0, ... 2 More...

CovarianceMatrix	vertexCovariance () const
	return SMatrix More...

virtual double	vertexNdof () const

virtual double	vertexNormalizedChi2 () const
	chi-squared divided by n.d.o.f. More...

virtual double	vx () const
	x coordinate of vertex position More...

virtual double	vy () const
	y coordinate of vertex position More...

virtual double	vz () const
	z coordinate of vertex position More...

virtual double	y () const
	rapidity More...

virtual	~LeafCandidate ()
	destructor More...

Public Member Functions inherited from reco::Candidate
template<typename S >
daughter_iterator< S >::type	beginFilter (const S &s) const

	Candidate ()
	default constructor More...

template<typename S >
daughter_iterator< S >::type	endFilter (const S &s) const

template<typename T >
T	get () const
	get a component More...

template<typename T , typename Tag >
T	get () const
	get a component More...

template<typename T >
T	get (size_type i) const
	get a component More...

template<typename T , typename Tag >
T	get (size_type i) const
	get a component More...

template<typename Ref >
Ref	masterRef () const
	cast master clone reference to a concrete type More...

template<typename T >
size_type	numberOf () const
	number of components More...

template<typename T , typename Tag >
size_type	numberOf () const
	number of components More...

virtual void	setSourceCandidatePtr (const CandidatePtr &ptr)
	Set the ptr to the source Candidate. More...

virtual	~Candidate ()
	destructor More...

Static Public Attributes
static const unsigned int	CaloMuon = 1<<4

static const unsigned int	GlobalMuon = 1<<1

static const unsigned int	PFMuon = 1<<5

static const unsigned int	RPCMuon = 1<<6

static const unsigned int	StandAloneMuon = 1<<3

static const unsigned int	TrackerMuon = 1<<2

Static Public Attributes inherited from reco::LeafCandidate
static const unsigned int	longLivedTag = 65536
	long lived flag More...

static const unsigned int	massConstraintTag = 131072
	do mass constraint flag More...

Private Member Functions
const std::vector< const MuonChamberMatch * >	chambers (int station, int muonSubdetId) const
	get vector of muon chambers for given station and detector More...

virtual bool	overlap (const Candidate &) const
	check overlap with another candidate More...

std::pair< const MuonChamberMatch , const MuonSegmentMatch >	pair (const std::vector< const MuonChamberMatch * > &, ArbitrationType type=SegmentAndTrackArbitration) const
	get pointers to best segment and corresponding chamber in vector of chambers More...

Private Attributes
MuonTrackType	bestTrackType_
	reference to the Track chosen to assign the momentum value to the muon More...

MuonEnergy	calEnergy_
	energy deposition More...

float	caloCompatibility_
	muon hypothesis compatibility with observer calorimeter energy More...

MuonQuality	combinedQuality_
	quality block More...

bool	energyValid_

TrackRef	globalTrack_
	reference to Track reconstructed in both tracked and muon detector More...

TrackRef	innerTrack_
	reference to Track reconstructed in the tracker only More...

MuonIsolation	isolationR03_
	Isolation information for two cones with dR=0.3 and dR=0.5. More...

MuonIsolation	isolationR05_

bool	isolationValid_

bool	matchesValid_

std::vector< MuonChamberMatch >	muMatches_
	Information on matching between tracks and segments. More...

TrackRef	outerTrack_
	reference to Track reconstructed in the muon detector only More...

MuonPFIsolation	pfIsolationR03_
	PF Isolation information for two cones with dR=0.3 and dR=0.4. More...

MuonPFIsolation	pfIsolationR04_

bool	pfIsolationValid_

reco::Candidate::LorentzVector	pfP4_

bool	qualityValid_

MuonTrackRefMap	refittedTrackMap_
	reference to the Global Track refitted with dedicated TeV reconstructors More...

MuonTime	time_
	timing More...

unsigned int	type_
	muon type mask More...

Additional Inherited Members
Protected Member Functions inherited from reco::RecoCandidate
template<typename R >
bool	checkOverlap (const R &r1, const R &r2) const
	check if two components overlap More...

Protected Member Functions inherited from reco::LeafCandidate
void	cacheCartesian () const
	set internal cache More...

void	cachePolar () const
	set internal cache More...

void	clearCache () const
	clear internal cache More...

Protected Attributes inherited from reco::LeafCandidate
bool	cacheCartesianFixed_

bool	cachePolarFixed_
	has cache been set? More...

float	eta_

float	mass_

LorentzVector	p4Cartesian_
	internal cache for p4 More...

PolarLorentzVector	p4Polar_
	internal cache for p4 More...

int	pdgId_
	PDG identifier. More...

float	phi_

float	pt_
	four-momentum Lorentz vector More...

Charge	qx3_
	electric charge More...

int	status_
	status word More...

Point	vertex_
	vertex position More...

Detailed Description

A reconstructed Muon. contains reference to three fits:

tracker alone
muon detector alone
combined muon plus tracker

Author: Luca Lista, Claudio Campagnari, Dmytro Kovalskyi, Jake Ribnik, Riccardo Bellan, Michalis Bachtis

Version

Id:: Muon.h,v 1.71.2.1 2012/10/15 00:28:04 bachtis Exp

Definition at line 28 of file Muon.h.

Member Typedef Documentation

typedef std::map<MuonTrackType, reco::TrackRef> reco::Muon::MuonTrackRefMap

Definition at line 40 of file Muon.h.

typedef std::pair<TrackRef, Muon::MuonTrackType> reco::Muon::MuonTrackTypePair

Definition at line 41 of file Muon.h.

Member Enumeration Documentation

enum reco::Muon::ArbitrationType

define arbitration schemes

Enumerator
NoArbitration
SegmentArbitration
SegmentAndTrackArbitration
SegmentAndTrackArbitrationCleaned

Definition at line 173 of file Muon.h.

173 { NoArbitration, SegmentArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned };

reco::Muon::SegmentArbitration

Definition: Muon.h:173

reco::Muon::SegmentAndTrackArbitration

Definition: Muon.h:173

reco::Muon::NoArbitration

Definition: Muon.h:173

reco::Muon::SegmentAndTrackArbitrationCleaned

Definition: Muon.h:173

enum reco::Muon::MuonTrackType

map for Global Muon refitters

Enumerator
None
InnerTrack
OuterTrack
CombinedTrack
TPFMS
Picky
DYT

Definition at line 39 of file Muon.h.

39 {None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT};

reco::Muon::OuterTrack

Definition: Muon.h:39

reco::Muon::Picky

Definition: Muon.h:39

reco::Muon::None

Definition: Muon.h:39

reco::Muon::InnerTrack

Definition: Muon.h:39

reco::Muon::TPFMS

Definition: Muon.h:39

reco::Muon::DYT

Definition: Muon.h:39

reco::Muon::CombinedTrack

Definition: Muon.h:39

Constructor & Destructor Documentation

Muon::Muon ( )

Definition at line 18 of file Muon.cc.

References bestTrackType_, caloCompatibility_, energyValid_, isolationValid_, matchesValid_, None, pfIsolationValid_, qualityValid_, and type_.

Referenced by clone().

            {
    energyValid_  = false;
    matchesValid_ = false;
    isolationValid_ = false;
    pfIsolationValid_ = false;
    qualityValid_ = false;
    caloCompatibility_ = -9999.;
    type_ = 0;
    bestTrackType_ = reco::Muon::None;
 }

Muon::Muon	(	Charge	q,
		const LorentzVector &	p4,
		const Point &	vtx = `Point( 0, 0, 0 )`
	)

constructor from values

Definition at line 6 of file Muon.cc.

References bestTrackType_, caloCompatibility_, energyValid_, isolationValid_, matchesValid_, None, pfIsolationValid_, qualityValid_, and type_.

                                                                    :
   RecoCandidate( q, p4, vtx, -13 * q ) {
      energyValid_  = false;
      matchesValid_ = false;
      isolationValid_ = false;
      pfIsolationValid_ = false;
      qualityValid_ = false;
      caloCompatibility_ = -9999.;
      type_ = 0;
      bestTrackType_ = reco::Muon::None;
 }

Member Function Documentation

virtual const Track* reco::Muon::bestTrack ( ) const

inlinevirtual

best track pointer

Reimplemented from reco::RecoCandidate.

Definition at line 62 of file Muon.h.

References edm::Ref< C, T, F >::get(), muonBestTrackType(), and muonTrack().

62 {return muonTrack(muonBestTrackType()).get();}

reco::Muon::muonBestTrackType

virtual MuonTrackType muonBestTrackType() const

Definition: Muon.h:65

reco::Muon::muonTrack

TrackRef muonTrack(const MuonTrackType &) const

Definition: Muon.cc:764

edm::Ref::get

T const * get() const

Returns C++ pointer to the item.

Definition: Ref.h:242

virtual TrackBaseRef reco::Muon::bestTrackRef ( ) const

inlinevirtual

best track RefToBase

Reimplemented from reco::RecoCandidate.

Definition at line 63 of file Muon.h.

References muonBestTrackType(), and muonTrack().

Referenced by SelectReplacementCandidates::getRawIDsAdvanced().

63 {return reco::TrackBaseRef(muonTrack(muonBestTrackType()));}

reco::Muon::muonBestTrackType

virtual MuonTrackType muonBestTrackType() const

Definition: Muon.h:65

reco::Muon::muonTrack

TrackRef muonTrack(const MuonTrackType &) const

Definition: Muon.cc:764

reco::TrackBaseRef

edm::RefToBase< reco::Track > TrackBaseRef

persistent reference to a Track, using views

Definition: TrackFwd.h:22

MuonEnergy reco::Muon::calEnergy ( ) const

inline

get energy deposition information

Definition at line 112 of file Muon.h.

References calEnergy_.

Referenced by MuonTimingFiller::addEcalTime(), FWMuonDetailView::addSceneInfo(), MuonEnergyDepositAnalyzer::analyze(), FWMuonLegoProxyBuilder::build(), FWMuonDetailView::build(), MuonCaloCompatibility::evaluate(), MuonMETAlgo::GetMuDepDeltas(), MuonIdProducer::makeCaloMuon(), ZMuMuMuonUserData::produce(), ZToLLEdmNtupleDumper::produce(), MuonIdProducer::produce(), setCalEnergy(), and FWMuonDetailView::setTextInfo().

112 { return calEnergy_; }

reco::Muon::calEnergy_

MuonEnergy calEnergy_

energy deposition

Definition: Muon.h:233

float reco::Muon::caloCompatibility ( ) const

inline

====================== MUON COMPATIBILITY BLOCK ===========================

Relative likelihood based on ECAL, HCAL, HO energy defined as L_muon/(L_muon+L_not_muon)

Definition at line 151 of file Muon.h.

References caloCompatibility_.

Referenced by muon::caloCompatibility(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), and CaloMuonMerger::produce().

151 { return caloCompatibility_; }

reco::Muon::caloCompatibility_

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:246

const std::vector< const MuonChamberMatch * > Muon::chambers	(	int	station,
		int	muonSubdetId
	)		const

private

get vector of muon chambers for given station and detector

Definition at line 287 of file Muon.cc.

References muMatches_.

Referenced by dDxDz(), dDyDz(), dX(), dY(), pullDxDz(), pullDyDz(), pullX(), pullY(), segmentDxDz(), segmentDxDzErr(), segmentDyDz(), segmentDyDzErr(), segmentX(), segmentXErr(), segmentY(), segmentYErr(), trackDist(), trackDistErr(), trackDxDz(), trackDxDzErr(), trackDyDz(), trackDyDzErr(), trackEdgeX(), trackEdgeY(), trackX(), trackXErr(), trackY(), and trackYErr().

 {
    std::vector<const MuonChamberMatch*> chambers;
    for(std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
          chamberMatch != muMatches_.end(); chamberMatch++)
       if(chamberMatch->station()==station && chamberMatch->detector()==muonSubdetId)
          chambers.push_back(&(*chamberMatch));
    return chambers;
 }

Muon * Muon::clone ( void ) const

virtual

create a clone

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon, and pat::Lepton< reco::Muon >.

Definition at line 40 of file Muon.cc.

References Muon().

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonWithPFIsoProducer::produce(), DistortedMuonProducerFromDB::produce(), DistortedMuonProducer::produce(), and UpdatedMuonInnerTrackRef::produce().

                          {
   return new Muon( * this );
 }

virtual TrackRef reco::Muon::combinedMuon ( ) const

inlinevirtual

reference to a stand-alone muon Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 56 of file Muon.h.

References globalTrack().

Referenced by MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), AlignmentMuonSelector::basicCuts(), MuonIdProducer::fillGlbQuality(), MuonTimingFiller::fillTiming(), muon::muonBestTrack(), overlap(), helper::MuonCollectionStoreManager::processMuon(), and muon::tevOptimized().

56 { return globalTrack(); }

reco::Muon::globalTrack

virtual TrackRef globalTrack() const

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:55

MuonQuality reco::Muon::combinedQuality ( ) const

inline

get energy deposition information

Definition at line 122 of file Muon.h.

References combinedQuality_.

Referenced by MuonIdProducer::fillGlbQuality(), MuonIdProducer::fillTrackerKink(), muon::isGoodMuon(), and setCombinedQuality().

122 { return combinedQuality_; }

reco::Muon::combinedQuality_

MuonQuality combinedQuality_

quality block

Definition: Muon.h:235

float Muon::dDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 353 of file Muon.cc.

References chambers(), and pair().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ;
 }

float Muon::dDyDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 361 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ;
 }

float Muon::dX	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

get deltas between (best) segment and track If no chamber or no segment returns 999999

Definition at line 336 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.first->x-chamberSegmentPair.second->x;
 }

float Muon::dY	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 344 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.first->y-chamberSegmentPair.second->y;
 }

virtual TrackRef reco::Muon::dytTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 60 of file Muon.h.

References DYT, and muonTrackFromMap().

Referenced by pat::Muon::dytTrack(), pat::Muon::embedDytMuon(), and muonTrack().

60 { return muonTrackFromMap(DYT);}

reco::Muon::DYT

Definition: Muon.h:39

reco::Muon::muonTrackFromMap

TrackRef muonTrackFromMap(const MuonTrackType &type) const

Definition: Muon.h:76

virtual TrackRef reco::Muon::globalTrack ( ) const

inlinevirtual

reference to Track reconstructed in both tracked and muon detector

Reimplemented in pat::Muon.

Definition at line 55 of file Muon.h.

References globalTrack_.

Referenced by EwkMuDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), TrackSplittingMonitor::analyze(), CosmicSplitterValidation::analyze(), MuonAssociatorByHits::associateMuons(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), muon::cocktailInputIsOK(), combinedMuon(), pat::Muon::combinedMuon(), pat::Muon::embedCombinedMuon(), MuonShowerInformationFiller::fillHitsByStation(), WMuNuValidator::filter(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), ZToMuMuGammaAnalyzer::muonSelection(), muonTrack(), helper::MuonCollectionStoreManager::processMuon(), cms::MuonMETValueMapProducer::produce(), BPhysicsOniaDQM::selGlobalMuon(), sigmaSwitch(), muon::sigmaSwitch(), SoftPFMuonTagInfoProducer::tagMuon(), muon::tevOptimized(), and tevOptimizedTMR().

55 { return globalTrack_; }

reco::Muon::globalTrack_

TrackRef globalTrack_

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:226

virtual TrackRef reco::Muon::innerTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 49 of file Muon.h.

References innerTrack_.

Referenced by EwkMuDQM::analyze(), EwkMuLumiMonitorDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), FWMuonBuilder::calculateField(), TCMETAlgo::CalculateTCMET(), MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), muon::cocktailInputIsOK(), pat::Muon::embedTrack(), MuonIdProducer::fillTrackerKink(), WMuNuValidator::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), cms::MuonTCMETValueMapProducer::isGoodCaloMuon(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodTrack(), muon::isHighPtMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), SoftPFMuonTagInfoProducer::isSoftMuon(), muon::isSoftMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), muon::isTightMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonIdProducer::makeCaloMuon(), muon::muonBestTrack(), muonBestTrackType(), MuonResidualsFromTrack::MuonResidualsFromTrack(), muonTrack(), MuonIdProducer::phiOfMuonIneteractionRegion(), helper::MuonCollectionStoreManager::processMuon(), MuonWithPFIsoProducer::produce(), UpdatedMuonInnerTrackRef::produce(), cms::MuonMETValueMapProducer::produce(), cms::MuonTCMETValueMapProducer::produce(), MuonIdProducer::produce(), cms::MuonTCMETValueMapProducer::propagateTrack(), MuonCosmicCompatibilityFiller::pvMatches(), BPhysicsOniaDQM::selGlobalMuon(), BPhysicsOniaDQM::selTrackerMuon(), sigmaSwitch(), muon::sigmaSwitch(), SoftPFMuonTagInfoProducer::tagMuon(), muon::tevOptimized(), tevOptimizedTMR(), track(), and pat::Muon::track().

49 { return innerTrack_; }

reco::Muon::innerTrack_

TrackRef innerTrack_

reference to Track reconstructed in the tracker only

Definition: Muon.h:222

bool Muon::isAValidMuonTrack ( const MuonTrackType & type ) const

Definition at line 760 of file Muon.cc.

References edm::Ref< C, T, F >::isNonnull(), and muonTrack().

Referenced by pat::PATMuonProducer::fillMuon().

                                                            {
   return muonTrack(type).isNonnull();
 }

bool reco::Muon::isCaloCompatibilityValid ( ) const

inline

Definition at line 153 of file Muon.h.

References caloCompatibility_.

Referenced by CaloMuonMerger::produce().

153 { return caloCompatibility_>=0; }

reco::Muon::caloCompatibility_

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:246

bool reco::Muon::isCaloMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 214 of file Muon.h.

References CaloMuon, and type_.

Referenced by MuonRecoAnalyzer::analyze(), TCMETAlgo::CalculateTCMET(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), and cms::MuonTCMETValueMapProducer::produce().

214 { return type_ & CaloMuon; }

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::CaloMuon

static const unsigned int CaloMuon

Definition: Muon.h:203

bool reco::Muon::isEnergyValid ( ) const

inline

====================== ENERGY BLOCK ===========================

energy deposition

Definition at line 110 of file Muon.h.

References energyValid_.

Referenced by MuonTimingFiller::addEcalTime(), FWMuonDetailView::addSceneInfo(), FWMuonLegoProxyBuilder::build(), FWMuonDetailView::build(), MuonIdProducer::makeCaloMuon(), MuonIdProducer::produce(), and FWMuonDetailView::setTextInfo().

110 { return energyValid_; }

reco::Muon::energyValid_

bool energyValid_

Definition: Muon.h:240

bool reco::Muon::isGlobalMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 211 of file Muon.h.

References GlobalMuon, and type_.

Referenced by GlbMuQualityCutsAnalysis::analyze(), EwkMuDQM::analyze(), RPCRecHitProbability::analyze(), RPCMonitorDigi::analyze(), EwkMuLumiMonitorDQM::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), MuonEnergyDepositAnalyzer::analyze(), ZMuMu_efficiencyAnalyzer::analyze(), ZMuMu_vtxAnalyzer::analyze(), MuTriggerAnalyzer::analyze(), HiggsDQM::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), ZToMuMuGammaAnalyzer::basicMuonSelection(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), MuonCosmicCompatibilityFiller::combinedCosmicID(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), MuonIdProducer::fillGlbQuality(), EwkMuTauHistManager::fillHistograms(), MuonShowerInformationFiller::fillHitsByStation(), pat::PATMuonProducer::fillMuon(), WMuNuValidator::filter(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isLooseMuon(), muon::isLooseMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), muon::isTightMuon(), muon::muonBestTrack(), DistortedPFCandProducer::produce(), ZMuMuMuonUserData::produce(), ZMuMuUserData::produce(), cms::MuonMETValueMapProducer::produce(), MuonProducer::produce(), ZToLLEdmNtupleDumper::produce(), cms::MuonTCMETValueMapProducer::produce(), MuonMCClassifier::produce(), MuonCosmicCompatibilityFiller::pvMatches(), MuScleFitMuonSelector::selectMuons(), and PFMuonSelector::TopPag12LjetsCuts().

211 { return type_ & GlobalMuon; }

reco::Muon::GlobalMuon

static const unsigned int GlobalMuon

Definition: Muon.h:200

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

bool reco::Muon::isIsolationValid ( ) const

inline

Definition at line 166 of file Muon.h.

References isolationValid_.

Referenced by MuonMETAlgo::GetMuDepDeltas().

166 { return isolationValid_; }

reco::Muon::isolationValid_

bool isolationValid_

Definition: Muon.h:242

bool reco::Muon::isMatchesValid ( ) const

inline

====================== MUON MATCH BLOCK ===========================

Definition at line 139 of file Muon.h.

References matchesValid_.

Referenced by FWMuonBuilder::buildMuon(), muon::isGoodMuon(), and MuonIdProducer::overlap().

139 { return matchesValid_; }

reco::Muon::matchesValid_

bool matchesValid_

Definition: Muon.h:241

bool reco::Muon::isMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 210 of file Muon.h.

210 { return true; }

const MuonIsolation& reco::Muon::isolationR03 ( ) const

inline

====================== ISOLATION BLOCK ===========================

Summary of muon isolation information

Definition at line 159 of file Muon.h.

References isolationR03_.

Referenced by EwkMuDQM::analyze(), ZToMuMuGammaAnalyzer::analyze(), pat::Muon::ecalIso(), MuonVPlusJetsIDSelectionFunctor::fall10Cuts(), WMuNuValidator::filter(), WMuNuSelector::filter(), MuonVPlusJetsIDSelectionFunctor::firstDataCuts(), MuonMETAlgo::GetMuDepDeltas(), pat::Muon::hcalIso(), MuonVPlusJetsIDSelectionFunctor::kitQCDCuts(), EwkMuLumiMonitorDQM::muIso(), ZToMuMuGammaAnalyzer::muonSelection(), MuonVPlusJetsIDSelectionFunctor::spring10Cuts(), MuonVPlusJetsIDSelectionFunctor::summer08Cuts(), and pat::Muon::trackIso().

159 { return isolationR03_; }

reco::Muon::isolationR03_

MuonIsolation isolationR03_

Isolation information for two cones with dR=0.3 and dR=0.5.

Definition: Muon.h:248

const MuonIsolation& reco::Muon::isolationR05 ( ) const

inline

Definition at line 160 of file Muon.h.

References isolationR05_.

Referenced by EwkMuTauHistManager::fillHistograms().

160 { return isolationR05_; }

reco::Muon::isolationR05_

MuonIsolation isolationR05_

Definition: Muon.h:249

bool reco::Muon::isPFIsolationValid ( ) const

inline

Definition at line 169 of file Muon.h.

References pfIsolationValid_.

169 { return pfIsolationValid_; }

reco::Muon::pfIsolationValid_

bool pfIsolationValid_

Definition: Muon.h:243

bool reco::Muon::isPFMuon ( ) const

inline

Definition at line 215 of file Muon.h.

References PFMuon, and type_.

Referenced by SoftPFMuonTagInfoProducer::isLooseMuon(), muon::isLooseMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), muon::isTightMuon(), and MuonProducer::produce().

215 {return type_ & PFMuon;} //fix me ! Has to go to type

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::PFMuon

static const unsigned int PFMuon

Definition: Muon.h:204

bool reco::Muon::isQualityValid ( ) const

inline

====================== Quality BLOCK ===========================

energy deposition

Definition at line 120 of file Muon.h.

References qualityValid_.

Referenced by MuonIdProducer::fillTrackerKink(), and muon::isGoodMuon().

120 { return qualityValid_; }

reco::Muon::qualityValid_

bool qualityValid_

Definition: Muon.h:244

bool reco::Muon::isRPCMuon ( ) const

inline

Definition at line 216 of file Muon.h.

References RPCMuon, and type_.

216 {return type_ & RPCMuon;}

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::RPCMuon

static const unsigned int RPCMuon

Definition: Muon.h:205

bool reco::Muon::isStandAloneMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 213 of file Muon.h.

References StandAloneMuon, and type_.

Referenced by EwkMuLumiMonitorDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), TCMETAlgo::CalculateTCMET(), MuonShowerInformationFiller::fillHitsByStation(), muon::isGoodMuon(), muon::muonBestTrack(), MuonIdProducer::phiOfMuonIneteractionRegion(), DistortedPFCandProducer::produce(), ZMuMuMuonUserData::produce(), MuonProducer::produce(), ZToLLEdmNtupleDumper::produce(), and MuonCosmicCompatibilityFiller::pvMatches().

213 { return type_ & StandAloneMuon; }

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::StandAloneMuon

static const unsigned int StandAloneMuon

Definition: Muon.h:202

bool reco::Muon::isTimeValid ( ) const

inline

====================== TIMING BLOCK ===========================

timing information

Definition at line 130 of file Muon.h.

References reco::MuonTime::nDof, and time_.

Referenced by MuonCosmicCompatibilityFiller::muonTiming(), and MuonIdProducer::produce().

130 { return (time_.nDof>0); }

reco::MuonTime::nDof

int nDof

number of muon stations used

Definition: MuonTime.h:10

reco::Muon::time_

MuonTime time_

timing

Definition: Muon.h:239

bool reco::Muon::isTrackerMuon ( ) const

inlinevirtual

Reimplemented from reco::LeafCandidate.

Definition at line 212 of file Muon.h.

References TrackerMuon, and type_.

Referenced by GlbMuQualityCutsAnalysis::analyze(), EwkMuDQM::analyze(), MuonEnergyDepositAnalyzer::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), HiggsDQM::analyze(), HLTMuonMatchAndPlot::analyze(), MuonAssociatorByHits::associateMuons(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), FWMuonBuilder::buildMuon(), TCMETAlgo::CalculateTCMET(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), EwkMuTauHistManager::fillHistograms(), MuonIdProducer::fillMuonId(), WMuNuValidator::filter(), WMuNuSelector::filter(), LeptonRecoSkim::filter(), MuonMETAlgo::GetMuDepDeltas(), muon::isGoodMuon(), cms::MuonTCMETValueMapProducer::isGoodMuon(), SoftPFMuonTagInfoProducer::isLooseMuon(), muon::isLooseMuon(), FourVectorHLTOffline::isVBTFMuon(), muon::muonBestTrack(), MuonResidualsFromTrack::MuonResidualsFromTrack(), ZToMuMuGammaAnalyzer::muonSelection(), DistortedPFCandProducer::produce(), ZMuMuMuonUserData::produce(), cms::MuonMETValueMapProducer::produce(), MuonProducer::produce(), ZToLLEdmNtupleDumper::produce(), cms::MuonTCMETValueMapProducer::produce(), MuonCosmicCompatibilityFiller::pvMatches(), MuScleFitMuonSelector::selectMuons(), and PFMuonSelector::TopPag12LjetsCuts().

212 { return type_ & TrackerMuon; }

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::TrackerMuon

static const unsigned int TrackerMuon

Definition: Muon.h:201

std::vector<MuonChamberMatch>& reco::Muon::matches ( )

inline

get muon matching information

Definition at line 141 of file Muon.h.

References muMatches_.

Referenced by MuonIdProducer::fillMuonId(), TrackerMuonHitExtractor::getMuonHits(), MuonResidualsFromTrack::MuonResidualsFromTrack(), numberOfChambersNoRPC(), numberOfMatches(), MuonIdProducer::overlap(), muon::overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), MuonIdProducer::produce(), setMatches(), muon::sharedSegments(), and MuonIdTruthInfo::truthMatchMuon().

141 { return muMatches_;}

reco::Muon::muMatches_

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:237

const std::vector<MuonChamberMatch>& reco::Muon::matches ( ) const

inline

Definition at line 142 of file Muon.h.

References muMatches_.

142 { return muMatches_; }

reco::Muon::muMatches_

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:237

virtual TrackRef reco::Muon::muonBestTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 64 of file Muon.h.

References muonBestTrackType(), and muonTrack().

Referenced by pat::Muon::embedMuonBestTrack(), SoftPFMuonTagInfoProducer::isSoftMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), and muon::isTightMuon().

64 {return muonTrack(muonBestTrackType());}

reco::Muon::muonBestTrackType

virtual MuonTrackType muonBestTrackType() const

Definition: Muon.h:65

reco::Muon::muonTrack

TrackRef muonTrack(const MuonTrackType &) const

Definition: Muon.cc:764

virtual MuonTrackType reco::Muon::muonBestTrackType ( ) const

inlinevirtual

Definition at line 65 of file Muon.h.

References bestTrackType_, InnerTrack, innerTrack(), None, OuterTrack, and standAloneMuon().

Referenced by bestTrack(), bestTrackRef(), and muonBestTrack().

                                                     {
       if (bestTrackType_!=None) return bestTrackType_;
       if (!innerTrack().isNull()) return InnerTrack;
       if (!standAloneMuon().isNull()) return OuterTrack;
       return None;
     }

TrackRef Muon::muonTrack ( const MuonTrackType & type ) const

Definition at line 764 of file Muon.cc.

References CombinedTrack, DYT, dytTrack(), globalTrack(), InnerTrack, innerTrack(), muonTrackFromMap(), OuterTrack, Picky, pickyTrack(), standAloneMuon(), TPFMS, and tpfmsTrack().

Referenced by bestTrack(), bestTrackRef(), isAValidMuonTrack(), and muonBestTrack().

                                                        {
   switch (type) {
   case InnerTrack:     return innerTrack();
   case OuterTrack:     return standAloneMuon(); 
   case CombinedTrack:  return globalTrack();
   case TPFMS:          return tpfmsTrack();
   case Picky:          return pickyTrack();
   case DYT:            return dytTrack();
   default:             return muonTrackFromMap(type);
   }
 }

TrackRef reco::Muon::muonTrackFromMap ( const MuonTrackType & type ) const

inline

Definition at line 76 of file Muon.h.

References refittedTrackMap_.

Referenced by dytTrack(), muonTrack(), pickyTrack(), and tpfmsTrack().

                                                                {
       MuonTrackRefMap::const_iterator iter = refittedTrackMap_.find(type);
       if (iter != refittedTrackMap_.end()) 
     return iter->second;
       else 
     return TrackRef();
     }

int reco::Muon::numberOfChambers ( ) const

inline

====================== USEFUL METHODs ===========================

number of chambers (MuonChamberMatches include RPC rolls)

Definition at line 179 of file Muon.h.

References muMatches_.

Referenced by numberOfChambersNoRPC(), ZMuMuMuonUserData::produce(), and ZToLLEdmNtupleDumper::produce().

179 { return muMatches_.size(); }

reco::Muon::muMatches_

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:237

int Muon::numberOfChambersNoRPC ( ) const

number of chambers not including RPC matches (MuonChamberMatches include RPC rolls)

Definition at line 44 of file Muon.cc.

References matches(), numberOfChambers(), MuonSubdetId::RPC, and pileupDistInMC::total.

 {
   int total = 0;
   int nAll = numberOfChambers();
   for (int iC = 0; iC < nAll; ++iC){
     if (matches()[iC].detector() == MuonSubdetId::RPC) continue;
     total++;
   }
 
   return total;
 }

int Muon::numberOfMatchedStations ( ArbitrationType type = SegmentAndTrackArbitration ) const

get number of stations with matched segments just adds the bits returned by stationMask

Definition at line 100 of file Muon.cc.

References stationMask(), and mergeVDriftHistosByStation::stations.

Referenced by muon::isHighPtMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), and muon::isTightMuon().

 {
    int stations(0);
 
    unsigned int theStationMask = stationMask(type);
    // eight stations, eight bits
    for(int it = 0; it < 8; ++it)
       if (theStationMask & 1<<it)
          ++stations;
 
    return stations;
 }

int Muon::numberOfMatches ( ArbitrationType type = SegmentAndTrackArbitration ) const

get number of chambers with matched segments

Definition at line 56 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInChamberByDR, matches(), muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by EwkMuDQM::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonCosmicCompatibilityFiller::checkMuonSegments(), TauDiscriminationAgainstMuon< TauType, TauDiscriminator >::evaluateMuonVeto(), MuonVPlusJetsIDSelectionFunctor::fall10Cuts(), MuonIdProducer::fillMuonId(), TrackerMuonHitExtractor::getMuonHits(), muon::isGoodMuon(), MuonIdProducer::isGoodTrackerMuon(), BTagHLTOfflineSource::isVBTFMuon(), FourVectorHLTOffline::isVBTFMuon(), MuonVPlusJetsIDSelectionFunctor::kitQCDCuts(), ZToMuMuGammaAnalyzer::muonSelection(), muon::overlap(), ZMuMuMuonUserData::produce(), ZToLLEdmNtupleDumper::produce(), and PFMuonSelector::TopPag12LjetsCuts().

 {
    int matches(0);
    for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
          chamberMatch != muMatches_.end(); chamberMatch++ )
    {
       if(chamberMatch->segmentMatches.empty()) continue;
       if(type == NoArbitration) {
          matches++;
          continue;
       }
 
       for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
             segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
       {
          if(type == SegmentArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR)) {
                matches++;
                break;
             }
          if(type == SegmentAndTrackArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
                matches++;
                break;
             }
      if(type == SegmentAndTrackArbitrationCleaned)
        if(segmentMatch->isMask(MuonSegmentMatch::BestInChamberByDR) &&
              segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) && 
              segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
          matches++;
          break;
        }
          if(type > 1<<7)
             if(segmentMatch->isMask(type)) {
                matches++;
                break;
             }
       }
    }
 
    return matches;
 }

int Muon::numberOfSegments	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

get number of segments

Definition at line 241 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

 {
    int segments(0);
    for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
          chamberMatch != muMatches_.end(); chamberMatch++ )
    {
       if(chamberMatch->segmentMatches.empty()) continue;
       if(!(chamberMatch->station()==station && chamberMatch->detector()==muonSubdetId)) continue;
 
       if(type == NoArbitration) {
          segments += chamberMatch->segmentMatches.size();
          continue;
       }
 
       for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
             segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
       {
          if(type == SegmentArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
                segments++;
                break;
             }
          if(type == SegmentAndTrackArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
                segments++;
                break;
             }
      if(type == SegmentAndTrackArbitrationCleaned)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
                segments++;
                break;
             }
          if(type > 1<<7)
             if(segmentMatch->isMask(type)) {
                segments++;
                break;
             }
       }
    }
 
    return segments;
 }

virtual TrackRef reco::Muon::outerTrack ( ) const

inlinevirtual

reference to Track reconstructed in the muon detector only

Reimplemented in pat::Muon.

Definition at line 52 of file Muon.h.

References outerTrack_.

Referenced by RPCRecHitProbability::analyze(), RPCMonitorDigi::analyze(), MuonEnergyDepositAnalyzer::analyze(), HLTMuonMatchAndPlot::analyze(), CosmicSplitterValidation::analyze(), MuonAssociatorByHits::associateMuons(), FWMuonBuilder::buildMuon(), FWMuonBuilder::calculateField(), TCMETAlgo::CalculateTCMET(), MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), pat::Muon::embedStandAloneMuon(), MuonShowerInformationFiller::fillHitsByStation(), MuonMETAlgo::GetMuDepDeltas(), CosmicSplitterValidation::is_gold_muon(), muon::isGoodMuon(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), muon::muonBestTrack(), MuonCosmicCompatibilityFiller::muonTiming(), cms::MuonMETValueMapProducer::produce(), MuonCosmicCompatibilityFiller::pvMatches(), standAloneMuon(), and pat::Muon::standAloneMuon().

52 { return outerTrack_; }

reco::Muon::outerTrack_

TrackRef outerTrack_

reference to Track reconstructed in the muon detector only

Definition: Muon.h:224

bool Muon::overlap ( const Candidate & c ) const

privatevirtual

check overlap with another candidate

Implements reco::RecoCandidate.

Definition at line 29 of file Muon.cc.

References trackerHits::c, reco::RecoCandidate::checkOverlap(), reco::RecoCandidate::combinedMuon(), combinedMuon(), python.connectstrParser::o, reco::RecoCandidate::standAloneMuon(), standAloneMuon(), reco::RecoCandidate::track(), and track().

                                               {
   const RecoCandidate * o = dynamic_cast<const RecoCandidate *>( & c );
   return ( o != 0 && 
        ( checkOverlap( track(), o->track() ) ||
          checkOverlap( standAloneMuon(), o->standAloneMuon() ) ||
          checkOverlap( combinedMuon(), o->combinedMuon() ) ||
          checkOverlap( standAloneMuon(), o->track() ) ||
          checkOverlap( combinedMuon(), o->track() ) )
        );
 }

std::pair< const MuonChamberMatch , const MuonSegmentMatch > Muon::pair	(	const std::vector< const MuonChamberMatch * > &	chambers,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

private

get pointers to best segment and corresponding chamber in vector of chambers

Definition at line 297 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, m, NoArbitration, alignCSCRings::s, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by dDxDz(), dDyDz(), dX(), dY(), pullDxDz(), pullDyDz(), pullX(), pullY(), segmentDxDz(), segmentDxDzErr(), segmentDyDz(), segmentDyDzErr(), segmentX(), segmentXErr(), segmentY(), segmentYErr(), trackDist(), trackDistErr(), trackDxDz(), trackDxDzErr(), trackDyDz(), trackDyDzErr(), trackEdgeX(), trackEdgeY(), trackX(), trackXErr(), trackY(), and trackYErr().

 {
    MuonChamberMatch* m = 0;
    MuonSegmentMatch* s = 0;
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair(m,s);
 
    if(chambers.empty()) return chamberSegmentPair;
    for( std::vector<const MuonChamberMatch*>::const_iterator chamberMatch = chambers.begin();
          chamberMatch != chambers.end(); chamberMatch++ )
    {
       if((*chamberMatch)->segmentMatches.empty()) continue;
       if(type == NoArbitration)
          return std::make_pair(*chamberMatch, &((*chamberMatch)->segmentMatches.front()));
 
       for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = (*chamberMatch)->segmentMatches.begin();
             segmentMatch != (*chamberMatch)->segmentMatches.end(); segmentMatch++ )
       {
          if(type == SegmentArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) 
                return std::make_pair(*chamberMatch, &(*segmentMatch));
          if(type == SegmentAndTrackArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
      if(type == SegmentAndTrackArbitrationCleaned)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
          if(type > 1<<7)
             if(segmentMatch->isMask(type))
                return std::make_pair(*chamberMatch, &(*segmentMatch));
       }
    }
 
    return chamberSegmentPair;
 }

const MuonPFIsolation& reco::Muon::pfIsolationR03 ( ) const

inline

Definition at line 162 of file Muon.h.

References pfIsolationR03_.

162 { return pfIsolationR03_; }

reco::Muon::pfIsolationR03_

MuonPFIsolation pfIsolationR03_

PF Isolation information for two cones with dR=0.3 and dR=0.4.

Definition: Muon.h:252

const MuonPFIsolation& reco::Muon::pfIsolationR04 ( ) const

inline

Definition at line 163 of file Muon.h.

References pfIsolationR04_.

163 { return pfIsolationR04_; }

reco::Muon::pfIsolationR04_

MuonPFIsolation pfIsolationR04_

Definition: Muon.h:253

reco::Candidate::LorentzVector reco::Muon::pfP4 ( ) const

inline

set reference to PFCandidate

====================== PF BLOCK ===========================

Definition at line 103 of file Muon.h.

References pfP4_.

Referenced by RecoMuonValidator::MuonME::fill(), and MuonProducer::produce().

103 {return pfP4_;}

reco::Muon::pfP4_

reco::Candidate::LorentzVector pfP4_

Definition: Muon.h:259

virtual TrackRef reco::Muon::pickyTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 59 of file Muon.h.

References muonTrackFromMap(), and Picky.

Referenced by muon::cocktailInputIsOK(), pat::Muon::embedPickyMuon(), muonTrack(), pat::Muon::pickyTrack(), and muon::tevOptimized().

59 { return muonTrackFromMap(Picky);}

reco::Muon::Picky

Definition: Muon.h:39

reco::Muon::muonTrackFromMap

TrackRef muonTrackFromMap(const MuonTrackType &type) const

Definition: Muon.h:76

float Muon::pullDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`,
		bool	includeSegmentError = `true`
	)		const

Definition at line 391 of file Muon.cc.

References chambers(), pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    if(includeSegmentError)
       return (chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ)/sqrt(pow(chamberSegmentPair.first->dXdZErr,2)+pow(chamberSegmentPair.second->dXdZErr,2));
    return (chamberSegmentPair.first->dXdZ-chamberSegmentPair.second->dXdZ)/chamberSegmentPair.first->dXdZErr;
 }

float Muon::pullDyDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`,
		bool	includeSegmentError = `true`
	)		const

Definition at line 401 of file Muon.cc.

References chambers(), MuonSubdetId::DT, pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    if(includeSegmentError)
       return (chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ)/sqrt(pow(chamberSegmentPair.first->dYdZErr,2)+pow(chamberSegmentPair.second->dYdZErr,2));
    return (chamberSegmentPair.first->dYdZ-chamberSegmentPair.second->dYdZ)/chamberSegmentPair.first->dYdZErr;
 }

float Muon::pullX	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`,
		bool	includeSegmentError = `true`
	)		const

Definition at line 370 of file Muon.cc.

References chambers(), pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    if(includeSegmentError)
       return (chamberSegmentPair.first->x-chamberSegmentPair.second->x)/sqrt(pow(chamberSegmentPair.first->xErr,2)+pow(chamberSegmentPair.second->xErr,2));
    return (chamberSegmentPair.first->x-chamberSegmentPair.second->x)/chamberSegmentPair.first->xErr;
 }

float Muon::pullY	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`,
		bool	includeSegmentError = `true`
	)		const

Definition at line 380 of file Muon.cc.

References chambers(), MuonSubdetId::DT, pair(), funct::pow(), and mathSSE::sqrt().

Referenced by muon::isGoodMuon(), and muon::segmentCompatibility().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    if(includeSegmentError)
       return (chamberSegmentPair.first->y-chamberSegmentPair.second->y)/sqrt(pow(chamberSegmentPair.first->yErr,2)+pow(chamberSegmentPair.second->yErr,2));
    return (chamberSegmentPair.first->y-chamberSegmentPair.second->y)/chamberSegmentPair.first->yErr;
 }

float Muon::segmentDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 429 of file Muon.cc.

References chambers(), and pair().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.second->dXdZ;
 }

float Muon::segmentDxDzErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 463 of file Muon.cc.

References chambers(), and pair().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.second->dXdZErr;
 }

float Muon::segmentDyDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 437 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.second->dYdZ;
 }

float Muon::segmentDyDzErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 471 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.second->dYdZErr;
 }

float Muon::segmentX	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

get (best) segment information If no segment returns 999999

Definition at line 412 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::segmentCompatibility().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.second->x;
 }

float Muon::segmentXErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 446 of file Muon.cc.

References chambers(), and pair().

 {
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasPhi()) return 999999;
    return chamberSegmentPair.second->xErr;
 }

float Muon::segmentY	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 420 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.second->y;
 }

float Muon::segmentYErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 454 of file Muon.cc.

References chambers(), MuonSubdetId::DT, and pair().

 {
    if(station==4 && muonSubdetId==MuonSubdetId::DT) return 999999; // no y information
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(chambers(station,muonSubdetId),type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) return 999999;
    if(! chamberSegmentPair.second->hasZed()) return 999999;
    return chamberSegmentPair.second->yErr;
 }

virtual void reco::Muon::setBestTrack ( MuonTrackType muonType )

inlinevirtual

Definition at line 94 of file Muon.h.

References bestTrackType_.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), pat::PATMuonProducer::fillMuon(), and MuonIdProducer::makeMuon().

94 {bestTrackType_ = muonType;}

reco::Muon::bestTrackType_

MuonTrackType bestTrackType_

reference to the Track chosen to assign the momentum value to the muon

Definition: Muon.h:230

void reco::Muon::setCalEnergy ( const MuonEnergy & calEnergy )

inline

set energy deposition information

Definition at line 114 of file Muon.h.

References calEnergy(), calEnergy_, and energyValid_.

Referenced by MuonIdProducer::fillMuonId(), and CaloMuonMerger::produce().

114 { calEnergy_ = calEnergy; energyValid_ = true; }

reco::Muon::calEnergy_

MuonEnergy calEnergy_

energy deposition

Definition: Muon.h:233

reco::Muon::energyValid_

bool energyValid_

Definition: Muon.h:240

reco::Muon::calEnergy

MuonEnergy calEnergy() const

get energy deposition information

Definition: Muon.h:112

void reco::Muon::setCaloCompatibility ( float input )

inline

Definition at line 152 of file Muon.h.

References caloCompatibility_, and LaserDQM_cfg::input.

Referenced by CaloMuonMerger::produce().

152 { caloCompatibility_ = input; }

reco::Muon::caloCompatibility_

float caloCompatibility_

muon hypothesis compatibility with observer calorimeter energy

Definition: Muon.h:246

LaserDQM_cfg.input

tuple input

Definition: LaserDQM_cfg.py:38

void Muon::setCombined ( const TrackRef & t )

virtual

Definition at line 757 of file Muon.cc.

References setGlobalTrack().

Referenced by GlobalMuonToMuonProducer::produce().

757 { setGlobalTrack(t); }

reco::Muon::setGlobalTrack

virtual void setGlobalTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:756

void reco::Muon::setCombinedQuality ( const MuonQuality & combinedQuality )

inline

set energy deposition information

Definition at line 124 of file Muon.h.

References combinedQuality(), combinedQuality_, and qualityValid_.

Referenced by MuonIdProducer::fillGlbQuality(), and MuonIdProducer::fillTrackerKink().

124 { combinedQuality_ = combinedQuality; qualityValid_ = true; }

reco::Muon::combinedQuality

MuonQuality combinedQuality() const

get energy deposition information

Definition: Muon.h:122

reco::Muon::combinedQuality_

MuonQuality combinedQuality_

quality block

Definition: Muon.h:235

reco::Muon::qualityValid_

bool qualityValid_

Definition: Muon.h:244

void Muon::setGlobalTrack ( const TrackRef & t )

virtual

set reference to Track

Definition at line 756 of file Muon.cc.

References globalTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), setCombined(), and setMuonTrack().

756 { globalTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::globalTrack_

TrackRef globalTrack_

reference to Track reconstructed in both tracked and muon detector

Definition: Muon.h:226

void Muon::setInnerTrack ( const TrackRef & t )

virtual

set reference to Track

Definition at line 753 of file Muon.cc.

References innerTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), UpdatedMuonInnerTrackRef::produce(), CaloMuonMerger::produce(), MuonsFromRefitTracksProducer::produce(), setMuonTrack(), and setTrack().

753 { innerTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::innerTrack_

TrackRef innerTrack_

reference to Track reconstructed in the tracker only

Definition: Muon.h:222

void Muon::setIsolation	(	const MuonIsolation &	isoR03,
		const MuonIsolation &	isoR05
	)

Definition at line 728 of file Muon.cc.

References isolationR03_, isolationR05_, and isolationValid_.

Referenced by MuonIdProducer::fillMuonIsolation(), and MuonWithPFIsoProducer::produce().

 { 
    isolationR03_ = isoR03;
    isolationR05_ = isoR05;
    isolationValid_ = true; 
 }

void reco::Muon::setMatches ( const std::vector< MuonChamberMatch > & matches )

inline

set muon matching information

Definition at line 144 of file Muon.h.

References matches(), matchesValid_, and muMatches_.

Referenced by MuonIdProducer::fillMuonId().

144 { muMatches_ = matches; matchesValid_ = true; }

reco::Muon::matches

std::vector< MuonChamberMatch > & matches()

get muon matching information

Definition: Muon.h:141

reco::Muon::muMatches_

std::vector< MuonChamberMatch > muMatches_

Information on matching between tracks and segments.

Definition: Muon.h:237

reco::Muon::matchesValid_

bool matchesValid_

Definition: Muon.h:241

void Muon::setMuonTrack	(	const MuonTrackType &	type,
		const TrackRef &	t
	)

Definition at line 776 of file Muon.cc.

References CombinedTrack, InnerTrack, OuterTrack, refittedTrackMap_, setGlobalTrack(), setInnerTrack(), setStandAlone(), lumiQTWidget::t, and type().

Referenced by MuonIdProducer::makeMuon().

                                                                     {
   
   switch (type) {
   case InnerTrack:    setInnerTrack(t);             break;
   case OuterTrack:    setStandAlone(t);             break;
   case CombinedTrack: setGlobalTrack(t);            break;
   default:            refittedTrackMap_[type] = t;  break;
   }
 
 }

void Muon::setOuterTrack ( const TrackRef & t )

virtual

set reference to Track

Definition at line 752 of file Muon.cc.

References outerTrack_, and lumiQTWidget::t.

Referenced by MuonsFromRefitTracksProducer::cloneAndSwitchTrack(), MuonIdProducer::makeMuon(), MuonsFromRefitTracksProducer::produce(), and setStandAlone().

752 { outerTrack_ = t; }

lumiQTWidget.t

tuple t

Definition: lumiQTWidget.py:50

reco::Muon::outerTrack_

TrackRef outerTrack_

reference to Track reconstructed in the muon detector only

Definition: Muon.h:224

void Muon::setPFIsolation	(	const MuonPFIsolation &	isoR03,
		const MuonPFIsolation &	isoR04
	)

Definition at line 736 of file Muon.cc.

References pfIsolationR03_, pfIsolationR04_, and pfIsolationValid_.

Referenced by MuPFIsoHelper::embedPFIsolation().

 { 
    pfIsolationR03_ = isoR03;
    pfIsolationR04_ = isoR04;
    pfIsolationValid_ = true; 
 }

void Muon::setPFP4 ( const reco::Candidate::LorentzVector & p4_ )

virtual

Definition at line 744 of file Muon.cc.

References reco::LeafCandidate::p4(), PFMuon, pfP4_, and type_.

Referenced by MuonProducer::produce().

 { 
     pfP4_ = p4;
     type_ = type_ | PFMuon;
 }

void Muon::setStandAlone ( const TrackRef & t )

virtual

Definition at line 755 of file Muon.cc.

References setOuterTrack().

Referenced by GlobalMuonToMuonProducer::produce(), and setMuonTrack().

755 { setOuterTrack(t); }

reco::Muon::setOuterTrack

virtual void setOuterTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:752

void reco::Muon::setTime ( const MuonTime & time )

inline

set timing information

Definition at line 134 of file Muon.h.

References time(), and time_.

134 { time_ = time; }

reco::Muon::time

MuonTime time() const

get timing information

Definition: Muon.h:132

reco::Muon::time_

MuonTime time_

timing

Definition: Muon.h:239

void Muon::setTrack ( const TrackRef & t )

virtual

Definition at line 754 of file Muon.cc.

References setInnerTrack().

Referenced by GlobalMuonToMuonProducer::produce().

754 { setInnerTrack(t); }

reco::Muon::setInnerTrack

virtual void setInnerTrack(const TrackRef &t)

set reference to Track

Definition: Muon.cc:753

void reco::Muon::setType ( unsigned int type )

inline

Definition at line 207 of file Muon.h.

References type(), and type_.

Referenced by CaloMuonMerger::produce(), and MuonIdProducer::produce().

207 { type_ = type; }

reco::Muon::type_

unsigned int type_

muon type mask

Definition: Muon.h:256

reco::Muon::type

unsigned int type() const

Definition: Muon.h:208

virtual TrackRef reco::Muon::standAloneMuon ( ) const

inlinevirtual

reference to a stand-alone muon Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 53 of file Muon.h.

References outerTrack().

Referenced by ZMuMuPerformances::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), AlignmentMuonSelector::basicCuts(), FWMuonLegoProxyBuilder::build(), MuonCaloCompatibility::evaluate(), MuonIdProducer::fillMuonId(), MuonIdProducer::fillMuonIsolation(), MuonTimingFiller::fillTiming(), muonBestTrackType(), muonTrack(), overlap(), MuonIdProducer::phiOfMuonIneteractionRegion(), helper::MuonCollectionStoreManager::processMuon(), and MuonCosmicCompatibilityFiller::pvMatches().

53 { return outerTrack(); }

reco::Muon::outerTrack

virtual TrackRef outerTrack() const

reference to Track reconstructed in the muon detector only

Definition: Muon.h:52

unsigned int Muon::stationGapMaskDistance ( float distanceCut = 10. ) const

get bit map of stations with tracks within given distance (in cm) of chamber edges bit assignments are same as above

Definition at line 173 of file Muon.cc.

References muMatches_, and plotscripts::stationIndex().

 {
    unsigned int totMask(0);
    for( int stationIndex = 1; stationIndex < 5; stationIndex++ )
    {
       for( int detectorIndex = 1; detectorIndex < 4; detectorIndex++ )
       {
          unsigned int curMask(0);
          for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
                chamberMatch != muMatches_.end(); chamberMatch++ )
          {
             if(!(chamberMatch->station()==stationIndex && chamberMatch->detector()==detectorIndex)) continue;
 
             float edgeX = chamberMatch->edgeX;
             float edgeY = chamberMatch->edgeY;
             if(edgeX<0 && fabs(edgeX)>fabs(distanceCut) &&
                   edgeY<0 && fabs(edgeY)>fabs(distanceCut)) // inside the chamber so negates all gaps for this station
             {
                curMask = 0;
                break;
             }
             if( ( fabs(edgeX) < fabs(distanceCut) && edgeY < fabs(distanceCut) ) ||
         ( fabs(edgeY) < fabs(distanceCut) && edgeX < fabs(distanceCut) ) ) // inside gap
                curMask = 1<<( (stationIndex-1)+4*(detectorIndex-1) );
          }
 
          totMask += curMask; // add to total mask
       }
    }
 
    return totMask;
 }

unsigned int Muon::stationGapMaskPull ( float sigmaCut = 3. ) const

same as above for given number of sigmas

Definition at line 206 of file Muon.cc.

References muMatches_, and plotscripts::stationIndex().

 {
    unsigned int totMask(0);
    for( int stationIndex = 1; stationIndex < 5; stationIndex++ )
    {
       for( int detectorIndex = 1; detectorIndex < 4; detectorIndex++ )
       {
          unsigned int curMask(0);
          for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
                chamberMatch != muMatches_.end(); chamberMatch++ )
          {
             if(!(chamberMatch->station()==stationIndex && chamberMatch->detector()==detectorIndex)) continue;
 
             float edgeX = chamberMatch->edgeX;
             float edgeY = chamberMatch->edgeY;
             float xErr  = chamberMatch->xErr+0.000001; // protect against division by zero later
             float yErr  = chamberMatch->yErr+0.000001; // protect against division by zero later
             if(edgeX<0 && fabs(edgeX/xErr)>fabs(sigmaCut) &&
                   edgeY<0 && fabs(edgeY/yErr)>fabs(sigmaCut)) // inside the chamber so negates all gaps for this station
             {
                curMask = 0;
                break;
             }
             if( ( fabs(edgeX/xErr) < fabs(sigmaCut) && edgeY/yErr < fabs(sigmaCut) ) ||
         ( fabs(edgeY/yErr) < fabs(sigmaCut) && edgeX/xErr < fabs(sigmaCut) ) ) // inside gap
                curMask = 1<<((stationIndex-1)+4*(detectorIndex-1));
          }
 
          totMask += curMask; // add to total mask
       }
    }
 
    return totMask;
 }

unsigned int Muon::stationMask ( ArbitrationType type = SegmentAndTrackArbitration ) const

get bit map of stations with matched segments bits 0-1-2-3 = DT stations 1-2-3-4 bits 4-5-6-7 = CSC stations 1-2-3-4

Definition at line 113 of file Muon.cc.

References reco::MuonSegmentMatch::BelongsToTrackByCleaning, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, muMatches_, NoArbitration, SegmentAndTrackArbitration, SegmentAndTrackArbitrationCleaned, and SegmentArbitration.

Referenced by muon::isGoodMuon(), and numberOfMatchedStations().

 {
    unsigned int totMask(0);
    unsigned int curMask(0);
    for( std::vector<MuonChamberMatch>::const_iterator chamberMatch = muMatches_.begin();
          chamberMatch != muMatches_.end(); chamberMatch++ )
    {
       if(chamberMatch->segmentMatches.empty()) continue;
       if(type == NoArbitration) {
          curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
          // do not double count
          if(!(totMask & curMask))
             totMask += curMask;
          continue;
       }
 
       for( std::vector<MuonSegmentMatch>::const_iterator segmentMatch = chamberMatch->segmentMatches.begin();
             segmentMatch != chamberMatch->segmentMatches.end(); segmentMatch++ )
       {
          if(type == SegmentArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR)) {
                curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
                // do not double count
                if(!(totMask & curMask))
                   totMask += curMask;
                break;
             }
          if(type == SegmentAndTrackArbitration)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
                   segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR)) {
                curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
                // do not double count
                if(!(totMask & curMask))
                   totMask += curMask;
                break;
             }
      if(type == SegmentAndTrackArbitrationCleaned)
             if(segmentMatch->isMask(MuonSegmentMatch::BestInStationByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByDR) &&
               segmentMatch->isMask(MuonSegmentMatch::BelongsToTrackByCleaning)) {
                curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
                // do not double count
                if(!(totMask & curMask))
                   totMask += curMask;
                break;
             }
          if(type > 1<<7)
             if(segmentMatch->isMask(type)) {
                curMask = 1<<( (chamberMatch->station()-1)+4*(chamberMatch->detector()-1) );
                // do not double count
                if(!(totMask & curMask))
                   totMask += curMask;
                break;
             }
       }
    }
 
    return totMask;
 }

float reco::Muon::t0 ( int n = 0 )

inline

Definition at line 309 of file Muon.h.

References i, muMatches_, and n.

                        {
     int i = 0;
     for( std::vector<MuonChamberMatch>::const_iterator chamber = muMatches_.begin();
          chamber != muMatches_.end(); ++chamber )
       for ( std::vector<reco::MuonSegmentMatch>::const_iterator segment = chamber->segmentMatches.begin();
         segment != chamber->segmentMatches.end(); ++segment )
         {
            if (i==n) return segment->t0;
            ++i;
         }
     return 0;
      }

MuonTime reco::Muon::time ( ) const

inline

get timing information

Definition at line 132 of file Muon.h.

References time_.

Referenced by MuonCosmicCompatibilityFiller::muonTiming(), MuonIdProducer::produce(), and setTime().

132 { return time_; }

reco::Muon::time_

MuonTime time_

timing

Definition: Muon.h:239

virtual TrackRef reco::Muon::tpfmsTrack ( ) const

inlinevirtual

Reimplemented in pat::Muon.

Definition at line 58 of file Muon.h.

References muonTrackFromMap(), and TPFMS.

Referenced by muon::cocktailInputIsOK(), pat::Muon::embedTpfmsMuon(), muonTrack(), muon::tevOptimized(), and pat::Muon::tpfmsTrack().

58 { return muonTrackFromMap(TPFMS);}

reco::Muon::TPFMS

Definition: Muon.h:39

reco::Muon::muonTrackFromMap

TrackRef muonTrackFromMap(const MuonTrackType &type) const

Definition: Muon.h:76

virtual TrackRef reco::Muon::track ( void ) const

inlinevirtual

reference to a Track

Reimplemented from reco::RecoCandidate.

Reimplemented in pat::Muon.

Definition at line 50 of file Muon.h.

References innerTrack().

Referenced by ZMuMuPerformances::analyze(), MuonKinVsEtaAnalyzer::analyze(), MuonRecoAnalyzer::analyze(), MuonAssociatorByHits::associateMuons(), MuonCosmicCompatibilityFiller::backToBack2LegCosmic(), AlignmentMuonSelector::basicCuts(), FWMuonLegoProxyBuilder::build(), MuonCaloCompatibility::evaluate(), RecoMuonValidator::MuonME::fill(), MuonIdProducer::fillMuonId(), MuonIdProducer::fillMuonIsolation(), MuonIdProducer::isGoodTrackerMuon(), SoftPFMuonTagInfoProducer::isSoftMuon(), SoftPFMuonTagInfoProducer::isTightMuon(), ZToMuMuGammaAnalyzer::muonSelection(), overlap(), helper::MuonCollectionStoreManager::processMuon(), DistortedPFCandProducer::produce(), CaloMuonMerger::produce(), MuonCosmicCompatibilityFiller::pvMatches(), muon::tevOptimized(), and MuonIdTruthInfo::truthMatchMuon().

50 { return innerTrack(); }

reco::Muon::innerTrack

virtual TrackRef innerTrack() const

Definition: Muon.h:49

float Muon::trackDist	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 690 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::RequiredStationMask(), and muon::segmentCompatibility().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) dist  = currDist;
       }
       return dist;
    } else return chamberSegmentPair.first->dist();
 }

float Muon::trackDistErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 707 of file Muon.cc.

References chambers(), and pair().

Referenced by muon::RequiredStationMask().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->distErr();
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->distErr();
 }

float Muon::trackDxDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 564 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->dXdZ;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->dXdZ;
 }

float Muon::trackDxDzErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 648 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->dXdZErr;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->dXdZErr;
 }

float Muon::trackDyDz	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 585 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->dYdZ;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->dYdZ;
 }

float Muon::trackDyDzErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 669 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->dYdZErr;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->dYdZErr;
 }

float Muon::trackEdgeX	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

get track information in chamber that contains (best) segment If no segment, get track information in chamber that has the most negative distance between the track and the nearest chamber edge (the chamber with the deepest track) If no chamber returns 999999

Definition at line 480 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->edgeX;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->edgeX;
 }

float Muon::trackEdgeY	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 501 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->edgeY;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->edgeY;
 }

float Muon::trackX	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 522 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->x;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->x;
 }

float Muon::trackXErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 606 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->xErr;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->xErr;
 }

float Muon::trackY	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 543 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->y;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->y;
 }

float Muon::trackYErr	(	int	station,
		int	muonSubdetId,
		ArbitrationType	type = `SegmentAndTrackArbitration`
	)		const

Definition at line 627 of file Muon.cc.

References chambers(), and pair().

 {
    const std::vector<const MuonChamberMatch*> muonChambers = chambers(station, muonSubdetId);
    if(muonChambers.empty()) return 999999;
 
    std::pair<const MuonChamberMatch*,const MuonSegmentMatch*> chamberSegmentPair = pair(muonChambers,type);
    if(chamberSegmentPair.first==0 || chamberSegmentPair.second==0) {
       float dist  = 999999;
       float supVar = 999999;
       for(std::vector<const MuonChamberMatch*>::const_iterator muonChamber = muonChambers.begin();
             muonChamber != muonChambers.end(); ++muonChamber) {
          float currDist = (*muonChamber)->dist();
          if(currDist<dist) {
             dist  = currDist;
             supVar = (*muonChamber)->yErr;
          }
       }
       return supVar;
    } else return chamberSegmentPair.first->yErr;
 }