PatTrackAnalyzer Class Reference

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::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDAnalyzerBase () 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
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
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::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 25 of file PatTrackAnalyzer.cc.

Constructor & Destructor Documentation

PatTrackAnalyzer()

PatTrackAnalyzer::PatTrackAnalyzer

(

const edm::ParameterSet &

params

)

constructor and destructor

Definition at line 60 of file PatTrackAnalyzer.cc.

References TFileService::kSharedResource.

    : 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")) {
  usesResource(TFileService::kSharedResource);
}

~PatTrackAnalyzer()

PatTrackAnalyzer::~PatTrackAnalyzer ( )

override

Definition at line 68 of file PatTrackAnalyzer.cc.

{}

Member Function Documentation

analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 114 of file PatTrackAnalyzer.cc.

References funct::abs(), pwdgSkimBPark_cfi::beamSpot, beamSpotToken_, hfClusterShapes_cfi::hits, mps_fire::i, edm::HandleBase::isValid(), HLTObjectsMonitor_cfi::plots, plots_, qualities_, quality, reco::TrackBase::qualityByName(), srcMuonsToken_, srcTracksToken_, HLT_2022v12_cff::track, and tracks.

                                                                             {
  // 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());
    }
  }
}

beginJob()

void PatTrackAnalyzer::beginJob ( void  )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 70 of file PatTrackAnalyzer.cc.

References compareTotals::fs, mps_fire::i, M_PI, HLTObjectsMonitor_cfi::plots, plots_, qualities_, and quality.

                                {
  // 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

beamSpotToken_

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

private

Definition at line 39 of file PatTrackAnalyzer.cc.

Referenced by analyze().

plots_

std::vector<Plots> PatTrackAnalyzer::plots_

private

Definition at line 57 of file PatTrackAnalyzer.cc.

Referenced by analyze(), and beginJob().

qualities_

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

private

Definition at line 42 of file PatTrackAnalyzer.cc.

Referenced by analyze(), and beginJob().

srcMuonsToken_

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

private

Definition at line 38 of file PatTrackAnalyzer.cc.

Referenced by analyze().

srcTracksToken_

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

private

Definition at line 37 of file PatTrackAnalyzer.cc.

Referenced by analyze().