#include <DQM/TrackerMonitorTrack/src/TrackEfficiencyMonitor.cc>

Inheritance diagram for TrackEfficiencyMonitor:

Public Types
enum	SemiCylinder { Up, Down }

typedef reco::Track	Track

typedef reco::TrackCollection	TrackCollection

Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

SemiCylinder	checkSemiCylinder (const Track &)

int	compatibleLayers (const NavigationSchool &navigationSchool, TrajectoryStateOnSurface theTSOS)

std::pair< TrajectoryStateOnSurface, const DetLayer * >	findNextLayer (TrajectoryStateOnSurface startTSOS, const std::vector< const DetLayer *> &trackCompatibleLayers, bool isUpMuon)

void	testSTATracks (edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks)

void	testTrackerTracks (edm::Handle< TrackCollection > tkTracks, edm::Handle< TrackCollection > staTracks, const NavigationSchool &navigationSchool)

	TrackEfficiencyMonitor (const edm::ParameterSet &)

bool	trackerAcceptance (TrajectoryStateOnSurface theTSOS, double theRadius, double theMaxZ)

	~TrackEfficiencyMonitor () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
const MagneticField *	bField

edm::ParameterSet	conf_

MonitorElement *	deltaX

MonitorElement *	deltaY

DQMStore *	dqmStore_

int	failedToPropagate

bool	findDetLayer

MonitorElement *	GlobalMuonPtEtaPhiHighPt

MonitorElement *	GlobalMuonPtEtaPhiLowPt

const edm::ESGetToken< GeometricSearchTracker, TrackerRecoGeometryRecord >	gstToken_

std::string	histname

bool	isBFieldOff_

const MeasurementTracker *	measurementTracker

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	mfToken_

const edm::ESGetToken< MeasurementTracker, CkfComponentsRecord >	mtToken_

MonitorElement *	muonCompatibleLayers

MonitorElement *	muonD0

MonitorElement *	muonEta

MonitorElement *	muonPhi

edm::EDGetTokenT< edm::View< reco::Muon > >	muonToken_

MonitorElement *	muonX

MonitorElement *	muonY

MonitorElement *	muonZ

const edm::ESGetToken< NavigationSchool, NavigationSchoolRecord >	navToken_

int	nCompatibleLayers

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	propToken_

MonitorElement *	signDeltaX

MonitorElement *	signDeltaY

MonitorElement *	StandaloneMuonPtEtaPhiHighPt

MonitorElement *	StandaloneMuonPtEtaPhiLowPt

double	theMaxZ_

MuonServiceProxy *	theMuonServiceProxy

const DirectTrackerNavigation *	theNavigation

const Propagator *	thePropagator

double	theRadius_

edm::InputTag	theSTATracksLabel_

edm::EDGetTokenT< reco::TrackCollection >	theSTATracksToken_

edm::InputTag	theTKTracksLabel_

edm::EDGetTokenT< reco::TrackCollection >	theTKTracksToken_

const GeometricSearchTracker *	theTracker

const TransientTrackBuilder *	theTTrackBuilder

MonitorElement *	trackCompatibleLayers

MonitorElement *	trackD0

bool	trackEfficiency_

MonitorElement *	trackEta

MonitorElement *	trackPhi

MonitorElement *	trackX

MonitorElement *	trackY

MonitorElement *	trackZ

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	ttbToken_

Additional Inherited Members
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Monitoring source to measure the track efficiency

Definition at line 43 of file TrackEfficiencyMonitor.h.

Member Typedef Documentation

◆ Track

typedef reco::Track TrackEfficiencyMonitor::Track

Definition at line 45 of file TrackEfficiencyMonitor.h.

◆ TrackCollection

typedef reco::TrackCollection TrackEfficiencyMonitor::TrackCollection

Definition at line 46 of file TrackEfficiencyMonitor.h.

Member Enumeration Documentation

◆ SemiCylinder

enum TrackEfficiencyMonitor::SemiCylinder

Enumerator
Up
Down

Definition at line 53 of file TrackEfficiencyMonitor.h.

53 { Up, Down };

TrackEfficiencyMonitor::Down

Definition: TrackEfficiencyMonitor.h:53

TrackEfficiencyMonitor::Up

Definition: TrackEfficiencyMonitor.h:53

Constructor & Destructor Documentation

◆ TrackEfficiencyMonitor()

TrackEfficiencyMonitor::TrackEfficiencyMonitor ( const edm::ParameterSet & iConfig )

explicit

Definition at line 38 of file TrackEfficiencyMonitor.cc.

References conf_, dqmStore_, edm::ParameterSet::getParameter(), isBFieldOff_, muonToken_, Utilities::operator, theMaxZ_, theRadius_, theSTATracksLabel_, theSTATracksToken_, theTKTracksLabel_, theTKTracksToken_, and trackEfficiency_.

     : ttbToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       propToken_(esConsumes(edm::ESInputTag("", "SteppingHelixPropagatorAny"))),
       navToken_(esConsumes(edm::ESInputTag("", "CosmicNavigationSchool"))),
       gstToken_(esConsumes()),
       mfToken_(esConsumes()),
       mtToken_(esConsumes())
 //-----------------------------------------------------------------------------------
 {
   dqmStore_ = edm::Service<DQMStore>().operator->();
 
   theRadius_ = iConfig.getParameter<double>("theRadius");
   theMaxZ_ = iConfig.getParameter<double>("theMaxZ");
   isBFieldOff_ = iConfig.getParameter<bool>("isBFieldOff");
   trackEfficiency_ = iConfig.getParameter<bool>("trackEfficiency");
   theTKTracksLabel_ = iConfig.getParameter<edm::InputTag>("TKTrackCollection");
   theSTATracksLabel_ = iConfig.getParameter<edm::InputTag>("STATrackCollection");
   muonToken_ = consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag>("muoncoll"));
 
   theTKTracksToken_ = consumes<reco::TrackCollection>(theTKTracksLabel_);
   theSTATracksToken_ = consumes<reco::TrackCollection>(theSTATracksLabel_);
 
   conf_ = iConfig;
 }

◆ ~TrackEfficiencyMonitor()

TrackEfficiencyMonitor::~TrackEfficiencyMonitor ( )

override

Definition at line 64 of file TrackEfficiencyMonitor.cc.

66 {}

Member Function Documentation

◆ analyze()

void TrackEfficiencyMonitor::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 273 of file TrackEfficiencyMonitor.cc.

References bField, failedToPropagate, dqm::impl::MonitorElement::Fill(), findDetLayer, edm::EventSetup::getData(), GlobalMuonPtEtaPhiHighPt, GlobalMuonPtEtaPhiLowPt, gstToken_, iEvent, isBFieldOff_, muon::isGoodMuon(), measurementTracker, mfToken_, mtToken_, HLT_2024v14_cff::muon, DiMuonV_cfg::muons, muonToken_, navToken_, nCompatibleLayers, TrackCollections2monitor_cff::normalizedChi2, propToken_, StandaloneMuonPtEtaPhiHighPt, StandaloneMuonPtEtaPhiLowPt, muonTagProbeFilters_cff::staTracks, testSTATracks(), testTrackerTracks(), theNavigation, thePropagator, theSTATracksToken_, theTKTracksToken_, theTracker, theTTrackBuilder, trackEfficiency_, and ttbToken_.

 {
   edm::Handle<reco::TrackCollection> tkTracks = iEvent.getHandle(theTKTracksToken_);
   edm::Handle<reco::TrackCollection> staTracks = iEvent.getHandle(theSTATracksToken_);
 
   //initialize values
   failedToPropagate = 0;
   nCompatibleLayers = 0;
   findDetLayer = false;
 
   const NavigationSchool& nav = iSetup.getData(navToken_);
   measurementTracker = &iSetup.getData(mtToken_);
   theTTrackBuilder = &iSetup.getData(ttbToken_);
   thePropagator = &iSetup.getData(propToken_);
   bField = &iSetup.getData(mfToken_);
   theTracker = &iSetup.getData(gstToken_);
   theNavigation = new DirectTrackerNavigation(theTracker);
 
   edm::Handle<edm::View<reco::Muon> > muons = iEvent.getHandle(muonToken_);
   if (!muons.isValid())
     return;
   for (edm::View<reco::Muon>::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
     if ((*muon).pt() < 5)
       continue;
     if (fabs((*muon).eta()) > 2.4)
       continue;
     if ((*muon).vertexNormalizedChi2() > 10)
       continue;
     if ((*muon).isStandAloneMuon() and (*muon).isGlobalMuon()) {
       if ((*muon).pt() < 20)
         GlobalMuonPtEtaPhiLowPt->Fill((*muon).eta(), (*muon).phi());
       else
         GlobalMuonPtEtaPhiHighPt->Fill((*muon).eta(), (*muon).phi());
     }
     if ((*muon).isStandAloneMuon()) {
       if ((*muon).pt() < 20)
         StandaloneMuonPtEtaPhiLowPt->Fill((*muon).eta(), (*muon).phi());
       else
         StandaloneMuonPtEtaPhiHighPt->Fill((*muon).eta(), (*muon).phi());
     }
   }
   if (trackEfficiency_) {
     //---------------------------------------------------
     // Select muons with good quality
     // If B field is on, no up-down matching between the muons
     //---------------------------------------------------
     bool isGoodMuon = false;
     double mudd0 = 0., mudphi = 0., muddsz = 0., mudeta = 0.;
     if (isBFieldOff_) {
       if (staTracks->size() == 2) {
         for (unsigned int bindex = 0; bindex < staTracks->size(); ++bindex) {
           if (0 == bindex) {
             mudd0 += (*staTracks)[bindex].d0();
             mudphi += (*staTracks)[bindex].phi();
             muddsz += (*staTracks)[bindex].dsz();
             mudeta += (*staTracks)[bindex].eta();
           }
           if (1 == bindex) {
             mudd0 -= (*staTracks)[bindex].d0();
             mudphi -= (*staTracks)[bindex].phi();
             muddsz -= (*staTracks)[bindex].dsz();
             mudeta -= (*staTracks)[bindex].eta();
           }
         }
         if ((fabs(mudd0) < 15.0) && (fabs(mudphi) < 0.045) && (fabs(muddsz) < 20.0) && (fabs(mudeta) < 0.060))
           isGoodMuon = true;
       }
 
       if (isGoodMuon)
         testTrackerTracks(tkTracks, staTracks, nav);
 
     } else if (staTracks->size() == 1 || staTracks->size() == 2)
       testTrackerTracks(tkTracks, staTracks, nav);
   }
 
   if (!trackEfficiency_ && tkTracks->size() == 1) {
     if ((tkTracks->front()).normalizedChi2() < 5 && (tkTracks->front()).hitPattern().numberOfValidHits() > 8)
       testSTATracks(tkTracks, staTracks);
   }
 
   delete theNavigation;
 }

◆ bookHistograms()

void TrackEfficiencyMonitor::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 69 of file TrackEfficiencyMonitor.cc.

 {
   std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
   std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
 
   ibooker.setCurrentFolder(MEFolderName);
 
   //
   int muonXBin = conf_.getParameter<int>("muonXBin");
   double muonXMin = conf_.getParameter<double>("muonXMin");
   double muonXMax = conf_.getParameter<double>("muonXMax");
 
   histname = "muonX_";
   muonX = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonXBin, muonXMin, muonXMax);
   muonX->setAxisTitle("");
 
   //
   int muonYBin = conf_.getParameter<int>("muonYBin");
   double muonYMin = conf_.getParameter<double>("muonYMin");
   double muonYMax = conf_.getParameter<double>("muonYMax");
 
   histname = "muonY_";
   muonY = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonYBin, muonYMin, muonYMax);
   muonY->setAxisTitle("");
 
   //
   int muonZBin = conf_.getParameter<int>("muonZBin");
   double muonZMin = conf_.getParameter<double>("muonZMin");
   double muonZMax = conf_.getParameter<double>("muonZMax");
 
   histname = "muonZ_";
   muonZ = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonZBin, muonZMin, muonZMax);
   muonZ->setAxisTitle("");
 
   //
   int muonEtaBin = conf_.getParameter<int>("muonEtaBin");
   double muonEtaMin = conf_.getParameter<double>("muonEtaMin");
   double muonEtaMax = conf_.getParameter<double>("muonEtaMax");
 
   histname = "muonEta_";
   muonEta = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonEtaBin, muonEtaMin, muonEtaMax);
   muonEta->setAxisTitle("");
 
   //
   int muonPhiBin = conf_.getParameter<int>("muonPhiBin");
   double muonPhiMin = conf_.getParameter<double>("muonPhiMin");
   double muonPhiMax = conf_.getParameter<double>("muonPhiMax");
 
   histname = "muonPhi_";
   muonPhi = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonPhiBin, muonPhiMin, muonPhiMax);
   muonPhi->setAxisTitle("");
 
   //
   int muonD0Bin = conf_.getParameter<int>("muonD0Bin");
   double muonD0Min = conf_.getParameter<double>("muonD0Min");
   double muonD0Max = conf_.getParameter<double>("muonD0Max");
 
   histname = "muonD0_";
   muonD0 = ibooker.book1D(histname + AlgoName, histname + AlgoName, muonD0Bin, muonD0Min, muonD0Max);
   muonD0->setAxisTitle("");
 
   //
   int muonCompatibleLayersBin = conf_.getParameter<int>("muonCompatibleLayersBin");
   double muonCompatibleLayersMin = conf_.getParameter<double>("muonCompatibleLayersMin");
   double muonCompatibleLayersMax = conf_.getParameter<double>("muonCompatibleLayersMax");
 
   histname = "muonCompatibleLayers_";
   muonCompatibleLayers = ibooker.book1D(histname + AlgoName,
                                         histname + AlgoName,
                                         muonCompatibleLayersBin,
                                         muonCompatibleLayersMin,
                                         muonCompatibleLayersMax);
   muonCompatibleLayers->setAxisTitle("");
 
   //------------------------------------------------------------------------------------
 
   //
   int trackXBin = conf_.getParameter<int>("trackXBin");
   double trackXMin = conf_.getParameter<double>("trackXMin");
   double trackXMax = conf_.getParameter<double>("trackXMax");
 
   histname = "trackX_";
   trackX = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackXBin, trackXMin, trackXMax);
   trackX->setAxisTitle("");
 
   //
   int trackYBin = conf_.getParameter<int>("trackYBin");
   double trackYMin = conf_.getParameter<double>("trackYMin");
   double trackYMax = conf_.getParameter<double>("trackYMax");
 
   histname = "trackY_";
   trackY = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackYBin, trackYMin, trackYMax);
   trackY->setAxisTitle("");
 
   //
   int trackZBin = conf_.getParameter<int>("trackZBin");
   double trackZMin = conf_.getParameter<double>("trackZMin");
   double trackZMax = conf_.getParameter<double>("trackZMax");
 
   histname = "trackZ_";
   trackZ = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackZBin, trackZMin, trackZMax);
   trackZ->setAxisTitle("");
 
   //
   int trackEtaBin = conf_.getParameter<int>("trackEtaBin");
   double trackEtaMin = conf_.getParameter<double>("trackEtaMin");
   double trackEtaMax = conf_.getParameter<double>("trackEtaMax");
 
   histname = "trackEta_";
   trackEta = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackEtaBin, trackEtaMin, trackEtaMax);
   trackEta->setAxisTitle("");
 
   //
   int trackPhiBin = conf_.getParameter<int>("trackPhiBin");
   double trackPhiMin = conf_.getParameter<double>("trackPhiMin");
   double trackPhiMax = conf_.getParameter<double>("trackPhiMax");
 
   histname = "trackPhi_";
   trackPhi = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackPhiBin, trackPhiMin, trackPhiMax);
   trackPhi->setAxisTitle("");
 
   //
   int trackD0Bin = conf_.getParameter<int>("trackD0Bin");
   double trackD0Min = conf_.getParameter<double>("trackD0Min");
   double trackD0Max = conf_.getParameter<double>("trackD0Max");
 
   histname = "trackD0_";
   trackD0 = ibooker.book1D(histname + AlgoName, histname + AlgoName, trackD0Bin, trackD0Min, trackD0Max);
   trackD0->setAxisTitle("");
 
   //
   int trackCompatibleLayersBin = conf_.getParameter<int>("trackCompatibleLayersBin");
   double trackCompatibleLayersMin = conf_.getParameter<double>("trackCompatibleLayersMin");
   double trackCompatibleLayersMax = conf_.getParameter<double>("trackCompatibleLayersMax");
 
   histname = "trackCompatibleLayers_";
   trackCompatibleLayers = ibooker.book1D(histname + AlgoName,
                                          histname + AlgoName,
                                          trackCompatibleLayersBin,
                                          trackCompatibleLayersMin,
                                          trackCompatibleLayersMax);
   trackCompatibleLayers->setAxisTitle("");
 
   //------------------------------------------------------------------------------------
 
   //
   int deltaXBin = conf_.getParameter<int>("deltaXBin");
   double deltaXMin = conf_.getParameter<double>("deltaXMin");
   double deltaXMax = conf_.getParameter<double>("deltaXMax");
 
   histname = "deltaX_";
   deltaX = ibooker.book1D(histname + AlgoName, histname + AlgoName, deltaXBin, deltaXMin, deltaXMax);
   deltaX->setAxisTitle("");
 
   //
   int deltaYBin = conf_.getParameter<int>("deltaYBin");
   double deltaYMin = conf_.getParameter<double>("deltaYMin");
   double deltaYMax = conf_.getParameter<double>("deltaYMax");
 
   histname = "deltaY_";
   deltaY = ibooker.book1D(histname + AlgoName, histname + AlgoName, deltaYBin, deltaYMin, deltaYMax);
   deltaY->setAxisTitle("");
 
   //
   int signDeltaXBin = conf_.getParameter<int>("signDeltaXBin");
   double signDeltaXMin = conf_.getParameter<double>("signDeltaXMin");
   double signDeltaXMax = conf_.getParameter<double>("signDeltaXMax");
 
   histname = "signDeltaX_";
   signDeltaX = ibooker.book1D(histname + AlgoName, histname + AlgoName, signDeltaXBin, signDeltaXMin, signDeltaXMax);
   signDeltaX->setAxisTitle("");
 
   //
   int signDeltaYBin = conf_.getParameter<int>("signDeltaYBin");
   double signDeltaYMin = conf_.getParameter<double>("signDeltaYMin");
   double signDeltaYMax = conf_.getParameter<double>("signDeltaYMax");
 
   histname = "signDeltaY_";
   signDeltaY = ibooker.book1D(histname + AlgoName, histname + AlgoName, signDeltaYBin, signDeltaYMin, signDeltaYMax);
   signDeltaY->setAxisTitle("");
 
   histname = "GlobalMuonPtEtaPhi_LowPt_";
   GlobalMuonPtEtaPhiLowPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
   GlobalMuonPtEtaPhiLowPt->setAxisTitle("");
 
   histname = "StandaloneMuonPtEtaPhi_LowPt_";
   StandaloneMuonPtEtaPhiLowPt =
       ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
   StandaloneMuonPtEtaPhiLowPt->setAxisTitle("");
 
   histname = "GlobalMuonPtEtaPhi_HighPt_";
   GlobalMuonPtEtaPhiHighPt = ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
   GlobalMuonPtEtaPhiHighPt->setAxisTitle("");
 
   histname = "StandaloneMuonPtEtaPhi_HighPt_";
   StandaloneMuonPtEtaPhiHighPt =
       ibooker.book2D(histname + AlgoName, histname + AlgoName, 20, -2.4, 2.4, 20, -3.25, 3.25);
   StandaloneMuonPtEtaPhiHighPt->setAxisTitle("");
 }

◆ checkSemiCylinder()

TrackEfficiencyMonitor::SemiCylinder TrackEfficiencyMonitor::checkSemiCylinder ( const Track & tk )

Definition at line 546 of file TrackEfficiencyMonitor.cc.

References Down, reco::Track::innerPosition(), and Up.

Referenced by testSTATracks(), and testTrackerTracks().

 {
   return tk.innerPosition().phi() > 0 ? TrackEfficiencyMonitor::Up : TrackEfficiencyMonitor::Down;
 }

◆ compatibleLayers()

int TrackEfficiencyMonitor::compatibleLayers	(	const NavigationSchool &	navigationSchool,
		TrajectoryStateOnSurface	theTSOS
	)

Definition at line 599 of file TrackEfficiencyMonitor.cc.

References alongMomentum, Propagator::clone(), findDetLayer, findNextLayer(), TrajectoryStateOnSurface::freeState(), MeasurementTracker::geometricSearchTracker(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), dqmdumpme::k, hgcalTBTopologyTester_cfi::layers, measurementTracker, NavigationSchool::nextLayers(), Propagator::propagate(), Propagator::setPropagationDirection(), GeometricSearchDet::surface(), thePropagator, GeometricSearchTracker::tobLayers(), trackCompatibleLayers, and PV3DBase< T, PVType, FrameType >::y().

Referenced by testTrackerTracks().

 {
   //---------------------------------------------------
   // check the number of compatible layers
   //---------------------------------------------------
 
   std::vector<const BarrelDetLayer*> barrelTOBLayers = measurementTracker->geometricSearchTracker()->tobLayers();
 
   unsigned int layers = 0;
   for (unsigned int k = 0; k < barrelTOBLayers.size(); k++) {
     const DetLayer* firstLay = barrelTOBLayers[barrelTOBLayers.size() - 1 - k];
 
     //Propagator*  theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
 
     Propagator* theTmpPropagator = thePropagator->clone();
     theTmpPropagator->setPropagationDirection(alongMomentum);
 
     TrajectoryStateOnSurface startTSOS = theTmpPropagator->propagate(*theTSOS.freeState(), firstLay->surface());
 
     std::vector<const DetLayer*> trackCompatibleLayers;
 
     findDetLayer = true;
     bool isUpMuon = false;
     bool firstdtep = true;
 
     if (startTSOS.isValid()) {
       if (firstdtep)
         layers++;
 
       int nwhile = 0;
 
       //for other compatible layers
       while (startTSOS.isValid() && firstLay && findDetLayer) {
         if (firstdtep && startTSOS.globalPosition().y() > 0)
           isUpMuon = true;
 
         if (firstdtep) {
           std::vector<const DetLayer*> firstCompatibleLayers;
           firstCompatibleLayers.push_back(firstLay);
           std::pair<TrajectoryStateOnSurface, const DetLayer*> nextLayer =
               findNextLayer(theTSOS, firstCompatibleLayers, isUpMuon);
           firstdtep = false;
         } else {
           trackCompatibleLayers = navigationSchool.nextLayers(*firstLay, *(startTSOS.freeState()), alongMomentum);
           if (!trackCompatibleLayers.empty()) {
             std::pair<TrajectoryStateOnSurface, const DetLayer*> nextLayer =
                 findNextLayer(startTSOS, trackCompatibleLayers, isUpMuon);
             if (firstLay != nextLayer.second) {
               firstLay = nextLayer.second;
               startTSOS = nextLayer.first;
               layers++;
             } else
               firstLay = nullptr;
           }
         }
         nwhile++;
         if (nwhile > 100)
           break;
       }
       delete theTmpPropagator;
       break;
     }
     delete theTmpPropagator;
   }
   return layers;
 }

◆ findNextLayer()

std::pair< TrajectoryStateOnSurface, const DetLayer * > TrackEfficiencyMonitor::findNextLayer	(	TrajectoryStateOnSurface	startTSOS,
		const std::vector< const DetLayer *> &	trackCompatibleLayers,
		bool	isUpMuon
	)

Definition at line 668 of file TrackEfficiencyMonitor.cc.

References alongMomentum, Propagator::clone(), findDetLayer, TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::isValid(), Propagator::propagate(), Propagator::setPropagationDirection(), thePropagator, and trackCompatibleLayers.

Referenced by compatibleLayers().

 {
   //Propagator*  theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
 
   Propagator* theTmpPropagator = thePropagator->clone();
   theTmpPropagator->setPropagationDirection(alongMomentum);
 
   std::vector<const DetLayer*>::const_iterator itl;
   findDetLayer = false;
   for (itl = trackCompatibleLayers.begin(); itl != trackCompatibleLayers.end(); ++itl) {
     TrajectoryStateOnSurface tsos = theTmpPropagator->propagate(*(sTSOS.freeState()), (**itl).surface());
     if (tsos.isValid()) {
       sTSOS = tsos;
       findDetLayer = true;
 
       break;
     }
   }
   std::pair<TrajectoryStateOnSurface, const DetLayer*> blabla;
   blabla.first = sTSOS;
   blabla.second = &**itl;
   delete theTmpPropagator;
   return blabla;
 }

◆ testSTATracks()

void TrackEfficiencyMonitor::testSTATracks	(	edm::Handle< TrackCollection >	tkTracks,
		edm::Handle< TrackCollection >	staTracks
	)

Definition at line 478 of file TrackEfficiencyMonitor.cc.

References TransientTrackBuilder::build(), checkSemiCylinder(), d0, PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), failedToPropagate, dqm::impl::MonitorElement::Fill(), TrajectoryStateOnSurface::globalDirection(), TrajectoryStateOnSurface::globalPosition(), reco::TransientTrack::impactPointState(), reco::TransientTrack::innermostMeasurementState(), PFRecoTauChargedHadronQualityPlugins_cfi::isTrack, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localPosition(), muonD0, muonEta, muonPhi, muonX, muonY, muonZ, reco::TransientTrack::outermostMeasurementState(), phi, PV3DBase< T, PVType, FrameType >::phi(), funct::pow(), Propagator::propagate(), muonTagProbeFilters_cff::staTracks, TrajectoryStateOnSurface::surface(), thePropagator, theTTrackBuilder, trackD0, trackEta, trackPhi, trackX, trackY, trackZ, Up, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

 {
   reco::TransientTrack tkTT = theTTrackBuilder->build(tkTracks->front());
   double ipX = tkTT.impactPointState().globalPosition().x();
   double ipY = tkTT.impactPointState().globalPosition().y();
   double ipZ = tkTT.impactPointState().globalPosition().z();
   double eta = tkTT.impactPointState().globalDirection().eta();
   double phi = tkTT.impactPointState().globalDirection().phi();
   double d0 = (*tkTracks)[0].d0();
 
   TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
   LocalVector diffLocal;
   TrajectoryStateOnSurface staState;
   bool isTrack = false;
 
   if (!staTracks->empty()) {
     //---------------------------------------------------
     //look for associated muons
     //---------------------------------------------------
 
     float DR2min = 1000;
     reco::TrackCollection::const_iterator closestTrk = staTracks->end();
     //----------------------loop on tracker tracks:
     for (reco::TrackCollection::const_iterator staTrack = staTracks->begin(); staTrack != staTracks->end();
          ++staTrack) {
       if (checkSemiCylinder(*staTrack) == TrackEfficiencyMonitor::Up) {
         reco::TransientTrack staTT = theTTrackBuilder->build(*staTrack);
         failedToPropagate = 1;
         staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
 
         if (staState.isValid()) {
           failedToPropagate = 0;
           diffLocal = tkInner.localPosition() - staState.localPosition();
 
           double DR2 = diffLocal.x() * diffLocal.x() + diffLocal.y() * diffLocal.y();
           if (DR2 < DR2min) {
             DR2min = DR2;
             closestTrk = staTrack;
           }
           if (pow(DR2, 0.5) < 100.)
             isTrack = true;
         }
       }
     }
   }
 
   if (failedToPropagate == 0) {
     trackX->Fill(ipX);
     trackY->Fill(ipY);
     trackZ->Fill(ipZ);
     trackEta->Fill(eta);
     trackPhi->Fill(phi);
     trackD0->Fill(d0);
 
     if (isTrack) {
       muonX->Fill(ipX);
       muonY->Fill(ipY);
       muonZ->Fill(ipZ);
       muonEta->Fill(eta);
       muonPhi->Fill(phi);
       muonD0->Fill(d0);
     }
   }
 }

◆ testTrackerTracks()

void TrackEfficiencyMonitor::testTrackerTracks	(	edm::Handle< TrackCollection >	tkTracks,
		edm::Handle< TrackCollection >	staTracks,
		const NavigationSchool &	navigationSchool
	)

Definition at line 358 of file TrackEfficiencyMonitor.cc.

References TransientTrackBuilder::build(), checkSemiCylinder(), compatibleLayers(), d0, deltaX, deltaY, PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), failedToPropagate, dqm::impl::MonitorElement::Fill(), TrajectoryStateOnSurface::globalDirection(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, reco::TransientTrack::impactPointState(), reco::TransientTrack::innermostMeasurementState(), PFRecoTauChargedHadronQualityPlugins_cfi::isTrack, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), metname, muonCompatibleLayers, muonD0, muonEta, muonPhi, muonX, muonY, muonZ, nCompatibleLayers, TrackCollections2monitor_cff::numberOfValidHits, reco::TransientTrack::outermostMeasurementState(), phi, PV3DBase< T, PVType, FrameType >::phi(), LocalTrajectoryError::positionError(), funct::pow(), Propagator::propagate(), signDeltaX, signDeltaY, muonTagProbeFilters_cff::staTracks, AlCaHLTBitMon_QueryRunRegistry::string, TrajectoryStateOnSurface::surface(), theMaxZ_, thePropagator, theRadius_, theTTrackBuilder, trackCompatibleLayers, trackD0, trackerAcceptance(), trackEta, trackPhi, trackX, trackY, trackZ, Up, PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), PV3DBase< T, PVType, FrameType >::y(), LocalError::yy(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

 {
   const std::string metname = "testStandAloneMuonTracks";
 
   //---------------------------------------------------
   // get the index of the "up" muon
   // histograms will only be computed for the "up" muon
   //---------------------------------------------------
 
   int nUpMuon = 0;
   int idxUpMuon = -1;
   for (unsigned int i = 0; i < staTracks->size(); i++) {
     if (checkSemiCylinder((*staTracks)[i]) == TrackEfficiencyMonitor::Up) {
       nUpMuon++;
       idxUpMuon = i;
     }
   }
 
   if (nUpMuon == 1) {
     //---------------------------------------------------
     //get the muon informations
     //---------------------------------------------------
 
     reco::TransientTrack staTT = theTTrackBuilder->build((*staTracks)[idxUpMuon]);
     double ipX = staTT.impactPointState().globalPosition().x();
     double ipY = staTT.impactPointState().globalPosition().y();
     double ipZ = staTT.impactPointState().globalPosition().z();
     double eta = staTT.impactPointState().globalDirection().eta();
     double phi = staTT.impactPointState().globalDirection().phi();
     double d0 = (*staTracks)[idxUpMuon].d0();
 
     TrajectoryStateOnSurface theTSOS = staTT.outermostMeasurementState();
     TrajectoryStateOnSurface theTSOSCompLayers = staTT.outermostMeasurementState();
 
     //---------------------------------------------------
     //check if the muon is in the tracker acceptance
     //---------------------------------------------------
     bool isInTrackerAcceptance = false;
     isInTrackerAcceptance = trackerAcceptance(theTSOS, theRadius_, theMaxZ_);
 
     //---------------------------------------------------st
     //count the number of compatible layers
     //---------------------------------------------------
     nCompatibleLayers = compatibleLayers(navigationSchool, theTSOSCompLayers);
 
     if (isInTrackerAcceptance && (*staTracks)[idxUpMuon].hitPattern().numberOfValidHits() > 28) {
       //---------------------------------------------------
       //count the number of good muon candidates
       //---------------------------------------------------
 
       TrajectoryStateOnSurface staState;
       LocalVector diffLocal;
 
       bool isTrack = false;
       if (!tkTracks->empty()) {
         //---------------------------------------------------
         //look for associated tracks
         //---------------------------------------------------
         float DR2min = 1000;
         reco::TrackCollection::const_iterator closestTrk = tkTracks->end();
 
         for (reco::TrackCollection::const_iterator tkTrack = tkTracks->begin(); tkTrack != tkTracks->end(); ++tkTrack) {
           reco::TransientTrack tkTT = theTTrackBuilder->build(*tkTrack);
           TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
           staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
           failedToPropagate = 1;
 
           if (staState.isValid()) {
             failedToPropagate = 0;
             diffLocal = tkInner.localPosition() - staState.localPosition();
             double DR2 = diffLocal.x() * diffLocal.x() + diffLocal.y() * diffLocal.y();
             if (DR2 < DR2min) {
               DR2min = DR2;
               closestTrk = tkTrack;
             }
             if (pow(DR2, 0.5) < 100.)
               isTrack = true;
           }
         }
 
         if (DR2min != 1000) {
           reco::TransientTrack tkTT = theTTrackBuilder->build(*closestTrk);
           TrajectoryStateOnSurface tkInner = tkTT.innermostMeasurementState();
           staState = thePropagator->propagate(staTT.outermostMeasurementState(), tkInner.surface());
           deltaX->Fill(diffLocal.x());
           deltaY->Fill(diffLocal.y());
           signDeltaX->Fill(diffLocal.x() /
                            (tkInner.localError().positionError().xx() + staState.localError().positionError().xx()));
           signDeltaY->Fill(diffLocal.y() /
                            (tkInner.localError().positionError().yy() + staState.localError().positionError().yy()));
         }
       }
 
       if (failedToPropagate == 0) {
         muonX->Fill(ipX);
         muonY->Fill(ipY);
         muonZ->Fill(ipZ);
         muonEta->Fill(eta);
         muonPhi->Fill(phi);
         muonD0->Fill(d0);
         muonCompatibleLayers->Fill(nCompatibleLayers);
 
         if (isTrack) {
           trackX->Fill(ipX);
           trackY->Fill(ipY);
           trackZ->Fill(ipZ);
           trackEta->Fill(eta);
           trackPhi->Fill(phi);
           trackD0->Fill(d0);
           trackCompatibleLayers->Fill(nCompatibleLayers);
         }
       }
     }
   }
 }

◆ trackerAcceptance()

bool TrackEfficiencyMonitor::trackerAcceptance	(	TrajectoryStateOnSurface	theTSOS,
		double	theRadius,
		double	theMaxZ
	)

Definition at line 553 of file TrackEfficiencyMonitor.cc.

References accept(), alongMomentum, Cylinder::build(), Propagator::clone(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), oppositeToMomentum, Propagator::propagate(), Propagator::setPropagationDirection(), TrackEfficiencyMonitor_cfi::theMaxZ, thePropagator, TrackEfficiencyMonitor_cfi::theRadius, PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by testTrackerTracks().

 {
   //---------------------------------------------------
   // check if the muon is in the tracker acceptance
   // check the compatibility with a cylinder of radius "theRadius"
   //---------------------------------------------------
 
   //Propagator*  theTmpPropagator = new SteppingHelixPropagator(&*bField,anyDirection);
 
   //Propagator*  theTmpPropagator = &*thePropagator;
   Propagator* theTmpPropagator = thePropagator->clone();
 
   if (theTSOS.globalPosition().y() < 0)
     theTmpPropagator->setPropagationDirection(oppositeToMomentum);
   else
     theTmpPropagator->setPropagationDirection(alongMomentum);
 
   Cylinder::PositionType pos0;
   Cylinder::RotationType rot0;
   const Cylinder::CylinderPointer cyl = Cylinder::build(pos0, rot0, theRadius);
   TrajectoryStateOnSurface tsosAtCyl = theTmpPropagator->propagate(*theTSOS.freeState(), *cyl);
   double accept = false;
   if (tsosAtCyl.isValid()) {
     if (fabs(tsosAtCyl.globalPosition().z()) < theMaxZ) {
       Cylinder::PositionType pos02;
       Cylinder::RotationType rot02;
       const Cylinder::CylinderPointer cyl2 = Cylinder::build(pos02, rot02, theRadius - 10);
       TrajectoryStateOnSurface tsosAtCyl2 = theTmpPropagator->propagate(*tsosAtCyl.freeState(), *cyl2);
       if (tsosAtCyl2.isValid()) {
         Cylinder::PositionType pos03;
         Cylinder::RotationType rot03;
         const Cylinder::CylinderPointer cyl3 = Cylinder::build(pos03, rot03, theRadius);
         TrajectoryStateOnSurface tsosAtCyl3 = theTmpPropagator->propagate(*tsosAtCyl2.freeState(), *cyl3);
         if (tsosAtCyl3.isValid()) {
           accept = true;
         }
       }
     }
   }
   delete theTmpPropagator;
   //muon propagated to the barrel cylinder
   return accept;
 }

Member Data Documentation

◆ bField

const MagneticField* TrackEfficiencyMonitor::bField

private

Definition at line 126 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ conf_

edm::ParameterSet TrackEfficiencyMonitor::conf_

private

Definition at line 70 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and TrackEfficiencyMonitor().

◆ deltaX

MonitorElement* TrackEfficiencyMonitor::deltaX

private

Definition at line 103 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ deltaY

MonitorElement* TrackEfficiencyMonitor::deltaY

private

Definition at line 104 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ dqmStore_

DQMStore* TrackEfficiencyMonitor::dqmStore_

private

Definition at line 69 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ failedToPropagate

int TrackEfficiencyMonitor::failedToPropagate

private

Definition at line 83 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), testSTATracks(), and testTrackerTracks().

◆ findDetLayer

bool TrackEfficiencyMonitor::findDetLayer

private

Definition at line 85 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), compatibleLayers(), and findNextLayer().

◆ GlobalMuonPtEtaPhiHighPt

MonitorElement* TrackEfficiencyMonitor::GlobalMuonPtEtaPhiHighPt

private

Definition at line 109 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ GlobalMuonPtEtaPhiLowPt

MonitorElement* TrackEfficiencyMonitor::GlobalMuonPtEtaPhiLowPt

private

Definition at line 107 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ gstToken_

const edm::ESGetToken<GeometricSearchTracker, TrackerRecoGeometryRecord> TrackEfficiencyMonitor::gstToken_

private

Definition at line 117 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ histname

std::string TrackEfficiencyMonitor::histname

private

Definition at line 67 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms().

◆ isBFieldOff_

bool TrackEfficiencyMonitor::isBFieldOff_

private

Definition at line 74 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ measurementTracker

const MeasurementTracker* TrackEfficiencyMonitor::measurementTracker

private

Definition at line 127 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and compatibleLayers().

◆ mfToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TrackEfficiencyMonitor::mfToken_

private

Definition at line 118 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ mtToken_

const edm::ESGetToken<MeasurementTracker, CkfComponentsRecord> TrackEfficiencyMonitor::mtToken_

private

Definition at line 119 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ muonCompatibleLayers

MonitorElement* TrackEfficiencyMonitor::muonCompatibleLayers

private

Definition at line 93 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ muonD0

MonitorElement* TrackEfficiencyMonitor::muonD0

private

Definition at line 92 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonEta

MonitorElement* TrackEfficiencyMonitor::muonEta

private

Definition at line 90 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonPhi

MonitorElement* TrackEfficiencyMonitor::muonPhi

private

Definition at line 91 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonToken_

edm::EDGetTokenT<edm::View<reco::Muon> > TrackEfficiencyMonitor::muonToken_

private

Definition at line 121 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ muonX

MonitorElement* TrackEfficiencyMonitor::muonX

private

Definition at line 87 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonY

MonitorElement* TrackEfficiencyMonitor::muonY

private

Definition at line 88 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ muonZ

MonitorElement* TrackEfficiencyMonitor::muonZ

private

Definition at line 89 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ navToken_

const edm::ESGetToken<NavigationSchool, NavigationSchoolRecord> TrackEfficiencyMonitor::navToken_

private

Definition at line 116 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ nCompatibleLayers

int TrackEfficiencyMonitor::nCompatibleLayers

private

Definition at line 84 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and testTrackerTracks().

◆ propToken_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> TrackEfficiencyMonitor::propToken_

private

Definition at line 115 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ signDeltaX

MonitorElement* TrackEfficiencyMonitor::signDeltaX

private

Definition at line 105 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ signDeltaY

MonitorElement* TrackEfficiencyMonitor::signDeltaY

private

Definition at line 106 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), and testTrackerTracks().

◆ StandaloneMuonPtEtaPhiHighPt

MonitorElement* TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiHighPt

private

Definition at line 110 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ StandaloneMuonPtEtaPhiLowPt

MonitorElement* TrackEfficiencyMonitor::StandaloneMuonPtEtaPhiLowPt

private

Definition at line 108 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and bookHistograms().

◆ theMaxZ_

double TrackEfficiencyMonitor::theMaxZ_

private

Definition at line 73 of file TrackEfficiencyMonitor.h.

Referenced by testTrackerTracks(), and TrackEfficiencyMonitor().

◆ theMuonServiceProxy

MuonServiceProxy* TrackEfficiencyMonitor::theMuonServiceProxy

private

Definition at line 112 of file TrackEfficiencyMonitor.h.

◆ theNavigation

const DirectTrackerNavigation* TrackEfficiencyMonitor::theNavigation

private

Definition at line 111 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ thePropagator

const Propagator* TrackEfficiencyMonitor::thePropagator

private

Definition at line 123 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), compatibleLayers(), findNextLayer(), testSTATracks(), testTrackerTracks(), and trackerAcceptance().

◆ theRadius_

double TrackEfficiencyMonitor::theRadius_

private

Definition at line 72 of file TrackEfficiencyMonitor.h.

Referenced by testTrackerTracks(), and TrackEfficiencyMonitor().

◆ theSTATracksLabel_

edm::InputTag TrackEfficiencyMonitor::theSTATracksLabel_

private

Definition at line 79 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ theSTATracksToken_

edm::EDGetTokenT<reco::TrackCollection> TrackEfficiencyMonitor::theSTATracksToken_

private

Definition at line 81 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ theTKTracksLabel_

edm::InputTag TrackEfficiencyMonitor::theTKTracksLabel_

private

Definition at line 78 of file TrackEfficiencyMonitor.h.

Referenced by TrackEfficiencyMonitor().

◆ theTKTracksToken_

edm::EDGetTokenT<reco::TrackCollection> TrackEfficiencyMonitor::theTKTracksToken_

private

Definition at line 80 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ theTracker

const GeometricSearchTracker* TrackEfficiencyMonitor::theTracker

private

Definition at line 125 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

◆ theTTrackBuilder

const TransientTrackBuilder* TrackEfficiencyMonitor::theTTrackBuilder

private

Definition at line 124 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), testSTATracks(), and testTrackerTracks().

◆ trackCompatibleLayers

MonitorElement* TrackEfficiencyMonitor::trackCompatibleLayers

private

Definition at line 101 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), compatibleLayers(), findNextLayer(), and testTrackerTracks().

◆ trackD0

MonitorElement* TrackEfficiencyMonitor::trackD0

private

Definition at line 100 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackEfficiency_

bool TrackEfficiencyMonitor::trackEfficiency_

private

Definition at line 75 of file TrackEfficiencyMonitor.h.

Referenced by analyze(), and TrackEfficiencyMonitor().

◆ trackEta

MonitorElement* TrackEfficiencyMonitor::trackEta

private

Definition at line 98 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackPhi

MonitorElement* TrackEfficiencyMonitor::trackPhi

private

Definition at line 99 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackX

MonitorElement* TrackEfficiencyMonitor::trackX

private

Definition at line 95 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackY

MonitorElement* TrackEfficiencyMonitor::trackY

private

Definition at line 96 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ trackZ

MonitorElement* TrackEfficiencyMonitor::trackZ

private

Definition at line 97 of file TrackEfficiencyMonitor.h.

Referenced by bookHistograms(), testSTATracks(), and testTrackerTracks().

◆ ttbToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> TrackEfficiencyMonitor::ttbToken_

private

Definition at line 114 of file TrackEfficiencyMonitor.h.

Referenced by analyze().

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Track

◆ TrackCollection

Member Enumeration Documentation

◆ SemiCylinder

Constructor & Destructor Documentation

◆ TrackEfficiencyMonitor()

◆ ~TrackEfficiencyMonitor()

Member Function Documentation

◆ analyze()

◆ bookHistograms()

◆ checkSemiCylinder()

◆ compatibleLayers()

◆ findNextLayer()

◆ testSTATracks()

◆ testTrackerTracks()

◆ trackerAcceptance()

Member Data Documentation

◆ bField

◆ conf_

◆ deltaX

◆ deltaY

◆ dqmStore_

◆ failedToPropagate

◆ findDetLayer

◆ GlobalMuonPtEtaPhiHighPt

◆ GlobalMuonPtEtaPhiLowPt

◆ gstToken_

◆ histname

◆ isBFieldOff_

◆ measurementTracker

◆ mfToken_

◆ mtToken_

◆ muonCompatibleLayers

◆ muonD0

◆ muonEta

◆ muonPhi

◆ muonToken_

◆ muonX

◆ muonY

◆ muonZ

◆ navToken_

◆ nCompatibleLayers

◆ propToken_

◆ signDeltaX

◆ signDeltaY

◆ StandaloneMuonPtEtaPhiHighPt

◆ StandaloneMuonPtEtaPhiLowPt

◆ theMaxZ_

◆ theMuonServiceProxy

◆ theNavigation

◆ thePropagator

◆ theRadius_

◆ theSTATracksLabel_

◆ theSTATracksToken_

◆ theTKTracksLabel_

◆ theTKTracksToken_

◆ theTracker

◆ theTTrackBuilder

◆ trackCompatibleLayers

◆ trackD0

◆ trackEfficiency_

◆ trackEta

◆ trackPhi

◆ trackX

◆ trackY

◆ trackZ

◆ ttbToken_