#include <TrackAnalyzer.h>

Classes
struct	Key

struct	KeyHasher

struct	TkParameterMEs

struct	TkRecHitsPerSubDetMEs

Public Member Functions
void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)

void	doReset ()

void	doSoftReset (DQMStore *dqmStore_)

void	initHisto (DQMStore::IBooker &ibooker, const edm::EventSetup &, const edm::ParameterSet &)

void	setBX (const edm::Event &)

void	setLumi (const edm::Event &, const edm::EventSetup &iSetup)

void	setLumiFlag ()

void	setNumberOfGoodVertices (const edm::Event &)

	TrackAnalyzer (const edm::ParameterSet &)

	TrackAnalyzer (const edm::ParameterSet &, edm::ConsumesCollector &iC)

void	undoSoftReset (DQMStore *dqmStore_)

	~TrackAnalyzer ()

Private Types
enum	monQuantity { VsPU, VsBX, VsPIXELLUMI, VsSCALLUMI, END }

Private Member Functions
void	bookHistosForBeamSpot (DQMStore::IBooker &ibooker)

void	bookHistosForEfficiencyFromHitPatter (DQMStore::IBooker &ibooker, const edm::EventSetup &iSetup, const std::string suffix)

void	bookHistosForHitProperties (DQMStore::IBooker &ibooker)

void	bookHistosForLScertification (DQMStore::IBooker &ibooker)

void	bookHistosForState (std::string sname, DQMStore::IBooker &ibooker)

void	bookHistosForTrackerSpecific (DQMStore::IBooker &ibooker)

void	fillHistosForEfficiencyFromHitPatter (const reco::Track &track, const std::string suffix, const float monitoring)

void	fillHistosForHitProperties (const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)

void	fillHistosForLScertification (const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)

void	fillHistosForState (const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)

void	fillHistosForTrackerSpecific (const reco::Track &track)

void	initHistos ()

Private Attributes
MonitorElement *	AbsDistanceOfClosestApproachToBS

MonitorElement *	algorithm

edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

unsigned int	bx_

MonitorElement *	Chi2

MonitorElement *	Chi2oNDF

MonitorElement *	Chi2oNDF_lumiFlag

MonitorElement *	Chi2oNDFVsEta = 0

MonitorElement *	Chi2oNDFVsNHits = 0

MonitorElement *	Chi2oNDFVsPhi

MonitorElement *	Chi2oNDFVsPt = 0

MonitorElement *	Chi2oNDFVsTheta

MonitorElement *	Chi2Prob

MonitorElement *	Chi2ProbVsEta

MonitorElement *	Chi2ProbVsPhi

MonitorElement *	Chi2ProbVsTheta

edm::ParameterSet const *	conf_

MonitorElement *	DeltaZToPV

MonitorElement *	DistanceOfClosestApproach

MonitorElement *	DistanceOfClosestApproachToBS

MonitorElement *	DistanceOfClosestApproachToBSVsPhi

MonitorElement *	DistanceOfClosestApproachToPV

MonitorElement *	DistanceOfClosestApproachToPVVsPhi

MonitorElement *	DistanceOfClosestApproachVsEta

MonitorElement *	DistanceOfClosestApproachVsPhi

MonitorElement *	DistanceOfClosestApproachVsTheta

MonitorElement *	dNdEta_HighPurity

MonitorElement *	dNdPhi_HighPurity

MonitorElement *	dNdPt_HighPurity

MonitorElement *	dNhitdPt_HighPurity

bool	doAllPlots_

bool	doBSPlots_

bool	doDCAPlots_

bool	doDCAwrt000Plots_

bool	doDCAwrtPVPlots_

bool	doEffFromHitPatternVsBX_

bool	doEffFromHitPatternVsLUMI_

bool	doEffFromHitPatternVsPU_

bool	doGeneralPropertiesPlots_

bool	doHIPlots_

bool	doHitPropertiesPlots_

bool	doLayersVsPhiVsEtaPerTrack_

bool	doLumiAnalysis_

bool	doMeasurementStatePlots_

bool	doPVPlots_

bool	doRecHitsPerTrackProfile_

bool	doRecHitVsPhiVsEtaPerTrack_

bool	doRecHitVsPtVsEtaPerTrack_

bool	doSIPPlots_

bool	doTestPlots_

bool	doThetaPlots_

bool	doTrack2DChi2Plots_

bool	doTrackerSpecific_

bool	doTrackLayersVsPhiVsEtaPerTrack_

bool	doTrackPxPyPlots_

bool	doTrackRecHitVsPhiVsEtaPerTrack_

bool	doTrackRecHitVsPtVsEtaPerTrack_

unsigned int	good_vertices_

std::string	histname

std::unordered_map< Key, MonitorElement *, KeyHasher >	hits_bad_

std::unordered_map< Key, MonitorElement *, KeyHasher >	hits_inactive_

std::unordered_map< Key, MonitorElement *, KeyHasher >	hits_missing_

std::unordered_map< Key, MonitorElement *, KeyHasher >	hits_total_

std::unordered_map< Key, MonitorElement *, KeyHasher >	hits_valid_

MonitorElement *	LongDCASig

float	lumi_factor_per_bx_

edm::EDGetTokenT< LumiScalersCollection >	lumiscalersToken_

int	minNumberOfPixelsPerCluster_

float	minPixelClusterCharge_

std::string	monName [monQuantity::END] = { "", "VsBX", "VsPIXELLUMI", "VsSCALLUMI" }

MonitorElement *	NhitVsEta_HighPurity

MonitorElement *	NhitVsPhi_HighPurity

MonitorElement *	NumberOfLayersPerTrack [4] = { 0 , 0 , 0 , 0 }

MonitorElement *	NumberOfLayersPerTrackVsEta

MonitorElement *	NumberOfLayersPerTrackVsPhi

MonitorElement *	NumberOfLayersPerTrackVsTheta

MonitorElement *	NumberOfLayersVsPhiVsEtaPerTrack [4] = { 0 , 0 , 0 , 0 }

MonitorElement *	NumberOfLostRecHitsPerTrack

MonitorElement *	NumberOfLostRecHitsPerTrackVsEta = 0

MonitorElement *	NumberOfLostRecHitsPerTrackVsPhi = 0

MonitorElement *	NumberOfLostRecHitsPerTrackVsPt = 0

MonitorElement *	NumberOfLostRecHitsPerTrackVsTheta = 0

MonitorElement *	NumberOfLostRecHitVsPhiVsEtaPerTrack = 0

MonitorElement *	NumberOfLostRecHitVsPtVsEtaPerTrack = 0

MonitorElement *	NumberOfMIRecHitsPerTrack = 0

MonitorElement *	NumberOfMIRecHitsPerTrackVsEta = 0

MonitorElement *	NumberOfMIRecHitsPerTrackVsPhi = 0

MonitorElement *	NumberOfMIRecHitsPerTrackVsPt = 0

MonitorElement *	NumberOfMIRecHitsPerTrackVsTheta = 0

MonitorElement *	NumberOfMIRecHitVsPhiVsEtaPerTrack = 0

MonitorElement *	NumberOfMIRecHitVsPtVsEtaPerTrack = 0

MonitorElement *	NumberOfMORecHitsPerTrack = 0

MonitorElement *	NumberOfMORecHitsPerTrackVsEta = 0

MonitorElement *	NumberOfMORecHitsPerTrackVsPhi = 0

MonitorElement *	NumberOfMORecHitsPerTrackVsPt = 0

MonitorElement *	NumberOfMORecHitsPerTrackVsTheta = 0

MonitorElement *	NumberOfMORecHitVsPhiVsEtaPerTrack = 0

MonitorElement *	NumberOfMORecHitVsPtVsEtaPerTrack = 0

MonitorElement *	NumberOfRecHitsPerTrack

MonitorElement *	NumberOfRecHitsPerTrack_lumiFlag

MonitorElement *	NumberOfRecHitsPerTrackVsEta = 0

MonitorElement *	NumberOfRecHitsPerTrackVsPhi = 0

MonitorElement *	NumberOfRecHitsPerTrackVsTheta = 0

MonitorElement *	NumberOfRecHitVsPhiVsEtaPerTrack = 0

MonitorElement *	NumberOfValidRecHitsPerTrack

MonitorElement *	NumberOfValidRecHitsPerTrackVsEta = 0

MonitorElement *	NumberOfValidRecHitsPerTrackVsPhi = 0

MonitorElement *	NumberOfValidRecHitsPerTrackVsPt = 0

MonitorElement *	NumberOfValidRecHitsPerTrackVsTheta = 0

MonitorElement *	NumberOfValidRecHitVsPhiVsEtaPerTrack = 0

MonitorElement *	NumberOfValidRecHitVsPtVsEtaPerTrack = 0

MonitorElement *	oriAlgo

float	pixel_lumi_

edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > >	pixelClustersToken_

MonitorElement *	Ptdist_HighPurity

int	pvNDOF_

edm::EDGetTokenT< reco::VertexCollection >	pvToken_

std::string	qualityString_

float	scal_lumi_

MonitorElement *	sip2dToPV

MonitorElement *	sip3dToPV

MonitorElement *	sipDxyToBS

MonitorElement *	sipDxyToPV

MonitorElement *	sipDzToBS

MonitorElement *	sipDzToPV

std::string	stateName_

MonitorElement *	stoppingSource

MonitorElement *	stoppingSourceVSeta

MonitorElement *	stoppingSourceVSphi

MonitorElement *	TESTDistanceOfClosestApproachToBS

MonitorElement *	TESTDistanceOfClosestApproachToBSVsPhi

std::map< std::string, TkParameterMEs >	TkParameterMEMap

std::map< std::string, TkRecHitsPerSubDetMEs >	TkRecHitsPerSubDetMEMap

std::string	TopFolder_

MonitorElement *	TransDCASig

bool	useBPixLayer1_

MonitorElement *	ValidFractionPerTrack = 0

MonitorElement *	ValidFractionVsPhiVsEtaPerTrack = 0

MonitorElement *	xPointOfClosestApproach

MonitorElement *	xPointOfClosestApproachToPV

MonitorElement *	xPointOfClosestApproachVsZ0wrt000

MonitorElement *	xPointOfClosestApproachVsZ0wrtBS

MonitorElement *	xPointOfClosestApproachVsZ0wrtPV

MonitorElement *	yPointOfClosestApproach

MonitorElement *	yPointOfClosestApproachToPV

MonitorElement *	yPointOfClosestApproachVsZ0wrt000

MonitorElement *	yPointOfClosestApproachVsZ0wrtBS

MonitorElement *	yPointOfClosestApproachVsZ0wrtPV

MonitorElement *	zPointOfClosestApproach

MonitorElement *	zPointOfClosestApproachToPV

MonitorElement *	zPointOfClosestApproachVsPhi

Detailed Description

Definition at line 36 of file TrackAnalyzer.h.

Member Enumeration Documentation

enum dqm::TrackAnalyzer::monQuantity

private

Enumerator
VsPU
VsBX
VsPIXELLUMI
VsSCALLUMI
END

Definition at line 456 of file TrackAnalyzer.h.

                      {
       VsPU,
       VsBX,
       VsPIXELLUMI,
       VsSCALLUMI,
       END
     };

Constructor & Destructor Documentation

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

Definition at line 26 of file TrackAnalyzer.cc.

References edm::ParameterSet::getParameter(), initHistos(), AlCaHLTBitMon_QueryRunRegistry::string, and TopFolder_.

     : conf_( nullptr )
     , stateName_                       (iConfig.getParameter<std::string>("MeasurementState") )
     , doTrackerSpecific_               ( iConfig.getParameter<bool>("doTrackerSpecific") )
     , doAllPlots_                      ( iConfig.getParameter<bool>("doAllPlots") )
     , doBSPlots_                       ( iConfig.getParameter<bool>("doBeamSpotPlots") )
     , doPVPlots_                       ( iConfig.getParameter<bool>("doPrimaryVertexPlots") )
     , doDCAPlots_                      ( iConfig.getParameter<bool>("doDCAPlots") )
     , doGeneralPropertiesPlots_        ( iConfig.getParameter<bool>("doGeneralPropertiesPlots") )
     , doMeasurementStatePlots_         ( iConfig.getParameter<bool>("doMeasurementStatePlots") )
     , doHitPropertiesPlots_            ( iConfig.getParameter<bool>("doHitPropertiesPlots") )
     , doRecHitVsPhiVsEtaPerTrack_      ( iConfig.getParameter<bool>("doRecHitVsPhiVsEtaPerTrack") )
     , doRecHitVsPtVsEtaPerTrack_       ( iConfig.getParameter<bool>("doRecHitVsPtVsEtaPerTrack") )
     , doLayersVsPhiVsEtaPerTrack_      ( iConfig.getParameter<bool>("doLayersVsPhiVsEtaPerTrack") )
     , doRecHitsPerTrackProfile_        ( iConfig.getParameter<bool>("doRecHitsPerTrackProfile") )
     , doThetaPlots_                    ( iConfig.getParameter<bool>("doThetaPlots") )
     , doTrackPxPyPlots_                ( iConfig.getParameter<bool>("doTrackPxPyPlots") )
     , doDCAwrtPVPlots_                 ( iConfig.getParameter<bool>("doDCAwrtPVPlots") )
     , doDCAwrt000Plots_                ( iConfig.getParameter<bool>("doDCAwrt000Plots") )
     , doLumiAnalysis_                  ( iConfig.getParameter<bool>("doLumiAnalysis") )
     , doTestPlots_                     ( iConfig.getParameter<bool>("doTestPlots") )
     , doHIPlots_                       ( iConfig.getParameter<bool>("doHIPlots")  )
     , doSIPPlots_                      ( iConfig.getParameter<bool>("doSIPPlots") )
     , doEffFromHitPatternVsPU_         ( iConfig.getParameter<bool>("doEffFromHitPatternVsPU")   )
     , doEffFromHitPatternVsBX_         ( iConfig.getParameter<bool>("doEffFromHitPatternVsBX")   )
     , doEffFromHitPatternVsLUMI_       ( iConfig.getParameter<bool>("doEffFromHitPatternVsLUMI") )
     , pvNDOF_                          ( iConfig.getParameter<int> ("pvNDOF") )
     , useBPixLayer1_                   ( iConfig.getParameter<bool>("useBPixLayer1") )
     , minNumberOfPixelsPerCluster_     ( iConfig.getParameter<int>("minNumberOfPixelsPerCluster") )
     , minPixelClusterCharge_           ( iConfig.getParameter<double>("minPixelClusterCharge") )
     , qualityString_                   ( iConfig.getParameter<std::string>("qualityString"))
     , good_vertices_(0)
     , bx_(0)
     , pixel_lumi_(0.)
     , scal_lumi_(0.)
 {
   initHistos();
   TopFolder_ = iConfig.getParameter<std::string>("FolderName"); 
 }

TrackAnalyzer::TrackAnalyzer	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &	iC
	)

Definition at line 66 of file TrackAnalyzer.cc.

References beamSpotToken_, edm::ConsumesCollector::consumes(), GetLumi::FREQ_ORBIT, edm::ParameterSet::getParameter(), lumi_factor_per_bx_, lumiscalersToken_, edm::ConsumesCollector::mayConsume(), pixelClustersToken_, pvToken_, GetLumi::rXSEC_PIXEL_CLUSTER, GetLumi::SECONDS_PER_LS, useBPixLayer1_, and GetLumi::XSEC_PIXEL_CLUSTER.

   : TrackAnalyzer(iConfig)
 {
   edm::InputTag bsSrc                 = iConfig.getParameter<edm::InputTag>("beamSpot");
   edm::InputTag primaryVertexInputTag = iConfig.getParameter<edm::InputTag>("primaryVertex");
   edm::InputTag pixelClusterInputTag  = iConfig.getParameter<edm::InputTag>("pixelCluster4lumi");
   edm::InputTag scalInputTag          = iConfig.getParameter<edm::InputTag>("scal");
   beamSpotToken_      = iC.consumes<reco::BeamSpot>(bsSrc);
   pvToken_            = iC.consumes<reco::VertexCollection>(primaryVertexInputTag);
   pixelClustersToken_ = iC.mayConsume<edmNew::DetSetVector<SiPixelCluster> >(pixelClusterInputTag);
   lumiscalersToken_   = iC.mayConsume<LumiScalersCollection>(scalInputTag);
   
   if(useBPixLayer1_) 
     lumi_factor_per_bx_ = GetLumi::FREQ_ORBIT * GetLumi::SECONDS_PER_LS / GetLumi::XSEC_PIXEL_CLUSTER  ;
   else
     lumi_factor_per_bx_ = GetLumi::FREQ_ORBIT * GetLumi::SECONDS_PER_LS / GetLumi::rXSEC_PIXEL_CLUSTER  ;
 
 
 }

TrackAnalyzer::~TrackAnalyzer ( )

Definition at line 162 of file TrackAnalyzer.cc.

163 {

164 }

Member Function Documentation

void TrackAnalyzer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const reco::Track &	track
	)

Definition at line 1027 of file TrackAnalyzer.cc.

Referenced by TrackingMonitor::analyze().

 {
   auto pt    = track.pt();
   auto phi   = track.phi();
   // double eta   = track.eta();
   auto phiIn =  track.innerPosition().phi();
   auto etaIn =  track.innerPosition().eta();
   auto phiOut =  track.outerPosition().phi();
   auto etaOut =  track.outerPosition().eta();
 
   int nRecHits      = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
   int nValidRecHits = track.numberOfValidHits();
   int nLostRecHits  = track.numberOfLostHits();
   int nLostIn =      track.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS);
   int nLostOut =     track.hitPattern().numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS);
 
   auto chi2     = track.chi2();
   auto chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
   auto chi2oNDF = track.normalizedChi2();
   
   if ( doHitPropertiesPlots_ || doAllPlots_ ){
     // rec hits
     NumberOfRecHitsPerTrack     -> Fill(nRecHits);
     NumberOfValidRecHitsPerTrack-> Fill(nValidRecHits);
     NumberOfLostRecHitsPerTrack -> Fill(nLostRecHits);
     NumberOfMIRecHitsPerTrack -> Fill(nLostIn);
     NumberOfMORecHitsPerTrack -> Fill(nLostOut);
     ValidFractionPerTrack -> Fill(track.validFraction());
 
 
     // 2D plots    
     if ( doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_ ) {
       NumberOfValidRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nValidRecHits);
       NumberOfLostRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nLostRecHits);
       NumberOfMIRecHitVsPhiVsEtaPerTrack->Fill(etaIn,phiIn,nLostIn);
       NumberOfMORecHitVsPhiVsEtaPerTrack->Fill(etaOut,phiOut,nLostOut);
       ValidFractionVsPhiVsEtaPerTrack -> Fill(etaIn,phiIn,track.validFraction());
     }
     if ( doRecHitVsPtVsEtaPerTrack_ || doAllPlots_ ) {
       NumberOfValidRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nValidRecHits);
       NumberOfLostRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nLostRecHits);
       NumberOfMIRecHitVsPtVsEtaPerTrack->Fill(etaIn,pt,nLostIn);
       NumberOfMORecHitVsPtVsEtaPerTrack->Fill(etaOut,pt,nLostOut);
     }
     NumberOfValidRecHitsPerTrackVsPt->Fill(pt,nValidRecHits);
     NumberOfLostRecHitsPerTrackVsPt->Fill(pt,nLostRecHits);
     NumberOfMIRecHitsPerTrackVsPt->Fill(pt,nLostIn);
     NumberOfMORecHitsPerTrackVsPt->Fill(pt,nLostOut);
 
     int nLayers[4]   = { track.hitPattern().trackerLayersWithMeasurement(),
                          track.hitPattern().trackerLayersTotallyOffOrBad(),
                          track.hitPattern().numberOfValidStripLayersWithMonoAndStereo() +  track.hitPattern().pixelLayersWithMeasurement(),
                          track.hitPattern().trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS)
                        };
 
     // layers
     for (int i=0;i<4;++i) NumberOfLayersPerTrack[i]->Fill(nLayers[i]);
 
     // 2D plots    
     if ( doLayersVsPhiVsEtaPerTrack_ || doAllPlots_ )
       for (int i=0;i<4;++i) NumberOfLayersVsPhiVsEtaPerTrack[i]->Fill(etaIn,phiIn,nLayers[i]);
 
   }
 
   if (doEffFromHitPatternVsPU_   || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"",           float(good_vertices_) );
   if (doEffFromHitPatternVsBX_   || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"VsBX",       float(bx_)            );
   if (doEffFromHitPatternVsLUMI_ || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"VsSCALLUMI", scal_lumi_            );
   //  if (doEffFromHitPatternVsLUMI_ || doAllPlots_) fillHistosForEfficiencyFromHitPatter(track,"VsPIXELLUMI", pixel_lumi_           );
 
 
   if (doGeneralPropertiesPlots_ || doAllPlots_){
     // fitting
     Chi2     -> Fill(chi2);
     Chi2Prob -> Fill(chi2prob);
     Chi2oNDF -> Fill(chi2oNDF);
 
     // DCA
     // temporary patch in order to put back those MEs in Muon Workspace 
     if (doDCAPlots_) {
       if (doDCAwrt000Plots_) {
     DistanceOfClosestApproach->Fill(track.dxy());
     DistanceOfClosestApproachVsPhi->Fill(phi, track.dxy());
       }
 
       // PCA
       xPointOfClosestApproach->Fill(track.referencePoint().x());
       yPointOfClosestApproach->Fill(track.referencePoint().y());
       zPointOfClosestApproach->Fill(track.referencePoint().z());
     }
 
     // algorithm
     algorithm->Fill(static_cast<double>(track.algo()));
     oriAlgo->Fill(static_cast<double>(track.originalAlgo()));
 
     // stopping source
     int max = stoppingSource->getNbinsX();
     double stop = track.stopReason() > max ? double(max-1) : static_cast<double>(track.stopReason());
     stoppingSource->Fill(stop);
     stoppingSourceVSeta->Fill(track.eta(),stop);
     stoppingSourceVSphi->Fill(track.phi(),stop);
   }
 
   if ( doLumiAnalysis_ ) {
     NumberOfRecHitsPerTrack_lumiFlag -> Fill(nRecHits);
     Chi2oNDF_lumiFlag                -> Fill(chi2oNDF);
   }
 
   if(doDCAPlots_ || doBSPlots_ || doSIPPlots_ || doAllPlots_) {
     
     edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
     iEvent.getByToken(beamSpotToken_,recoBeamSpotHandle);
     const reco::BeamSpot& bs = *recoBeamSpotHandle;
 
     DistanceOfClosestApproachToBS      -> Fill(track.dxy(bs.position()));
     AbsDistanceOfClosestApproachToBS   -> Fill(std::abs(track.dxy(bs.position())));
     DistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position()));
     zPointOfClosestApproachVsPhi       -> Fill(track.phi(), track.vz());
     xPointOfClosestApproachVsZ0wrt000  -> Fill(track.dz(),  track.vx());
     yPointOfClosestApproachVsZ0wrt000  -> Fill(track.dz(),  track.vy());
     xPointOfClosestApproachVsZ0wrtBS   -> Fill(track.dz(bs.position()),(track.vx()-bs.position(track.vz()).x()));
     yPointOfClosestApproachVsZ0wrtBS   -> Fill(track.dz(bs.position()),(track.vy()-bs.position(track.vz()).y()));
     if (doTestPlots_) {
       TESTDistanceOfClosestApproachToBS      -> Fill(track.dxy(bs.position(track.vz())));
       TESTDistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position(track.vz())));
     }
 
     if(doSIPPlots_) {
       sipDxyToBS->Fill(track.dxy(bs.position())/track.dxyError());
       sipDzToBS->Fill(track.dz(bs.position())/track.dzError());
     }
   }
   
   if(doDCAPlots_ || doPVPlots_ || doSIPPlots_ || doAllPlots_) {
     edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle;
     iEvent.getByToken(pvToken_,recoPrimaryVerticesHandle);
     if (recoPrimaryVerticesHandle.isValid() && recoPrimaryVerticesHandle->size() > 0) {
       const reco::Vertex& pv = (*recoPrimaryVerticesHandle)[0];
     
 
       //HI PLOTS/////// 
 
       if(doHIPlots_)
     {
        double longDCAsig = 0, transDCAsig = 0;
        double zerr2 = track.dzError()*track.dzError()+pv.zError()*pv.zError();
        double xyerr2 = track.d0Error()*track.d0Error()+pv.xError()*pv.yError();
        if(zerr2 > 0) longDCAsig = track.dz(pv.position())/zerr2;
            if(xyerr2 > 0) transDCAsig = track.dxy(pv.position())/xyerr2;       
        LongDCASig->Fill(longDCAsig);
        TransDCASig->Fill(transDCAsig);
 
 
        
 
        if(track.quality(reco::TrackBase::qualityByName(qualityString_)) ==1)
          {
            dNdEta_HighPurity->Fill(track.eta());
            dNdPhi_HighPurity->Fill(track.phi());
            dNdPt_HighPurity->Fill(track.ptError()/track.pt());
            NhitVsEta_HighPurity->Fill(track.eta(),track.numberOfValidHits());
            NhitVsPhi_HighPurity->Fill(track.phi(),track.numberOfValidHits());
            dNhitdPt_HighPurity->Fill(track.pt(),track.numberOfValidHits());
            Ptdist_HighPurity->Fill(track.pt());
          }//end of high quality tracks requirement
         }
 
 
       xPointOfClosestApproachToPV->Fill(track.vx()-pv.position().x());
       yPointOfClosestApproachToPV->Fill(track.vy()-pv.position().y());
       zPointOfClosestApproachToPV->Fill(track.dz(pv.position()));
       DistanceOfClosestApproachToPV      -> Fill(track.dxy(pv.position()));
       DeltaZToPV                         -> Fill(track.dz (pv.position()));
       DistanceOfClosestApproachToPVVsPhi -> Fill(track.phi(), track.dxy(pv.position()));
       xPointOfClosestApproachVsZ0wrtPV   -> Fill(track.dz(pv.position()),(track.vx()-pv.position().x()));
       yPointOfClosestApproachVsZ0wrtPV   -> Fill(track.dz(pv.position()),(track.vy()-pv.position().y()));
 
 
       if(doSIPPlots_) {
         edm::ESHandle<TransientTrackBuilder> theB;
         iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
         reco::TransientTrack transTrack = theB->build(track);
 
         GlobalVector dir(track.px(), track.py(), track.pz());
         std::pair<bool, Measurement1D> ip3d = IPTools::signedImpactParameter3D(transTrack, dir, pv);
         std::pair<bool, Measurement1D> ip2d = IPTools::signedTransverseImpactParameter(transTrack, dir, pv);
         if(ip3d.first) sip3dToPV->Fill(ip3d.second.value() / ip3d.second.error());
         if(ip2d.first) sip2dToPV->Fill(ip2d.second.value() / ip2d.second.error());
         sipDxyToPV->Fill(track.dxy(pv.position())/track.dxyError());
         sipDzToPV->Fill(track.dz(pv.position())/track.dzError());
       }
     }
   }
 
   if(doDCAPlots_ || doAllPlots_) {
     if (doDCAwrt000Plots_) {
       if (doThetaPlots_) {
     DistanceOfClosestApproachVsTheta->Fill(track.theta(), track.d0());
       }
       DistanceOfClosestApproachVsEta->Fill(track.eta(), track.d0());
     }  
     
   }
 
   //Tracker Specific Histograms
   if(doTrackerSpecific_ || doAllPlots_) {
     fillHistosForTrackerSpecific(track);
   }
 
   if (doMeasurementStatePlots_ || doAllPlots_){
 
     if (stateName_ == "All") {
       fillHistosForState(iSetup, track, std::string("OuterSurface"));
       fillHistosForState(iSetup, track, std::string("InnerSurface"));
       fillHistosForState(iSetup, track, std::string("ImpactPoint"));
     } else if ( 
            stateName_ != "OuterSurface" && 
            stateName_ != "InnerSurface" && 
            stateName_ != "ImpactPoint" &&
            stateName_ != "default" 
            ) {
       fillHistosForState(iSetup, track, std::string("default"));
     } else {
       fillHistosForState(iSetup, track, stateName_);
     }
   }
   
   if ( doAllPlots_ ) {
   }
 
 }

void TrackAnalyzer::bookHistosForBeamSpot ( DQMStore::IBooker & ibooker )

private

Definition at line 702 of file TrackAnalyzer.cc.

Referenced by initHisto().

                                                                    {
 
     // parameters from the configuration
     std::string QualName       = conf_->getParameter<std::string>("Quality");
     std::string AlgoName       = conf_->getParameter<std::string>("AlgoName");
 
     // use the AlgoName and Quality Name 
     std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
 
     // book the Beam Spot related histograms
     // ---------------------------------------------------------------------------------//
     
     if(doDCAPlots_ || doBSPlots_ || doAllPlots_) {
     
       int    DxyBin       = conf_->getParameter<int>(   "DxyBin");
       double DxyMin       = conf_->getParameter<double>("DxyMin");
       double DxyMax       = conf_->getParameter<double>("DxyMax");
       
       int    AbsDxyBin    = conf_->getParameter<int>(   "AbsDxyBin");
       double AbsDxyMin    = conf_->getParameter<double>("AbsDxyMin");
       double AbsDxyMax    = conf_->getParameter<double>("AbsDxyMax");
       
       int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
       double PhiMin     = conf_->getParameter<double>("PhiMin");
       double PhiMax     = conf_->getParameter<double>("PhiMax");
       
       int    X0Bin        = conf_->getParameter<int>(   "X0Bin");
       double X0Min        = conf_->getParameter<double>("X0Min");
       double X0Max        = conf_->getParameter<double>("X0Max");
       
       int    Y0Bin        = conf_->getParameter<int>(   "Y0Bin");
       double Y0Min        = conf_->getParameter<double>("Y0Min");
       double Y0Max        = conf_->getParameter<double>("Y0Max");
       
       int    Z0Bin        = conf_->getParameter<int>(   "Z0Bin");
       double Z0Min        = conf_->getParameter<double>("Z0Min");
       double Z0Max        = conf_->getParameter<double>("Z0Max");
       
       int    VZBinProf    = conf_->getParameter<int>(   "VZBinProf");
       double VZMinProf    = conf_->getParameter<double>("VZMinProf");
       double VZMaxProf    = conf_->getParameter<double>("VZMaxProf");
       
       
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
       
       histname = "DistanceOfClosestApproachToBS_";
       DistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
       DistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
       DistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
       
       histname = "AbsDistanceOfClosestApproachToBS_";
       AbsDistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,AbsDxyBin,AbsDxyMin,AbsDxyMax);
       AbsDistanceOfClosestApproachToBS->setAxisTitle("Track |d_{xy}| wrt beam spot (cm)",1);
       AbsDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
       
       histname = "DistanceOfClosestApproachToBSVsPhi_";
       DistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
       DistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
       DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi",1);
       DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
       
       histname = "xPointOfClosestApproachVsZ0wrt000_";
       xPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
       xPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)",1);
       xPointOfClosestApproachVsZ0wrt000->setAxisTitle("x component of Track PCA to beam line (cm)",2);
       
       histname = "yPointOfClosestApproachVsZ0wrt000_";
       yPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
       yPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)",1);
       yPointOfClosestApproachVsZ0wrt000->setAxisTitle("y component of Track PCA to beam line (cm)",2);
       
       histname = "xPointOfClosestApproachVsZ0wrtBS_";
       xPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
       xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot  (cm)",1);
       xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("x component of Track PCA to BS (cm)",2);
       
       histname = "yPointOfClosestApproachVsZ0wrtBS_";
       yPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
       yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
       yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("y component of Track PCA to BS (cm)",2);
       
       histname = "zPointOfClosestApproachVsPhi_";
       zPointOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, VZBinProf, VZMinProf, VZMaxProf, "");
       zPointOfClosestApproachVsPhi->setAxisTitle("Track #phi",1);
       zPointOfClosestApproachVsPhi->setAxisTitle("z component of Track PCA to beam line (cm)",2);
     }
     
     if(doDCAPlots_ || doPVPlots_ || doAllPlots_) {
       
       int    DxyBin       = conf_->getParameter<int>(   "DxyBin");
       double DxyMin       = conf_->getParameter<double>("DxyMin");
       double DxyMax       = conf_->getParameter<double>("DxyMax");
       
       int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
       double PhiMin     = conf_->getParameter<double>("PhiMin");
       double PhiMax     = conf_->getParameter<double>("PhiMax");
       
       int    X0Bin        = conf_->getParameter<int>(   "X0Bin");
       double X0Min        = conf_->getParameter<double>("X0Min");
       double X0Max        = conf_->getParameter<double>("X0Max");
       
       int    Y0Bin        = conf_->getParameter<int>(   "Y0Bin");
       double Y0Min        = conf_->getParameter<double>("Y0Min");
       double Y0Max        = conf_->getParameter<double>("Y0Max");
       
       int    Z0Bin        = conf_->getParameter<int>(   "Z0Bin");
       double Z0Min        = conf_->getParameter<double>("Z0Min");
       double Z0Max        = conf_->getParameter<double>("Z0Max");
       
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
       
       histname = "DistanceOfClosestApproachToPV_";
       DistanceOfClosestApproachToPV = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
       DistanceOfClosestApproachToPV->setAxisTitle("Track d_{xy} w.r.t. PV (cm)",1);
       DistanceOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
       
       histname = "DeltaZToPV_";
       DeltaZToPV = ibooker.book1D(histname+CategoryName,histname+CategoryName,Z0Bin,Z0Min,Z0Max);
       DeltaZToPV->setAxisTitle("Track d_{z} w.r.t. PV (cm)",1);
       DeltaZToPV->setAxisTitle("Number of Tracks",2);
       
       histname = "DistanceOfClosestApproachToPVVsPhi_";
       DistanceOfClosestApproachToPVVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
       DistanceOfClosestApproachToPVVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
       DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track #phi",1);
       DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track d_{xy} w.r.t. PV (cm)",2);
       
       histname = "xPointOfClosestApproachVsZ0wrtPV_";
       xPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
       xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)",1);
       xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("x component of Track PCA to PV (cm)",2);
       
       histname = "yPointOfClosestApproachVsZ0wrtPV_";
       yPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
       yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. PV (cm)",1);
       yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("y component of Track PCA to PV (cm)",2);
       
     }
 
     if (doBSPlots_ || doAllPlots_) {
       if (doTestPlots_) {
     
     int    DxyBin       = conf_->getParameter<int>(   "DxyBin");
     double DxyMin       = conf_->getParameter<double>("DxyMin");
     double DxyMax       = conf_->getParameter<double>("DxyMax");
       
     int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
     double PhiMin     = conf_->getParameter<double>("PhiMin");
     double PhiMax     = conf_->getParameter<double>("PhiMax");
 
     histname = "TESTDistanceOfClosestApproachToBS_";
     TESTDistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
     TESTDistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
     TESTDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
     
     histname = "TESTDistanceOfClosestApproachToBSVsPhi_";
     TESTDistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
     TESTDistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
     TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi",1);
     TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
     
       }
       
     }
     
     // book the Profile plots for DCA related histograms
     // ---------------------------------------------------------------------------------//
     if(doDCAPlots_ || doAllPlots_) {
 
       if (doDCAwrt000Plots_) {
 
     int    EtaBin     = conf_->getParameter<int>(   "EtaBin");
     double EtaMin     = conf_->getParameter<double>("EtaMin");
     double EtaMax     = conf_->getParameter<double>("EtaMax");
     
     int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
     double PhiMin     = conf_->getParameter<double>("PhiMin");
     double PhiMax     = conf_->getParameter<double>("PhiMax");
 
     int    DxyBin       = conf_->getParameter<int>(   "DxyBin");
     double DxyMin       = conf_->getParameter<double>("DxyMin");
     double DxyMax       = conf_->getParameter<double>("DxyMax");
       
     if (doThetaPlots_) {
       int    ThetaBin   = conf_->getParameter<int>(   "ThetaBin");
       double ThetaMin   = conf_->getParameter<double>("ThetaMin");
       double ThetaMax   = conf_->getParameter<double>("ThetaMax");
       
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
       histname = "DistanceOfClosestApproachVsTheta_";
       DistanceOfClosestApproachVsTheta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, ThetaBin, ThetaMin, ThetaMax, DxyMin,DxyMax,"");
       DistanceOfClosestApproachVsTheta->setAxisTitle("Track #theta",1);
       DistanceOfClosestApproachVsTheta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
     }
     
     histname = "DistanceOfClosestApproachVsEta_";
     DistanceOfClosestApproachVsEta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, EtaBin, EtaMin, EtaMax, DxyMin, DxyMax,"");
     DistanceOfClosestApproachVsEta->setAxisTitle("Track #eta",1);
     DistanceOfClosestApproachVsEta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
     // temporary patch in order to put back those MEs in Muon Workspace
     
     histname = "DistanceOfClosestApproach_";
     DistanceOfClosestApproach = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
     DistanceOfClosestApproach->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",1);
     DistanceOfClosestApproach->setAxisTitle("Number of Tracks",2);
     
     histname = "DistanceOfClosestApproachVsPhi_";
     DistanceOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyMin,DxyMax,"");
     DistanceOfClosestApproachVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
     DistanceOfClosestApproachVsPhi->setAxisTitle("Track #phi",1);
     DistanceOfClosestApproachVsPhi->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
       }
     }
 
 
     if (doSIPPlots_ || doAllPlots_) {
       const double sipBins = 200;
       const double sipMin = -20;
       const double sipMax = 20;
 
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
 
       // SIP wrt. beamspot
       histname = "SIPDxyToBS_";
       sipDxyToBS = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sipDxyToBS->setAxisTitle("Track dxy significance wrt beam spot",1);
       sipDxyToBS->setAxisTitle("Number of Tracks",2);
 
       histname = "SIPDzToBS_";
       sipDzToBS = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sipDzToBS->setAxisTitle("Track dz significance wrt beam spot",1);
       sipDzToBS->setAxisTitle("Number of Tracks",2);
 
       // SIP wrt. vertex
       histname = "SIP3DToPV_";
       sip3dToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sip3dToPV->setAxisTitle("3D IP significance wrt primary vertex",1);
       sip3dToPV->setAxisTitle("Number of Tracks",2);
 
       histname = "SIP2DToPV_";
       sip2dToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sip2dToPV->setAxisTitle("2D IP significance wrt primary vertex",1);
       sip2dToPV->setAxisTitle("Number of Tracks",2);
 
       histname = "SIPDxyToPV_";
       sipDxyToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sipDxyToPV->setAxisTitle("Track dxy significance wrt primary vertex",1);
       sipDxyToPV->setAxisTitle("Number of Tracks",2);
 
       histname = "SIPDzToPV_";
       sipDzToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, sipBins, sipMin, sipMax);
       sipDzToPV->setAxisTitle("Track dz significance wrt primary vertex",1);
       sipDzToPV->setAxisTitle("Number of Tracks",2);
     }
 }

void TrackAnalyzer::bookHistosForEfficiencyFromHitPatter	(	DQMStore::IBooker &	ibooker,
		const edm::EventSetup &	iSetup,
		const std::string	suffix
	)

private

Definition at line 205 of file TrackAnalyzer.cc.

References DQMStore::IBooker::book1D(), eostools::cat(), conf_, objects.autophobj::float, edm::EventSetup::get(), edm::ParameterSet::getParameter(), hits_bad_, hits_inactive_, hits_missing_, hits_total_, hits_valid_, mps_fire::i, createfilelist::int, GetLumi::lastBunchCrossing, LogDebug, hpstanc_transforms::max, min(), LaserDQM_cfi::mon, monName, dataset::name, NBINS, pileupCalc::nbins, TrackerGeometry::numberOfLayers(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, fftjetcommon_cfi::title, and TopFolder_.

Referenced by initHisto().

 {
 
     ibooker.setCurrentFolder(TopFolder_ + "/HitEffFromHitPattern" + suffix);
     
     int LUMIBin   = conf_->getParameter<int>("LUMIBin");
     float LUMIMin = conf_->getParameter<double>("LUMIMin");
     float LUMIMax = conf_->getParameter<double>("LUMIMax");
     
 
     int NBINS[]        = { 50,   int(GetLumi::lastBunchCrossing),  300  , LUMIBin};
     float MIN[]        = { 0.5,     0.5,  0., LUMIMin };
     float MAX[]        = { 50.5, float(GetLumi::lastBunchCrossing)+0.5,  3., LUMIMax };
     std::string NAME[] = { "", "VsBX", "VsLUMI", "VsLUMI" };
     
     int mon = -1;
     int nbins = -1;
     float min = -1.;
     float max = -1.;
     std::string name = "";
     for (int i=0; i<monQuantity::END; i++) {
       if (monName[i] == suffix) {
     mon = i;
     nbins = NBINS[i];
     min = MIN[i];
     max = MAX[i];
     name = NAME[i];
       }
     }
   
     edm::ESHandle<TrackerGeometry> trackerGeometry;
     iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
 
     // Values are not ordered randomly, but the order is taken from
     // http://cmslxr.fnal.gov/dxr/CMSSW/source/Geometry/CommonDetUnit/interface/GeomDetEnumerators.h#15
     const char * dets[] = { "None", "PXB", "PXF", "TIB", "TID", "TOB", "TEC"};
 
     // Also in this case, ordering is not random but extracted from
     // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
     // The category "total" is an addition to ease the computation of
     // the efficiencies and is not part of the original HitPattern.
     const char * hit_category[] = { "valid", "missing", "inactive", "bad", "total"};
 
     // We set sub_det to be a 1-based index since to it is the sub-sub-structure in the HitPattern
     char title[50];
     for (unsigned int det = 1; det < sizeof(dets)/sizeof(char*); ++det ) {
       for (unsigned int sub_det = 1;
            sub_det <= trackerGeometry->numberOfLayers(det); ++sub_det) {
         for (unsigned int cat = 0;
              cat < sizeof(hit_category)/sizeof(char *); ++cat) {
           memset(title, 0, sizeof(title));
           snprintf(title, sizeof(title), "Hits%s_%s_%s_Subdet%d", name.c_str(), hit_category[cat], dets[det], sub_det);
           switch(cat) {
             case 0:
               hits_valid_.insert(std::make_pair(
           Key(det, sub_det, mon),
           ibooker.book1D(title, title, nbins, min, max)));
               break;
             case 1:
               hits_missing_.insert(std::make_pair(
           Key(det, sub_det, mon),
                   ibooker.book1D(title, title, nbins, min, max)));
               break;
             case 2:
               hits_inactive_.insert(std::make_pair(
           Key(det, sub_det, mon),
                   ibooker.book1D(title, title, nbins, min, max)));
               break;
             case 3:
               hits_bad_.insert(std::make_pair(
           Key(det, sub_det, mon),
                   ibooker.book1D(title, title, nbins, min, max)));
               break;
             case 4:
               hits_total_.insert(std::make_pair(
           Key(det, sub_det, mon),
                   ibooker.book1D(title, title, nbins, min, max)));
               break;
             default:
               LogDebug("TrackAnalyzer") << "Invalid hit category used " << cat << " ignored\n";
           }
         }
       }
     }
 }

void TrackAnalyzer::bookHistosForHitProperties ( DQMStore::IBooker & ibooker )

private

Definition at line 294 of file TrackAnalyzer.cc.

Referenced by initHisto().

                                                                         {
   
     // parameters from the configuration
     std::string QualName       = conf_->getParameter<std::string>("Quality");
     std::string AlgoName       = conf_->getParameter<std::string>("AlgoName");
     std::string MEBSFolderName = conf_->getParameter<std::string>("BSFolderName"); 
 
     // use the AlgoName and Quality Name 
     std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
 
     // get binning from the configuration
     int    TKHitBin     = conf_->getParameter<int>(   "RecHitBin");
     double TKHitMin     = conf_->getParameter<double>("RecHitMin");
     double TKHitMax     = conf_->getParameter<double>("RecHitMax");
 
     int    TKLostBin    = conf_->getParameter<int>(   "RecLostBin");
     double TKLostMin    = conf_->getParameter<double>("RecLostMin");
     double TKLostMax    = conf_->getParameter<double>("RecLostMax");
 
     int    TKLayBin     = conf_->getParameter<int>(   "RecLayBin");
     double TKLayMin     = conf_->getParameter<double>("RecLayMin");
     double TKLayMax     = conf_->getParameter<double>("RecLayMax");
 
     int    PhiBin       = conf_->getParameter<int>(   "PhiBin");
     double PhiMin       = conf_->getParameter<double>("PhiMin");
     double PhiMax       = conf_->getParameter<double>("PhiMax");
 
     int    EtaBin       = conf_->getParameter<int>(   "EtaBin");
     double EtaMin       = conf_->getParameter<double>("EtaMin");
     double EtaMax       = conf_->getParameter<double>("EtaMax");
 
     int    PtBin = conf_->getParameter<int>(   "TrackPtBin");
     double PtMin = conf_->getParameter<double>("TrackPtMin");
     double PtMax = conf_->getParameter<double>("TrackPtMax");
 
     int    VXBin        = conf_->getParameter<int>(   "VXBin");
     double VXMin        = conf_->getParameter<double>("VXMin");
     double VXMax        = conf_->getParameter<double>("VXMax");
 
     int    VYBin        = conf_->getParameter<int>(   "VYBin");
     double VYMin        = conf_->getParameter<double>("VYMin");
     double VYMax        = conf_->getParameter<double>("VYMax");
 
     int    VZBin        = conf_->getParameter<int>(   "VZBin");
     double VZMin        = conf_->getParameter<double>("VZMin");
     double VZMax        = conf_->getParameter<double>("VZMax");
 
     ibooker.setCurrentFolder(TopFolder_);
 
     // book the Hit Property histograms
     // ---------------------------------------------------------------------------------//
 
     TkParameterMEs tkmes;
     if ( doHitPropertiesPlots_ || doAllPlots_ ){
 
       ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
       
       histname = "NumberOfRecHitsPerTrack_";
       NumberOfRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
       NumberOfRecHitsPerTrack->setAxisTitle("Number of all RecHits of each Track");
       NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfValidRecHitsPerTrack_";
       NumberOfValidRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
       NumberOfValidRecHitsPerTrack->setAxisTitle("Number of valid RecHits for each Track");
       NumberOfValidRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfLostRecHitsPerTrack_";
       NumberOfLostRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLostBin, TKLostMin, TKLostMax);
       NumberOfLostRecHitsPerTrack->setAxisTitle("Number of lost RecHits for each Track");
       NumberOfLostRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfMissingInnerRecHitsPerTrack_";
       NumberOfMIRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 10, -0.5, 9.5);
       NumberOfMIRecHitsPerTrack->setAxisTitle("Number of missing-inner RecHits for each Track");
       NumberOfMIRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfMissingOuterRecHitsPerTrack_";
       NumberOfMORecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 10, -0.5, 9.5);
       NumberOfMORecHitsPerTrack->setAxisTitle("Number of missing-outer RecHits for each Track");
       NumberOfMORecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "ValidFractionPerTrack_";
       ValidFractionPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, 101, 0., 1.01);
       ValidFractionPerTrack->setAxisTitle("ValidFraction of RecHits for each Track");
       ValidFractionPerTrack->setAxisTitle("Number of Tracks", 2);
 
 
 
       if ( doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_ ){
     
     histname = "NumberOfValidRecHitVsPhiVsEtaPerTrack_";
     NumberOfValidRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName, 
                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
     NumberOfValidRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
     NumberOfValidRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
 
         histname = "NumberOfLostRecHitVsPhiVsEtaPerTrack_";
         NumberOfLostRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 5., "");
         NumberOfLostRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfLostRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
 
 
         histname = "NumberMIRecHitVsPhiVsEtaPerTrack_";
         NumberOfMIRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 15., "");
         NumberOfMIRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfMIRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
 
         histname = "NumberMORecHitVsPhiVsEtaPerTrack_";
         NumberOfMORecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 15., "");
         NumberOfMORecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfMORecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
 
         histname = "ValidFractionVsPhiVsEtaPerTrack_";
         ValidFractionVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 2., "");
         ValidFractionVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         ValidFractionVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
 
       }
 
       if ( doRecHitVsPtVsEtaPerTrack_ || doAllPlots_ ){
     
     histname = "NumberOfValidRecHitVsPtVsEtaPerTrack_";
     NumberOfValidRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName, 
                                     EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 40., "");
     NumberOfValidRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
     NumberOfValidRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
 
         histname = "NumberOfLostRecHitVsPtVsEtaPerTrack_";
         NumberOfLostRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 5., "");
         NumberOfLostRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfLostRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
 
 
         histname = "NumberMIRecHitVsPtVsEtaPerTrack_";
         NumberOfMIRecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 15., "");
         NumberOfMIRecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfMIRecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
 
         histname = "NumberMORecHitVsPtVsEtaPerTrack_";
         NumberOfMORecHitVsPtVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
                                                                     EtaBin, EtaMin, EtaMax, PtBin, PtMin, PtMax, 0, 15., "");
         NumberOfMORecHitVsPtVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
         NumberOfMORecHitVsPtVsEtaPerTrack->setAxisTitle("Track p_{T} [GeV] ", 2);
 
       }
 
       histname = "NumberOfValidRecHitsPerTrackVsPt_";
       NumberOfValidRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax, TKHitMin, TKHitMax,"");
       NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
       NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track",2);
     
       histname = "NumberOfLostRecHitsPerTrackVsPt_";
       NumberOfLostRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
       NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
       NumberOfLostRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
       
       
       histname = "NumberMIRecHitsPerTrackVsPt_";
       NumberOfMIRecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
       NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
       NumberOfMIRecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
       
       histname = "NumberMORecHitsPerTrackVsPt_";
       NumberOfMORecHitsPerTrackVsPt = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PtBin, PtMin, PtMax,TKHitMin, TKHitMax,"");
       NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]", 1);
       NumberOfMORecHitsPerTrackVsPt->setAxisTitle("Average Number of Lost RecHits per Track", 2);
 
       std::string layerTypeName[4] = {"","Off","3D","Missing"};
       for (int i=0; i<4; ++i) {
         histname = "NumberOf"+ layerTypeName[i] + "LayersPerTrack_";
         NumberOfLayersPerTrack[i] = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLayBin, TKLayMin, TKLayMax);
         NumberOfLayersPerTrack[i]->setAxisTitle("Number of " + layerTypeName[i] + " Layers of each Track", 1);
         NumberOfLayersPerTrack[i]->setAxisTitle("Number of Tracks", 2);
       }
       if ( doLayersVsPhiVsEtaPerTrack_ || doAllPlots_ )
     for (int i=0; i<4; ++i) {
           histname = "NumberOf"+ layerTypeName[i] + "LayersVsPhiVsEtaPerTrack_";
       NumberOfLayersVsPhiVsEtaPerTrack[i] = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName, 
                                     EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
       NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #eta ", 1);
       NumberOfLayersVsPhiVsEtaPerTrack[i]->setAxisTitle("Track #phi ", 2);
       }
     }
 
     // book the General Property histograms
     // ---------------------------------------------------------------------------------//
     
     if (doGeneralPropertiesPlots_ || doAllPlots_){
       
       int    Chi2Bin      = conf_->getParameter<int>(   "Chi2Bin");
       double Chi2Min      = conf_->getParameter<double>("Chi2Min");
       double Chi2Max      = conf_->getParameter<double>("Chi2Max");
       
       int    Chi2NDFBin   = conf_->getParameter<int>(   "Chi2NDFBin");
       double Chi2NDFMin   = conf_->getParameter<double>("Chi2NDFMin");
       double Chi2NDFMax   = conf_->getParameter<double>("Chi2NDFMax");
       
       int    Chi2ProbBin  = conf_->getParameter<int>(   "Chi2ProbBin");
       double Chi2ProbMin  = conf_->getParameter<double>("Chi2ProbMin");
       double Chi2ProbMax  = conf_->getParameter<double>("Chi2ProbMax");
     
 
       //HI PLOTS////                                                       
       int TransDCABins = conf_->getParameter<int>("TransDCABins");
       double TransDCAMin = conf_->getParameter<double>("TransDCAMin");
       double TransDCAMax = conf_->getParameter<double>("TransDCAMax");
 
       int LongDCABins = conf_->getParameter<int>("LongDCABins");
       double LongDCAMin = conf_->getParameter<double>("LongDCAMin");
       double LongDCAMax = conf_->getParameter<double>("LongDCAMax");
 
 
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
 
       histname = "Chi2_";
       Chi2 = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2Bin, Chi2Min, Chi2Max);
       Chi2->setAxisTitle("Track #chi^{2}"  ,1);
       Chi2->setAxisTitle("Number of Tracks",2);
 
       histname = "Chi2Prob_";
       Chi2Prob = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2ProbBin, Chi2ProbMin, Chi2ProbMax);
       Chi2Prob->setAxisTitle("Track #chi^{2} probability",1);
       Chi2Prob->setAxisTitle("Number of Tracks"        ,2);
       
       histname = "Chi2oNDF_";
       Chi2oNDF = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
       Chi2oNDF->setAxisTitle("Track #chi^{2}/ndf",1);
       Chi2oNDF->setAxisTitle("Number of Tracks"  ,2);
 
 
       //HI PLOTS///                                                                                                                                                                                       
       if (doHIPlots_)
         {
           histname = "LongDCASig_";
           LongDCASig = ibooker.book1D(histname+CategoryName, histname+CategoryName,LongDCABins,LongDCAMin,LongDCAMax);
           LongDCASig->setAxisTitle("dz/#sigma_{dz}",1);
 
           histname = "TransDCASig_";
           TransDCASig = ibooker.book1D(histname+CategoryName,histname+CategoryName,TransDCABins,TransDCAMin,TransDCAMax);
           TransDCASig->setAxisTitle("dxy/#sigma_{dxy}",1);
 
       histname = "dNdPhi_HighPurity_";
       dNdPhi_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,PhiBin,PhiMin,PhiMax);
       dNdPhi_HighPurity->setAxisTitle("#phi",1);
 
       histname = "dNdEta_HighPurity_";
           dNdEta_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,EtaBin,EtaMin,EtaMax);
           dNdEta_HighPurity->setAxisTitle("#eta",1);
 
           histname = "dNdPt_HighPurity_";
           dNdPt_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,150,0,0.3);
           dNdPt_HighPurity->setAxisTitle("#sigma_{p_{T}}/p_{T}",1);
 
       histname = "NhitVsEta_HighPurity_";
       NhitVsEta_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,EtaBin,EtaMin,EtaMax,-0.5,39.5,"");
       NhitVsEta_HighPurity->setAxisTitle("Track #eta",1);
       NhitVsEta_HighPurity->setAxisTitle("Number of Valid RecHits in each Track",2);
 
           histname = "NhitVsPhi_HighPurity_";
           NhitVsPhi_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,PhiBin,PhiMin,PhiMax,-0.5,39.5,"");
           NhitVsPhi_HighPurity->setAxisTitle("Track #phi",1);
           NhitVsPhi_HighPurity->setAxisTitle("Number of Valid RecHits in each Track",2);
 
       histname = "Ptdist_HighPurity_";
           Ptdist_HighPurity = ibooker.book1D(histname+CategoryName,histname+CategoryName,150,0,50.);
           Ptdist_HighPurity->setAxisTitle("p_{T} (GeV/c)",1);
           Ptdist_HighPurity->setAxisTitle("Number of Tracks",2);
 
           histname = "dNhitdPt_HighPurity_";
           dNhitdPt_HighPurity = ibooker.bookProfile(histname+CategoryName,histname+CategoryName,150,0,25.,-0.5,39.5,"");
           dNhitdPt_HighPurity->setAxisTitle("p_{T} (GeV/c)",1);
           dNhitdPt_HighPurity->setAxisTitle("N_{hit}",2);
       
         }
 
 
       
       if(doDCAPlots_ || doPVPlots_ || doSIPPlots_ || doAllPlots_)  {
     histname = "xPointOfClosestApproach_";
     xPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
     xPointOfClosestApproach->setAxisTitle("x component of Track PCA to beam line (cm)",1);
     xPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
     
     histname = "yPointOfClosestApproach_";
     yPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
     yPointOfClosestApproach->setAxisTitle("y component of Track PCA to beam line (cm)",1);
     yPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
     
     histname = "zPointOfClosestApproach_";
     zPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
     zPointOfClosestApproach->setAxisTitle("z component of Track PCA to beam line (cm)",1);
     zPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
     
     histname = "xPointOfClosestApproachToPV_";
         xPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
     xPointOfClosestApproachToPV->setAxisTitle("x component of Track PCA to pv (cm)",1);
     xPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
     
     histname = "yPointOfClosestApproachToPV_";
     yPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
     yPointOfClosestApproachToPV->setAxisTitle("y component of Track PCA to pv line (cm)",1);
     yPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
     
     histname = "zPointOfClosestApproachToPV_";
     zPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
     zPointOfClosestApproachToPV->setAxisTitle("z component of Track PCA to pv line (cm)",1);
     zPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
       }
 
       // See DataFormats/TrackReco/interface/TrackBase.h for track algorithm enum definition
       // http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/DataFormats/TrackReco/interface/TrackBase.h?view=log
       histname = "algorithm_";
       algorithm = ibooker.book1D(histname+CategoryName, histname+CategoryName, reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize));
       algorithm->setAxisTitle("Tracking algorithm",1);
       algorithm->setAxisTitle("Number of Tracks",2);
 
       histname = "originalAlgorithm_";
       oriAlgo = ibooker.book1D(histname+CategoryName, histname+CategoryName, reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize));
       oriAlgo->setAxisTitle("Tracking algorithm",1);
       oriAlgo->setAxisTitle("Number of Tracks",2);
 
       for (size_t ibin=0; ibin<reco::TrackBase::algoSize-1; ibin++) {
     algorithm->setBinLabel(ibin+1,reco::TrackBase::algoNames[ibin]);
         oriAlgo->setBinLabel(ibin+1,reco::TrackBase::algoNames[ibin]);
       }
 
       size_t StopReasonNameSize = sizeof(StopReasonName::StopReasonName)/sizeof(std::string);
       if(StopReasonNameSize != static_cast<unsigned int>(StopReason::SIZE)) {
         throw cms::Exception("Assert") << "StopReason::SIZE is " << static_cast<unsigned int>(StopReason::SIZE)
                                        << " but StopReasonName's only for "
                                        << StopReasonNameSize
                                        << ". Please update DataFormats/TrackReco/interface/TrajectoryStopReasons.h.";
       }
 
       histname = "stoppingSource_";
       stoppingSource = ibooker.book1D(histname+CategoryName, histname+CategoryName, StopReasonNameSize, 0., double(StopReasonNameSize));
       stoppingSource->setAxisTitle("stopping reason",1);
       stoppingSource->setAxisTitle("Number of Tracks",2);
       
       histname = "stoppingSourceVSeta_";
       stoppingSourceVSeta = ibooker.book2D(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, StopReasonNameSize, 0., double(StopReasonNameSize));
       stoppingSourceVSeta->setAxisTitle("track #eta",1);
       stoppingSourceVSeta->setAxisTitle("stopping reason",2);
       
       histname = "stoppingSourceVSphi_";
       stoppingSourceVSphi = ibooker.book2D(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, StopReasonNameSize, 0., double(StopReasonNameSize));
       stoppingSourceVSphi->setAxisTitle("track #phi",1);
       stoppingSourceVSphi->setAxisTitle("stopping reason",2);
 
       for (size_t ibin=0; ibin<StopReasonNameSize; ibin++) {
     stoppingSource->setBinLabel(ibin+1,StopReasonName::StopReasonName[ibin],1);
     stoppingSourceVSeta->setBinLabel(ibin+1,StopReasonName::StopReasonName[ibin],2);
     stoppingSourceVSphi->setBinLabel(ibin+1,StopReasonName::StopReasonName[ibin],2);
       }
 
     }
 
 }

void TrackAnalyzer::bookHistosForLScertification ( DQMStore::IBooker & ibooker )

private

Definition at line 663 of file TrackAnalyzer.cc.

References DQMStore::IBooker::book1D(), Chi2oNDF_lumiFlag, conf_, doLumiAnalysis_, edm::ParameterSet::getParameter(), histname, NumberOfRecHitsPerTrack_lumiFlag, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, and TopFolder_.

Referenced by initHisto().

                                                                           {
 
     // parameters from the configuration
     std::string QualName       = conf_->getParameter<std::string>("Quality");
     std::string AlgoName       = conf_->getParameter<std::string>("AlgoName");
 
     // use the AlgoName and Quality Name 
     std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
 
 
     // book LS analysis related histograms
     // -----------------------------------
     if ( doLumiAnalysis_ ) {
 
       // get binning from the configuration
       int    TKHitBin     = conf_->getParameter<int>(   "RecHitBin");
       double TKHitMin     = conf_->getParameter<double>("RecHitMin");
       double TKHitMax     = conf_->getParameter<double>("RecHitMax");
 
       int    Chi2NDFBin   = conf_->getParameter<int>(   "Chi2NDFBin");
       double Chi2NDFMin   = conf_->getParameter<double>("Chi2NDFMin");
       double Chi2NDFMax   = conf_->getParameter<double>("Chi2NDFMax");
 
       // add by Mia in order to deal w/ LS transitions  
       ibooker.setCurrentFolder(TopFolder_+"/LSanalysis");
 
       histname = "NumberOfRecHitsPerTrack_lumiFlag_";
       NumberOfRecHitsPerTrack_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
       NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of all RecHits of each Track");
       NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of Tracks", 2);
 
       histname = "Chi2oNDF_lumiFlag_";
       Chi2oNDF_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
       Chi2oNDF_lumiFlag->setAxisTitle("Track #chi^{2}/ndf",1);
       Chi2oNDF_lumiFlag->setAxisTitle("Number of Tracks"  ,2);
 
     }
 }

void TrackAnalyzer::bookHistosForState	(	std::string	sname,
		DQMStore::IBooker &	ibooker
	)

private

Definition at line 1318 of file TrackAnalyzer.cc.

Referenced by initHisto().

 {
 
     // parameters from the configuration
     std::string QualName       = conf_->getParameter<std::string>("Quality");
     std::string AlgoName       = conf_->getParameter<std::string>("AlgoName");
 
     // use the AlgoName and Quality Name 
     std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
 
     // get binning from the configuration
     double Chi2NDFMin = conf_->getParameter<double>("Chi2NDFMin");
     double Chi2NDFMax = conf_->getParameter<double>("Chi2NDFMax");
 
     int    RecHitBin   = conf_->getParameter<int>(   "RecHitBin");
     double RecHitMin   = conf_->getParameter<double>("RecHitMin");
     double RecHitMax   = conf_->getParameter<double>("RecHitMax");
 
     int    RecLayBin   = conf_->getParameter<int>(   "RecHitBin");
     double RecLayMin   = conf_->getParameter<double>("RecHitMin");
     double RecLayMax   = conf_->getParameter<double>("RecHitMax");
 
 
     int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
     double PhiMin     = conf_->getParameter<double>("PhiMin");
     double PhiMax     = conf_->getParameter<double>("PhiMax");
 
     int    EtaBin     = conf_->getParameter<int>(   "EtaBin");
     double EtaMin     = conf_->getParameter<double>("EtaMin");
     double EtaMax     = conf_->getParameter<double>("EtaMax");
 
     int    ThetaBin   = conf_->getParameter<int>(   "ThetaBin");
     double ThetaMin   = conf_->getParameter<double>("ThetaMin");
     double ThetaMax   = conf_->getParameter<double>("ThetaMax");
 
     int    TrackQBin  = conf_->getParameter<int>(   "TrackQBin");
     double TrackQMin  = conf_->getParameter<double>("TrackQMin");
     double TrackQMax  = conf_->getParameter<double>("TrackQMax");
 
     int    TrackPtBin = conf_->getParameter<int>(   "TrackPtBin");
     double TrackPtMin = conf_->getParameter<double>("TrackPtMin");
     double TrackPtMax = conf_->getParameter<double>("TrackPtMax");
 
     int    TrackPBin  = conf_->getParameter<int>(   "TrackPBin");
     double TrackPMin  = conf_->getParameter<double>("TrackPMin");
     double TrackPMax  = conf_->getParameter<double>("TrackPMax");
 
     int    TrackPxBin = conf_->getParameter<int>(   "TrackPxBin");
     double TrackPxMin = conf_->getParameter<double>("TrackPxMin");
     double TrackPxMax = conf_->getParameter<double>("TrackPxMax");
 
     int    TrackPyBin = conf_->getParameter<int>(   "TrackPyBin");
     double TrackPyMin = conf_->getParameter<double>("TrackPyMin");
     double TrackPyMax = conf_->getParameter<double>("TrackPyMax");
 
     int    TrackPzBin = conf_->getParameter<int>(   "TrackPzBin");
     double TrackPzMin = conf_->getParameter<double>("TrackPzMin");
     double TrackPzMax = conf_->getParameter<double>("TrackPzMax");
 
     int    ptErrBin   = conf_->getParameter<int>(   "ptErrBin");
     double ptErrMin   = conf_->getParameter<double>("ptErrMin");
     double ptErrMax   = conf_->getParameter<double>("ptErrMax");
 
     int    pxErrBin   = conf_->getParameter<int>(   "pxErrBin");
     double pxErrMin   = conf_->getParameter<double>("pxErrMin");
     double pxErrMax   = conf_->getParameter<double>("pxErrMax");
 
     int    pyErrBin   = conf_->getParameter<int>(   "pyErrBin");
     double pyErrMin   = conf_->getParameter<double>("pyErrMin");
     double pyErrMax   = conf_->getParameter<double>("pyErrMax");
 
     int    pzErrBin   = conf_->getParameter<int>(   "pzErrBin");
     double pzErrMin   = conf_->getParameter<double>("pzErrMin");
     double pzErrMax   = conf_->getParameter<double>("pzErrMax");
 
     int    pErrBin    = conf_->getParameter<int>(   "pErrBin");
     double pErrMin    = conf_->getParameter<double>("pErrMin");
     double pErrMax    = conf_->getParameter<double>("pErrMax");
 
     int    phiErrBin  = conf_->getParameter<int>(   "phiErrBin");
     double phiErrMin  = conf_->getParameter<double>("phiErrMin");
     double phiErrMax  = conf_->getParameter<double>("phiErrMax");
 
     int    etaErrBin  = conf_->getParameter<int>(   "etaErrBin");
     double etaErrMin  = conf_->getParameter<double>("etaErrMin");
     double etaErrMax  = conf_->getParameter<double>("etaErrMax");
 
 
     double Chi2ProbMin  = conf_->getParameter<double>("Chi2ProbMin");
     double Chi2ProbMax  = conf_->getParameter<double>("Chi2ProbMax");
 
     ibooker.setCurrentFolder(TopFolder_);
 
     TkParameterMEs tkmes;
 
     std::string histTag = (sname == "default") ? CategoryName : sname + "_" + CategoryName;
 
     if(doAllPlots_) {
 
       // general properties
       ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
       
       if (doThetaPlots_) {
     histname = "Chi2oNDFVsTheta_" + histTag;
     tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
     tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
     tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
       }
       histname = "Chi2oNDFVsPhi_" + histTag;
       tkmes.Chi2oNDFVsPhi   = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
       tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
       tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
       
       histname = "Chi2ProbVsPhi_" + histTag;
       tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
       tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi"  ,1);
       tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
       
       histname = "Chi2ProbVsEta_" + histTag;
       tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
       tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta"  ,1);
       tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
 
     }
     
     // general properties
     ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
 
 
     histname = "Chi2oNDFVsEta_" + histTag;
     tkmes.Chi2oNDFVsEta   = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
     tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
     tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
 
     histname = "Chi2oNDFVsPt_" + histTag;
     tkmes.Chi2oNDFVsPt   = ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, Chi2NDFMin, Chi2NDFMax,"");
     tkmes.Chi2oNDFVsPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
     tkmes.Chi2oNDFVsPt->setAxisTitle("Track #chi^{2}/ndf",2);
 
     histname = "Chi2oNDFVsNHits_" + histTag;
     tkmes.Chi2oNDFVsNHits   = ibooker.bookProfile(histname, histname, 50, 0, 50, Chi2NDFMin, Chi2NDFMax,"");
     tkmes.Chi2oNDFVsNHits->setAxisTitle("Track NHits", 1);
     tkmes.Chi2oNDFVsNHits->setAxisTitle("Track #chi^{2}/ndf",2);
 
     histname = "TrackP_" + histTag;
     tkmes.TrackP = ibooker.book1D(histname, histname, TrackPBin, TrackPMin, TrackPMax);
     tkmes.TrackP->setAxisTitle("Track |p| (GeV/c)", 1);
     tkmes.TrackP->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPt_" + histTag;
     tkmes.TrackPt = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
     tkmes.TrackPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
     tkmes.TrackPt->setAxisTitle("Number of Tracks",2);
 
     if (doTrackPxPyPlots_) {
       histname = "TrackPx_" + histTag;
       tkmes.TrackPx = ibooker.book1D(histname, histname, TrackPxBin, TrackPxMin, TrackPxMax);
       tkmes.TrackPx->setAxisTitle("Track p_{x} (GeV/c)", 1);
       tkmes.TrackPx->setAxisTitle("Number of Tracks",2);
 
       histname = "TrackPy_" + histTag;
       tkmes.TrackPy = ibooker.book1D(histname, histname, TrackPyBin, TrackPyMin, TrackPyMax);
       tkmes.TrackPy->setAxisTitle("Track p_{y} (GeV/c)", 1);
       tkmes.TrackPy->setAxisTitle("Number of Tracks",2);
     }
     histname = "TrackPz_" + histTag;
     tkmes.TrackPz = ibooker.book1D(histname, histname, TrackPzBin, TrackPzMin, TrackPzMax);
     tkmes.TrackPz->setAxisTitle("Track p_{z} (GeV/c)", 1);
     tkmes.TrackPz->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPhi_" + histTag;
     tkmes.TrackPhi = ibooker.book1D(histname, histname, PhiBin, PhiMin, PhiMax);
     tkmes.TrackPhi->setAxisTitle("Track #phi", 1);
     tkmes.TrackPhi->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackEta_" + histTag;
     tkmes.TrackEta = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
     tkmes.TrackEta->setAxisTitle("Track #eta", 1);
     tkmes.TrackEta->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackEtaPhi_" + histTag;
     tkmes.TrackEtaPhi = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
     tkmes.TrackEtaPhi->setAxisTitle("Track #eta", 1);
     tkmes.TrackEtaPhi->setAxisTitle("Track #phi", 2);
 
     histname = "TrackEtaPhiInner_" + histTag;
     tkmes.TrackEtaPhiInner = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
     tkmes.TrackEtaPhiInner->setAxisTitle("Track #eta", 1);
     tkmes.TrackEtaPhiInner->setAxisTitle("Track #phi", 2);
 
     histname = "TrackEtaPhiOuter_" + histTag;
     tkmes.TrackEtaPhiOuter = ibooker.book2D(histname, histname, EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax);
     tkmes.TrackEtaPhiOuter->setAxisTitle("Track #eta", 1);
     tkmes.TrackEtaPhiOuter->setAxisTitle("Track #phi", 2);
 
 
 
     if (doThetaPlots_) {  
       histname = "TrackTheta_" + histTag;
       tkmes.TrackTheta = ibooker.book1D(histname, histname, ThetaBin, ThetaMin, ThetaMax);
       tkmes.TrackTheta->setAxisTitle("Track #theta", 1);
       tkmes.TrackTheta->setAxisTitle("Number of Tracks",2);
     }
     histname = "TrackQ_" + histTag;
     tkmes.TrackQ = ibooker.book1D(histname, histname, TrackQBin, TrackQMin, TrackQMax);
     tkmes.TrackQ->setAxisTitle("Track Charge", 1);
     tkmes.TrackQ->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPErrOverP_" + histTag;
     tkmes.TrackPErr = ibooker.book1D(histname, histname, pErrBin, pErrMin, pErrMax);
     tkmes.TrackPErr->setAxisTitle("track error(p)/p", 1);
     tkmes.TrackPErr->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPtErrOverPt_" + histTag;
     tkmes.TrackPtErr = ibooker.book1D(histname, histname, ptErrBin, ptErrMin, ptErrMax);
     tkmes.TrackPtErr->setAxisTitle("track error(p_{T})/p_{T}", 1);
     tkmes.TrackPtErr->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPtErrOverPtVsEta_" + histTag;
     tkmes.TrackPtErrVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, ptErrMin, ptErrMax);
     tkmes.TrackPtErrVsEta->setAxisTitle("Track #eta",1);
     tkmes.TrackPtErrVsEta->setAxisTitle("track error(p_{T})/p_{T}", 2);
 
     if (doTrackPxPyPlots_) {
       histname = "TrackPxErrOverPx_" + histTag;
       tkmes.TrackPxErr = ibooker.book1D(histname, histname, pxErrBin, pxErrMin, pxErrMax);
       tkmes.TrackPxErr->setAxisTitle("track error(p_{x})/p_{x}", 1);
       tkmes.TrackPxErr->setAxisTitle("Number of Tracks",2);
       
       histname = "TrackPyErrOverPy_" + histTag;
       tkmes.TrackPyErr = ibooker.book1D(histname, histname, pyErrBin, pyErrMin, pyErrMax);
       tkmes.TrackPyErr->setAxisTitle("track error(p_{y})/p_{y}", 1);
       tkmes.TrackPyErr->setAxisTitle("Number of Tracks",2);
     }
     histname = "TrackPzErrOverPz_" + histTag;
     tkmes.TrackPzErr = ibooker.book1D(histname, histname, pzErrBin, pzErrMin, pzErrMax);
     tkmes.TrackPzErr->setAxisTitle("track error(p_{z})/p_{z}", 1);
     tkmes.TrackPzErr->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackPhiErr_" + histTag;
     tkmes.TrackPhiErr = ibooker.book1D(histname, histname, phiErrBin, phiErrMin, phiErrMax);
     tkmes.TrackPhiErr->setAxisTitle("track error(#phi)");
     tkmes.TrackPhiErr->setAxisTitle("Number of Tracks",2);
 
     histname = "TrackEtaErr_" + histTag;
     tkmes.TrackEtaErr = ibooker.book1D(histname, histname, etaErrBin, etaErrMin, etaErrMax);
     tkmes.TrackEtaErr->setAxisTitle("track error(#eta)");
     tkmes.TrackEtaErr->setAxisTitle("Number of Tracks",2);
 
     // rec hit profiles
     ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
     histname = "NumberOfRecHitsPerTrackVsPhi_" + histTag;
     tkmes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitBin, RecHitMin, RecHitMax,"");
     tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
     tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of RecHits in each Track",2);
 
     if (doThetaPlots_) {
       histname = "NumberOfRecHitsPerTrackVsTheta_" + histTag;
       tkmes.NumberOfRecHitsPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecHitBin, RecHitMin, RecHitMax,"");
       tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Track #phi",1);
       tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Number of RecHits in each Track",2);
     }
     histname = "NumberOfRecHitsPerTrackVsEta_" + histTag;
     tkmes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitBin, RecHitMin, RecHitMax,"");
     tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
     tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of RecHits in each Track",2);
 
     histname = "NumberOfValidRecHitsPerTrackVsPhi_" + histTag;
     tkmes.NumberOfValidRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitMin, RecHitMax,"");
     tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
     tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Number of valid RecHits in each Track",2);
     
     histname = "NumberOfValidRecHitsPerTrackVsEta_" + histTag;
     tkmes.NumberOfValidRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitMin, RecHitMax,"");
     tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
     tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Number of valid RecHits in each Track",2);
     
     histname = "NumberOfValidRecHitsPerTrackVsPt_" + histTag;
     tkmes.NumberOfValidRecHitsPerTrackVsPt = ibooker.bookProfile(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax, RecHitMin, RecHitMax,"");
     tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
     tkmes.NumberOfValidRecHitsPerTrackVsPt->setAxisTitle("Number of valid RecHits in each Track",2);
     
     histname = "NumberOfLayersPerTrackVsPhi_" + histTag;
     tkmes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecLayBin, RecLayMin, RecLayMax,"");
     tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
     tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of Layers in each Track",2);
 
     if (doThetaPlots_) {
       histname = "NumberOfLayersPerTrackVsTheta_" + histTag;
       tkmes.NumberOfLayersPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecLayBin, RecLayMin, RecLayMax,"");
       tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Track #phi",1);
       tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Number of Layers in each Track",2);
     }
     histname = "NumberOfLayersPerTrackVsEta_" + histTag;
     tkmes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecLayBin, RecLayMin, RecLayMax,"");
     tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
     tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of Layers in each Track",2);
 
     if (doThetaPlots_) {
       histname = "Chi2oNDFVsTheta_" + histTag;
       tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
       tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
       tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
     }
     if (doAllPlots_) {
       histname = "Chi2oNDFVsPhi_" + histTag;
       tkmes.Chi2oNDFVsPhi   = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
       tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
       tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
       
       histname = "Chi2oNDFVsEta_" + histTag;
       tkmes.Chi2oNDFVsEta   = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
       tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
       tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
       
       histname = "Chi2ProbVsPhi_" + histTag;
       tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
       tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi"  ,1);
       tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
       
       histname = "Chi2ProbVsEta_" + histTag;
       tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
       tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta"  ,1);
       tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
     }
 
     // now put the MEs in the map
     TkParameterMEMap.insert( std::make_pair(sname, tkmes) );
 
 }

void TrackAnalyzer::bookHistosForTrackerSpecific ( DQMStore::IBooker & ibooker )

private

Definition at line 1802 of file TrackAnalyzer.cc.

Referenced by initHisto().

 {
 
     // parameters from the configuration
     std::string QualName     = conf_->getParameter<std::string>("Quality");
     std::string AlgoName     = conf_->getParameter<std::string>("AlgoName");
 
     // use the AlgoName and Quality Name 
     std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
 
     int    PhiBin     = conf_->getParameter<int>(   "PhiBin");
     double PhiMin     = conf_->getParameter<double>("PhiMin");
     double PhiMax     = conf_->getParameter<double>("PhiMax");
 
     int    EtaBin     = conf_->getParameter<int>(   "EtaBin");
     double EtaMin     = conf_->getParameter<double>("EtaMin");
     double EtaMax     = conf_->getParameter<double>("EtaMax");
 
     int    PtBin = conf_->getParameter<int>(   "TrackPtBin");
     double PtMin = conf_->getParameter<double>("TrackPtMin");
     double PtMax = conf_->getParameter<double>("TrackPtMax");
 
     // book hit property histograms
     // ---------------------------------------------------------------------------------//
     ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
 
 
 
     std::vector<std::string> subdetectors = conf_->getParameter<std::vector<std::string> >("subdetectors");
     int detBin = conf_->getParameter<int>("subdetectorBin");
 
     for ( auto det : subdetectors ) {
       
       // hits properties
       ibooker.setCurrentFolder(TopFolder_+"/HitProperties/"+det);
       
       TkRecHitsPerSubDetMEs recHitsPerSubDet_mes;
 
       recHitsPerSubDet_mes.detectorTag = det;
       int detID = -1;
       if ( det == "TIB" ) detID = StripSubdetector::TIB; // 3
       if ( det == "TOB" ) detID = StripSubdetector::TOB; // 5
       if ( det == "TID" ) detID = StripSubdetector::TID; // 4
       if ( det == "TEC" ) detID = StripSubdetector::TEC; // 6
       if ( det == "PixBarrel" ) detID = PixelSubdetector::PixelBarrel; // 1
       if ( det == "PixEndcap" ) detID = PixelSubdetector::PixelEndcap; // 2
       if ( det == "Pixel" ) detID = 0;
       if ( det == "Strip" ) detID = 7;
       
       recHitsPerSubDet_mes.detectorId  = detID;
 
       histname = "NumberOfRecHitsPerTrack_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of " + det + " valid RecHits in each Track",1);
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfRecHitsPerTrackVsPhi_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
 
       histname = "NumberOfRecHitsPerTrackVsEta_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
 
       histname = "NumberOfRecHitsPerTrackVsPt_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt = ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
       recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPt->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
 
       histname = "NumberOfLayersPerTrack_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfLayersPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
       recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of " + det + " valid Layers in each Track",1);
       recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of Tracks", 2);
 
       histname = "NumberOfLayersPerTrackVsPhi_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
 
       histname = "NumberOfLayersPerTrackVsEta_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
 
       histname = "NumberOfLayersPerTrackVsPt_" + det + "_" + CategoryName;
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt = ibooker.bookProfile(histname, histname, PtBin, PtMin, PtMax, detBin, -0.5, double(detBin)-0.5,"");
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Track p_{T} [GeV]",1);
       recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPt->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
 
       TkRecHitsPerSubDetMEMap.insert(std::pair<std::string,TkRecHitsPerSubDetMEs>(det,recHitsPerSubDet_mes));
 
       
     }
 
 
 }

void TrackAnalyzer::doReset ( )

Definition at line 1993 of file TrackAnalyzer.cc.

References Chi2oNDF_lumiFlag, NumberOfRecHitsPerTrack_lumiFlag, and HcalObjRepresent::Reset().

Referenced by TrackingMonitor::beginLuminosityBlock().

                             {
   TkParameterMEs tkmes;
   if ( Chi2oNDF_lumiFlag                ) Chi2oNDF_lumiFlag                -> Reset();
   if ( NumberOfRecHitsPerTrack_lumiFlag ) NumberOfRecHitsPerTrack_lumiFlag -> Reset();
 }

void TrackAnalyzer::doSoftReset ( DQMStore * dqmStore_ )

Definition at line 1985 of file TrackAnalyzer.cc.

References Chi2oNDF, and NumberOfRecHitsPerTrack.

                                                     {
   TkParameterMEs tkmes;
   dqmStore_->softReset(Chi2oNDF);
   dqmStore_->softReset(NumberOfRecHitsPerTrack);
 }

void TrackAnalyzer::fillHistosForEfficiencyFromHitPatter	(	const reco::Track &	track,
		const std::string	suffix,
		const float	monitoring
	)

private

Definition at line 1260 of file TrackAnalyzer.cc.

References python.rootplot.argparse::category, reco::TrackBase::dxy(), HcalObjRepresent::Fill(), reco::TrackBase::hitPattern(), hits_bad_, hits_inactive_, hits_missing_, hits_total_, hits_valid_, AnalysisDataFormats_SUSYBSMObjects::hp, mps_fire::i, LogDebug, LaserDQM_cfi::mon, monName, listBenchmarks::pattern, and reco::TrackBase::pt().

Referenced by analyze().

                                                                                                                                 {
 
     int mon = -1;
     for (int i=0; i<monQuantity::END; i++) {
       if (monName[i] == suffix) mon = i;
     }
 
     //    if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > 0) {
     if (track.pt() > 1.0 && track.dxy() < 0.1 and monitoring > -9.) {
       auto hp = track.hitPattern();
       // Here hit_category is meant to iterate over
       // reco::HitPattern::HitCategory, defined here:
       // http://cmslxr.fnal.gov/dxr/CMSSW/source/DataFormats/TrackReco/interface/HitPattern.h
       for (unsigned int category = 0; category < 3; ++category) {
         for (int hit = 0; hit < hp.numberOfHits((reco::HitPattern::HitCategory)(category)); ++hit) {
           auto pattern = hp.getHitPattern((reco::HitPattern::HitCategory)(category), hit);
           // Boolean bad is missing simply because it is inferred and the only missing case.
           bool valid = hp.validHitFilter(pattern);
           bool missing = hp.missingHitFilter(pattern);
           bool inactive = hp.inactiveHitFilter(pattern);
           int hit_type = -1;
           hit_type = valid ? 0 :
               ( missing ? 1 :
                 ( inactive ? 2 : 3));
           if (hits_valid_.find(Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)) == hits_valid_.end()) {
             LogDebug("TrackAnalyzer") << "Invalid combination of detector and subdetector: ("
                                       << hp.getSubStructure(pattern) << ", "
                                       << hp.getSubSubStructure(pattern) << ", "
                                       << mon
                       << "): ignoring it.\n";
             continue;
       }
           switch (hit_type) {
             case 0:
               hits_valid_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               break;
             case 1:
               hits_missing_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               hits_total_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               break;
             case 2:
               hits_inactive_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               break;
             case 3:
               hits_bad_[Key(hp.getSubStructure(pattern), hp.getSubSubStructure(pattern), mon)]->Fill(monitoring);
               break;
             default:
               LogDebug("TrackAnalyzer") << "Invalid hit category used " << hit_type << " ignored\n";
           }
         }
       }
     }
   
 }

void dqm::TrackAnalyzer::fillHistosForHitProperties	(	const edm::EventSetup &	iSetup,
		const reco::Track &	track,
		std::string	sname
	)

private

void dqm::TrackAnalyzer::fillHistosForLScertification	(	const edm::EventSetup &	iSetup,
		const reco::Track &	track,
		std::string	sname
	)

private

void TrackAnalyzer::fillHistosForState	(	const edm::EventSetup &	iSetup,
		const reco::Track &	track,
		std::string	sname
	)

private

Definition at line 1653 of file TrackAnalyzer.cc.

Referenced by analyze().

 {
     //get the kinematic parameters
     double p, px, py, pz, pt, theta, phi, eta, q;
     double pxerror, pyerror, pzerror, pterror, perror, phierror, etaerror;
 
     auto phiIn =  track.innerPosition().phi();
     auto etaIn =  track.innerPosition().eta();
     auto phiOut =  track.outerPosition().phi();
     auto etaOut =  track.outerPosition().eta();
 
 
     if (sname == "default") {
 
       p     = track.p();
       px    = track.px();
       py    = track.py();
       pz    = track.pz();
       pt    = track.pt();
       phi   = track.phi();
       theta = track.theta();
       eta   = track.eta();
       q     = track.charge();
       
       pterror  = (pt) ? track.ptError()/(pt*pt) : 0.0;
       pxerror  = -1.0;
       pyerror  = -1.0;
       pzerror  = -1.0;
       perror   = -1.0;
       phierror = track.phiError();
       etaerror = track.etaError();
       
     } else {
       
       edm::ESHandle<TransientTrackBuilder> theB;
       iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
       reco::TransientTrack TransTrack = theB->build(track);
       
       TrajectoryStateOnSurface TSOS;
 
       if      (sname == "OuterSurface")  TSOS = TransTrack.outermostMeasurementState();
       else if (sname == "InnerSurface")  TSOS = TransTrack.innermostMeasurementState();
       else if (sname == "ImpactPoint")   TSOS = TransTrack.impactPointState();
 
       p     = TSOS.globalMomentum().mag();
       px    = TSOS.globalMomentum().x();
       py    = TSOS.globalMomentum().y();
       pz    = TSOS.globalMomentum().z();
       pt    = TSOS.globalMomentum().perp();
       phi   = TSOS.globalMomentum().phi();
       theta = TSOS.globalMomentum().theta();
       eta   = TSOS.globalMomentum().eta();
       q     = TSOS.charge();
 
       //get the error of the kinimatic parameters
       AlgebraicSymMatrix66 errors = TSOS.cartesianError().matrix();
       double partialPterror = errors(3,3)*pow(TSOS.globalMomentum().x(),2) + errors(4,4)*pow(TSOS.globalMomentum().y(),2);
       pterror  = sqrt(partialPterror)/TSOS.globalMomentum().perp();
       pxerror  = sqrt(errors(3,3))/TSOS.globalMomentum().x();
       pyerror  = sqrt(errors(4,4))/TSOS.globalMomentum().y();
       pzerror  = sqrt(errors(5,5))/TSOS.globalMomentum().z();
       perror   = sqrt(partialPterror+errors(5,5)*pow(TSOS.globalMomentum().z(),2))/TSOS.globalMomentum().mag();
       phierror = sqrt(TSOS.curvilinearError().matrix()(2,2));
       etaerror = sqrt(TSOS.curvilinearError().matrix()(1,1))*fabs(sin(TSOS.globalMomentum().theta()));
 
     }
 
     std::map<std::string, TkParameterMEs>::iterator iPos = TkParameterMEMap.find(sname); 
     if (iPos != TkParameterMEMap.end()) {
 
       TkParameterMEs tkmes = iPos->second;
       
       // momentum
       tkmes.TrackP->Fill(p);
       if (doTrackPxPyPlots_) {
     tkmes.TrackPx->Fill(px);
     tkmes.TrackPy->Fill(py);
       }
       tkmes.TrackPz->Fill(pz);
       tkmes.TrackPt->Fill(pt);
       
       // angles
       tkmes.TrackPhi->Fill(phi);
       tkmes.TrackEta->Fill(eta);
       tkmes.TrackEtaPhi->Fill(eta,phi);
       tkmes.TrackEtaPhiInner->Fill(etaIn,phiIn);
       tkmes.TrackEtaPhiOuter->Fill(etaOut,phiOut);
 
       if (doThetaPlots_) {
     tkmes.TrackTheta->Fill(theta);
       }
       tkmes.TrackQ->Fill(q);
       
       // errors
       tkmes.TrackPtErr->Fill(pterror);
       tkmes.TrackPtErrVsEta->Fill(eta,pterror);
       if (doTrackPxPyPlots_) {
     tkmes.TrackPxErr->Fill(pxerror);
     tkmes.TrackPyErr->Fill(pyerror);
       }
       tkmes.TrackPzErr->Fill(pzerror);
       tkmes.TrackPErr->Fill(perror);
       tkmes.TrackPhiErr->Fill(phierror);
       tkmes.TrackEtaErr->Fill(etaerror);
       
       int nRecHits      = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
       int nValidRecHits = track.numberOfValidHits();
       // rec hits 
       tkmes.NumberOfRecHitsPerTrackVsPhi->Fill(phi,    nRecHits);
       if (doThetaPlots_) {
     tkmes.NumberOfRecHitsPerTrackVsTheta->Fill(theta,nRecHits);
       }
       tkmes.NumberOfRecHitsPerTrackVsEta->Fill(eta,    nRecHits);
       
       tkmes.NumberOfValidRecHitsPerTrackVsPhi->Fill(phi,    nValidRecHits);
       tkmes.NumberOfValidRecHitsPerTrackVsEta->Fill(eta,    nValidRecHits);
       tkmes.NumberOfValidRecHitsPerTrackVsPt ->Fill(pt,     nValidRecHits);
 
       int nLayers = track.hitPattern().trackerLayersWithMeasurement();
       // rec layers 
       tkmes.NumberOfLayersPerTrackVsPhi->Fill(phi,     nLayers);
       if (doThetaPlots_) {
     tkmes.NumberOfLayersPerTrackVsTheta->Fill(theta, nLayers);
       }
       tkmes.NumberOfLayersPerTrackVsEta->Fill(eta,     nLayers);
       
       double chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
       double chi2oNDF = track.normalizedChi2();
 
       tkmes.Chi2oNDFVsEta->Fill(eta, chi2oNDF);
       tkmes.Chi2oNDFVsPt->Fill(pt, chi2oNDF);
       tkmes.Chi2oNDFVsNHits->Fill(nRecHits, chi2oNDF);
 
       if(doAllPlots_) {
     
     // general properties
     if (doThetaPlots_) {
       tkmes.Chi2oNDFVsTheta->Fill(theta, chi2oNDF);
     }
     tkmes.Chi2oNDFVsPhi->Fill(phi, chi2oNDF);
     tkmes.Chi2ProbVsPhi->Fill(phi, chi2prob);
     tkmes.Chi2ProbVsEta->Fill(eta, chi2prob);
       }
       
     }
 
 }

void TrackAnalyzer::fillHistosForTrackerSpecific ( const reco::Track & track )

private

Definition at line 1902 of file TrackAnalyzer.cc.

Referenced by analyze().

 {
     
   double phi   = track.phi();
   double eta   = track.eta();
   double pt    = track.pt();
 
   for ( std::map<std::string,TkRecHitsPerSubDetMEs>::iterator it = TkRecHitsPerSubDetMEMap.begin();
        it != TkRecHitsPerSubDetMEMap.end(); it++ ) {
 
     int nValidLayers  = 0;
     int nValidRecHits = 0;
     int substr = it->second.detectorId;
     switch(substr) {
     case 0 :
       nValidLayers  = track.hitPattern().pixelBarrelLayersWithMeasurement() 
     + track.hitPattern().pixelEndcapLayersWithMeasurement();    // case 0: pixel
       nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits()
     + track.hitPattern().numberOfValidPixelEndcapHits();        // case 0: pixel
       break;
     case StripSubdetector::TIB :
       nValidLayers  = track.hitPattern().stripTIBLayersWithMeasurement();       // case 3: strip TIB
       nValidRecHits = track.hitPattern().numberOfValidStripTIBHits();           // case 3: strip TIB
       break;
     case StripSubdetector::TID :
       nValidLayers  = track.hitPattern().stripTIDLayersWithMeasurement();       // case 4: strip TID
       nValidRecHits = track.hitPattern().numberOfValidStripTIDHits();           // case 4: strip TID
       break;
     case StripSubdetector::TOB :
       nValidLayers  = track.hitPattern().stripTOBLayersWithMeasurement();       // case 5: strip TOB
       nValidRecHits = track.hitPattern().numberOfValidStripTOBHits();           // case 5: strip TOB
       break;
     case StripSubdetector::TEC :
       nValidLayers  = track.hitPattern().stripTECLayersWithMeasurement();       // case 6: strip TEC
       nValidRecHits = track.hitPattern().numberOfValidStripTECHits();           // case 6: strip TEC
       break;
     case PixelSubdetector::PixelBarrel :
       nValidLayers  = track.hitPattern().pixelBarrelLayersWithMeasurement();    // case 1: pixel PXB
       nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits();        // case 1: pixel PXB
       break;
     case PixelSubdetector::PixelEndcap :
       nValidLayers  = track.hitPattern().pixelEndcapLayersWithMeasurement();    // case 2: pixel PXF
       nValidRecHits = track.hitPattern().numberOfValidPixelEndcapHits();        // case 2: pixel PXF
       break;
     case 7 :
       nValidLayers  = track.hitPattern().stripTIBLayersWithMeasurement()       // case 7: strip
     + track.hitPattern().stripTIDLayersWithMeasurement()
     + track.hitPattern().stripTOBLayersWithMeasurement()
     + track.hitPattern().stripTECLayersWithMeasurement();
       nValidRecHits = track.hitPattern().numberOfValidStripTIBHits()           // case 7: strip
     + track.hitPattern().numberOfValidStripTIDHits()
     + track.hitPattern().numberOfValidStripTOBHits()
     + track.hitPattern().numberOfValidStripTECHits();
       break;
     default :
       break;
     }
 
     //Fill Layers and RecHits
     it->second.NumberOfRecHitsPerTrack      -> Fill(nValidRecHits); 
     it->second.NumberOfRecHitsPerTrackVsPhi -> Fill(phi,    nValidRecHits);
     it->second.NumberOfRecHitsPerTrackVsEta -> Fill(eta,    nValidRecHits);
     it->second.NumberOfRecHitsPerTrackVsPt  -> Fill(pt,     nValidRecHits);
     
     it->second.NumberOfLayersPerTrack      -> Fill(nValidLayers);
     it->second.NumberOfLayersPerTrackVsPhi -> Fill(phi,     nValidLayers);
     it->second.NumberOfLayersPerTrackVsEta -> Fill(eta,     nValidLayers);
     it->second.NumberOfLayersPerTrackVsPt  -> Fill(pt,      nValidLayers);
   }
 
 }

void TrackAnalyzer::initHisto	(	DQMStore::IBooker &	ibooker,
		const edm::EventSetup &	iSetup,
		const edm::ParameterSet &	iConfig
	)

Definition at line 166 of file TrackAnalyzer.cc.

References bookHistosForBeamSpot(), bookHistosForEfficiencyFromHitPatter(), bookHistosForHitProperties(), bookHistosForLScertification(), bookHistosForState(), bookHistosForTrackerSpecific(), conf_, doAllPlots_, doEffFromHitPatternVsBX_, doEffFromHitPatternVsLUMI_, doEffFromHitPatternVsPU_, doMeasurementStatePlots_, doTrackerSpecific_, and stateName_.

Referenced by TrackingMonitor::bookHistograms().

 {
   conf_ = &iConfig;
   bookHistosForHitProperties(ibooker);
   bookHistosForBeamSpot(ibooker);
   bookHistosForLScertification( ibooker);
   if (doEffFromHitPatternVsPU_   || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "");
   if (doEffFromHitPatternVsBX_   || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsBX");
   if (doEffFromHitPatternVsLUMI_ || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsSCALLUMI");
   //  if (doEffFromHitPatternVsLUMI_ || doAllPlots_) bookHistosForEfficiencyFromHitPatter(ibooker, iSetup, "VsPIXELLUMI");
 
   // book tracker specific related histograms
   // ---------------------------------------------------------------------------------//
   if(doTrackerSpecific_ || doAllPlots_) bookHistosForTrackerSpecific(ibooker);
     
   // book state related histograms
   // ---------------------------------------------------------------------------------//
   if (doMeasurementStatePlots_ || doAllPlots_) {
 
     
     if (stateName_ == "All") {
       bookHistosForState("OuterSurface", ibooker);
       bookHistosForState("InnerSurface", ibooker);
       bookHistosForState("ImpactPoint" , ibooker);
     } else if (
            stateName_ != "OuterSurface" && 
            stateName_ != "InnerSurface" && 
            stateName_ != "ImpactPoint" &&
            stateName_ != "default" 
            ) {
       bookHistosForState("default", ibooker);
 
     } else {
       bookHistosForState(stateName_, ibooker);
     }
     conf_ = nullptr;
   }
 }

void TrackAnalyzer::initHistos ( )

private

Definition at line 86 of file TrackAnalyzer.cc.

Referenced by TrackAnalyzer().

 {
   Chi2 = nullptr;
   Chi2Prob = nullptr;
   Chi2ProbVsPhi = nullptr;
   Chi2ProbVsEta = nullptr;
   Chi2oNDF = nullptr;
   Chi2oNDFVsEta = nullptr;
   Chi2oNDFVsPhi = nullptr;
   Chi2oNDFVsTheta = nullptr;
         
   NumberOfRecHitsPerTrack = nullptr;
   NumberOfValidRecHitsPerTrack = nullptr;
   NumberOfLostRecHitsPerTrack = nullptr;
 
   NumberOfRecHitsPerTrackVsPhi = nullptr;
   NumberOfRecHitsPerTrackVsTheta = nullptr;
   NumberOfRecHitsPerTrackVsEta = nullptr;
 
   NumberOfRecHitVsPhiVsEtaPerTrack = nullptr;
 
   NumberOfValidRecHitsPerTrackVsPhi = nullptr;
   NumberOfValidRecHitsPerTrackVsEta = nullptr;
 
   DistanceOfClosestApproach = nullptr;
   DistanceOfClosestApproachToBS = nullptr;
   AbsDistanceOfClosestApproachToBS = nullptr;
   DistanceOfClosestApproachToPV = nullptr;
   DeltaZToPV = nullptr;
   DistanceOfClosestApproachVsTheta = nullptr;
   DistanceOfClosestApproachVsPhi = nullptr;  
   DistanceOfClosestApproachToBSVsPhi = nullptr;
   DistanceOfClosestApproachToPVVsPhi = nullptr;
   DistanceOfClosestApproachVsEta = nullptr;
   xPointOfClosestApproach = nullptr;
   xPointOfClosestApproachVsZ0wrt000 = nullptr;
   xPointOfClosestApproachVsZ0wrtBS = nullptr;
   yPointOfClosestApproach = nullptr;
   yPointOfClosestApproachVsZ0wrt000 = nullptr;
   yPointOfClosestApproachVsZ0wrtBS = nullptr;
   zPointOfClosestApproach = nullptr;
   zPointOfClosestApproachVsPhi = nullptr;
   algorithm = nullptr;
   oriAlgo = nullptr;
   stoppingSource = nullptr;
   stoppingSourceVSeta = nullptr;
   stoppingSourceVSphi = nullptr;
     // TESTING
   TESTDistanceOfClosestApproachToBS = nullptr;
   TESTDistanceOfClosestApproachToBSVsPhi = nullptr;
 
 // by Mia in order to deal w/ LS transitions
   Chi2oNDF_lumiFlag = nullptr;
   NumberOfRecHitsPerTrack_lumiFlag = nullptr;
 
   //special Plots for HI DQM  //SHOULD I ADD THE BOOL HERE??                                                                                                                                               
   LongDCASig = nullptr;
   TransDCASig = nullptr;
   dNdPhi_HighPurity = nullptr;
   dNdEta_HighPurity = nullptr;
   dNdPt_HighPurity = nullptr;
   NhitVsEta_HighPurity = nullptr;
   NhitVsPhi_HighPurity = nullptr;
 
   // IP significance
   sipDxyToBS = nullptr;
   sipDzToBS = nullptr;
   sip3dToPV = nullptr;
   sip2dToPV = nullptr;
   sipDxyToPV = nullptr;
   sipDzToPV = nullptr;
 
 }

void TrackAnalyzer::setBX ( const edm::Event & iEvent )

Definition at line 973 of file TrackAnalyzer.cc.

References edm::EventBase::bunchCrossing(), and bx_.

Referenced by TrackingMonitor::analyze().

                                                  {
   bx_ = iEvent.bunchCrossing();
 }

void TrackAnalyzer::setLumi	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

Definition at line 978 of file TrackAnalyzer.cc.

References edmNew::DetSetVector< T >::begin(), GetLumi::CM2_TO_NANOBARN, edmNew::DetSetVector< T >::end(), edm::EventSetup::get(), edm::Event::getByToken(), edm::HandleBase::isValid(), TrackerTopology::layer(), lumi_factor_per_bx_, lumiscalersToken_, minNumberOfPixelsPerCluster_, minPixelClusterCharge_, pixel_lumi_, PixelSubdetector::PixelBarrel, HiRegitMuonDetachedTripletStep_cff::pixelClusters, pixelClustersToken_, edm::ESHandle< T >::product(), scal_lumi_, edmNew::DetSet< T >::size(), and DetId::subdetId().

Referenced by TrackingMonitor::analyze().

                                                                                 {
   // as done by pixelLumi http://cmslxr.fnal.gov/source/DQM/PixelLumi/plugins/PixelLumiDQM.cc
 
   edm::Handle<LumiScalersCollection> lumiScalers;
   iEvent.getByToken(lumiscalersToken_, lumiScalers);
   if ( lumiScalers.isValid() && lumiScalers->size() ) {
     LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
     scal_lumi_ = scalit->instantLumi();
   } else 
     scal_lumi_ = -1;
 
   edm::Handle< edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
   iEvent.getByToken(pixelClustersToken_, pixelClusters);
   if ( pixelClusters.isValid() ) {
 
     edm::ESHandle<TrackerTopology> tTopoHandle;
     iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
     const TrackerTopology* const tTopo = tTopoHandle.product();
 
     // Count the number of clusters with at least a minimum
     // number of pixels per cluster and at least a minimum charge.
     size_t numClusters = 0;
     size_t tot = 0;
 
     edmNew::DetSetVector<SiPixelCluster>::const_iterator  pixCluDet = pixelClusters->begin();
     for ( ; pixCluDet!=pixelClusters->end(); ++pixCluDet) {
     
       DetId detid = pixCluDet->detId();
       size_t subdetid = detid.subdetId();
       //      std::cout << tTopo->print(detid) << std::endl;
       if ( subdetid == (int) PixelSubdetector::PixelBarrel ) 
     if ( tTopo->layer(detid)==1 ) 
       continue;
       
       edmNew::DetSet<SiPixelCluster>::const_iterator  pixClu = pixCluDet->begin();    
       for ( ; pixClu != pixCluDet->end(); ++pixClu ) {
     ++tot;
     if ( (pixClu->size()   >= minNumberOfPixelsPerCluster_) &&
          (pixClu->charge() >= minPixelClusterCharge_      ) ) {
       ++numClusters;
     }
       }
     }
     pixel_lumi_ = lumi_factor_per_bx_ * numClusters / GetLumi::CM2_TO_NANOBARN ; // ?!?!
   } else
     pixel_lumi_ = -1.;
 
 }

void TrackAnalyzer::setLumiFlag ( )

Definition at line 1976 of file TrackAnalyzer.cc.

References Chi2oNDF_lumiFlag, and NumberOfRecHitsPerTrack_lumiFlag.

Referenced by TrackingMonitor::bookHistograms().

                                 { 
 
   TkParameterMEs tkmes;
   if ( Chi2oNDF_lumiFlag                ) Chi2oNDF_lumiFlag                -> setLumiFlag();
   if ( NumberOfRecHitsPerTrack_lumiFlag ) NumberOfRecHitsPerTrack_lumiFlag -> setLumiFlag();
 }

void TrackAnalyzer::setNumberOfGoodVertices ( const edm::Event & iEvent )

Definition at line 960 of file TrackAnalyzer.cc.

References edm::Event::getByToken(), good_vertices_, edm::HandleBase::isValid(), pvNDOF_, pvToken_, and findQualityFiles::v.

Referenced by TrackingMonitor::analyze().

                                                                    {
 
   good_vertices_ = 0;
   
   edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle;
   iEvent.getByToken(pvToken_, recoPrimaryVerticesHandle);
   if (recoPrimaryVerticesHandle.isValid())
     if (recoPrimaryVerticesHandle->size() > 0)
       for (auto v : *recoPrimaryVerticesHandle)
         if (v.ndof() >= pvNDOF_ && !v.isFake())
           ++good_vertices_;
 }

void TrackAnalyzer::undoSoftReset ( DQMStore * dqmStore_ )

Definition at line 2001 of file TrackAnalyzer.cc.

References Chi2oNDF, and NumberOfRecHitsPerTrack.

                                                       {
   TkParameterMEs tkmes;
   dqmStore_->disableSoftReset(Chi2oNDF);
   dqmStore_->disableSoftReset(NumberOfRecHitsPerTrack);
 }

Member Data Documentation

MonitorElement* dqm::TrackAnalyzer::AbsDistanceOfClosestApproachToBS

private

Definition at line 357 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::algorithm

private

Definition at line 378 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

edm::EDGetTokenT<reco::BeamSpot> dqm::TrackAnalyzer::beamSpotToken_

private

Definition at line 77 of file TrackAnalyzer.h.

Referenced by analyze(), and TrackAnalyzer().

unsigned int dqm::TrackAnalyzer::bx_

private

Definition at line 453 of file TrackAnalyzer.h.

Referenced by analyze(), and setBX().

MonitorElement* dqm::TrackAnalyzer::Chi2

private

Definition at line 341 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::Chi2oNDF

private

Definition at line 343 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), doSoftReset(), initHistos(), and undoSoftReset().

MonitorElement* dqm::TrackAnalyzer::Chi2oNDF_lumiFlag

private

Definition at line 387 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForLScertification(), doReset(), initHistos(), and setLumiFlag().

MonitorElement* dqm::TrackAnalyzer::Chi2oNDFVsEta = 0

private

Definition at line 347 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2oNDFVsNHits = 0

private

Definition at line 345 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::Chi2oNDFVsPhi

private

Definition at line 348 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2oNDFVsPt = 0

private

Definition at line 346 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::Chi2oNDFVsTheta

private

Definition at line 349 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2Prob

private

Definition at line 342 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2ProbVsEta

private

Definition at line 351 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2ProbVsPhi

private

Definition at line 352 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::Chi2ProbVsTheta

private

Definition at line 353 of file TrackAnalyzer.h.

edm::ParameterSet const* dqm::TrackAnalyzer::conf_

private

Definition at line 83 of file TrackAnalyzer.h.

Referenced by bookHistosForBeamSpot(), bookHistosForEfficiencyFromHitPatter(), bookHistosForHitProperties(), bookHistosForLScertification(), bookHistosForState(), bookHistosForTrackerSpecific(), and initHisto().

MonitorElement* dqm::TrackAnalyzer::DeltaZToPV

private

Definition at line 359 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproach

private

Definition at line 355 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachToBS

private

Definition at line 356 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi

private

Definition at line 362 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachToPV

private

Definition at line 358 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachToPVVsPhi

private

Definition at line 363 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachVsEta

private

Definition at line 364 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachVsPhi

private

Definition at line 361 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::DistanceOfClosestApproachVsTheta

private

Definition at line 360 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::dNdEta_HighPurity

private

Definition at line 394 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::dNdPhi_HighPurity

private

Definition at line 393 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::dNdPt_HighPurity

private

Definition at line 395 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::dNhitdPt_HighPurity

private

Definition at line 399 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doAllPlots_

private

Definition at line 88 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), bookHistosForHitProperties(), bookHistosForState(), fillHistosForState(), and initHisto().

bool dqm::TrackAnalyzer::doBSPlots_

private

Definition at line 89 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool dqm::TrackAnalyzer::doDCAPlots_

private

Definition at line 91 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doDCAwrt000Plots_

private

Definition at line 111 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool dqm::TrackAnalyzer::doDCAwrtPVPlots_

private

Definition at line 110 of file TrackAnalyzer.h.

bool dqm::TrackAnalyzer::doEffFromHitPatternVsBX_

private

Definition at line 127 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool dqm::TrackAnalyzer::doEffFromHitPatternVsLUMI_

private

Definition at line 128 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool dqm::TrackAnalyzer::doEffFromHitPatternVsPU_

private

Definition at line 126 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool dqm::TrackAnalyzer::doGeneralPropertiesPlots_

private

Definition at line 92 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doHIPlots_

private

Definition at line 119 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doHitPropertiesPlots_

private

Definition at line 94 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doLayersVsPhiVsEtaPerTrack_

private

Definition at line 98 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doLumiAnalysis_

private

Definition at line 113 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForLScertification().

bool dqm::TrackAnalyzer::doMeasurementStatePlots_

private

Definition at line 93 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool dqm::TrackAnalyzer::doPVPlots_

private

Definition at line 90 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doRecHitsPerTrackProfile_

private

Definition at line 103 of file TrackAnalyzer.h.

bool dqm::TrackAnalyzer::doRecHitVsPhiVsEtaPerTrack_

private

Definition at line 95 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doRecHitVsPtVsEtaPerTrack_

private

Definition at line 96 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doSIPPlots_

private

Definition at line 122 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and bookHistosForHitProperties().

bool dqm::TrackAnalyzer::doTestPlots_

private

Definition at line 116 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool dqm::TrackAnalyzer::doThetaPlots_

private

Definition at line 106 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), bookHistosForState(), and fillHistosForState().

bool dqm::TrackAnalyzer::doTrack2DChi2Plots_

private

Definition at line 102 of file TrackAnalyzer.h.

bool dqm::TrackAnalyzer::doTrackerSpecific_

private

Definition at line 87 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool dqm::TrackAnalyzer::doTrackLayersVsPhiVsEtaPerTrack_

private

Definition at line 101 of file TrackAnalyzer.h.

bool dqm::TrackAnalyzer::doTrackPxPyPlots_

private

Definition at line 107 of file TrackAnalyzer.h.

Referenced by bookHistosForState(), and fillHistosForState().

bool dqm::TrackAnalyzer::doTrackRecHitVsPhiVsEtaPerTrack_

private

Definition at line 99 of file TrackAnalyzer.h.

bool dqm::TrackAnalyzer::doTrackRecHitVsPtVsEtaPerTrack_

private

Definition at line 100 of file TrackAnalyzer.h.

unsigned int dqm::TrackAnalyzer::good_vertices_

private

Definition at line 452 of file TrackAnalyzer.h.

Referenced by analyze(), and setNumberOfGoodVertices().

std::string dqm::TrackAnalyzer::histname

private

Definition at line 465 of file TrackAnalyzer.h.

Referenced by bookHistosForBeamSpot(), bookHistosForHitProperties(), bookHistosForLScertification(), bookHistosForState(), and bookHistosForTrackerSpecific().

std::unordered_map<Key, MonitorElement *, KeyHasher> dqm::TrackAnalyzer::hits_bad_

private

Definition at line 450 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

std::unordered_map<Key, MonitorElement *, KeyHasher> dqm::TrackAnalyzer::hits_inactive_

private

Definition at line 449 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

std::unordered_map<Key, MonitorElement *, KeyHasher> dqm::TrackAnalyzer::hits_missing_

private

Definition at line 448 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

std::unordered_map<Key, MonitorElement *, KeyHasher> dqm::TrackAnalyzer::hits_total_

private

Definition at line 451 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

std::unordered_map<Key, MonitorElement *, KeyHasher> dqm::TrackAnalyzer::hits_valid_

private

Definition at line 447 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

MonitorElement* dqm::TrackAnalyzer::LongDCASig

private

Definition at line 391 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

float dqm::TrackAnalyzer::lumi_factor_per_bx_

private

Definition at line 81 of file TrackAnalyzer.h.

Referenced by setLumi(), and TrackAnalyzer().

edm::EDGetTokenT<LumiScalersCollection> dqm::TrackAnalyzer::lumiscalersToken_

private

Definition at line 80 of file TrackAnalyzer.h.

Referenced by setLumi(), and TrackAnalyzer().

int dqm::TrackAnalyzer::minNumberOfPixelsPerCluster_

private

Definition at line 131 of file TrackAnalyzer.h.

Referenced by setLumi().

float dqm::TrackAnalyzer::minPixelClusterCharge_

private

Definition at line 132 of file TrackAnalyzer.h.

Referenced by setLumi().

std::string dqm::TrackAnalyzer::monName[monQuantity::END] = { "", "VsBX", "VsPIXELLUMI", "VsSCALLUMI" }

private

Definition at line 463 of file TrackAnalyzer.h.

Referenced by bookHistosForEfficiencyFromHitPatter(), and fillHistosForEfficiencyFromHitPatter().

MonitorElement* dqm::TrackAnalyzer::NhitVsEta_HighPurity

private

Definition at line 396 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::NhitVsPhi_HighPurity

private

Definition at line 397 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfLayersPerTrack[4] = { 0 , 0 , 0 , 0 }

private

Definition at line 332 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfLayersPerTrackVsEta

private

Definition at line 336 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLayersPerTrackVsPhi

private

Definition at line 334 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLayersPerTrackVsTheta

private

Definition at line 335 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack[4] = { 0 , 0 , 0 , 0 }

private

Definition at line 338 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitsPerTrack

private

Definition at line 290 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitsPerTrackVsEta = 0

private

Definition at line 309 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitsPerTrackVsPhi = 0

private

Definition at line 307 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitsPerTrackVsPt = 0

private

Definition at line 310 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitsPerTrackVsTheta = 0

private

Definition at line 308 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitVsPhiVsEtaPerTrack = 0

private

Definition at line 311 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfLostRecHitVsPtVsEtaPerTrack = 0

private

Definition at line 312 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitsPerTrack = 0

private

Definition at line 291 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitsPerTrackVsEta = 0

private

Definition at line 316 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitsPerTrackVsPhi = 0

private

Definition at line 314 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitsPerTrackVsPt = 0

private

Definition at line 317 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitsPerTrackVsTheta = 0

private

Definition at line 315 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitVsPhiVsEtaPerTrack = 0

private

Definition at line 318 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMIRecHitVsPtVsEtaPerTrack = 0

private

Definition at line 319 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitsPerTrack = 0

private

Definition at line 292 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitsPerTrackVsEta = 0

private

Definition at line 323 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitsPerTrackVsPhi = 0

private

Definition at line 321 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitsPerTrackVsPt = 0

private

Definition at line 324 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitsPerTrackVsTheta = 0

private

Definition at line 322 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitVsPhiVsEtaPerTrack = 0

private

Definition at line 325 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfMORecHitVsPtVsEtaPerTrack = 0

private

Definition at line 326 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitsPerTrack

private

Definition at line 288 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), doSoftReset(), initHistos(), and undoSoftReset().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag

private

Definition at line 388 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForLScertification(), doReset(), initHistos(), and setLumiFlag().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsEta = 0

private

Definition at line 297 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsPhi = 0

private

Definition at line 295 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitsPerTrackVsTheta = 0

private

Definition at line 296 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack = 0

private

Definition at line 298 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitsPerTrack

private

Definition at line 289 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsEta = 0

private

Definition at line 302 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPhi = 0

private

Definition at line 300 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPt = 0

private

Definition at line 303 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitsPerTrackVsTheta = 0

private

Definition at line 301 of file TrackAnalyzer.h.

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitVsPhiVsEtaPerTrack = 0

private

Definition at line 304 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::NumberOfValidRecHitVsPtVsEtaPerTrack = 0

private

Definition at line 305 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement * dqm::TrackAnalyzer::oriAlgo

private

Definition at line 378 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

float dqm::TrackAnalyzer::pixel_lumi_

private

Definition at line 454 of file TrackAnalyzer.h.

Referenced by setLumi().

edm::EDGetTokenT<edmNew::DetSetVector<SiPixelCluster> > dqm::TrackAnalyzer::pixelClustersToken_

private

Definition at line 79 of file TrackAnalyzer.h.

Referenced by setLumi(), and TrackAnalyzer().

MonitorElement* dqm::TrackAnalyzer::Ptdist_HighPurity

private

Definition at line 398 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

int dqm::TrackAnalyzer::pvNDOF_

private

Definition at line 129 of file TrackAnalyzer.h.

Referenced by setNumberOfGoodVertices().

edm::EDGetTokenT<reco::VertexCollection> dqm::TrackAnalyzer::pvToken_

private

Definition at line 78 of file TrackAnalyzer.h.

Referenced by analyze(), setNumberOfGoodVertices(), and TrackAnalyzer().

std::string dqm::TrackAnalyzer::qualityString_

private

Definition at line 133 of file TrackAnalyzer.h.

Referenced by analyze().

float dqm::TrackAnalyzer::scal_lumi_

private

Definition at line 455 of file TrackAnalyzer.h.

Referenced by analyze(), and setLumi().

MonitorElement* dqm::TrackAnalyzer::sip2dToPV

private

Definition at line 405 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::sip3dToPV

private

Definition at line 404 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::sipDxyToBS

private

Definition at line 402 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::sipDxyToPV

private

Definition at line 406 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::sipDzToBS

private

Definition at line 403 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::sipDzToPV

private

Definition at line 407 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

std::string dqm::TrackAnalyzer::stateName_

private

Definition at line 85 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

MonitorElement* dqm::TrackAnalyzer::stoppingSource

private

Definition at line 379 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::stoppingSourceVSeta

private

Definition at line 380 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::stoppingSourceVSphi

private

Definition at line 381 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::TESTDistanceOfClosestApproachToBS

private

Definition at line 383 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi

private

Definition at line 384 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

std::map<std::string, TkParameterMEs> dqm::TrackAnalyzer::TkParameterMEMap

private

Definition at line 285 of file TrackAnalyzer.h.

Referenced by bookHistosForState(), and fillHistosForState().

std::map<std::string, TkRecHitsPerSubDetMEs> dqm::TrackAnalyzer::TkRecHitsPerSubDetMEMap

private

Definition at line 423 of file TrackAnalyzer.h.

Referenced by bookHistosForTrackerSpecific(), and fillHistosForTrackerSpecific().

std::string dqm::TrackAnalyzer::TopFolder_

private

Definition at line 75 of file TrackAnalyzer.h.

Referenced by bookHistosForBeamSpot(), bookHistosForEfficiencyFromHitPatter(), bookHistosForHitProperties(), bookHistosForLScertification(), bookHistosForState(), bookHistosForTrackerSpecific(), and TrackAnalyzer().

MonitorElement* dqm::TrackAnalyzer::TransDCASig

private

Definition at line 392 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

bool dqm::TrackAnalyzer::useBPixLayer1_

private

Definition at line 130 of file TrackAnalyzer.h.

Referenced by TrackAnalyzer().

MonitorElement* dqm::TrackAnalyzer::ValidFractionPerTrack = 0

private

Definition at line 328 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::ValidFractionVsPhiVsEtaPerTrack = 0

private

Definition at line 329 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::xPointOfClosestApproach

private

Definition at line 365 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::xPointOfClosestApproachToPV

private

Definition at line 366 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000

private

Definition at line 367 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS

private

Definition at line 368 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::xPointOfClosestApproachVsZ0wrtPV

private

Definition at line 369 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* dqm::TrackAnalyzer::yPointOfClosestApproach

private

Definition at line 370 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::yPointOfClosestApproachToPV

private

Definition at line 371 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000

private

Definition at line 372 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS

private

Definition at line 373 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::yPointOfClosestApproachVsZ0wrtPV

private

Definition at line 374 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* dqm::TrackAnalyzer::zPointOfClosestApproach

private

Definition at line 375 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForHitProperties(), and initHistos().

MonitorElement* dqm::TrackAnalyzer::zPointOfClosestApproachToPV

private

Definition at line 376 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

MonitorElement* dqm::TrackAnalyzer::zPointOfClosestApproachVsPhi

private

Definition at line 377 of file TrackAnalyzer.h.

Referenced by analyze(), bookHistosForBeamSpot(), and initHistos().

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation