Inheritance diagram for PatTrackAnalyzer:

Classes
struct	Plots

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

void	beginJob () override

	PatTrackAnalyzer (const edm::ParameterSet &params)
	constructor and destructor More...

	~PatTrackAnalyzer () override

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

std::vector< Plots >	plots_

std::vector< std::string >	qualities_

edm::EDGetTokenT< pat::MuonCollection >	srcMuonsToken_

edm::EDGetTokenT< edm::View< reco::Track > >	srcTracksToken_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 25 of file PatTrackAnalyzer.cc.

Constructor & Destructor Documentation

PatTrackAnalyzer::PatTrackAnalyzer ( const edm::ParameterSet & params )

constructor and destructor

Definition at line 60 of file PatTrackAnalyzer.cc.

     : srcTracksToken_(mayConsume<edm::View<reco::Track> >(params.getParameter<edm::InputTag>("src"))),
       srcMuonsToken_(mayConsume<pat::MuonCollection>(params.getParameter<edm::InputTag>("src"))),
       beamSpotToken_(consumes<reco::BeamSpot>(params.getParameter<edm::InputTag>("beamSpot"))),
       qualities_(params.getParameter<std::vector<std::string> >("qualities")) {}

PatTrackAnalyzer::~PatTrackAnalyzer ( )

override

Definition at line 66 of file PatTrackAnalyzer.cc.

66 {}

Member Function Documentation

void PatTrackAnalyzer::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	es
	)

override

Definition at line 112 of file PatTrackAnalyzer.cc.

                                                                              {
   // handles to kinds of data we might want to read
   edm::Handle<reco::BeamSpot> beamSpot;
   edm::Handle<edm::View<reco::Track> > tracksHandle;
   edm::Handle<pat::MuonCollection> muonsHandle;
 
   // read the beam spot
   event.getByToken(beamSpotToken_, beamSpot);
 
   // our internal copy of track points
   // (we need this in order to able to simultaneously access tracks
   //  directly or embedded in PAT objects, like muons, normally you
   //  would iterate over the handle directly)
   std::vector<const reco::Track *> tracks;
 
   event.getByToken(srcTracksToken_, tracksHandle);
   if (tracksHandle.isValid()) {
     // framework was able to read the collection as a view of
     // tracks, no copy them to our "tracks" variable
     for (edm::View<reco::Track>::const_iterator iter = tracksHandle->begin(); iter != tracksHandle->end(); ++iter)
       tracks.push_back(&*iter);
   } else {
     // does not exist or is not a track collection
     // let's assume it is a collection of PAT muons
     event.getByToken(srcMuonsToken_, muonsHandle);
 
     // and copy them over
     // NOTE: We are using ->globalTrack() here
     //       This means we are using the global fit over both
     //       the inner tracker and the muon stations!
     //       other alternatives are: innerTrack(), outerTrack()
     for (pat::MuonCollection::const_iterator iter = muonsHandle->begin(); iter != muonsHandle->end(); ++iter) {
       reco::TrackRef track = iter->globalTrack();
       // the muon might not be a "global" muon
       if (track.isNonnull())
         tracks.push_back(&*track);
     }
   }
 
   // we are done filling the tracks into our "tracks" vector.
   // now analyze them, once for each track quality category
 
   unsigned int nQualities = qualities_.size();
   for (unsigned int i = 0; i < nQualities; ++i) {
     // we convert the quality flag from its name as a string
     // to the enumeration value used by the tracking code
     // (which is essentially an integer number)
     reco::Track::TrackQuality quality = reco::Track::qualityByName(qualities_[i]);
 
     // our set of plots
     Plots &plots = plots_[i];
 
     // now loop over the tracks
     for (std::vector<const reco::Track *>::const_iterator iter = tracks.begin(); iter != tracks.end(); ++iter) {
       // this is our track
       const reco::Track &track = **iter;
 
       // ignore tracks that fail the quality cut
       if (!track.quality(quality))
         continue;
 
       // and fill all the plots
       plots.eta->Fill(track.eta());
       plots.phi->Fill(track.phi());
 
       plots.pt->Fill(track.pt());
       plots.ptErr->Fill(track.ptError());
 
       plots.invPt->Fill(track.qoverp());
       plots.invPtErr->Fill(track.qoverpError());
 
       // the transverse IP is taken with respect to
       // the beam spot instead of (0, 0)
       // because the beam spot in CMS is not at (0, 0)
       plots.d0->Fill(track.dxy(beamSpot->position()));
       plots.d0Err->Fill(track.dxyError());
 
       plots.nHits->Fill(track.numberOfValidHits());
 
       // the hit pattern contains information about
       // which modules of the detector have been hit
       const reco::HitPattern &hits = track.hitPattern();
 
       double absEta = std::abs(track.eta());
       // now fill the number of hits in a layer depending on eta
       plots.pxbHitsEta->Fill(absEta, hits.numberOfValidPixelBarrelHits());
       plots.pxeHitsEta->Fill(absEta, hits.numberOfValidPixelEndcapHits());
       plots.tibHitsEta->Fill(absEta, hits.numberOfValidStripTIBHits());
       plots.tobHitsEta->Fill(absEta, hits.numberOfValidStripTOBHits());
       plots.tidHitsEta->Fill(absEta, hits.numberOfValidStripTIDHits());
       plots.tecHitsEta->Fill(absEta, hits.numberOfValidStripTECHits());
     }
   }
 }

void PatTrackAnalyzer::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 68 of file PatTrackAnalyzer.cc.

                                 {
   // retrieve handle to auxiliary service
   //  used for storing histograms into ROOT file
   edm::Service<TFileService> fs;
 
   // now book the histograms, for each category
   unsigned int nQualities = qualities_.size();
 
   plots_.resize(nQualities);
 
   for (unsigned int i = 0; i < nQualities; ++i) {
     // the name of the quality flag
     const char *quality = qualities_[i].c_str();
 
     // the set of plots
     Plots &plots = plots_[i];
 
     plots.eta = fs->make<TH1F>(Form("eta_%s", quality), Form("track \\eta (%s)", quality), 100, -3, 3);
     plots.phi = fs->make<TH1F>(Form("phi_%s", quality), Form("track \\phi (%s)", quality), 100, -M_PI, +M_PI);
     plots.pt = fs->make<TH1F>(Form("pt_%s", quality), Form("track p_{T} (%s)", quality), 100, 0, 10);
     plots.ptErr = fs->make<TH1F>(Form("ptErr_%s", quality), Form("track p_{T} error (%s)", quality), 100, 0, 1);
     plots.invPt = fs->make<TH1F>(Form("invPt_%s", quality), Form("track 1/p_{T} (%s)", quality), 100, -5, 5);
     plots.invPtErr =
         fs->make<TH1F>(Form("invPtErr_%s", quality), Form("track 1/p_{T} error (%s)", quality), 100, 0, 0.1);
     plots.d0 = fs->make<TH1F>(Form("d0_%s", quality), Form("track d0 (%s)", quality), 100, 0, 0.1);
     plots.d0Err = fs->make<TH1F>(Form("d0Err_%s", quality), Form("track d0 error (%s)", quality), 100, 0, 0.1);
     plots.nHits =
         fs->make<TH1F>(Form("nHits_%s", quality), Form("track number of total hits (%s)", quality), 60, 0, 60);
 
     plots.pxbHitsEta =
         fs->make<TProfile>(Form("pxbHitsEta_%s", quality), Form("#hits in Pixel Barrel (%s)", quality), 100, 0, 3);
     plots.pxeHitsEta =
         fs->make<TProfile>(Form("pxeHitsEta_%s", quality), Form("#hits in Pixel Endcap (%s)", quality), 100, 0, 3);
     plots.tibHitsEta = fs->make<TProfile>(
         Form("tibHitsEta_%s", quality), Form("#hits in Tracker Inner Barrel (%s)", quality), 100, 0, 3);
     plots.tobHitsEta = fs->make<TProfile>(
         Form("tobHitsEta_%s", quality), Form("#hits in Tracker Outer Barrel (%s)", quality), 100, 0, 3);
     plots.tidHitsEta = fs->make<TProfile>(
         Form("tidHitsEta_%s", quality), Form("#hits in Tracker Inner Disk (%s)", quality), 100, 0, 3);
     plots.tecHitsEta =
         fs->make<TProfile>(Form("tecHitsEta_%s", quality), Form("#hits in Tracker Endcap (%s)", quality), 100, 0, 3);
   }
 }

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> PatTrackAnalyzer::beamSpotToken_

private

Definition at line 39 of file PatTrackAnalyzer.cc.

Referenced by analyze().

std::vector<Plots> PatTrackAnalyzer::plots_

private

Definition at line 57 of file PatTrackAnalyzer.cc.

Referenced by analyze(), and beginJob().

std::vector<std::string> PatTrackAnalyzer::qualities_

private

Definition at line 42 of file PatTrackAnalyzer.cc.

Referenced by analyze(), and beginJob().

edm::EDGetTokenT<pat::MuonCollection> PatTrackAnalyzer::srcMuonsToken_

private

Definition at line 38 of file PatTrackAnalyzer.cc.

Referenced by analyze().

edm::EDGetTokenT<edm::View<reco::Track> > PatTrackAnalyzer::srcTracksToken_

private

Definition at line 37 of file PatTrackAnalyzer.cc.

Referenced by analyze().

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation