Inheritance diagram for PatTrackAnalyzer:

Classes
struct	Plots

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

virtual void	beginJob () override

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

	~PatTrackAnalyzer ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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 &)

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 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 61 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 ( )

Definition at line 69 of file PatTrackAnalyzer.cc.

70 {

71 }

Member Function Documentation

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

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 140 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 73 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