#include <StandaloneTrackMonitor.h>

Inheritance diagram for StandaloneTrackMonitor:

Public Member Functions
	StandaloneTrackMonitor (const edm::ParameterSet &)

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Protected Member Functions
void	addClusterToMap (uint32_t detid, const SiStripCluster *cluster)

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

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

void	processClusters (edm::Event const &iEvent, edm::EventSetup const &iSetup, const TrackerGeometry &tkGeom, double wfac=1)

void	processHit (const TrackingRecHit &recHit, edm::EventSetup const &iSetup, const TrackerGeometry &tkGeom, double wfac=1)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Attributes
MonitorElement *	beamSpotXYposerrH_

MonitorElement *	beamSpotXYposH_

MonitorElement *	beamSpotZposerrH_

MonitorElement *	beamSpotZposH_

const edm::InputTag	bsTag_

const edm::EDGetTokenT< reco::BeamSpot >	bsToken_

MonitorElement *	bunchCrossingH_

std::map< uint32_t, std::set< const SiStripCluster * > >	clusterMap_

const edm::InputTag	clusterTag_

const edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > >	clusterToken_

const bool	doPUCorrection_

std::string	folderName_

const bool	haveAllHistograms_

MonitorElement *	hOffTrkClusChargeThickH_

MonitorElement *	hOffTrkClusChargeThinH_

MonitorElement *	hOffTrkClusWidthThickH_

MonitorElement *	hOffTrkClusWidthThinH_

MonitorElement *	hOnTrkClusChargeThickH_

MonitorElement *	hOnTrkClusChargeThinH_

MonitorElement *	hOnTrkClusWidthThickH_

MonitorElement *	hOnTrkClusWidthThinH_

const bool	isMC_

unsigned long long	m_cacheID_

std::string	moduleName_

MonitorElement *	nHitsVsCosThetaH_

MonitorElement *	nHitsVsEtaH_

MonitorElement *	nHitsVsnVtxH_

MonitorElement *	nHitsVsPhiH_

MonitorElement *	nHitsVspTH_

MonitorElement *	nlostHitsH_

MonitorElement *	nLostHitsVsCosThetaH_

MonitorElement *	nLostHitsVsEtaH_

MonitorElement *	nLostHitsVsPhiH_

MonitorElement *	nLostHitsVspTH_

MonitorElement *	nPixBarrelH_

MonitorElement *	nPixEndcapH_

MonitorElement *	nPUH_

MonitorElement *	nStripTECH_

MonitorElement *	nStripTIBH_

MonitorElement *	nStripTIDH_

MonitorElement *	nStripTOBH_

MonitorElement *	nTracksH_

MonitorElement *	nvalidPixelHitsH_

MonitorElement *	nvalidStripHitsH_

MonitorElement *	nvalidTrackerHitsH_

MonitorElement *	nVertexH_

edm::ParameterSet	parameters_

MonitorElement *	pixelLayerwithMeasurementH_

const std::string	puScaleFactorFile_

const edm::InputTag	puSummaryTag_

const edm::EDGetTokenT< std::vector< PileupSummaryInfo > >	puSummaryToken_

SiStripClusterInfo	siStripClusterInfo_

MonitorElement *	stripLayerwithMeasurementH_

MonitorElement *	trackChargeH_

MonitorElement *	trackChi2bynDOFH_

MonitorElement *	trackChi2H_

MonitorElement *	trackCosThetaH_

MonitorElement *	trackd0H_

MonitorElement *	trackEtaerrH_

MonitorElement *	trackEtaH_

MonitorElement *	tracknDOFH_

MonitorElement *	trackPH_

MonitorElement *	trackPhierrH_

MonitorElement *	trackPhiH_

MonitorElement *	trackPterrH_

MonitorElement *	trackPtH_

MonitorElement *	trackPtOver10GeVH_

MonitorElement *	trackPtUpto2GeVH_

MonitorElement *	trackqOverperrH_

MonitorElement *	trackqOverpH_

const std::string	trackQuality_

const edm::InputTag	trackTag_

MonitorElement *	trackThetaerrH_

const edm::EDGetTokenT< reco::TrackCollection >	trackToken_

MonitorElement *	trkLayerwithMeasurementH_

MonitorElement *	trueNIntH_

const bool	verbose_

const edm::InputTag	vertexTag_

const edm::EDGetTokenT< reco::VertexCollection >	vertexToken_

MonitorElement *	vertexXposH_

MonitorElement *	vertexYposH_

MonitorElement *	vertexZposH_

std::vector< float >	vpu_

Additional Inherited Members
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 >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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 Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 31 of file StandaloneTrackMonitor.h.

Constructor & Destructor Documentation

◆ StandaloneTrackMonitor()

StandaloneTrackMonitor::StandaloneTrackMonitor ( const edm::ParameterSet & ps )

Definition at line 25 of file StandaloneTrackMonitor.cc.

     : parameters_(ps),
       moduleName_(parameters_.getUntrackedParameter<std::string>("moduleName", "StandaloneTrackMonitor")),
       folderName_(parameters_.getUntrackedParameter<std::string>("folderName", "highPurityTracks")),
       trackTag_(parameters_.getUntrackedParameter<edm::InputTag>("trackInputTag", edm::InputTag("generalTracks"))),
       bsTag_(parameters_.getUntrackedParameter<edm::InputTag>("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))),
       vertexTag_(
           parameters_.getUntrackedParameter<edm::InputTag>("vertexTag", edm::InputTag("offlinePrimaryVertices"))),
       puSummaryTag_(parameters_.getUntrackedParameter<edm::InputTag>("puTag", edm::InputTag("addPileupInfo"))),
       clusterTag_(parameters_.getUntrackedParameter<edm::InputTag>("clusterTag", edm::InputTag("siStripClusters"))),
       trackToken_(consumes<reco::TrackCollection>(trackTag_)),
       bsToken_(consumes<reco::BeamSpot>(bsTag_)),
       vertexToken_(consumes<reco::VertexCollection>(vertexTag_)),
       puSummaryToken_(consumes<std::vector<PileupSummaryInfo> >(puSummaryTag_)),
       clusterToken_(consumes<edmNew::DetSetVector<SiStripCluster> >(clusterTag_)),
       trackQuality_(parameters_.getUntrackedParameter<std::string>("trackQuality", "highPurity")),
       siStripClusterInfo_(consumesCollector()),
       doPUCorrection_(parameters_.getUntrackedParameter<bool>("doPUCorrection", false)),
       isMC_(parameters_.getUntrackedParameter<bool>("isMC", false)),
       haveAllHistograms_(parameters_.getUntrackedParameter<bool>("haveAllHistograms", false)),
       puScaleFactorFile_(
           parameters_.getUntrackedParameter<std::string>("puScaleFactorFile", "PileupScaleFactor_run203002.root")),
       verbose_(parameters_.getUntrackedParameter<bool>("verbose", false)) {
   trackEtaH_ = nullptr;
   trackEtaerrH_ = nullptr;
   trackCosThetaH_ = nullptr;
   trackThetaerrH_ = nullptr;
   trackPhiH_ = nullptr;
   trackPhierrH_ = nullptr;
   trackPH_ = nullptr;
   trackPtH_ = nullptr;
   trackPtUpto2GeVH_ = nullptr;
   trackPtOver10GeVH_ = nullptr;
   trackPterrH_ = nullptr;
   trackqOverpH_ = nullptr;
   trackqOverperrH_ = nullptr;
   trackChargeH_ = nullptr;
   nlostHitsH_ = nullptr;
   nvalidTrackerHitsH_ = nullptr;
   nvalidPixelHitsH_ = nullptr;
   nvalidStripHitsH_ = nullptr;
   trkLayerwithMeasurementH_ = nullptr;
   pixelLayerwithMeasurementH_ = nullptr;
   stripLayerwithMeasurementH_ = nullptr;
   beamSpotXYposH_ = nullptr;
   beamSpotXYposerrH_ = nullptr;
   beamSpotZposH_ = nullptr;
   beamSpotZposerrH_ = nullptr;
   trackChi2H_ = nullptr;
   tracknDOFH_ = nullptr;
   trackd0H_ = nullptr;
   trackChi2bynDOFH_ = nullptr;
   vertexXposH_ = nullptr;
   vertexYposH_ = nullptr;
   vertexZposH_ = nullptr;
  
   nPixBarrelH_ = nullptr;
   nPixEndcapH_ = nullptr;
   nStripTIBH_ = nullptr;
   nStripTOBH_ = nullptr;
   nStripTECH_ = nullptr;
   nStripTIDH_ = nullptr;
   nTracksH_ = nullptr;
  
   // for MC only
   nVertexH_ = nullptr;
   bunchCrossingH_ = nullptr;
   nPUH_ = nullptr;
   trueNIntH_ = nullptr;
  
   nHitsVspTH_ = nullptr;
   nHitsVsEtaH_ = nullptr;
   nHitsVsCosThetaH_ = nullptr;
   nHitsVsPhiH_ = nullptr;
   nHitsVsnVtxH_ = nullptr;
   nLostHitsVspTH_ = nullptr;
   nLostHitsVsEtaH_ = nullptr;
   nLostHitsVsCosThetaH_ = nullptr;
   nLostHitsVsPhiH_ = nullptr;
  
   hOnTrkClusChargeThinH_ = nullptr;
   hOnTrkClusWidthThinH_ = nullptr;
   hOnTrkClusChargeThickH_ = nullptr;
   hOnTrkClusWidthThickH_ = nullptr;
  
   hOffTrkClusChargeThinH_ = nullptr;
   hOffTrkClusWidthThinH_ = nullptr;
   hOffTrkClusChargeThickH_ = nullptr;
   hOffTrkClusWidthThickH_ = nullptr;
  
   // Read pileup weight factors
   if (isMC_ && doPUCorrection_) {
     vpu_.clear();
     TFile* f1 = TFile::Open(puScaleFactorFile_.c_str());
     TH1F* h1 = dynamic_cast<TH1F*>(f1->Get("pileupweight"));
     for (int i = 1; i <= h1->GetNbinsX(); ++i)
       vpu_.push_back(h1->GetBinContent(i));
     f1->Close();
   }
 }

References beamSpotXYposerrH_, beamSpotXYposH_, beamSpotZposerrH_, beamSpotZposH_, bunchCrossingH_, doPUCorrection_, DeadROC_duringRun::f1, hOffTrkClusChargeThickH_, hOffTrkClusChargeThinH_, hOffTrkClusWidthThickH_, hOffTrkClusWidthThinH_, hOnTrkClusChargeThickH_, hOnTrkClusChargeThinH_, hOnTrkClusWidthThickH_, hOnTrkClusWidthThinH_, mps_fire::i, isMC_, nHitsVsCosThetaH_, nHitsVsEtaH_, nHitsVsnVtxH_, nHitsVsPhiH_, nHitsVspTH_, nlostHitsH_, nLostHitsVsCosThetaH_, nLostHitsVsEtaH_, nLostHitsVsPhiH_, nLostHitsVspTH_, nPixBarrelH_, nPixEndcapH_, nPUH_, nStripTECH_, nStripTIBH_, nStripTIDH_, nStripTOBH_, nTracksH_, nvalidPixelHitsH_, nvalidStripHitsH_, nvalidTrackerHitsH_, nVertexH_, pixelLayerwithMeasurementH_, puScaleFactorFile_, stripLayerwithMeasurementH_, trackChargeH_, trackChi2bynDOFH_, trackChi2H_, trackCosThetaH_, trackd0H_, trackEtaerrH_, trackEtaH_, tracknDOFH_, trackPH_, trackPhierrH_, trackPhiH_, trackPterrH_, trackPtH_, trackPtOver10GeVH_, trackPtUpto2GeVH_, trackqOverperrH_, trackqOverpH_, trackThetaerrH_, trkLayerwithMeasurementH_, trueNIntH_, vertexXposH_, vertexYposH_, vertexZposH_, and vpu_.

Member Function Documentation

◆ addClusterToMap()

void StandaloneTrackMonitor::addClusterToMap	(	uint32_t	detid,
		const SiStripCluster *	cluster
	)

protected

Definition at line 619 of file StandaloneTrackMonitor.cc.

                                                                                           {
   std::map<uint32_t, std::set<const SiStripCluster*> >::iterator it = clusterMap_.find(detid);
   if (it == clusterMap_.end()) {
     std::set<const SiStripCluster*> s;
     s.insert(cluster);
     clusterMap_.insert(std::pair<uint32_t, std::set<const SiStripCluster*> >(detid, s));
   } else {
     std::set<const SiStripCluster*>& s = it->second;
     s.insert(cluster);
   }
 }

References clusterMap_, and alignCSCRings::s.

Referenced by processHit().

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 320 of file StandaloneTrackMonitor.cc.

                                                                                         {
   // Get event setup (to get global transformation)
   edm::ESHandle<TrackerGeometry> geomHandle;
   iSetup.get<TrackerDigiGeometryRecord>().get(geomHandle);
   const TrackerGeometry& tkGeom = (*geomHandle);
  
   siStripClusterInfo_.initEvent(iSetup);
  
   // Primary vertex collection
   edm::Handle<reco::VertexCollection> vertexColl;
   iEvent.getByToken(vertexToken_, vertexColl);
  
   // Beam spot
   edm::Handle<reco::BeamSpot> beamSpot;
   iEvent.getByToken(bsToken_, beamSpot);
  
   // Track collection
   edm::Handle<reco::TrackCollection> tracks;
   iEvent.getByToken(trackToken_, tracks);
  
   // Access PU information
   double wfac = 1.0;  // for data
   if (!iEvent.isRealData()) {
     edm::Handle<std::vector<PileupSummaryInfo> > PupInfo;
     iEvent.getByToken(puSummaryToken_, PupInfo);
  
     if (verbose_)
       edm::LogInfo("StandaloneTrackMonitor") << "nPUColl = " << PupInfo->size();
     for (auto const& v : *PupInfo) {
       int bx = v.getBunchCrossing();
       if (bunchCrossingH_)
         bunchCrossingH_->Fill(bx);
       if (bx == 0) {
         if (nPUH_)
           nPUH_->Fill(v.getPU_NumInteractions());
         int ntrueInt = v.getTrueNumInteractions();
         if (trueNIntH_)
           trueNIntH_->Fill(ntrueInt);
         if (doPUCorrection_)
           if (ntrueInt > -1 && ntrueInt < int(vpu_.size()))
             wfac = vpu_.at(ntrueInt);
       }
     }
   }
   if (verbose_)
     edm::LogInfo("StandaloneTrackMonitor") << "PU reweight factor = " << wfac;
  
   if (!vertexColl.isValid())
     edm::LogError("DqmTrackStudy") << "Error! Failed to get reco::Vertex Collection, " << vertexTag_;
   if (haveAllHistograms_) {
     int nvtx = (vertexColl.isValid() ? vertexColl->size() : 0);
     nVertexH_->Fill(nvtx);
   }
  
   int ntracks = 0;
   if (tracks.isValid()) {
     edm::LogInfo("StandaloneTrackMonitor") << "Total # of Tracks: " << tracks->size();
     if (verbose_)
       edm::LogInfo("StandaloneTrackMonitor") << "Total # of Tracks: " << tracks->size();
     reco::Track::TrackQuality quality = reco::Track::qualityByName(trackQuality_);
     for (auto const& track : *tracks) {
       if (!track.quality(quality))
         continue;
  
       ++ntracks;
  
       double eta = track.eta();
       double theta = track.theta();
       double phi = track.phi();
       double pt = track.pt();
  
       const reco::HitPattern& hitp = track.hitPattern();
       double nValidTrackerHits = hitp.numberOfValidTrackerHits();
       nHitsVsEtaH_->Fill(eta, nValidTrackerHits);
       nHitsVsCosThetaH_->Fill(std::cos(theta), nValidTrackerHits);
       nHitsVsPhiH_->Fill(phi, nValidTrackerHits);
       nHitsVspTH_->Fill(pt, nValidTrackerHits);
       nHitsVsnVtxH_->Fill(vertexColl->size(), nValidTrackerHits);
  
       int nLostHits = track.numberOfLostHits();
       nLostHitsVspTH_->Fill(pt, nLostHits);
       nLostHitsVsEtaH_->Fill(eta, nLostHits);
       nLostHitsVsCosThetaH_->Fill(std::cos(theta), nLostHits);
       nLostHitsVsPhiH_->Fill(phi, nLostHits);
  
       double nValidPixelHits = hitp.numberOfValidPixelHits();
       double nValidStripHits = hitp.numberOfValidStripHits();
       double pixelLayersWithMeasurement = hitp.pixelLayersWithMeasurement();
       double stripLayersWithMeasurement = hitp.stripLayersWithMeasurement();
  
       if (haveAllHistograms_) {
         double etaError = track.etaError();
         double thetaError = track.thetaError();
         double phiError = track.phiError();
         double p = track.p();
         double ptError = track.ptError();
         double qoverp = track.qoverp();
         double qoverpError = track.qoverpError();
         double charge = track.charge();
  
         double trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement();
  
         double dxy = track.dxy(beamSpot->position());
         double dxyError = track.dxyError();
         double dz = track.dz(beamSpot->position());
         double dzError = track.dzError();
  
         double trkd0 = track.d0();
         double chi2 = track.chi2();
         double ndof = track.ndof();
         double vx = track.vx();
         double vy = track.vy();
         double vz = track.vz();
  
         // Fill the histograms
         trackEtaH_->Fill(eta, wfac);
         trackEtaerrH_->Fill(etaError, wfac);
         trackCosThetaH_->Fill(std::cos(theta), wfac);
         trackThetaerrH_->Fill(thetaError, wfac);
         trackPhiH_->Fill(phi, wfac);
         trackPhierrH_->Fill(phiError, wfac);
         trackPH_->Fill(p, wfac);
         trackPtH_->Fill(pt, wfac);
         if (pt <= 2)
           trackPtUpto2GeVH_->Fill(pt, wfac);
         if (pt >= 10)
           trackPtOver10GeVH_->Fill(pt, wfac);
         trackPterrH_->Fill(ptError, wfac);
         trackqOverpH_->Fill(qoverp, wfac);
         trackqOverperrH_->Fill(qoverpError, wfac);
         trackChargeH_->Fill(charge, wfac);
         trackChi2H_->Fill(chi2, wfac);
         trackd0H_->Fill(trkd0, wfac);
         tracknDOFH_->Fill(ndof, wfac);
         trackChi2bynDOFH_->Fill(chi2 / ndof, wfac);
  
         nlostHitsH_->Fill(nLostHits, wfac);
         nvalidTrackerHitsH_->Fill(nValidTrackerHits, wfac);
         nvalidPixelHitsH_->Fill(nValidPixelHits, wfac);
         nvalidStripHitsH_->Fill(nValidStripHits, wfac);
  
         trkLayerwithMeasurementH_->Fill(trackerLayersWithMeasurement, wfac);
         pixelLayerwithMeasurementH_->Fill(pixelLayersWithMeasurement, wfac);
         stripLayerwithMeasurementH_->Fill(stripLayersWithMeasurement, wfac);
  
         beamSpotXYposH_->Fill(dxy, wfac);
         beamSpotXYposerrH_->Fill(dxyError, wfac);
         beamSpotZposH_->Fill(dz, wfac);
         beamSpotZposerrH_->Fill(dzError, wfac);
  
         vertexXposH_->Fill(vx, wfac);
         vertexYposH_->Fill(vy, wfac);
         vertexZposH_->Fill(vz, wfac);
       }
       int nPixBarrel = 0, nPixEndcap = 0, nStripTIB = 0, nStripTOB = 0, nStripTEC = 0, nStripTID = 0;
       for (auto it = track.recHitsBegin(); it != track.recHitsEnd(); ++it) {
         const TrackingRecHit& hit = (**it);
         if (hit.isValid()) {
           if (hit.geographicalId().det() == DetId::Tracker) {
             int subdetId = hit.geographicalId().subdetId();
             if (subdetId == PixelSubdetector::PixelBarrel)
               ++nPixBarrel;
             else if (subdetId == PixelSubdetector::PixelEndcap)
               ++nPixEndcap;
             else if (subdetId == StripSubdetector::TIB)
               ++nStripTIB;
             else if (subdetId == StripSubdetector::TOB)
               ++nStripTOB;
             else if (subdetId == StripSubdetector::TEC)
               ++nStripTEC;
             else if (subdetId == StripSubdetector::TID)
               ++nStripTID;
  
             // Find on-track clusters
             processHit(hit, iSetup, tkGeom, wfac);
           }
         }
       }
       if (verbose_)
         edm::LogInfo("StandaloneTrackMonitor")
             << " >>> HITs: nPixBarrel: " << nPixBarrel << " nPixEndcap: " << nPixEndcap << " nStripTIB: " << nStripTIB
             << " nStripTOB: " << nStripTOB << " nStripTEC: " << nStripTEC << " nStripTID: " << nStripTID;
       if (haveAllHistograms_) {
         nPixBarrelH_->Fill(nPixBarrel, wfac);
         nPixEndcapH_->Fill(nPixEndcap, wfac);
         nStripTIBH_->Fill(nStripTIB, wfac);
         nStripTOBH_->Fill(nStripTOB, wfac);
         nStripTECH_->Fill(nStripTEC, wfac);
         nStripTIDH_->Fill(nStripTID, wfac);
       }
     }
   } else {
     edm::LogError("DqmTrackStudy") << "Error! Failed to get reco::Track collection, " << trackTag_;
   }
   if (haveAllHistograms_)
     nTracksH_->Fill(ntracks);
  
   // off track cluster properties
   processClusters(iEvent, iSetup, tkGeom, wfac);
 }

References pwdgSkimBPark_cfi::beamSpot, beamSpotXYposerrH_, beamSpotXYposH_, beamSpotZposerrH_, beamSpotZposH_, bsToken_, bunchCrossingH_, l1GtPatternGenerator_cfi::bx, ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, funct::cos(), doPUCorrection_, PVValHelper::dxy, PVValHelper::dz, PVValHelper::eta, muonME0PseudoDigis_cfi::etaError, dqm::impl::MonitorElement::Fill(), edm::EventSetup::get(), get, haveAllHistograms_, iEvent, SiStripClusterInfo::initEvent(), edm::HandleBase::isValid(), ndof, nHitsVsCosThetaH_, nHitsVsEtaH_, nHitsVsnVtxH_, nHitsVsPhiH_, nHitsVspTH_, nlostHitsH_, nLostHitsVsCosThetaH_, nLostHitsVsEtaH_, nLostHitsVsPhiH_, nLostHitsVspTH_, nPixBarrelH_, nPixEndcapH_, nPUH_, nStripTECH_, nStripTIBH_, nStripTIDH_, nStripTOBH_, nTracksH_, reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidStripHits(), reco::HitPattern::numberOfValidTrackerHits(), nvalidPixelHitsH_, nvalidStripHitsH_, nvalidTrackerHitsH_, nVertexH_, AlCaHLTBitMon_ParallelJobs::p, phi, muonME0PseudoDigis_cfi::phiError, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::HitPattern::pixelLayersWithMeasurement(), pixelLayerwithMeasurementH_, processClusters(), processHit(), DiDispStaMuonMonitor_cfi::pt, puSummaryToken_, qcdUeDQM_cfi::quality, reco::TrackBase::qualityByName(), siStripClusterInfo_, reco::HitPattern::stripLayersWithMeasurement(), stripLayerwithMeasurementH_, StripSubdetector::TEC, theta(), StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, HLT_2018_cff::track, trackChargeH_, trackChi2bynDOFH_, trackChi2H_, trackCosThetaH_, trackd0H_, DetId::Tracker, reco::HitPattern::trackerLayersWithMeasurement(), trackEtaerrH_, trackEtaH_, tracknDOFH_, trackPH_, trackPhierrH_, trackPhiH_, trackPterrH_, trackPtH_, trackPtOver10GeVH_, trackPtUpto2GeVH_, trackqOverperrH_, trackqOverpH_, trackQuality_, PDWG_EXOHSCP_cff::tracks, trackTag_, trackThetaerrH_, trackToken_, trkLayerwithMeasurementH_, trueNIntH_, findQualityFiles::v, verbose_, vertexTag_, vertexToken_, vertexXposH_, vertexYposH_, vertexZposH_, and vpu_.

◆ bookHistograms()

void StandaloneTrackMonitor::bookHistograms	(	DQMStore::IBooker &	iBook,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 126 of file StandaloneTrackMonitor.cc.

                                                                          {
   edm::ParameterSet TrackEtaHistoPar = parameters_.getParameter<edm::ParameterSet>("trackEtaH");
   edm::ParameterSet TrackPtHistoPar = parameters_.getParameter<edm::ParameterSet>("trackPtH");
  
   std::string currentFolder = moduleName_ + "/" + folderName_;
   iBook.setCurrentFolder(currentFolder);
  
   // The following are common with the official tool
   if (haveAllHistograms_) {
     if (!trackEtaH_)
       trackEtaH_ = iBook.book1D("trackEta",
                                 "Track Eta",
                                 TrackEtaHistoPar.getParameter<int32_t>("Xbins"),
                                 TrackEtaHistoPar.getParameter<double>("Xmin"),
                                 TrackEtaHistoPar.getParameter<double>("Xmax"));
     if (!trackEtaerrH_)
       trackEtaerrH_ = iBook.book1D("trackEtaerr", "Track Eta Error", 50, 0.0, 1.0);
     if (!trackCosThetaH_)
       trackCosThetaH_ = iBook.book1D("trackCosTheta", "Track Cos(Theta)", 50, -1.0, 1.0);
     if (!trackThetaerrH_)
       trackThetaerrH_ = iBook.book1D("trackThetaerr", "Track Theta Error", 50, 0.0, 1.0);
     if (!trackPhiH_)
       trackPhiH_ = iBook.book1D("trackPhi", "Track Phi", 70, -3.5, 3.5);
     if (!trackPhierrH_)
       trackPhierrH_ = iBook.book1D("trackPhierr", "Track Phi Error", 50, 0.0, 1.0);
  
     if (!trackPH_)
       trackPH_ = iBook.book1D("trackP", "Track 4-momentum", 50, 0.0, 10.0);
     if (!trackPtH_)
       trackPtH_ = iBook.book1D("trackPt",
                                "Track Pt",
                                TrackPtHistoPar.getParameter<int32_t>("Xbins"),
                                TrackPtHistoPar.getParameter<double>("Xmin"),
                                TrackPtHistoPar.getParameter<double>("Xmax"));
     if (!trackPtUpto2GeVH_)
       trackPtUpto2GeVH_ = iBook.book1D("trackPtUpto2GeV", "Track Pt upto 2GeV", 100, 0, 2.0);
     if (!trackPtOver10GeVH_)
       trackPtOver10GeVH_ = iBook.book1D("trackPtOver10GeV", "Track Pt greater than 10 GeV", 100, 0, 100.0);
     if (!trackPterrH_)
       trackPterrH_ = iBook.book1D("trackPterr", "Track Pt Error", 100, 0.0, 100.0);
     if (!trackqOverpH_)
       trackqOverpH_ = iBook.book1D("trackqOverp", "q Over p", 40, -10.0, 10.0);
     if (!trackqOverperrH_)
       trackqOverperrH_ = iBook.book1D("trackqOverperr", "q Over p Error", 50, 0.0, 25.0);
     if (!trackChargeH_)
       trackChargeH_ = iBook.book1D("trackCharge", "Track Charge", 50, -5, 5);
     if (!trackChi2H_)
       trackChi2H_ = iBook.book1D("trackChi2", "Chi2", 100, 0.0, 100.0);
     if (!tracknDOFH_)
       tracknDOFH_ = iBook.book1D("tracknDOF", "nDOF", 100, 0.0, 100.0);
     if (!trackd0H_)
       trackd0H_ = iBook.book1D("trackd0", "Track d0", 100, -1, 1);
     if (!trackChi2bynDOFH_)
       trackChi2bynDOFH_ = iBook.book1D("trackChi2bynDOF", "Chi2 Over nDOF", 100, 0.0, 10.0);
  
     if (!nlostHitsH_)
       nlostHitsH_ = iBook.book1D("nlostHits", "No. of Lost Hits", 10, 0.0, 10.0);
     if (!nvalidTrackerHitsH_)
       nvalidTrackerHitsH_ = iBook.book1D("nvalidTrackerhits", "No. of Valid Tracker Hits", 35, 0.0, 35.0);
     if (!nvalidPixelHitsH_)
       nvalidPixelHitsH_ = iBook.book1D("nvalidPixelHits", "No. of Valid Hits in Pixel", 10, 0.0, 10.0);
     if (!nvalidStripHitsH_)
       nvalidStripHitsH_ = iBook.book1D("nvalidStripHits", "No.of Valid Hits in Strip", 25, 0.0, 25.0);
  
     if (!trkLayerwithMeasurementH_)
       trkLayerwithMeasurementH_ = iBook.book1D("trkLayerwithMeasurement", "No. of Layers per Track", 25, 0.0, 25.0);
     if (!pixelLayerwithMeasurementH_)
       pixelLayerwithMeasurementH_ =
           iBook.book1D("pixelLayerwithMeasurement", "No. of Pixel Layers per Track", 10, 0.0, 10.0);
     if (!stripLayerwithMeasurementH_)
       stripLayerwithMeasurementH_ =
           iBook.book1D("stripLayerwithMeasurement", "No. of Strip Layers per Track", 20, 0.0, 20.0);
  
     if (!beamSpotXYposH_)
       beamSpotXYposH_ = iBook.book1D("beamSpotXYpos", "XY position of beam spot", 40, -4.0, 4.0);
     if (!beamSpotXYposerrH_)
       beamSpotXYposerrH_ = iBook.book1D("beamSpotXYposerr", "Error in XY position of beam spot", 20, 0.0, 4.0);
     if (!beamSpotZposH_)
       beamSpotZposH_ = iBook.book1D("beamSpotZpos", "Z position of beam spot", 100, -20.0, 20.0);
     if (!beamSpotZposerrH_)
       beamSpotZposerrH_ = iBook.book1D("beamSpotZposerr", "Error in Z position of beam spot", 50, 0.0, 5.0);
  
     if (!vertexXposH_)
       vertexXposH_ = iBook.book1D("vertexXpos", "Vertex X position", 50, -1.0, 1.0);
     if (!vertexYposH_)
       vertexYposH_ = iBook.book1D("vertexYpos", "Vertex Y position", 50, -1.0, 1.0);
     if (!vertexZposH_)
       vertexZposH_ = iBook.book1D("vertexZpos", "Vertex Z position", 100, -20.0, 20.0);
     if (!nVertexH_)
       nVertexH_ = iBook.book1D("nVertex", "# of vertices", 60, -0.5, 59.5);
  
     if (!nPixBarrelH_)
       nPixBarrelH_ = iBook.book1D("nHitPixelBarrel", "No. of hits in Pixel Barrel per Track", 20, 0, 20.0);
     if (!nPixEndcapH_)
       nPixEndcapH_ = iBook.book1D("nHitPixelEndcap", "No. of hits in Pixel Endcap per Track", 20, 0, 20.0);
     if (!nStripTIBH_)
       nStripTIBH_ = iBook.book1D("nHitStripTIB", "No. of hits in Strip TIB per Track", 30, 0, 30.0);
     if (!nStripTOBH_)
       nStripTOBH_ = iBook.book1D("nHitStripTOB", "No. of hits in Strip TOB per Track", 30, 0, 30.0);
     if (!nStripTECH_)
       nStripTECH_ = iBook.book1D("nHitStripTEC", "No. of hits in Strip TEC per Track", 30, 0, 30.0);
     if (!nStripTIDH_)
       nStripTIDH_ = iBook.book1D("nHitStripTID", "No. of hits in Strip TID per Tracks", 30, 0, 30.0);
  
     if (!nTracksH_)
       nTracksH_ = iBook.book1D("nTracks", "No. of Tracks", 100, -0.5, 999.5);
   }
   if (isMC_) {
     if (!bunchCrossingH_)
       bunchCrossingH_ = iBook.book1D("bunchCrossing", "Bunch Crosssing", 60, 0, 60.0);
     if (!nPUH_)
       nPUH_ = iBook.book1D("nPU", "No of Pileup", 60, 0, 60.0);
     if (!trueNIntH_)
       trueNIntH_ = iBook.book1D("trueNInt", "True no of Interactions", 60, 0, 60.0);
   }
   // Exclusive histograms
   if (!nHitsVspTH_)
     nHitsVspTH_ = iBook.bookProfile("nHitsVspT",
                                     "Number of Hits Vs pT",
                                     TrackPtHistoPar.getParameter<int32_t>("Xbins"),
                                     TrackPtHistoPar.getParameter<double>("Xmin"),
                                     TrackPtHistoPar.getParameter<double>("Xmax"),
                                     0.0,
                                     0.0,
                                     "g");
   if (!nHitsVsnVtxH_)
     nHitsVsnVtxH_ = iBook.bookProfile("nHitsVsnVtx", "Number of Hits Vs Number of Vertex", 100, 0.0, 50, 0.0, 0.0, "g");
   if (!nHitsVsEtaH_)
     nHitsVsEtaH_ = iBook.bookProfile("nHitsVsEta",
                                      "Number of Hits Vs Eta",
                                      TrackEtaHistoPar.getParameter<int32_t>("Xbins"),
                                      TrackEtaHistoPar.getParameter<double>("Xmin"),
                                      TrackEtaHistoPar.getParameter<double>("Xmax"),
                                      0.0,
                                      0.0,
                                      "g");
   if (!nHitsVsCosThetaH_)
     nHitsVsCosThetaH_ =
         iBook.bookProfile("nHitsVsCosTheta", "Number of Hits Vs Cos(Theta)", 50, -1.0, 1.0, 0.0, 0.0, "g");
   if (!nHitsVsPhiH_)
     nHitsVsPhiH_ = iBook.bookProfile("nHitsVsPhi", "Number of Hits Vs Phi", 100, -3.5, 3.5, 0.0, 0.0, "g");
  
   if (!nLostHitsVspTH_)
     nLostHitsVspTH_ = iBook.bookProfile("nLostHitsVspT",
                                         "Number of Lost Hits Vs pT",
                                         TrackPtHistoPar.getParameter<int32_t>("Xbins"),
                                         TrackPtHistoPar.getParameter<double>("Xmin"),
                                         TrackPtHistoPar.getParameter<double>("Xmax"),
                                         0.0,
                                         0.0,
                                         "g");
   if (!nLostHitsVsEtaH_)
     nLostHitsVsEtaH_ = iBook.bookProfile("nLostHitsVsEta",
                                          "Number of Lost Hits Vs Eta",
                                          TrackEtaHistoPar.getParameter<int32_t>("Xbins"),
                                          TrackEtaHistoPar.getParameter<double>("Xmin"),
                                          TrackEtaHistoPar.getParameter<double>("Xmax"),
                                          0.0,
                                          0.0,
                                          "g");
   if (!nLostHitsVsCosThetaH_)
     nLostHitsVsCosThetaH_ =
         iBook.bookProfile("nLostHitsVsCosTheta", "Number of Lost Hits Vs Cos(Theta)", 50, -1.0, 1.0, 0.0, 0.0, "g");
   if (!nLostHitsVsPhiH_)
     nLostHitsVsPhiH_ = iBook.bookProfile("nLostHitsVsPhi", "Number of Lost Hits Vs Phi", 100, -3.5, 3.5, 0.0, 0.0, "g");
  
   // On and off-track cluster properties
   if (!hOnTrkClusChargeThinH_)
     hOnTrkClusChargeThinH_ =
         iBook.book1D("hOnTrkClusChargeThin", "On-track Cluster Charge (Thin Sensor)", 100, 0, 1000);
   if (!hOnTrkClusWidthThinH_)
     hOnTrkClusWidthThinH_ = iBook.book1D("hOnTrkClusWidthThin", "On-track Cluster Width (Thin Sensor)", 20, -0.5, 19.5);
   if (!hOnTrkClusChargeThickH_)
     hOnTrkClusChargeThickH_ =
         iBook.book1D("hOnTrkClusChargeThick", "On-track Cluster Charge (Thick Sensor)", 100, 0, 1000);
   if (!hOnTrkClusWidthThickH_)
     hOnTrkClusWidthThickH_ =
         iBook.book1D("hOnTrkClusWidthThick", "On-track Cluster Width (Thick Sensor)", 20, -0.5, 19.5);
  
   if (!hOffTrkClusChargeThinH_)
     hOffTrkClusChargeThinH_ =
         iBook.book1D("hOffTrkClusChargeThin", "Off-track Cluster Charge (Thin Sensor)", 100, 0, 1000);
   if (!hOffTrkClusWidthThinH_)
     hOffTrkClusWidthThinH_ =
         iBook.book1D("hOffTrkClusWidthThin", "Off-track Cluster Width (Thin Sensor)", 20, -0.5, 19.5);
   if (!hOffTrkClusChargeThickH_)
     hOffTrkClusChargeThickH_ =
         iBook.book1D("hOffTrkClusChargeThick", "Off-track Cluster Charge (Thick Sensor)", 100, 0, 1000);
   if (!hOffTrkClusWidthThickH_)
     hOffTrkClusWidthThickH_ =
         iBook.book1D("hOffTrkClusWidthThick", "Off-track Cluster Width (Thick Sensor)", 20, -0.5, 19.5);
 }

References beamSpotXYposerrH_, beamSpotXYposH_, beamSpotZposerrH_, beamSpotZposH_, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::bookProfile(), bunchCrossingH_, folderName_, edm::ParameterSet::getParameter(), haveAllHistograms_, hOffTrkClusChargeThickH_, hOffTrkClusChargeThinH_, hOffTrkClusWidthThickH_, hOffTrkClusWidthThinH_, hOnTrkClusChargeThickH_, hOnTrkClusChargeThinH_, hOnTrkClusWidthThickH_, hOnTrkClusWidthThinH_, isMC_, moduleName_, nHitsVsCosThetaH_, nHitsVsEtaH_, nHitsVsnVtxH_, nHitsVsPhiH_, nHitsVspTH_, nlostHitsH_, nLostHitsVsCosThetaH_, nLostHitsVsEtaH_, nLostHitsVsPhiH_, nLostHitsVspTH_, nPixBarrelH_, nPixEndcapH_, nPUH_, nStripTECH_, nStripTIBH_, nStripTIDH_, nStripTOBH_, nTracksH_, nvalidPixelHitsH_, nvalidStripHitsH_, nvalidTrackerHitsH_, nVertexH_, parameters_, pixelLayerwithMeasurementH_, dqm::implementation::NavigatorBase::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, stripLayerwithMeasurementH_, trackChargeH_, trackChi2bynDOFH_, trackChi2H_, trackCosThetaH_, trackd0H_, trackEtaerrH_, trackEtaH_, tracknDOFH_, trackPH_, trackPhierrH_, trackPhiH_, trackPterrH_, trackPtH_, trackPtOver10GeVH_, trackPtUpto2GeVH_, trackqOverperrH_, trackqOverpH_, trackThetaerrH_, trkLayerwithMeasurementH_, trueNIntH_, vertexXposH_, vertexYposH_, and vertexZposH_.

◆ processClusters()

void StandaloneTrackMonitor::processClusters	(	edm::Event const &	iEvent,
		edm::EventSetup const &	iSetup,
		const TrackerGeometry &	tkGeom,
		double	wfac = `1`
	)

protected

Definition at line 520 of file StandaloneTrackMonitor.cc.

                                                           {
   // SiStripClusters
   edm::Handle<edmNew::DetSetVector<SiStripCluster> > clusterHandle;
   iEvent.getByToken(clusterToken_, clusterHandle);
  
   if (clusterHandle.isValid()) {
     // Loop on Dets
     for (edmNew::DetSetVector<SiStripCluster>::const_iterator dsvit = clusterHandle->begin();
          dsvit != clusterHandle->end();
          ++dsvit) {
       uint32_t detId = dsvit->id();
       std::map<uint32_t, std::set<const SiStripCluster*> >::iterator jt = clusterMap_.find(detId);
       bool detid_found = (jt != clusterMap_.end()) ? true : false;
  
       // Loop on Clusters
       for (edmNew::DetSet<SiStripCluster>::const_iterator clusit = dsvit->begin(); clusit != dsvit->end(); ++clusit) {
         if (detid_found) {
           std::set<const SiStripCluster*>& s = jt->second;
           if (s.find(&*clusit) != s.end())
             continue;
         }
  
         siStripClusterInfo_.setCluster(*clusit, detId);
         float charge = siStripClusterInfo_.charge();
         float width = siStripClusterInfo_.width();
  
         const GeomDetUnit* detUnit = tkGeom.idToDetUnit(detId);
         float thickness = detUnit->surface().bounds().thickness();  // unit cm
         if (thickness > 0.035) {
           hOffTrkClusChargeThickH_->Fill(charge, wfac);
           hOffTrkClusWidthThickH_->Fill(width, wfac);
         } else {
           hOffTrkClusChargeThinH_->Fill(charge, wfac);
           hOffTrkClusWidthThinH_->Fill(width, wfac);
         }
       }
     }
   } else {
     edm::LogError("StandaloneTrackMonitor") << "ClusterCollection " << clusterTag_ << " not valid!!" << std::endl;
   }
 }

References Surface::bounds(), SiStripClusterInfo::charge(), ALCARECOTkAlJpsiMuMu_cff::charge, clusterMap_, clusterTag_, clusterToken_, dqm::impl::MonitorElement::Fill(), hOffTrkClusChargeThickH_, hOffTrkClusChargeThinH_, hOffTrkClusWidthThickH_, hOffTrkClusWidthThinH_, TrackerGeometry::idToDetUnit(), iEvent, edm::HandleBase::isValid(), alignCSCRings::s, SiStripClusterInfo::setCluster(), siStripClusterInfo_, GeomDet::surface(), Bounds::thickness(), Calorimetry_cff::thickness, ApeEstimator_cff::width, and SiStripClusterInfo::width().

Referenced by analyze().

◆ processHit()

void StandaloneTrackMonitor::processHit	(	const TrackingRecHit &	recHit,
		edm::EventSetup const &	iSetup,
		const TrackerGeometry &	tkGeom,
		double	wfac = `1`
	)

protected

Definition at line 564 of file StandaloneTrackMonitor.cc.

                                                      {
   uint32_t detid = recHit.geographicalId();
   const GeomDetUnit* detUnit = tkGeom.idToDetUnit(detid);
   float thickness = detUnit->surface().bounds().thickness();  // unit cm
  
   auto const& thit = static_cast<BaseTrackerRecHit const&>(recHit);
   if (!thit.isValid())
     return;
  
   auto const& clus = thit.firstClusterRef();
   if (!clus.isValid())
     return;
   if (!clus.isStrip())
     return;
  
   if (thit.isMatched()) {
     const SiStripMatchedRecHit2D& matchedHit = dynamic_cast<const SiStripMatchedRecHit2D&>(recHit);
  
     auto& clusterM = matchedHit.monoCluster();
     siStripClusterInfo_.setCluster(clusterM, detid);
     if (thickness > 0.035) {
       hOnTrkClusChargeThickH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThickH_->Fill(siStripClusterInfo_.width(), wfac);
     } else {
       hOnTrkClusChargeThinH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThinH_->Fill(siStripClusterInfo_.width(), wfac);
     }
     addClusterToMap(detid, &clusterM);
  
     auto& clusterS = matchedHit.stereoCluster();
     siStripClusterInfo_.setCluster(clusterS, detid);
     if (thickness > 0.035) {
       hOnTrkClusChargeThickH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThickH_->Fill(siStripClusterInfo_.width(), wfac);
     } else {
       hOnTrkClusChargeThinH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThinH_->Fill(siStripClusterInfo_.width(), wfac);
     }
     addClusterToMap(detid, &clusterS);
   } else {
     auto& cluster = clus.stripCluster();
     siStripClusterInfo_.setCluster(cluster, detid);
     if (thickness > 0.035) {
       hOnTrkClusChargeThickH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThickH_->Fill(siStripClusterInfo_.width(), wfac);
     } else {
       hOnTrkClusChargeThinH_->Fill(siStripClusterInfo_.charge(), wfac);
       hOnTrkClusWidthThinH_->Fill(siStripClusterInfo_.width(), wfac);
     }
     addClusterToMap(detid, &cluster);
   }
 }