CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
TrackAnalyzer Class Reference

#include <TrackAnalyzer.h>

Classes

struct  TkParameterMEs
 
struct  TkRecHitsPerSubDetMEs
 

Public Member Functions

virtual void analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
 
void doReset ()
 
void doSoftReset (DQMStore *dqmStore_)
 
virtual void initHisto (DQMStore::IBooker &ibooker)
 
void setLumiFlag ()
 
 TrackAnalyzer (const edm::ParameterSet &)
 
 TrackAnalyzer (const edm::ParameterSet &, edm::ConsumesCollector &iC)
 
void undoSoftReset (DQMStore *dqmStore_)
 
virtual ~TrackAnalyzer ()
 

Private Member Functions

void bookHistosForBeamSpot (DQMStore::IBooker &ibooker)
 
void bookHistosForHitProperties (DQMStore::IBooker &ibooker)
 
void bookHistosForLScertification (DQMStore::IBooker &ibooker)
 
void bookHistosForState (std::string sname, DQMStore::IBooker &ibooker)
 
void bookHistosForTrackerSpecific (DQMStore::IBooker &ibooker)
 
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 * algorithm
 
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
 
MonitorElement * Chi2
 
MonitorElement * Chi2oNDF
 
MonitorElement * Chi2oNDF_lumiFlag
 
MonitorElement * Chi2oNDFVsEta
 
MonitorElement * Chi2oNDFVsPhi
 
MonitorElement * Chi2oNDFVsTheta
 
MonitorElement * Chi2Prob
 
MonitorElement * Chi2ProbVsEta
 
MonitorElement * Chi2ProbVsPhi
 
MonitorElement * Chi2ProbVsTheta
 
edm::ParameterSet conf_
 
MonitorElement * DistanceOfClosestApproach
 
MonitorElement * DistanceOfClosestApproachToBS
 
MonitorElement * DistanceOfClosestApproachToBSVsPhi
 
MonitorElement * DistanceOfClosestApproachToPV
 
MonitorElement * DistanceOfClosestApproachToPVVsPhi
 
MonitorElement * DistanceOfClosestApproachVsEta
 
MonitorElement * DistanceOfClosestApproachVsPhi
 
MonitorElement * DistanceOfClosestApproachVsTheta
 
bool doAllPlots_
 
bool doBSPlots_
 
bool doDCAPlots_
 
bool doDCAwrt000Plots_
 
bool doDCAwrtPVPlots_
 
bool doGeneralPropertiesPlots_
 
bool doHIPlots_
 
bool doHitPropertiesPlots_
 
bool doLayersVsPhiVsEtaPerTrack_
 
bool doLumiAnalysis_
 
bool doMeasurementStatePlots_
 
bool doPVPlots_
 
bool doRecHitsPerTrackProfile_
 
bool doRecHitVsPhiVsEtaPerTrack_
 
bool doTestPlots_
 
bool doThetaPlots_
 
bool doTrack2DChi2Plots_
 
bool doTrackerSpecific_
 
bool doTrackLayersVsPhiVsEtaPerTrack_
 
bool doTrackPxPyPlots_
 
bool doTrackRecHitVsPhiVsEtaPerTrack_
 
std::string histname
 
MonitorElement * LongDCASig
 
MonitorElement * NumberOfLayersPerTrack
 
MonitorElement * NumberOfLayersPerTrackVsEta
 
MonitorElement * NumberOfLayersPerTrackVsPhi
 
MonitorElement * NumberOfLayersPerTrackVsTheta
 
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack
 
MonitorElement * NumberOfLostRecHitsPerTrack
 
MonitorElement * NumberOfRecHitsPerTrack
 
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
 
MonitorElement * NumberOfRecHitsPerTrackVsEta
 
MonitorElement * NumberOfRecHitsPerTrackVsPhi
 
MonitorElement * NumberOfRecHitsPerTrackVsTheta
 
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
 
MonitorElement * NumberOfValidRecHitsPerTrack
 
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
 
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
 
MonitorElement * NumberOfValidRecHitsPerTrackVsTheta
 
MonitorElement * NumberOfValidRecHitVsPhiVsEtaPerTrack
 
edm::EDGetTokenT
< reco::VertexCollection > 		pvToken_
 
MonitorElement * TESTDistanceOfClosestApproachToBS
 
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
 
std::map< std::string,
TkParameterMEs > 		TkParameterMEMap
 
std::map< std::string,
TkRecHitsPerSubDetMEs > 		TkRecHitsPerSubDetMEMap
 
std::string TopFolder_
 
MonitorElement * TransDCASig
 
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 31 of file TrackAnalyzer.h.

Constructor & Destructor Documentation

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

Definition at line 21 of file TrackAnalyzer.cc.

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

22  : conf_( iConfig )
23  , doTrackerSpecific_ ( conf_.getParameter<bool>("doTrackerSpecific") )
24  , doAllPlots_ ( conf_.getParameter<bool>("doAllPlots") )
25  , doBSPlots_ ( conf_.getParameter<bool>("doBeamSpotPlots") )
26  , doPVPlots_ ( conf_.getParameter<bool>("doPrimaryVertexPlots") )
27  , doDCAPlots_ ( conf_.getParameter<bool>("doDCAPlots") )
28  , doGeneralPropertiesPlots_ ( conf_.getParameter<bool>("doGeneralPropertiesPlots") )
29  , doMeasurementStatePlots_ ( conf_.getParameter<bool>("doMeasurementStatePlots") )
30  , doHitPropertiesPlots_ ( conf_.getParameter<bool>("doHitPropertiesPlots") )
31  , doRecHitVsPhiVsEtaPerTrack_ ( conf_.getParameter<bool>("doRecHitVsPhiVsEtaPerTrack") )
32  , doLayersVsPhiVsEtaPerTrack_ ( conf_.getParameter<bool>("doLayersVsPhiVsEtaPerTrack") )
33  , doRecHitsPerTrackProfile_ ( conf_.getParameter<bool>("doRecHitsPerTrackProfile") )
34  , doThetaPlots_ ( conf_.getParameter<bool>("doThetaPlots") )
35  , doTrackPxPyPlots_ ( conf_.getParameter<bool>("doTrackPxPyPlots") )
36  , doDCAwrtPVPlots_ ( conf_.getParameter<bool>("doDCAwrtPVPlots") )
37  , doDCAwrt000Plots_ ( conf_.getParameter<bool>("doDCAwrt000Plots") )
38  , doLumiAnalysis_ ( conf_.getParameter<bool>("doLumiAnalysis") )
39  , doTestPlots_ ( conf_.getParameter<bool>("doTestPlots") )
40  , doHIPlots_ ( conf_.getParameter<bool>("doHIPlots") )
41 {
42  initHistos();
43  TopFolder_ = conf_.getParameter<std::string>("FolderName");
44 
45 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackAnalyzer.h:66
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackAnalyzer.h:71
TrackAnalyzer::doHitPropertiesPlots_
bool doHitPropertiesPlots_
Definition: TrackAnalyzer.h:73
TrackAnalyzer::doRecHitVsPhiVsEtaPerTrack_
bool doRecHitVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:74
TrackAnalyzer::doMeasurementStatePlots_
bool doMeasurementStatePlots_
Definition: TrackAnalyzer.h:72
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::doDCAwrt000Plots_
bool doDCAwrt000Plots_
Definition: TrackAnalyzer.h:88
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
TrackAnalyzer::doLumiAnalysis_
bool doLumiAnalysis_
Definition: TrackAnalyzer.h:90
TrackAnalyzer::doDCAwrtPVPlots_
bool doDCAwrtPVPlots_
Definition: TrackAnalyzer.h:87
TrackAnalyzer::doTrackPxPyPlots_
bool doTrackPxPyPlots_
Definition: TrackAnalyzer.h:84
TrackAnalyzer::doLayersVsPhiVsEtaPerTrack_
bool doLayersVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:76
TrackAnalyzer::doRecHitsPerTrackProfile_
bool doRecHitsPerTrackProfile_
Definition: TrackAnalyzer.h:80
TrackAnalyzer::TrackAnalyzer ( const edm::ParameterSet &  iConfig,
edm::ConsumesCollector &  iC 
)

Definition at line 47 of file TrackAnalyzer.cc.

References beamSpotToken_, conf_, edm::ConsumesCollector::consumes(), edm::ParameterSet::getParameter(), and pvToken_.

48  : TrackAnalyzer(iConfig)
49 {
50  edm::InputTag bsSrc = conf_.getParameter<edm::InputTag>("beamSpot");
51  edm::InputTag primaryVertexInputTag = conf_.getParameter<edm::InputTag>("primaryVertex");
52  beamSpotToken_ = iC.consumes<reco::BeamSpot>(bsSrc);
53  pvToken_ = iC.consumes<reco::VertexCollection>(primaryVertexInputTag);
54 }
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:41
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
TrackAnalyzer::beamSpotToken_
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
Definition: TrackAnalyzer.h:61
TrackAnalyzer::TrackAnalyzer
TrackAnalyzer(const edm::ParameterSet &)
Definition: TrackAnalyzer.cc:21
TrackAnalyzer::pvToken_
edm::EDGetTokenT< reco::VertexCollection > pvToken_
Definition: TrackAnalyzer.h:62
TrackAnalyzer::~TrackAnalyzer ( )
virtual

Definition at line 119 of file TrackAnalyzer.cc.

120 {
121 }

Member Function Documentation

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

Definition at line 602 of file TrackAnalyzer.cc.

References reco::TrackBase::algo(), algorithm, beamSpotToken_, reco::TrackBase::chi2(), Chi2oNDF, Chi2oNDF_lumiFlag, Chi2Prob, conf_, reco::TrackBase::d0(), reco::TrackBase::d0Error(), DistanceOfClosestApproach, DistanceOfClosestApproachToBS, DistanceOfClosestApproachToBSVsPhi, DistanceOfClosestApproachToPV, DistanceOfClosestApproachToPVVsPhi, DistanceOfClosestApproachVsEta, DistanceOfClosestApproachVsPhi, DistanceOfClosestApproachVsTheta, doAllPlots_, doBSPlots_, doDCAPlots_, doDCAwrt000Plots_, doGeneralPropertiesPlots_, doHIPlots_, doHitPropertiesPlots_, doLayersVsPhiVsEtaPerTrack_, doLumiAnalysis_, doMeasurementStatePlots_, doPVPlots_, doRecHitVsPhiVsEtaPerTrack_, doTestPlots_, doThetaPlots_, doTrackerSpecific_, reco::TrackBase::dxy(), reco::TrackBase::dz(), reco::TrackBase::dzError(), eta(), reco::TrackBase::eta(), MonitorElement::Fill(), HcalObjRepresent::Fill(), fillHistosForState(), fillHistosForTrackerSpecific(), edm::Event::getByToken(), edm::ParameterSet::getParameter(), reco::TrackBase::hitPattern(), LongDCASig, reco::TrackBase::ndof(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfHits(), NumberOfLayersPerTrack, NumberOfLayersVsPhiVsEtaPerTrack, reco::TrackBase::numberOfLostHits(), NumberOfLostRecHitsPerTrack, NumberOfRecHitsPerTrack, NumberOfRecHitsPerTrack_lumiFlag, NumberOfRecHitVsPhiVsEtaPerTrack, reco::TrackBase::numberOfValidHits(), NumberOfValidRecHitsPerTrack, phi, reco::TrackBase::phi(), reco::BeamSpot::position(), reco::Vertex::position(), MetAnalyzer::pv(), pvToken_, reco::TrackBase::referencePoint(), AlCaHLTBitMon_QueryRunRegistry::string, TESTDistanceOfClosestApproachToBS, TESTDistanceOfClosestApproachToBSVsPhi, reco::TrackBase::theta(), reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), TransDCASig, reco::TrackBase::vx(), reco::TrackBase::vy(), reco::TrackBase::vz(), x, reco::Vertex::xError(), xPointOfClosestApproach, xPointOfClosestApproachVsZ0wrt000, xPointOfClosestApproachVsZ0wrtBS, xPointOfClosestApproachVsZ0wrtPV, detailsBasic3DVector::y, reco::Vertex::yError(), yPointOfClosestApproach, yPointOfClosestApproachVsZ0wrt000, yPointOfClosestApproachVsZ0wrtBS, yPointOfClosestApproachVsZ0wrtPV, reco::Vertex::zError(), zPointOfClosestApproach, and zPointOfClosestApproachVsPhi.

Referenced by TrackingMonitor::analyze().

603 {
604  double phi = track.phi();
605  double eta = track.eta();
606 
607  int nRecHits = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
608  int nValidRecHits = track.numberOfValidHits();
609  int nLostRecHits = track.numberOfLostHits();
610 
611  double chi2 = track.chi2();
612  double chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
613  double chi2oNDF = track.normalizedChi2();
614 
615  if ( doHitPropertiesPlots_ || doAllPlots_ ){
616  // rec hits
617  NumberOfRecHitsPerTrack -> Fill(nRecHits);
618  NumberOfValidRecHitsPerTrack-> Fill(nValidRecHits);
619  NumberOfLostRecHitsPerTrack -> Fill(nLostRecHits);
620 
621  // 2D plots
622  if ( doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_ )
623  NumberOfRecHitVsPhiVsEtaPerTrack->Fill(eta,phi,nRecHits);
624 
625  int nLayers = track.hitPattern().trackerLayersWithMeasurement();
626  // layers
627  NumberOfLayersPerTrack->Fill(nLayers);
628 
629  // 2D plots
630  if ( doLayersVsPhiVsEtaPerTrack_ || doAllPlots_ )
631  NumberOfLayersVsPhiVsEtaPerTrack->Fill(eta,phi,nLayers);
632  }
633 
634  if (doGeneralPropertiesPlots_ || doAllPlots_){
635  // fitting
636  Chi2 -> Fill(chi2);
637  Chi2Prob -> Fill(chi2prob);
638  Chi2oNDF -> Fill(chi2oNDF);
639 
640  // DCA
641  // temporary patch in order to put back those MEs in Muon Workspace
642  if (doDCAPlots_) {
643  if (doDCAwrt000Plots_) {
644  DistanceOfClosestApproach->Fill(track.dxy());
645  DistanceOfClosestApproachVsPhi->Fill(phi, track.dxy());
646  }
647 
648  // PCA
649  xPointOfClosestApproach->Fill(track.referencePoint().x());
650  yPointOfClosestApproach->Fill(track.referencePoint().y());
651  zPointOfClosestApproach->Fill(track.referencePoint().z());
652  }
653 
654  // algorithm
655  algorithm->Fill(static_cast<double>(track.algo()));
656  }
657 
658  if ( doLumiAnalysis_ ) {
659  NumberOfRecHitsPerTrack_lumiFlag -> Fill(nRecHits);
660  Chi2oNDF_lumiFlag -> Fill(chi2oNDF);
661  }
662 
663  if(doDCAPlots_ || doBSPlots_ || doAllPlots_) {
664 
665  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
666  iEvent.getByToken(beamSpotToken_,recoBeamSpotHandle);
667  reco::BeamSpot bs = *recoBeamSpotHandle;
668 
669  DistanceOfClosestApproachToBS -> Fill(track.dxy(bs.position()));
670  DistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position()));
671  zPointOfClosestApproachVsPhi -> Fill(track.phi(), track.vz());
672  xPointOfClosestApproachVsZ0wrt000 -> Fill(track.dz(), track.vx());
673  yPointOfClosestApproachVsZ0wrt000 -> Fill(track.dz(), track.vy());
674  xPointOfClosestApproachVsZ0wrtBS -> Fill(track.dz(bs.position()),(track.vx()-bs.position(track.vz()).x()));
675  yPointOfClosestApproachVsZ0wrtBS -> Fill(track.dz(bs.position()),(track.vy()-bs.position(track.vz()).y()));
676  if (doTestPlots_) {
677  TESTDistanceOfClosestApproachToBS -> Fill(track.dxy(bs.position(track.vz())));
678  TESTDistanceOfClosestApproachToBSVsPhi -> Fill(track.phi(), track.dxy(bs.position(track.vz())));
679  }
680  }
681 
682  if(doDCAPlots_ || doPVPlots_ || doAllPlots_) {
683  edm::Handle<reco::VertexCollection> recoPrimaryVerticesHandle;
684  iEvent.getByToken(pvToken_,recoPrimaryVerticesHandle);
685  if (recoPrimaryVerticesHandle->size() > 0) {
686  reco::Vertex pv = recoPrimaryVerticesHandle->at(0);
687 
688 
690  //HI PLOTS///////
692 
693  if(doHIPlots_)
694  {
695  double longDCAsig = 0, transDCAsig = 0;
696  double zerr2 = track.dzError()*track.dzError()+pv.zError()*pv.zError();
697  double xyerr2 = track.d0Error()*track.d0Error()+pv.xError()*pv.yError();
698  if(zerr2 > 0) longDCAsig = track.dz(pv.position())/zerr2;
699  if(xyerr2 > 0) transDCAsig = track.dxy(pv.position())/xyerr2;
700  LongDCASig->Fill(longDCAsig);
701  TransDCASig->Fill(transDCAsig);
702  }
703 
704 
705 
706  DistanceOfClosestApproachToPV -> Fill(track.dxy(pv.position()));
707  DistanceOfClosestApproachToPVVsPhi -> Fill(track.phi(), track.dxy(pv.position()));
708  xPointOfClosestApproachVsZ0wrtPV -> Fill(track.dz(pv.position()),(track.vx()-pv.position().x()));
709  yPointOfClosestApproachVsZ0wrtPV -> Fill(track.dz(pv.position()),(track.vy()-pv.position().y()));
710  }
711  }
712 
713  if(doDCAPlots_ || doAllPlots_) {
714  if (doDCAwrt000Plots_) {
715  if (doThetaPlots_) {
716  DistanceOfClosestApproachVsTheta->Fill(track.theta(), track.d0());
717  }
718  DistanceOfClosestApproachVsEta->Fill(track.eta(), track.d0());
719  }
720 
721  }
722 
723  //Tracker Specific Histograms
724  if(doTrackerSpecific_ || doAllPlots_) {
725  fillHistosForTrackerSpecific(track);
726  }
727 
728  if (doMeasurementStatePlots_ || doAllPlots_){
729  std::string StateName = conf_.getParameter<std::string>("MeasurementState");
730 
731  if (StateName == "All") {
732  fillHistosForState(iSetup, track, std::string("OuterSurface"));
733  fillHistosForState(iSetup, track, std::string("InnerSurface"));
734  fillHistosForState(iSetup, track, std::string("ImpactPoint"));
735  } else if (
736  StateName != "OuterSurface" &&
737  StateName != "InnerSurface" &&
738  StateName != "ImpactPoint" &&
739  StateName != "default"
740  ) {
741  fillHistosForState(iSetup, track, std::string("default"));
742  } else {
743  fillHistosForState(iSetup, track, StateName);
744  }
745  }
746 
747  if ( doAllPlots_ ) {
748  }
749 
750 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::DistanceOfClosestApproachToPVVsPhi
MonitorElement * DistanceOfClosestApproachToPVVsPhi
Definition: TrackAnalyzer.h:237
reco::TrackBase::referencePoint
const Point & referencePoint() const
Reference point on the track.
Definition: TrackBase.h:634
TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:204
TrackAnalyzer::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackAnalyzer.h:66
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:755
TrackAnalyzer::fillHistosForTrackerSpecific
void fillHistosForTrackerSpecific(const reco::Track &track)
Definition: TrackAnalyzer.cc:1275
reco::TrackBase::d0
double d0() const
dxy parameter in perigee convention (d0 = -dxy)
Definition: TrackBase.h:550
TrackAnalyzer::NumberOfValidRecHitsPerTrack
MonitorElement * NumberOfValidRecHitsPerTrack
Definition: TrackAnalyzer.h:198
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:514
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:449
reco::Vertex::zError
double zError() const
error on z
Definition: Vertex.h:118
TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:258
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:532
TrackAnalyzer::NumberOfLostRecHitsPerTrack
MonitorElement * NumberOfLostRecHitsPerTrack
Definition: TrackAnalyzer.h:199
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackAnalyzer.h:71
TrackAnalyzer::DistanceOfClosestApproachVsPhi
MonitorElement * DistanceOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:235
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:598
reco::TrackBase::numberOfLostHits
unsigned short numberOfLostHits() const
number of cases where track crossed a layer without getting a hit.
Definition: TrackBase.h:779
TrackAnalyzer::algorithm
MonitorElement * algorithm
Definition: TrackAnalyzer.h:252
eta
T eta() const
Definition: Basic3DVectorLD.h:177
TrackAnalyzer::doHitPropertiesPlots_
bool doHitPropertiesPlots_
Definition: TrackAnalyzer.h:73
TrackAnalyzer::DistanceOfClosestApproach
MonitorElement * DistanceOfClosestApproach
Definition: TrackAnalyzer.h:231
TrackAnalyzer::doRecHitVsPhiVsEtaPerTrack_
bool doRecHitVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:74
TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:259
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:477
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:106
TrackAnalyzer::doMeasurementStatePlots_
bool doMeasurementStatePlots_
Definition: TrackAnalyzer.h:72
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:197
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
reco::TrackBase::algo
TrackAlgorithm algo() const
Definition: TrackBase.h:450
TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:255
TrackAnalyzer::TransDCASig
MonitorElement * TransDCASig
Definition: TrackAnalyzer.h:263
TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000
MonitorElement * xPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:241
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:604
TrackAnalyzer::doDCAwrt000Plots_
bool doDCAwrt000Plots_
Definition: TrackAnalyzer.h:88
TrackAnalyzer::xPointOfClosestApproach
MonitorElement * xPointOfClosestApproach
Definition: TrackAnalyzer.h:239
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:502
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:508
TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS
MonitorElement * xPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:242
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:773
TrackAnalyzer::DistanceOfClosestApproachVsEta
MonitorElement * DistanceOfClosestApproachVsEta
Definition: TrackAnalyzer.h:238
TrackAnalyzer::zPointOfClosestApproachVsPhi
MonitorElement * zPointOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:251
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:562
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:767
reco::TrackBase::vz
double vz() const
z coordinate of the reference point on track
Definition: TrackBase.h:622
TrackAnalyzer::fillHistosForState
void fillHistosForState(const edm::EventSetup &iSetup, const reco::Track &track, std::string sname)
Definition: TrackAnalyzer.cc:1057
TrackAnalyzer::doLumiAnalysis_
bool doLumiAnalysis_
Definition: TrackAnalyzer.h:90
reco::Vertex::xError
double xError() const
error on x
Definition: Vertex.h:114
TrackAnalyzer::beamSpotToken_
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
Definition: TrackAnalyzer.h:61
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:411
TrackAnalyzer::xPointOfClosestApproachVsZ0wrtPV
MonitorElement * xPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:243
TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS
MonitorElement * yPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:247
TrackAnalyzer::NumberOfLayersPerTrack
MonitorElement * NumberOfLayersPerTrack
Definition: TrackAnalyzer.h:211
TrackAnalyzer::DistanceOfClosestApproachVsTheta
MonitorElement * DistanceOfClosestApproachVsTheta
Definition: TrackAnalyzer.h:234
TrackAnalyzer::DistanceOfClosestApproachToPV
MonitorElement * DistanceOfClosestApproachToPV
Definition: TrackAnalyzer.h:233
reco::TrackBase::vy
double vy() const
y coordinate of the reference point on track
Definition: TrackBase.h:616
TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi
MonitorElement * DistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:236
TrackAnalyzer::doLayersVsPhiVsEtaPerTrack_
bool doLayersVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:76
TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000
MonitorElement * yPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:246
TrackAnalyzer::TESTDistanceOfClosestApproachToBS
MonitorElement * TESTDistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:254
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:62
TrackAnalyzer::yPointOfClosestApproach
MonitorElement * yPointOfClosestApproach
Definition: TrackAnalyzer.h:244
TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:217
x
Definition: DDAxes.h:10
TrackAnalyzer::Chi2Prob
MonitorElement * Chi2Prob
Definition: TrackAnalyzer.h:220
Chi2
Definition: Chi2.h:17
TrackAnalyzer::yPointOfClosestApproachVsZ0wrtPV
MonitorElement * yPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:248
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:544
TrackAnalyzer::zPointOfClosestApproach
MonitorElement * zPointOfClosestApproach
Definition: TrackAnalyzer.h:249
TrackAnalyzer::DistanceOfClosestApproachToBS
MonitorElement * DistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:232
TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:221
reco::Vertex::yError
double yError() const
error on y
Definition: Vertex.h:116
reco::TrackBase::vx
double vx() const
x coordinate of the reference point on track
Definition: TrackBase.h:610
reco::HitPattern::numberOfHits
int numberOfHits(HitCategory category) const
Definition: HitPattern.h:718
TrackAnalyzer::LongDCASig
MonitorElement * LongDCASig
Definition: TrackAnalyzer.h:262
TrackAnalyzer::pvToken_
edm::EDGetTokenT< reco::VertexCollection > pvToken_
Definition: TrackAnalyzer.h:62
phi
Definition: DDAxes.h:10
void TrackAnalyzer::bookHistosForBeamSpot ( DQMStore::IBooker &  ibooker)
private

Definition at line 398 of file TrackAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, DQMStore::IBooker::book1D(), DQMStore::IBooker::bookProfile(), conf_, DistanceOfClosestApproach, DistanceOfClosestApproachToBS, DistanceOfClosestApproachToBSVsPhi, DistanceOfClosestApproachToPV, DistanceOfClosestApproachToPVVsPhi, DistanceOfClosestApproachVsEta, DistanceOfClosestApproachVsPhi, DistanceOfClosestApproachVsTheta, doAllPlots_, doBSPlots_, doDCAPlots_, doDCAwrt000Plots_, doPVPlots_, doTestPlots_, doThetaPlots_, HLT_25ns14e33_v3_cff::EtaMax, Gflash::EtaMin, edm::ParameterSet::getParameter(), MonitorElement::getTH1(), histname, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, TESTDistanceOfClosestApproachToBS, TESTDistanceOfClosestApproachToBSVsPhi, TopFolder_, xPointOfClosestApproachVsZ0wrt000, xPointOfClosestApproachVsZ0wrtBS, xPointOfClosestApproachVsZ0wrtPV, yPointOfClosestApproachVsZ0wrt000, yPointOfClosestApproachVsZ0wrtBS, yPointOfClosestApproachVsZ0wrtPV, and zPointOfClosestApproachVsPhi.

Referenced by initHisto().

398  {
399 
400  // parameters from the configuration
401  std::string QualName = conf_.getParameter<std::string>("Quality");
402  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
403 
404  // use the AlgoName and Quality Name
405  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
406 
407  // book the Beam Spot related histograms
408  // ---------------------------------------------------------------------------------//
409 
410  if(doDCAPlots_ || doBSPlots_ || doAllPlots_) {
411 
412  int DxyBin = conf_.getParameter<int>( "DxyBin");
413  double DxyMin = conf_.getParameter<double>("DxyMin");
414  double DxyMax = conf_.getParameter<double>("DxyMax");
415 
416  int PhiBin = conf_.getParameter<int>( "PhiBin");
417  double PhiMin = conf_.getParameter<double>("PhiMin");
418  double PhiMax = conf_.getParameter<double>("PhiMax");
419 
420  int X0Bin = conf_.getParameter<int>( "X0Bin");
421  double X0Min = conf_.getParameter<double>("X0Min");
422  double X0Max = conf_.getParameter<double>("X0Max");
423 
424  int Y0Bin = conf_.getParameter<int>( "Y0Bin");
425  double Y0Min = conf_.getParameter<double>("Y0Min");
426  double Y0Max = conf_.getParameter<double>("Y0Max");
427 
428  int Z0Bin = conf_.getParameter<int>( "Z0Bin");
429  double Z0Min = conf_.getParameter<double>("Z0Min");
430  double Z0Max = conf_.getParameter<double>("Z0Max");
431 
432  int VZBinProf = conf_.getParameter<int>( "VZBinProf");
433  double VZMinProf = conf_.getParameter<double>("VZMinProf");
434  double VZMaxProf = conf_.getParameter<double>("VZMaxProf");
435 
436 
437  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
438 
439  histname = "DistanceOfClosestApproachToBS_";
440  DistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
441  DistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
442  DistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
443 
444  histname = "DistanceOfClosestApproachToBSVsPhi_";
445  DistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
446  DistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
447  DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi",1);
448  DistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
449 
450  histname = "xPointOfClosestApproachVsZ0wrt000_";
451  xPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
452  xPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)",1);
453  xPointOfClosestApproachVsZ0wrt000->setAxisTitle("x component of Track PCA to beam line (cm)",2);
454 
455  histname = "yPointOfClosestApproachVsZ0wrt000_";
456  yPointOfClosestApproachVsZ0wrt000 = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
457  yPointOfClosestApproachVsZ0wrt000->setAxisTitle("d_{z} (cm)",1);
458  yPointOfClosestApproachVsZ0wrt000->setAxisTitle("y component of Track PCA to beam line (cm)",2);
459 
460  histname = "xPointOfClosestApproachVsZ0wrtBS_";
461  xPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
462  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
463  xPointOfClosestApproachVsZ0wrtBS->setAxisTitle("x component of Track PCA to BS (cm)",2);
464 
465  histname = "yPointOfClosestApproachVsZ0wrtBS_";
466  yPointOfClosestApproachVsZ0wrtBS = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
467  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
468  yPointOfClosestApproachVsZ0wrtBS->setAxisTitle("y component of Track PCA to BS (cm)",2);
469 
470  histname = "zPointOfClosestApproachVsPhi_";
471  zPointOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, VZBinProf, VZMinProf, VZMaxProf, "");
472  zPointOfClosestApproachVsPhi->setAxisTitle("Track #phi",1);
473  zPointOfClosestApproachVsPhi->setAxisTitle("y component of Track PCA to beam line (cm)",2);
474  }
475 
476  if(doDCAPlots_ || doPVPlots_ || doAllPlots_) {
477 
478  int DxyBin = conf_.getParameter<int>( "DxyBin");
479  double DxyMin = conf_.getParameter<double>("DxyMin");
480  double DxyMax = conf_.getParameter<double>("DxyMax");
481 
482  int PhiBin = conf_.getParameter<int>( "PhiBin");
483  double PhiMin = conf_.getParameter<double>("PhiMin");
484  double PhiMax = conf_.getParameter<double>("PhiMax");
485 
486  int X0Bin = conf_.getParameter<int>( "X0Bin");
487  double X0Min = conf_.getParameter<double>("X0Min");
488  double X0Max = conf_.getParameter<double>("X0Max");
489 
490  int Y0Bin = conf_.getParameter<int>( "Y0Bin");
491  double Y0Min = conf_.getParameter<double>("Y0Min");
492  double Y0Max = conf_.getParameter<double>("Y0Max");
493 
494  int Z0Bin = conf_.getParameter<int>( "Z0Bin");
495  double Z0Min = conf_.getParameter<double>("Z0Min");
496  double Z0Max = conf_.getParameter<double>("Z0Max");
497 
498  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
499 
500  histname = "DistanceOfClosestApproachToPV_";
501  DistanceOfClosestApproachToPV = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
502  DistanceOfClosestApproachToPV->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
503  DistanceOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
504 
505  histname = "DistanceOfClosestApproachToPVVsPhi_";
506  DistanceOfClosestApproachToPVVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
507  DistanceOfClosestApproachToPVVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
508  DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track #phi",1);
509  DistanceOfClosestApproachToPVVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
510 
511  histname = "xPointOfClosestApproachVsZ0wrtPV_";
512  xPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, X0Bin, X0Min, X0Max,"");
513  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
514  xPointOfClosestApproachVsZ0wrtPV->setAxisTitle("x component of Track PCA to PV (cm)",2);
515 
516  histname = "yPointOfClosestApproachVsZ0wrtPV_";
517  yPointOfClosestApproachVsZ0wrtPV = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, Z0Bin, Z0Min, Z0Max, Y0Bin, Y0Min, Y0Max,"");
518  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("d_{z} w.r.t. Beam Spot (cm)",1);
519  yPointOfClosestApproachVsZ0wrtPV->setAxisTitle("y component of Track PCA to PV (cm)",2);
520 
521  }
522 
523  if (doBSPlots_ || doAllPlots_) {
524  if (doTestPlots_) {
525 
526  int DxyBin = conf_.getParameter<int>( "DxyBin");
527  double DxyMin = conf_.getParameter<double>("DxyMin");
528  double DxyMax = conf_.getParameter<double>("DxyMax");
529 
530  int PhiBin = conf_.getParameter<int>( "PhiBin");
531  double PhiMin = conf_.getParameter<double>("PhiMin");
532  double PhiMax = conf_.getParameter<double>("PhiMax");
533 
534  histname = "TESTDistanceOfClosestApproachToBS_";
535  TESTDistanceOfClosestApproachToBS = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
536  TESTDistanceOfClosestApproachToBS->setAxisTitle("Track d_{xy} wrt beam spot (cm)",1);
537  TESTDistanceOfClosestApproachToBS->setAxisTitle("Number of Tracks",2);
538 
539  histname = "TESTDistanceOfClosestApproachToBSVsPhi_";
540  TESTDistanceOfClosestApproachToBSVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
541  TESTDistanceOfClosestApproachToBSVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
542  TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track #phi",1);
543  TESTDistanceOfClosestApproachToBSVsPhi->setAxisTitle("Track d_{xy} wrt beam spot (cm)",2);
544 
545  }
546 
547  }
548 
549  // book the Profile plots for DCA related histograms
550  // ---------------------------------------------------------------------------------//
551  if(doDCAPlots_ || doAllPlots_) {
552 
553  if (doDCAwrt000Plots_) {
554 
555  int EtaBin = conf_.getParameter<int>( "EtaBin");
556  double EtaMin = conf_.getParameter<double>("EtaMin");
557  double EtaMax = conf_.getParameter<double>("EtaMax");
558 
559  int PhiBin = conf_.getParameter<int>( "PhiBin");
560  double PhiMin = conf_.getParameter<double>("PhiMin");
561  double PhiMax = conf_.getParameter<double>("PhiMax");
562 
563  int DxyBin = conf_.getParameter<int>( "DxyBin");
564  double DxyMin = conf_.getParameter<double>("DxyMin");
565  double DxyMax = conf_.getParameter<double>("DxyMax");
566 
567  if (doThetaPlots_) {
568  int ThetaBin = conf_.getParameter<int>( "ThetaBin");
569  double ThetaMin = conf_.getParameter<double>("ThetaMin");
570  double ThetaMax = conf_.getParameter<double>("ThetaMax");
571 
572  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
573  histname = "DistanceOfClosestApproachVsTheta_";
574  DistanceOfClosestApproachVsTheta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, ThetaBin, ThetaMin, ThetaMax, DxyMin,DxyMax,"");
575  DistanceOfClosestApproachVsTheta->setAxisTitle("Track #theta",1);
576  DistanceOfClosestApproachVsTheta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
577  }
578 
579  histname = "DistanceOfClosestApproachVsEta_";
580  DistanceOfClosestApproachVsEta = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, EtaBin, EtaMin, EtaMax, DxyMin, DxyMax,"");
581  DistanceOfClosestApproachVsEta->setAxisTitle("Track #eta",1);
582  DistanceOfClosestApproachVsEta->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
583  // temporary patch in order to put back those MEs in Muon Workspace
584 
585  histname = "DistanceOfClosestApproach_";
586  DistanceOfClosestApproach = ibooker.book1D(histname+CategoryName,histname+CategoryName,DxyBin,DxyMin,DxyMax);
587  DistanceOfClosestApproach->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",1);
588  DistanceOfClosestApproach->setAxisTitle("Number of Tracks",2);
589 
590  histname = "DistanceOfClosestApproachVsPhi_";
591  DistanceOfClosestApproachVsPhi = ibooker.bookProfile(histname+CategoryName,histname+CategoryName, PhiBin, PhiMin, PhiMax, DxyMin,DxyMax,"");
592  DistanceOfClosestApproachVsPhi->getTH1()->SetCanExtend(TH1::kAllAxes);
593  DistanceOfClosestApproachVsPhi->setAxisTitle("Track #phi",1);
594  DistanceOfClosestApproachVsPhi->setAxisTitle("Track d_{xy} wrt (0,0,0) (cm)",2);
595  }
596  }
597 
598 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::DistanceOfClosestApproachToPVVsPhi
MonitorElement * DistanceOfClosestApproachToPVVsPhi
Definition: TrackAnalyzer.h:237
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::DistanceOfClosestApproachVsPhi
MonitorElement * DistanceOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:235
TrackAnalyzer::DistanceOfClosestApproach
MonitorElement * DistanceOfClosestApproach
Definition: TrackAnalyzer.h:231
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:255
TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000
MonitorElement * xPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:241
TrackAnalyzer::doDCAwrt000Plots_
bool doDCAwrt000Plots_
Definition: TrackAnalyzer.h:88
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS
MonitorElement * xPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:242
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:32
TrackAnalyzer::DistanceOfClosestApproachVsEta
MonitorElement * DistanceOfClosestApproachVsEta
Definition: TrackAnalyzer.h:238
TrackAnalyzer::zPointOfClosestApproachVsPhi
MonitorElement * zPointOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:251
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
TrackAnalyzer::xPointOfClosestApproachVsZ0wrtPV
MonitorElement * xPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:243
TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS
MonitorElement * yPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:247
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
TrackAnalyzer::DistanceOfClosestApproachVsTheta
MonitorElement * DistanceOfClosestApproachVsTheta
Definition: TrackAnalyzer.h:234
TrackAnalyzer::DistanceOfClosestApproachToPV
MonitorElement * DistanceOfClosestApproachToPV
Definition: TrackAnalyzer.h:233
TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi
MonitorElement * DistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:236
HLT_25ns14e33_v3_cff.EtaMax
tuple EtaMax
Definition: HLT_25ns14e33_v3_cff.py:1747
TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000
MonitorElement * yPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:246
TrackAnalyzer::TESTDistanceOfClosestApproachToBS
MonitorElement * TESTDistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:254
TrackAnalyzer::yPointOfClosestApproachVsZ0wrtPV
MonitorElement * yPointOfClosestApproachVsZ0wrtPV
Definition: TrackAnalyzer.h:248
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
TrackAnalyzer::DistanceOfClosestApproachToBS
MonitorElement * DistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:232
TrackAnalyzer::histname
std::string histname
Definition: TrackAnalyzer.h:281
void TrackAnalyzer::bookHistosForHitProperties ( DQMStore::IBooker &  ibooker)
private

Definition at line 159 of file TrackAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, reco::TrackBase::algoNames, algorithm, reco::TrackBase::algoSize, DQMStore::IBooker::book1D(), DQMStore::IBooker::bookProfile2D(), Chi2oNDF, Chi2Prob, conf_, doAllPlots_, doDCAPlots_, doGeneralPropertiesPlots_, doHIPlots_, doHitPropertiesPlots_, doLayersVsPhiVsEtaPerTrack_, doRecHitVsPhiVsEtaPerTrack_, HLT_25ns14e33_v3_cff::EtaMax, Gflash::EtaMin, edm::ParameterSet::getParameter(), histname, LongDCASig, NumberOfLayersPerTrack, NumberOfLayersVsPhiVsEtaPerTrack, NumberOfLostRecHitsPerTrack, NumberOfRecHitsPerTrack, NumberOfRecHitVsPhiVsEtaPerTrack, NumberOfValidRecHitsPerTrack, MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, TopFolder_, TransDCASig, xPointOfClosestApproach, xPointOfClosestApproachToPV, yPointOfClosestApproach, yPointOfClosestApproachToPV, zPointOfClosestApproach, and zPointOfClosestApproachToPV.

Referenced by initHisto().

159  {
160 
161  // parameters from the configuration
162  std::string QualName = conf_.getParameter<std::string>("Quality");
163  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
164  std::string MEBSFolderName = conf_.getParameter<std::string>("BSFolderName");
165 
166  // use the AlgoName and Quality Name
167  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
168 
169  // get binning from the configuration
170  int TKHitBin = conf_.getParameter<int>( "RecHitBin");
171  double TKHitMin = conf_.getParameter<double>("RecHitMin");
172  double TKHitMax = conf_.getParameter<double>("RecHitMax");
173 
174  int TKLostBin = conf_.getParameter<int>( "RecLostBin");
175  double TKLostMin = conf_.getParameter<double>("RecLostMin");
176  double TKLostMax = conf_.getParameter<double>("RecLostMax");
177 
178  int TKLayBin = conf_.getParameter<int>( "RecLayBin");
179  double TKLayMin = conf_.getParameter<double>("RecLayMin");
180  double TKLayMax = conf_.getParameter<double>("RecLayMax");
181 
182  int PhiBin = conf_.getParameter<int>( "PhiBin");
183  double PhiMin = conf_.getParameter<double>("PhiMin");
184  double PhiMax = conf_.getParameter<double>("PhiMax");
185 
186  int EtaBin = conf_.getParameter<int>( "EtaBin");
187  double EtaMin = conf_.getParameter<double>("EtaMin");
188  double EtaMax = conf_.getParameter<double>("EtaMax");
189 
190  int VXBin = conf_.getParameter<int>( "VXBin");
191  double VXMin = conf_.getParameter<double>("VXMin");
192  double VXMax = conf_.getParameter<double>("VXMax");
193 
194  int VYBin = conf_.getParameter<int>( "VYBin");
195  double VYMin = conf_.getParameter<double>("VYMin");
196  double VYMax = conf_.getParameter<double>("VYMax");
197 
198  int VZBin = conf_.getParameter<int>( "VZBin");
199  double VZMin = conf_.getParameter<double>("VZMin");
200  double VZMax = conf_.getParameter<double>("VZMax");
201 
202  ibooker.setCurrentFolder(TopFolder_);
203 
204  // book the Hit Property histograms
205  // ---------------------------------------------------------------------------------//
206 
207  TkParameterMEs tkmes;
208  if ( doHitPropertiesPlots_ || doAllPlots_ ){
209 
210  ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
211 
212  histname = "NumberOfRecHitsPerTrack_";
213  NumberOfRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
214  NumberOfRecHitsPerTrack->setAxisTitle("Number of all RecHits of each Track");
215  NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
216 
217  histname = "NumberOfValidRecHitsPerTrack_";
218  NumberOfValidRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
219  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of valid RecHits for each Track");
220  NumberOfValidRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
221 
222  histname = "NumberOfLostRecHitsPerTrack_";
223  NumberOfLostRecHitsPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLostBin, TKLostMin, TKLostMax);
224  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of lost RecHits for each Track");
225  NumberOfLostRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
226 
227  histname = "NumberOfLayersPerTrack_";
228  NumberOfLayersPerTrack = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKLayBin, TKLayMin, TKLayMax);
229  NumberOfLayersPerTrack->setAxisTitle("Number of Layers of each Track", 1);
230  NumberOfLayersPerTrack->setAxisTitle("Number of Tracks", 2);
231 
232 
233  if ( doRecHitVsPhiVsEtaPerTrack_ || doAllPlots_ ){
234 
235  histname = "NumberOfRecHitVsPhiVsEtaPerTrack_";
236  NumberOfRecHitVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
237  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
238  NumberOfRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
239  NumberOfRecHitVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
240  }
241 
242  if ( doLayersVsPhiVsEtaPerTrack_ || doAllPlots_ ){
243 
244  histname = "NumberOfLayersVsPhiVsEtaPerTrack_";
245  NumberOfLayersVsPhiVsEtaPerTrack = ibooker.bookProfile2D(histname+CategoryName, histname+CategoryName,
246  EtaBin, EtaMin, EtaMax, PhiBin, PhiMin, PhiMax, 0, 40., "");
247  NumberOfLayersVsPhiVsEtaPerTrack->setAxisTitle("Track #eta ", 1);
248  NumberOfLayersVsPhiVsEtaPerTrack->setAxisTitle("Track #phi ", 2);
249  }
250  }
251 
252  // book the General Property histograms
253  // ---------------------------------------------------------------------------------//
254 
255  if (doGeneralPropertiesPlots_ || doAllPlots_){
256 
257  int Chi2Bin = conf_.getParameter<int>( "Chi2Bin");
258  double Chi2Min = conf_.getParameter<double>("Chi2Min");
259  double Chi2Max = conf_.getParameter<double>("Chi2Max");
260 
261  int Chi2NDFBin = conf_.getParameter<int>( "Chi2NDFBin");
262  double Chi2NDFMin = conf_.getParameter<double>("Chi2NDFMin");
263  double Chi2NDFMax = conf_.getParameter<double>("Chi2NDFMax");
264 
265  int Chi2ProbBin = conf_.getParameter<int>( "Chi2ProbBin");
266  double Chi2ProbMin = conf_.getParameter<double>("Chi2ProbMin");
267  double Chi2ProbMax = conf_.getParameter<double>("Chi2ProbMax");
268 
269 
270  //HI PLOTS////
271  int TransDCABins = conf_.getParameter<int>("TransDCABins");
272  double TransDCAMin = conf_.getParameter<double>("TransDCAMin");
273  double TransDCAMax = conf_.getParameter<double>("TransDCAMax");
274 
275  int LongDCABins = conf_.getParameter<int>("LongDCABins");
276  double LongDCAMin = conf_.getParameter<double>("LongDCAMin");
277  double LongDCAMax = conf_.getParameter<double>("LongDCAMax");
279 
280 
281  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
282 
283  histname = "Chi2_";
284  Chi2 = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2Bin, Chi2Min, Chi2Max);
285  Chi2->setAxisTitle("Track #chi^{2}" ,1);
286  Chi2->setAxisTitle("Number of Tracks",2);
287 
288  histname = "Chi2Prob_";
289  Chi2Prob = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2ProbBin, Chi2ProbMin, Chi2ProbMax);
290  Chi2Prob->setAxisTitle("Track #chi^{2} probability",1);
291  Chi2Prob->setAxisTitle("Number of Tracks" ,2);
292 
293  histname = "Chi2oNDF_";
294  Chi2oNDF = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
295  Chi2oNDF->setAxisTitle("Track #chi^{2}/ndf",1);
296  Chi2oNDF->setAxisTitle("Number of Tracks" ,2);
297 
298 
300  //HI PLOTS///
302  if (doHIPlots_)
303  {
304  histname = "LongDCASig_";
305  LongDCASig = ibooker.book1D(histname+CategoryName, histname+CategoryName,LongDCABins,LongDCAMin,LongDCAMax);
306  LongDCASig->setAxisTitle("dz/#sigma_{dz}",1);
307 
308  histname = "TransDCASig_";
309  TransDCASig = ibooker.book1D(histname+CategoryName,histname+CategoryName,TransDCABins,TransDCAMin,TransDCAMax);
310  TransDCASig->setAxisTitle("dxy/#sigma_{dxy}",1);
311  }
312 
313 
314 
315  if (doDCAPlots_) {
316  histname = "xPointOfClosestApproach_";
317  xPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
318  xPointOfClosestApproach->setAxisTitle("x component of Track PCA to beam line (cm)",1);
319  xPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
320 
321  histname = "yPointOfClosestApproach_";
322  yPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
323  yPointOfClosestApproach->setAxisTitle("y component of Track PCA to beam line (cm)",1);
324  yPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
325 
326  histname = "zPointOfClosestApproach_";
327  zPointOfClosestApproach = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
328  zPointOfClosestApproach->setAxisTitle("z component of Track PCA to beam line (cm)",1);
329  zPointOfClosestApproach->setAxisTitle("Number of Tracks",2);
330 
331  histname = "xPointOfClosestApproachToPV_";
332  xPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VXBin, VXMin, VXMax);
333  xPointOfClosestApproachToPV->setAxisTitle("x component of Track PCA to pv (cm)",1);
334  xPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
335 
336  histname = "yPointOfClosestApproachToPV_";
337  yPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VYBin, VYMin, VYMax);
338  yPointOfClosestApproachToPV->setAxisTitle("y component of Track PCA to pv line (cm)",1);
339  yPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
340 
341  histname = "zPointOfClosestApproachToPV_";
342  zPointOfClosestApproachToPV = ibooker.book1D(histname+CategoryName, histname+CategoryName, VZBin, VZMin, VZMax);
343  zPointOfClosestApproachToPV->setAxisTitle("z component of Track PCA to pv line (cm)",1);
344  zPointOfClosestApproachToPV->setAxisTitle("Number of Tracks",2);
345  }
346 
347  // See DataFormats/TrackReco/interface/TrackBase.h for track algorithm enum definition
348  // http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/DataFormats/TrackReco/interface/TrackBase.h?view=log
349  histname = "algorithm_";
350  algorithm = ibooker.book1D(histname+CategoryName, histname+CategoryName, reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize));
351  algorithm->setAxisTitle("Tracking algorithm",1);
352  algorithm->setAxisTitle("Number of Tracks",2);
353  for (size_t ibin=0; ibin<reco::TrackBase::algoSize-1; ibin++)
354  algorithm->setBinLabel(ibin+1,reco::TrackBase::algoNames[ibin]);
355  }
356 
357 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:204
TrackAnalyzer::NumberOfValidRecHitsPerTrack
MonitorElement * NumberOfValidRecHitsPerTrack
Definition: TrackAnalyzer.h:198
TrackAnalyzer::xPointOfClosestApproachToPV
MonitorElement * xPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:240
TrackAnalyzer::NumberOfLostRecHitsPerTrack
MonitorElement * NumberOfLostRecHitsPerTrack
Definition: TrackAnalyzer.h:199
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackAnalyzer.h:71
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:920
TrackAnalyzer::algorithm
MonitorElement * algorithm
Definition: TrackAnalyzer.h:252
TrackAnalyzer::doHitPropertiesPlots_
bool doHitPropertiesPlots_
Definition: TrackAnalyzer.h:73
TrackAnalyzer::doRecHitVsPhiVsEtaPerTrack_
bool doRecHitVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:74
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:197
TrackAnalyzer::TransDCASig
MonitorElement * TransDCASig
Definition: TrackAnalyzer.h:263
TrackAnalyzer::xPointOfClosestApproach
MonitorElement * xPointOfClosestApproach
Definition: TrackAnalyzer.h:239
DQMStore::IBooker::bookProfile2D
MonitorElement * bookProfile2D(Args &&...args)
Definition: DQMStore.h:163
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TrackAnalyzer::yPointOfClosestApproachToPV
MonitorElement * yPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:245
Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:32
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
TrackAnalyzer::NumberOfLayersPerTrack
MonitorElement * NumberOfLayersPerTrack
Definition: TrackAnalyzer.h:211
reco::TrackBase::algoNames
static const std::string algoNames[]
Definition: TrackBase.h:136
TrackAnalyzer::zPointOfClosestApproachToPV
MonitorElement * zPointOfClosestApproachToPV
Definition: TrackAnalyzer.h:250
TrackAnalyzer::doLayersVsPhiVsEtaPerTrack_
bool doLayersVsPhiVsEtaPerTrack_
Definition: TrackAnalyzer.h:76
HLT_25ns14e33_v3_cff.EtaMax
tuple EtaMax
Definition: HLT_25ns14e33_v3_cff.py:1747
TrackAnalyzer::yPointOfClosestApproach
MonitorElement * yPointOfClosestApproach
Definition: TrackAnalyzer.h:244
TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:217
TrackAnalyzer::Chi2Prob
MonitorElement * Chi2Prob
Definition: TrackAnalyzer.h:220
Chi2
Definition: Chi2.h:17
TrackAnalyzer::zPointOfClosestApproach
MonitorElement * zPointOfClosestApproach
Definition: TrackAnalyzer.h:249
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:221
TrackAnalyzer::histname
std::string histname
Definition: TrackAnalyzer.h:281
TrackAnalyzer::LongDCASig
MonitorElement * LongDCASig
Definition: TrackAnalyzer.h:262
void TrackAnalyzer::bookHistosForLScertification ( DQMStore::IBooker &  ibooker)
private

Definition at line 359 of file TrackAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, 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().

359  {
360 
361  // parameters from the configuration
362  std::string QualName = conf_.getParameter<std::string>("Quality");
363  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
364 
365  // use the AlgoName and Quality Name
366  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
367 
368 
369  // book LS analysis related histograms
370  // -----------------------------------
371  if ( doLumiAnalysis_ ) {
372 
373  // get binning from the configuration
374  int TKHitBin = conf_.getParameter<int>( "RecHitBin");
375  double TKHitMin = conf_.getParameter<double>("RecHitMin");
376  double TKHitMax = conf_.getParameter<double>("RecHitMax");
377 
378  int Chi2NDFBin = conf_.getParameter<int>( "Chi2NDFBin");
379  double Chi2NDFMin = conf_.getParameter<double>("Chi2NDFMin");
380  double Chi2NDFMax = conf_.getParameter<double>("Chi2NDFMax");
381 
382  // add by Mia in order to deal w/ LS transitions
383  ibooker.setCurrentFolder(TopFolder_+"/LSanalysis");
384 
385  histname = "NumberOfRecHitsPerTrack_lumiFlag_";
386  NumberOfRecHitsPerTrack_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, TKHitBin, TKHitMin, TKHitMax);
387  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of all RecHits of each Track");
388  NumberOfRecHitsPerTrack_lumiFlag->setAxisTitle("Number of Tracks", 2);
389 
390  histname = "Chi2oNDF_lumiFlag_";
391  Chi2oNDF_lumiFlag = ibooker.book1D(histname+CategoryName, histname+CategoryName, Chi2NDFBin, Chi2NDFMin, Chi2NDFMax);
392  Chi2oNDF_lumiFlag->setAxisTitle("Track #chi^{2}/ndf",1);
393  Chi2oNDF_lumiFlag->setAxisTitle("Number of Tracks" ,2);
394 
395  }
396 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:258
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:259
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TrackAnalyzer::doLumiAnalysis_
bool doLumiAnalysis_
Definition: TrackAnalyzer.h:90
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
TrackAnalyzer::histname
std::string histname
Definition: TrackAnalyzer.h:281
void TrackAnalyzer::bookHistosForState ( std::string  sname,
DQMStore::IBooker &  ibooker 
)
private

Definition at line 754 of file TrackAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, DQMStore::IBooker::book1D(), DQMStore::IBooker::bookProfile(), TrackAnalyzer::TkParameterMEs::Chi2oNDFVsEta, TrackAnalyzer::TkParameterMEs::Chi2oNDFVsPhi, TrackAnalyzer::TkParameterMEs::Chi2oNDFVsTheta, TrackAnalyzer::TkParameterMEs::Chi2ProbVsEta, TrackAnalyzer::TkParameterMEs::Chi2ProbVsPhi, conf_, doAllPlots_, doThetaPlots_, doTrackPxPyPlots_, HLT_25ns14e33_v3_cff::EtaMax, Gflash::EtaMin, edm::ParameterSet::getParameter(), histname, TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsPhi, TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsTheta, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsPhi, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsTheta, TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsPhi, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, TkParameterMEMap, TopFolder_, TrackAnalyzer::TkParameterMEs::TrackEta, TrackAnalyzer::TkParameterMEs::TrackEtaErr, TrackAnalyzer::TkParameterMEs::TrackP, TrackAnalyzer::TkParameterMEs::TrackPErr, TrackAnalyzer::TkParameterMEs::TrackPhi, TrackAnalyzer::TkParameterMEs::TrackPhiErr, TrackAnalyzer::TkParameterMEs::TrackPt, TrackAnalyzer::TkParameterMEs::TrackPtErr, TrackAnalyzer::TkParameterMEs::TrackPtErrVsEta, TrackAnalyzer::TkParameterMEs::TrackPx, TrackAnalyzer::TkParameterMEs::TrackPxErr, TrackAnalyzer::TkParameterMEs::TrackPy, TrackAnalyzer::TkParameterMEs::TrackPyErr, TrackAnalyzer::TkParameterMEs::TrackPz, TrackAnalyzer::TkParameterMEs::TrackPzErr, TrackAnalyzer::TkParameterMEs::TrackQ, and TrackAnalyzer::TkParameterMEs::TrackTheta.

Referenced by initHisto().

755 {
756 
757  // parameters from the configuration
758  std::string QualName = conf_.getParameter<std::string>("Quality");
759  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
760 
761  // use the AlgoName and Quality Name
762  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
763 
764  // get binning from the configuration
765  double Chi2NDFMin = conf_.getParameter<double>("Chi2NDFMin");
766  double Chi2NDFMax = conf_.getParameter<double>("Chi2NDFMax");
767 
768  int RecHitBin = conf_.getParameter<int>( "RecHitBin");
769  double RecHitMin = conf_.getParameter<double>("RecHitMin");
770  double RecHitMax = conf_.getParameter<double>("RecHitMax");
771 
772  int RecLayBin = conf_.getParameter<int>( "RecHitBin");
773  double RecLayMin = conf_.getParameter<double>("RecHitMin");
774  double RecLayMax = conf_.getParameter<double>("RecHitMax");
775 
776 
777  int PhiBin = conf_.getParameter<int>( "PhiBin");
778  double PhiMin = conf_.getParameter<double>("PhiMin");
779  double PhiMax = conf_.getParameter<double>("PhiMax");
780 
781  int EtaBin = conf_.getParameter<int>( "EtaBin");
782  double EtaMin = conf_.getParameter<double>("EtaMin");
783  double EtaMax = conf_.getParameter<double>("EtaMax");
784 
785  int ThetaBin = conf_.getParameter<int>( "ThetaBin");
786  double ThetaMin = conf_.getParameter<double>("ThetaMin");
787  double ThetaMax = conf_.getParameter<double>("ThetaMax");
788 
789  int TrackQBin = conf_.getParameter<int>( "TrackQBin");
790  double TrackQMin = conf_.getParameter<double>("TrackQMin");
791  double TrackQMax = conf_.getParameter<double>("TrackQMax");
792 
793  int TrackPtBin = conf_.getParameter<int>( "TrackPtBin");
794  double TrackPtMin = conf_.getParameter<double>("TrackPtMin");
795  double TrackPtMax = conf_.getParameter<double>("TrackPtMax");
796 
797  int TrackPBin = conf_.getParameter<int>( "TrackPBin");
798  double TrackPMin = conf_.getParameter<double>("TrackPMin");
799  double TrackPMax = conf_.getParameter<double>("TrackPMax");
800 
801  int TrackPxBin = conf_.getParameter<int>( "TrackPxBin");
802  double TrackPxMin = conf_.getParameter<double>("TrackPxMin");
803  double TrackPxMax = conf_.getParameter<double>("TrackPxMax");
804 
805  int TrackPyBin = conf_.getParameter<int>( "TrackPyBin");
806  double TrackPyMin = conf_.getParameter<double>("TrackPyMin");
807  double TrackPyMax = conf_.getParameter<double>("TrackPyMax");
808 
809  int TrackPzBin = conf_.getParameter<int>( "TrackPzBin");
810  double TrackPzMin = conf_.getParameter<double>("TrackPzMin");
811  double TrackPzMax = conf_.getParameter<double>("TrackPzMax");
812 
813  int ptErrBin = conf_.getParameter<int>( "ptErrBin");
814  double ptErrMin = conf_.getParameter<double>("ptErrMin");
815  double ptErrMax = conf_.getParameter<double>("ptErrMax");
816 
817  int pxErrBin = conf_.getParameter<int>( "pxErrBin");
818  double pxErrMin = conf_.getParameter<double>("pxErrMin");
819  double pxErrMax = conf_.getParameter<double>("pxErrMax");
820 
821  int pyErrBin = conf_.getParameter<int>( "pyErrBin");
822  double pyErrMin = conf_.getParameter<double>("pyErrMin");
823  double pyErrMax = conf_.getParameter<double>("pyErrMax");
824 
825  int pzErrBin = conf_.getParameter<int>( "pzErrBin");
826  double pzErrMin = conf_.getParameter<double>("pzErrMin");
827  double pzErrMax = conf_.getParameter<double>("pzErrMax");
828 
829  int pErrBin = conf_.getParameter<int>( "pErrBin");
830  double pErrMin = conf_.getParameter<double>("pErrMin");
831  double pErrMax = conf_.getParameter<double>("pErrMax");
832 
833  int phiErrBin = conf_.getParameter<int>( "phiErrBin");
834  double phiErrMin = conf_.getParameter<double>("phiErrMin");
835  double phiErrMax = conf_.getParameter<double>("phiErrMax");
836 
837  int etaErrBin = conf_.getParameter<int>( "etaErrBin");
838  double etaErrMin = conf_.getParameter<double>("etaErrMin");
839  double etaErrMax = conf_.getParameter<double>("etaErrMax");
840 
841 
842  double Chi2ProbMin = conf_.getParameter<double>("Chi2ProbMin");
843  double Chi2ProbMax = conf_.getParameter<double>("Chi2ProbMax");
844 
845  ibooker.setCurrentFolder(TopFolder_);
846 
847  TkParameterMEs tkmes;
848 
849  std::string histTag = (sname == "default") ? CategoryName : sname + "_" + CategoryName;
850 
851  if(doAllPlots_) {
852 
853  // general properties
854  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
855 
856  if (doThetaPlots_) {
857  histname = "Chi2oNDFVsTheta_" + histTag;
858  tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
859  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
860  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
861  }
862  histname = "Chi2oNDFVsPhi_" + histTag;
863  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
864  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
865  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
866 
867  histname = "Chi2oNDFVsEta_" + histTag;
868  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
869  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
870  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
871 
872  histname = "Chi2ProbVsPhi_" + histTag;
873  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
874  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi" ,1);
875  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
876 
877  histname = "Chi2ProbVsEta_" + histTag;
878  tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
879  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta" ,1);
880  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
881 
882  }
883 
884  // general properties
885  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
886 
887  histname = "TrackP_" + histTag;
888  tkmes.TrackP = ibooker.book1D(histname, histname, TrackPBin, TrackPMin, TrackPMax);
889  tkmes.TrackP->setAxisTitle("Track |p| (GeV/c)", 1);
890  tkmes.TrackP->setAxisTitle("Number of Tracks",2);
891 
892  histname = "TrackPt_" + histTag;
893  tkmes.TrackPt = ibooker.book1D(histname, histname, TrackPtBin, TrackPtMin, TrackPtMax);
894  tkmes.TrackPt->setAxisTitle("Track p_{T} (GeV/c)", 1);
895  tkmes.TrackPt->setAxisTitle("Number of Tracks",2);
896 
897  if (doTrackPxPyPlots_) {
898  histname = "TrackPx_" + histTag;
899  tkmes.TrackPx = ibooker.book1D(histname, histname, TrackPxBin, TrackPxMin, TrackPxMax);
900  tkmes.TrackPx->setAxisTitle("Track p_{x} (GeV/c)", 1);
901  tkmes.TrackPx->setAxisTitle("Number of Tracks",2);
902 
903  histname = "TrackPy_" + histTag;
904  tkmes.TrackPy = ibooker.book1D(histname, histname, TrackPyBin, TrackPyMin, TrackPyMax);
905  tkmes.TrackPy->setAxisTitle("Track p_{y} (GeV/c)", 1);
906  tkmes.TrackPy->setAxisTitle("Number of Tracks",2);
907  }
908  histname = "TrackPz_" + histTag;
909  tkmes.TrackPz = ibooker.book1D(histname, histname, TrackPzBin, TrackPzMin, TrackPzMax);
910  tkmes.TrackPz->setAxisTitle("Track p_{z} (GeV/c)", 1);
911  tkmes.TrackPz->setAxisTitle("Number of Tracks",2);
912 
913  histname = "TrackPhi_" + histTag;
914  tkmes.TrackPhi = ibooker.book1D(histname, histname, PhiBin, PhiMin, PhiMax);
915  tkmes.TrackPhi->setAxisTitle("Track #phi", 1);
916  tkmes.TrackPhi->setAxisTitle("Number of Tracks",2);
917 
918  histname = "TrackEta_" + histTag;
919  tkmes.TrackEta = ibooker.book1D(histname, histname, EtaBin, EtaMin, EtaMax);
920  tkmes.TrackEta->setAxisTitle("Track #eta", 1);
921  tkmes.TrackEta->setAxisTitle("Number of Tracks",2);
922 
923  if (doThetaPlots_) {
924  histname = "TrackTheta_" + histTag;
925  tkmes.TrackTheta = ibooker.book1D(histname, histname, ThetaBin, ThetaMin, ThetaMax);
926  tkmes.TrackTheta->setAxisTitle("Track #theta", 1);
927  tkmes.TrackTheta->setAxisTitle("Number of Tracks",2);
928  }
929  histname = "TrackQ_" + histTag;
930  tkmes.TrackQ = ibooker.book1D(histname, histname, TrackQBin, TrackQMin, TrackQMax);
931  tkmes.TrackQ->setAxisTitle("Track Charge", 1);
932  tkmes.TrackQ->setAxisTitle("Number of Tracks",2);
933 
934  histname = "TrackPErrOverP_" + histTag;
935  tkmes.TrackPErr = ibooker.book1D(histname, histname, pErrBin, pErrMin, pErrMax);
936  tkmes.TrackPErr->setAxisTitle("track error(p)/p", 1);
937  tkmes.TrackPErr->setAxisTitle("Number of Tracks",2);
938 
939  histname = "TrackPtErrOverPt_" + histTag;
940  tkmes.TrackPtErr = ibooker.book1D(histname, histname, ptErrBin, ptErrMin, ptErrMax);
941  tkmes.TrackPtErr->setAxisTitle("track error(p_{T})/p_{T}", 1);
942  tkmes.TrackPtErr->setAxisTitle("Number of Tracks",2);
943 
944  histname = "TrackPtErrOverPtVsEta_" + histTag;
945  tkmes.TrackPtErrVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, ptErrMin, ptErrMax);
946  tkmes.TrackPtErrVsEta->setAxisTitle("Track #eta",1);
947  tkmes.TrackPtErrVsEta->setAxisTitle("track error(p_{T})/p_{T}", 2);
948 
949  if (doTrackPxPyPlots_) {
950  histname = "TrackPxErrOverPx_" + histTag;
951  tkmes.TrackPxErr = ibooker.book1D(histname, histname, pxErrBin, pxErrMin, pxErrMax);
952  tkmes.TrackPxErr->setAxisTitle("track error(p_{x})/p_{x}", 1);
953  tkmes.TrackPxErr->setAxisTitle("Number of Tracks",2);
954 
955  histname = "TrackPyErrOverPy_" + histTag;
956  tkmes.TrackPyErr = ibooker.book1D(histname, histname, pyErrBin, pyErrMin, pyErrMax);
957  tkmes.TrackPyErr->setAxisTitle("track error(p_{y})/p_{y}", 1);
958  tkmes.TrackPyErr->setAxisTitle("Number of Tracks",2);
959  }
960  histname = "TrackPzErrOverPz_" + histTag;
961  tkmes.TrackPzErr = ibooker.book1D(histname, histname, pzErrBin, pzErrMin, pzErrMax);
962  tkmes.TrackPzErr->setAxisTitle("track error(p_{z})/p_{z}", 1);
963  tkmes.TrackPzErr->setAxisTitle("Number of Tracks",2);
964 
965  histname = "TrackPhiErr_" + histTag;
966  tkmes.TrackPhiErr = ibooker.book1D(histname, histname, phiErrBin, phiErrMin, phiErrMax);
967  tkmes.TrackPhiErr->setAxisTitle("track error(#phi)");
968  tkmes.TrackPhiErr->setAxisTitle("Number of Tracks",2);
969 
970  histname = "TrackEtaErr_" + histTag;
971  tkmes.TrackEtaErr = ibooker.book1D(histname, histname, etaErrBin, etaErrMin, etaErrMax);
972  tkmes.TrackEtaErr->setAxisTitle("track error(#eta)");
973  tkmes.TrackEtaErr->setAxisTitle("Number of Tracks",2);
974 
975  // rec hit profiles
976  ibooker.setCurrentFolder(TopFolder_+"/GeneralProperties");
977  histname = "NumberOfRecHitsPerTrackVsPhi_" + histTag;
978  tkmes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitBin, RecHitMin, RecHitMax,"");
979  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
980  tkmes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of RecHits in each Track",2);
981 
982  if (doThetaPlots_) {
983  histname = "NumberOfRecHitsPerTrackVsTheta_" + histTag;
984  tkmes.NumberOfRecHitsPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecHitBin, RecHitMin, RecHitMax,"");
985  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Track #phi",1);
986  tkmes.NumberOfRecHitsPerTrackVsTheta->setAxisTitle("Number of RecHits in each Track",2);
987  }
988  histname = "NumberOfRecHitsPerTrackVsEta_" + histTag;
989  tkmes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitBin, RecHitMin, RecHitMax,"");
990  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
991  tkmes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of RecHits in each Track",2);
992 
993  histname = "NumberOfValidRecHitsPerTrackVsPhi_" + histTag;
994  tkmes.NumberOfValidRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecHitMin, RecHitMax,"");
995  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
996  tkmes.NumberOfValidRecHitsPerTrackVsPhi->setAxisTitle("Number of valid RecHits in each Track",2);
997 
998  // std::cout << "[TrackAnalyzer::bookHistosForState] histTag: " << histTag << std::endl;
999  histname = "NumberOfValidRecHitsPerTrackVsEta_" + histTag;
1000  tkmes.NumberOfValidRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecHitMin, RecHitMax,"");
1001  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
1002  tkmes.NumberOfValidRecHitsPerTrackVsEta->setAxisTitle("Number of valid RecHits in each Track",2);
1003 
1005  histname = "NumberOfLayersPerTrackVsPhi_" + histTag;
1006  tkmes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, RecLayBin, RecLayMin, RecLayMax,"");
1007  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
1008  tkmes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of Layers in each Track",2);
1009 
1010  if (doThetaPlots_) {
1011  histname = "NumberOfLayersPerTrackVsTheta_" + histTag;
1012  tkmes.NumberOfLayersPerTrackVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, RecLayBin, RecLayMin, RecLayMax,"");
1013  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Track #phi",1);
1014  tkmes.NumberOfLayersPerTrackVsTheta->setAxisTitle("Number of Layers in each Track",2);
1015  }
1016  histname = "NumberOfLayersPerTrackVsEta_" + histTag;
1017  tkmes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, RecLayBin, RecLayMin, RecLayMax,"");
1018  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
1019  tkmes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of Layers in each Track",2);
1020 
1021  if (doThetaPlots_) {
1022  histname = "Chi2oNDFVsTheta_" + histTag;
1023  tkmes.Chi2oNDFVsTheta = ibooker.bookProfile(histname, histname, ThetaBin, ThetaMin, ThetaMax, Chi2NDFMin, Chi2NDFMax,"");
1024  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #theta",1);
1025  tkmes.Chi2oNDFVsTheta->setAxisTitle("Track #chi^{2}/ndf",2);
1026  }
1027  if (doAllPlots_) {
1028  histname = "Chi2oNDFVsPhi_" + histTag;
1029  tkmes.Chi2oNDFVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, Chi2NDFMin, Chi2NDFMax,"");
1030  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #phi",1);
1031  tkmes.Chi2oNDFVsPhi->setAxisTitle("Track #chi^{2}/ndf",2);
1032 
1033  histname = "Chi2oNDFVsEta_" + histTag;
1034  tkmes.Chi2oNDFVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, Chi2NDFMin, Chi2NDFMax,"");
1035  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #eta",1);
1036  tkmes.Chi2oNDFVsEta->setAxisTitle("Track #chi^{2}/ndf",2);
1037 
1038  histname = "Chi2ProbVsPhi_" + histTag;
1039  tkmes.Chi2ProbVsPhi = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, PhiBin, PhiMin, PhiMax, Chi2ProbMin, Chi2ProbMax);
1040  tkmes.Chi2ProbVsPhi->setAxisTitle("Tracks #phi" ,1);
1041  tkmes.Chi2ProbVsPhi->setAxisTitle("Track #chi^{2} probability",2);
1042 
1043  histname = "Chi2ProbVsEta_" + histTag;
1044  tkmes.Chi2ProbVsEta = ibooker.bookProfile(histname+CategoryName, histname+CategoryName, EtaBin, EtaMin, EtaMax, Chi2ProbMin, Chi2ProbMax);
1045  tkmes.Chi2ProbVsEta->setAxisTitle("Tracks #eta" ,1);
1046  tkmes.Chi2ProbVsEta->setAxisTitle("Track #chi^{2} probability",2);
1047  }
1048 
1049  // now put the MEs in the map
1050  TkParameterMEMap.insert( std::make_pair(sname, tkmes) );
1051 
1052 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::TkParameterMEMap
std::map< std::string, TkParameterMEs > TkParameterMEMap
Definition: TrackAnalyzer.h:194
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:32
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
TrackAnalyzer::doTrackPxPyPlots_
bool doTrackPxPyPlots_
Definition: TrackAnalyzer.h:84
HLT_25ns14e33_v3_cff.EtaMax
tuple EtaMax
Definition: HLT_25ns14e33_v3_cff.py:1747
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
TrackAnalyzer::histname
std::string histname
Definition: TrackAnalyzer.h:281
void TrackAnalyzer::bookHistosForTrackerSpecific ( DQMStore::IBooker &  ibooker)
private

Definition at line 1192 of file TrackAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, DQMStore::IBooker::book1D(), DQMStore::IBooker::bookProfile(), conf_, TrackAnalyzer::TkRecHitsPerSubDetMEs::detectorId, TrackAnalyzer::TkRecHitsPerSubDetMEs::detectorTag, HLT_25ns14e33_v3_cff::EtaMax, Gflash::EtaMin, edm::ParameterSet::getParameter(), histname, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfLayersPerTrack, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfLayersPerTrackVsEta, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfLayersPerTrackVsPhi, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfRecHitsPerTrack, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfRecHitsPerTrackVsEta, TrackAnalyzer::TkRecHitsPerSubDetMEs::NumberOfRecHitsPerTrackVsPhi, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, produceOfflineValidationTex::subdetectors, StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, TkRecHitsPerSubDetMEMap, StripSubdetector::TOB, and TopFolder_.

Referenced by initHisto().

1193 {
1194 
1195  // parameters from the configuration
1196  std::string QualName = conf_.getParameter<std::string>("Quality");
1197  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
1198 
1199  // use the AlgoName and Quality Name
1200  std::string CategoryName = QualName != "" ? AlgoName + "_" + QualName : AlgoName;
1201 
1202  int PhiBin = conf_.getParameter<int>( "PhiBin");
1203  double PhiMin = conf_.getParameter<double>("PhiMin");
1204  double PhiMax = conf_.getParameter<double>("PhiMax");
1205 
1206  int EtaBin = conf_.getParameter<int>( "EtaBin");
1207  double EtaMin = conf_.getParameter<double>("EtaMin");
1208  double EtaMax = conf_.getParameter<double>("EtaMax");
1209 
1210  // book hit property histograms
1211  // ---------------------------------------------------------------------------------//
1212  ibooker.setCurrentFolder(TopFolder_+"/HitProperties");
1213 
1214 
1215 
1216  std::vector<std::string> subdetectors = conf_.getParameter<std::vector<std::string> >("subdetectors");
1217  int detBin = conf_.getParameter<int>("subdetectorBin");
1218 
1219  for ( auto det : subdetectors ) {
1220 
1221  // hits properties
1222  ibooker.setCurrentFolder(TopFolder_+"/HitProperties/"+det);
1223 
1224  TkRecHitsPerSubDetMEs recHitsPerSubDet_mes;
1225 
1226  recHitsPerSubDet_mes.detectorTag = det;
1227  int detID = -1;
1228  if ( det == "TIB" ) detID = StripSubdetector::TIB;
1229  if ( det == "TOB" ) detID = StripSubdetector::TOB;
1230  if ( det == "TID" ) detID = StripSubdetector::TID;
1231  if ( det == "TEC" ) detID = StripSubdetector::TEC;
1232  if ( det == "PixBarrel" ) detID = PixelSubdetector::PixelBarrel;
1233  if ( det == "PixEndcap" ) detID = PixelSubdetector::PixelEndcap;
1234  recHitsPerSubDet_mes.detectorId = detID;
1235 
1236  histname = "NumberOfRecHitsPerTrack_" + det + "_" + CategoryName;
1237  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
1238  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of " + det + " valid RecHits in each Track",1);
1239  recHitsPerSubDet_mes.NumberOfRecHitsPerTrack->setAxisTitle("Number of Tracks", 2);
1240 
1241  histname = "NumberOfRecHitsPerTrackVsPhi_" + det + "_" + CategoryName;
1242  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
1243  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Track #phi",1);
1244  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsPhi->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
1245 
1246  histname = "NumberOfRecHitsPerTrackVsEta_" + det + "_" + CategoryName;
1247  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
1248  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Track #eta",1);
1249  recHitsPerSubDet_mes.NumberOfRecHitsPerTrackVsEta->setAxisTitle("Number of " + det + " valid RecHits in each Track",2);
1250 
1251  histname = "NumberOfLayersPerTrack_" + det + "_" + CategoryName;
1252  recHitsPerSubDet_mes.NumberOfLayersPerTrack = ibooker.book1D(histname, histname, detBin, -0.5, double(detBin)-0.5);
1253  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of " + det + " valid Layers in each Track",1);
1254  recHitsPerSubDet_mes.NumberOfLayersPerTrack->setAxisTitle("Number of Tracks", 2);
1255 
1256  histname = "NumberOfLayersPerTrackVsPhi_" + det + "_" + CategoryName;
1257  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi = ibooker.bookProfile(histname, histname, PhiBin, PhiMin, PhiMax, detBin, -0.5, double(detBin)-0.5,"");
1258  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Track #phi",1);
1259  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsPhi->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
1260 
1261  histname = "NumberOfLayersPerTrackVsEta_" + det + "_" + CategoryName;
1262  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta = ibooker.bookProfile(histname, histname, EtaBin, EtaMin, EtaMax, detBin, -0.5, double(detBin)-0.5,"");
1263  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Track #eta",1);
1264  recHitsPerSubDet_mes.NumberOfLayersPerTrackVsEta->setAxisTitle("Number of " + det + " valid Layers in each Track",2);
1265 
1266  TkRecHitsPerSubDetMEMap.insert(std::pair<std::string,TkRecHitsPerSubDetMEs>(det,recHitsPerSubDet_mes));
1267 
1268 
1269  }
1270 
1271 
1272 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::TkRecHitsPerSubDetMEMap
std::map< std::string, TkRecHitsPerSubDetMEs > TkRecHitsPerSubDetMEMap
Definition: TrackAnalyzer.h:277
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::TopFolder_
std::string TopFolder_
Definition: TrackAnalyzer.h:59
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
Gflash::EtaMin
const double EtaMin[kNumberCalorimeter]
Definition: GflashNameSpace.h:32
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
HLT_25ns14e33_v1_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns14e33_v1_cff.py:1043
HLT_25ns14e33_v3_cff.EtaMax
tuple EtaMax
Definition: HLT_25ns14e33_v3_cff.py:1747
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
TrackAnalyzer::histname
std::string histname
Definition: TrackAnalyzer.h:281
void TrackAnalyzer::doReset ( )

Definition at line 1347 of file TrackAnalyzer.cc.

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

Referenced by TrackingMonitor::beginLuminosityBlock().

1347  {
1348  TkParameterMEs tkmes;
1349  if ( Chi2oNDF_lumiFlag ) Chi2oNDF_lumiFlag -> Reset();
1350  if ( NumberOfRecHitsPerTrack_lumiFlag ) NumberOfRecHitsPerTrack_lumiFlag -> Reset();
1351 }
TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:258
TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:259
HcalObjRepresent::Reset
void Reset(std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:620
void TrackAnalyzer::doSoftReset ( DQMStore *  dqmStore_)

Definition at line 1339 of file TrackAnalyzer.cc.

References Chi2oNDF, NumberOfRecHitsPerTrack, and DQMStore::softReset().

1339  {
1340  TkParameterMEs tkmes;
1341  dqmStore_->softReset(Chi2oNDF);
1342  dqmStore_->softReset(NumberOfRecHitsPerTrack);
1343 }
TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:197
DQMStore::softReset
void softReset(MonitorElement *me)
Definition: DQMStore.cc:3363
TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:221
void TrackAnalyzer::fillHistosForHitProperties ( const edm::EventSetup &  iSetup,
const reco::Track &  track,
std::string  sname 
)
private
void 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 1057 of file TrackAnalyzer.cc.

References TrajectoryStateOnSurface::cartesianError(), TrajectoryStateOnSurface::charge(), reco::TrackBase::charge(), reco::TrackBase::chi2(), TrackAnalyzer::TkParameterMEs::Chi2oNDFVsEta, TrackAnalyzer::TkParameterMEs::Chi2oNDFVsPhi, TrackAnalyzer::TkParameterMEs::Chi2oNDFVsTheta, TrackAnalyzer::TkParameterMEs::Chi2ProbVsEta, TrackAnalyzer::TkParameterMEs::Chi2ProbVsPhi, TrajectoryStateOnSurface::curvilinearError(), doAllPlots_, doThetaPlots_, doTrackPxPyPlots_, benchmark_cfg::errors, PV3DBase< T, PVType, FrameType >::eta(), eta(), reco::TrackBase::eta(), reco::TrackBase::etaError(), MonitorElement::Fill(), edm::EventSetup::get(), TrajectoryStateOnSurface::globalMomentum(), reco::TrackBase::hitPattern(), reco::TransientTrack::impactPointState(), reco::TransientTrack::innermostMeasurementState(), PV3DBase< T, PVType, FrameType >::mag(), CartesianTrajectoryError::matrix(), CurvilinearTrajectoryError::matrix(), reco::TrackBase::ndof(), reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfHits(), TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsPhi, TrackAnalyzer::TkParameterMEs::NumberOfLayersPerTrackVsTheta, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsPhi, TrackAnalyzer::TkParameterMEs::NumberOfRecHitsPerTrackVsTheta, reco::TrackBase::numberOfValidHits(), TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsEta, TrackAnalyzer::TkParameterMEs::NumberOfValidRecHitsPerTrackVsPhi, reco::TransientTrack::outermostMeasurementState(), AlCaHLTBitMon_ParallelJobs::p, reco::TrackBase::p(), PV3DBase< T, PVType, FrameType >::perp(), phi, PV3DBase< T, PVType, FrameType >::phi(), reco::TrackBase::phi(), reco::TrackBase::phiError(), funct::pow(), EnergyCorrector::pt, reco::TrackBase::pt(), reco::TrackBase::ptError(), reco::TrackBase::px(), reco::TrackBase::py(), reco::TrackBase::pz(), lumiQueryAPI::q, funct::sin(), mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::theta(), theta(), reco::TrackBase::theta(), TkParameterMEMap, reco::HitPattern::TRACK_HITS, reco::HitPattern::trackerLayersWithMeasurement(), TrackAnalyzer::TkParameterMEs::TrackEta, TrackAnalyzer::TkParameterMEs::TrackEtaErr, TrackAnalyzer::TkParameterMEs::TrackP, TrackAnalyzer::TkParameterMEs::TrackPErr, TrackAnalyzer::TkParameterMEs::TrackPhi, TrackAnalyzer::TkParameterMEs::TrackPhiErr, TrackAnalyzer::TkParameterMEs::TrackPt, TrackAnalyzer::TkParameterMEs::TrackPtErr, TrackAnalyzer::TkParameterMEs::TrackPtErrVsEta, TrackAnalyzer::TkParameterMEs::TrackPx, TrackAnalyzer::TkParameterMEs::TrackPxErr, TrackAnalyzer::TkParameterMEs::TrackPy, TrackAnalyzer::TkParameterMEs::TrackPyErr, TrackAnalyzer::TkParameterMEs::TrackPz, TrackAnalyzer::TkParameterMEs::TrackPzErr, TrackAnalyzer::TkParameterMEs::TrackQ, TrackAnalyzer::TkParameterMEs::TrackTheta, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

1058 {
1059  //get the kinematic parameters
1060  double p, px, py, pz, pt, theta, phi, eta, q;
1061  double pxerror, pyerror, pzerror, pterror, perror, phierror, etaerror;
1062 
1063  if (sname == "default") {
1064 
1065  p = track.p();
1066  px = track.px();
1067  py = track.py();
1068  pz = track.pz();
1069  pt = track.pt();
1070  phi = track.phi();
1071  theta = track.theta();
1072  eta = track.eta();
1073  q = track.charge();
1074 
1075  pterror = (pt) ? track.ptError()/(pt*pt) : 0.0;
1076  pxerror = -1.0;
1077  pyerror = -1.0;
1078  pzerror = -1.0;
1079  perror = -1.0;
1080  phierror = track.phiError();
1081  etaerror = track.etaError();
1082 
1083  } else {
1084 
1085  edm::ESHandle<TransientTrackBuilder> theB;
1086  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
1087  reco::TransientTrack TransTrack = theB->build(track);
1088 
1089  TrajectoryStateOnSurface TSOS;
1090 
1091  if (sname == "OuterSurface") TSOS = TransTrack.outermostMeasurementState();
1092  else if (sname == "InnerSurface") TSOS = TransTrack.innermostMeasurementState();
1093  else if (sname == "ImpactPoint") TSOS = TransTrack.impactPointState();
1094 
1095  p = TSOS.globalMomentum().mag();
1096  px = TSOS.globalMomentum().x();
1097  py = TSOS.globalMomentum().y();
1098  pz = TSOS.globalMomentum().z();
1099  pt = TSOS.globalMomentum().perp();
1100  phi = TSOS.globalMomentum().phi();
1101  theta = TSOS.globalMomentum().theta();
1102  eta = TSOS.globalMomentum().eta();
1103  q = TSOS.charge();
1104 
1105  //get the error of the kinimatic parameters
1106  AlgebraicSymMatrix66 errors = TSOS.cartesianError().matrix();
1107  double partialPterror = errors(3,3)*pow(TSOS.globalMomentum().x(),2) + errors(4,4)*pow(TSOS.globalMomentum().y(),2);
1108  pterror = sqrt(partialPterror)/TSOS.globalMomentum().perp();
1109  pxerror = sqrt(errors(3,3))/TSOS.globalMomentum().x();
1110  pyerror = sqrt(errors(4,4))/TSOS.globalMomentum().y();
1111  pzerror = sqrt(errors(5,5))/TSOS.globalMomentum().z();
1112  perror = sqrt(partialPterror+errors(5,5)*pow(TSOS.globalMomentum().z(),2))/TSOS.globalMomentum().mag();
1113  phierror = sqrt(TSOS.curvilinearError().matrix()(2,2));
1114  etaerror = sqrt(TSOS.curvilinearError().matrix()(1,1))*fabs(sin(TSOS.globalMomentum().theta()));
1115 
1116  }
1117 
1118  std::map<std::string, TkParameterMEs>::iterator iPos = TkParameterMEMap.find(sname);
1119  if (iPos != TkParameterMEMap.end()) {
1120 
1121  TkParameterMEs tkmes = iPos->second;
1122 
1123  // momentum
1124  tkmes.TrackP->Fill(p);
1125  if (doTrackPxPyPlots_) {
1126  tkmes.TrackPx->Fill(px);
1127  tkmes.TrackPy->Fill(py);
1128  }
1129  tkmes.TrackPz->Fill(pz);
1130  tkmes.TrackPt->Fill(pt);
1131 
1132  // angles
1133  tkmes.TrackPhi->Fill(phi);
1134  tkmes.TrackEta->Fill(eta);
1135  if (doThetaPlots_) {
1136  tkmes.TrackTheta->Fill(theta);
1137  }
1138  tkmes.TrackQ->Fill(q);
1139 
1140  // errors
1141  tkmes.TrackPtErr->Fill(pterror);
1142  tkmes.TrackPtErrVsEta->Fill(eta,pterror);
1143  if (doTrackPxPyPlots_) {
1144  tkmes.TrackPxErr->Fill(pxerror);
1145  tkmes.TrackPyErr->Fill(pyerror);
1146  }
1147  tkmes.TrackPzErr->Fill(pzerror);
1148  tkmes.TrackPErr->Fill(perror);
1149  tkmes.TrackPhiErr->Fill(phierror);
1150  tkmes.TrackEtaErr->Fill(etaerror);
1151 
1152  int nRecHits = track.hitPattern().numberOfHits(reco::HitPattern::TRACK_HITS);
1153  int nValidRecHits = track.numberOfValidHits();
1154  // rec hits
1155  tkmes.NumberOfRecHitsPerTrackVsPhi->Fill(phi, nRecHits);
1156  if (doThetaPlots_) {
1157  tkmes.NumberOfRecHitsPerTrackVsTheta->Fill(theta,nRecHits);
1158  }
1159  tkmes.NumberOfRecHitsPerTrackVsEta->Fill(eta, nRecHits);
1160 
1161  tkmes.NumberOfValidRecHitsPerTrackVsPhi->Fill(phi, nValidRecHits);
1162  tkmes.NumberOfValidRecHitsPerTrackVsEta->Fill(eta, nValidRecHits);
1163 
1164  int nLayers = track.hitPattern().trackerLayersWithMeasurement();
1165  // rec layers
1166  tkmes.NumberOfLayersPerTrackVsPhi->Fill(phi, nLayers);
1167  if (doThetaPlots_) {
1168  tkmes.NumberOfLayersPerTrackVsTheta->Fill(theta, nLayers);
1169  }
1170  tkmes.NumberOfLayersPerTrackVsEta->Fill(eta, nLayers);
1171 
1172  double chi2prob = TMath::Prob(track.chi2(),(int)track.ndof());
1173  double chi2oNDF = track.normalizedChi2();
1174 
1175  if(doAllPlots_) {
1176 
1177  // general properties
1178  if (doThetaPlots_) {
1179  tkmes.Chi2oNDFVsTheta->Fill(theta, chi2oNDF);
1180  }
1181  tkmes.Chi2oNDFVsPhi->Fill(phi, chi2oNDF);
1182  tkmes.Chi2oNDFVsEta->Fill(eta, chi2oNDF);
1183  tkmes.Chi2ProbVsPhi->Fill(phi, chi2prob);
1184  tkmes.Chi2ProbVsEta->Fill(eta, chi2prob);
1185  }
1186 
1187  }
1188 
1189 }
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:568
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:72
benchmark_cfg.errors
tuple errors
Definition: benchmark_cfg.py:136
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:514
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:532
TrajectoryStateOnSurface::curvilinearError
const CurvilinearTrajectoryError & curvilinearError() const
Definition: TrajectoryStateOnSurface.h:110
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
AlgebraicSymMatrix66
ROOT::Math::SMatrix< double, 6, 6, ROOT::Math::MatRepSym< double, 6 > > AlgebraicSymMatrix66
Definition: AlgebraicROOTObjects.h:32
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:69
TrajectoryStateOnSurface::cartesianError
const CartesianTrajectoryError cartesianError() const
Definition: TrajectoryStateOnSurface.h:107
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:170
PV3DBase::y
T y() const
Definition: PV3DBase.h:63
reco::TrackBase::etaError
double etaError() const
error on eta
Definition: TrackBase.h:737
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:598
TrackAnalyzer::TkParameterMEMap
std::map< std::string, TkParameterMEs > TkParameterMEMap
Definition: TrackAnalyzer.h:194
reco::TrackBase::px
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:580
eta
T eta() const
Definition: Basic3DVectorLD.h:177
reco::HitPattern::trackerLayersWithMeasurement
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:477
reco::TransientTrack::innermostMeasurementState
TrajectoryStateOnSurface innermostMeasurementState() const
Definition: TransientTrack.h:81
PV3DBase::theta
Geom::Theta< T > theta() const
Definition: PV3DBase.h:75
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:67
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:604
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:502
reco::TrackBase::ndof
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:508
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:574
PV3DBase::z
T z() const
Definition: PV3DBase.h:64
reco::TrackBase::ptError
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:716
reco::TrackBase::phiError
double phiError() const
error on phi
Definition: TrackBase.h:743
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:773
reco::TransientTrack::outermostMeasurementState
TrajectoryStateOnSurface outermostMeasurementState() const
Definition: TransientTrack.h:78
CartesianTrajectoryError::matrix
const AlgebraicSymMatrix66 & matrix() const
Definition: CartesianTrajectoryError.h:29
reco::TrackBase::pz
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:592
TSOS
TrajectoryStateOnSurface TSOS
Definition: TestHits.cc:19
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:411
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:76
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
TrackAnalyzer::doTrackPxPyPlots_
bool doTrackPxPyPlots_
Definition: TrackAnalyzer.h:84
CurvilinearTrajectoryError::matrix
const AlgebraicSymMatrix55 & matrix() const
Definition: CurvilinearTrajectoryError.h:64
TrajectoryStateOnSurface::globalMomentum
GlobalVector globalMomentum() const
Definition: TrajectoryStateOnSurface.h:92
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:520
reco::TransientTrack::impactPointState
TrajectoryStateOnSurface impactPointState() const
Definition: TransientTrack.h:94
PV3DBase::x
T x() const
Definition: PV3DBase.h:62
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:40
reco::TrackBase::py
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:586
reco::HitPattern::numberOfHits
int numberOfHits(HitCategory category) const
Definition: HitPattern.h:718
phi
Definition: DDAxes.h:10
void TrackAnalyzer::fillHistosForTrackerSpecific ( const reco::Track &  track)
private

Definition at line 1275 of file TrackAnalyzer.cc.

References eta(), reco::TrackBase::eta(), HcalObjRepresent::Fill(), reco::TrackBase::hitPattern(), reco::HitPattern::numberOfValidPixelBarrelHits(), reco::HitPattern::numberOfValidPixelEndcapHits(), reco::HitPattern::numberOfValidStripTECHits(), reco::HitPattern::numberOfValidStripTIBHits(), reco::HitPattern::numberOfValidStripTIDHits(), reco::HitPattern::numberOfValidStripTOBHits(), phi, reco::TrackBase::phi(), PixelSubdetector::PixelBarrel, reco::HitPattern::pixelBarrelLayersWithMeasurement(), PixelSubdetector::PixelEndcap, reco::HitPattern::pixelEndcapLayersWithMeasurement(), reco::HitPattern::stripTECLayersWithMeasurement(), reco::HitPattern::stripTIBLayersWithMeasurement(), reco::HitPattern::stripTIDLayersWithMeasurement(), reco::HitPattern::stripTOBLayersWithMeasurement(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, TkRecHitsPerSubDetMEMap, and StripSubdetector::TOB.

Referenced by analyze().

1276 {
1277 
1278  double phi = track.phi();
1279  double eta = track.eta();
1280 
1281  for ( std::map<std::string,TkRecHitsPerSubDetMEs>::iterator it = TkRecHitsPerSubDetMEMap.begin();
1282  it != TkRecHitsPerSubDetMEMap.end(); it++ ) {
1283 
1284  int nValidLayers = 0;
1285  int nValidRecHits = 0;
1286  int substr = it->second.detectorId;
1287  switch(substr) {
1288  case StripSubdetector::TIB :
1289  nValidLayers = track.hitPattern().stripTIBLayersWithMeasurement(); // case 0: strip TIB
1290  nValidRecHits = track.hitPattern().numberOfValidStripTIBHits(); // case 0: strip TIB
1291  break;
1292  case StripSubdetector::TID :
1293  nValidLayers = track.hitPattern().stripTIDLayersWithMeasurement(); // case 0: strip TID
1294  nValidRecHits = track.hitPattern().numberOfValidStripTIDHits(); // case 0: strip TID
1295  break;
1296  case StripSubdetector::TOB :
1297  nValidLayers = track.hitPattern().stripTOBLayersWithMeasurement(); // case 0: strip TOB
1298  nValidRecHits = track.hitPattern().numberOfValidStripTOBHits(); // case 0: strip TOB
1299  break;
1300  case StripSubdetector::TEC :
1301  nValidLayers = track.hitPattern().stripTECLayersWithMeasurement(); // case 0: strip TEC
1302  nValidRecHits = track.hitPattern().numberOfValidStripTECHits(); // case 0: strip TEC
1303  break;
1304  case PixelSubdetector::PixelBarrel :
1305  nValidLayers = track.hitPattern().pixelBarrelLayersWithMeasurement(); // case 0: pixel PXB
1306  nValidRecHits = track.hitPattern().numberOfValidPixelBarrelHits(); // case 0: pixel PXB
1307  break;
1308  case PixelSubdetector::PixelEndcap :
1309  nValidLayers = track.hitPattern().pixelEndcapLayersWithMeasurement(); // case 0: pixel PXF
1310  nValidRecHits = track.hitPattern().numberOfValidPixelEndcapHits(); // case 0: pixel PXF
1311  break;
1312  default :
1313  break;
1314  }
1315 
1316  //Fill Layers and RecHits
1317  it->second.NumberOfRecHitsPerTrack -> Fill(nValidRecHits);
1318  it->second.NumberOfRecHitsPerTrackVsPhi -> Fill(phi, nValidRecHits);
1319  it->second.NumberOfRecHitsPerTrackVsEta -> Fill(eta, nValidRecHits);
1320 
1321  it->second.NumberOfLayersPerTrack -> Fill(nValidLayers);
1322  it->second.NumberOfLayersPerTrackVsPhi -> Fill(phi, nValidLayers);
1323  it->second.NumberOfLayersPerTrackVsEta -> Fill(eta, nValidLayers);
1324  }
1325 
1326 }
reco::HitPattern::stripTOBLayersWithMeasurement
int stripTOBLayersWithMeasurement() const
Definition: HitPattern.cc:563
reco::HitPattern::stripTIBLayersWithMeasurement
int stripTIBLayersWithMeasurement() const
Definition: HitPattern.cc:541
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:598
eta
T eta() const
Definition: Basic3DVectorLD.h:177
TrackAnalyzer::TkRecHitsPerSubDetMEMap
std::map< std::string, TkRecHitsPerSubDetMEs > TkRecHitsPerSubDetMEMap
Definition: TrackAnalyzer.h:277
reco::HitPattern::pixelEndcapLayersWithMeasurement
int pixelEndcapLayersWithMeasurement() const
Definition: HitPattern.cc:529
reco::HitPattern::numberOfValidStripTOBHits
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:779
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:604
reco::HitPattern::numberOfValidPixelBarrelHits
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:754
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
reco::HitPattern::stripTIDLayersWithMeasurement
int stripTIDLayersWithMeasurement() const
Definition: HitPattern.cc:552
reco::HitPattern::numberOfValidStripTIDHits
int numberOfValidStripTIDHits() const
Definition: HitPattern.h:774
reco::HitPattern::numberOfValidStripTECHits
int numberOfValidStripTECHits() const
Definition: HitPattern.h:784
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:411
reco::HitPattern::pixelBarrelLayersWithMeasurement
int pixelBarrelLayersWithMeasurement() const
Definition: HitPattern.cc:517
reco::HitPattern::numberOfValidStripTIBHits
int numberOfValidStripTIBHits() const
Definition: HitPattern.h:769
reco::HitPattern::numberOfValidPixelEndcapHits
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:759
reco::HitPattern::stripTECLayersWithMeasurement
int stripTECLayersWithMeasurement() const
Definition: HitPattern.cc:574
phi
Definition: DDAxes.h:10
void TrackAnalyzer::initHisto ( DQMStore::IBooker &  ibooker)
virtual

Definition at line 123 of file TrackAnalyzer.cc.

References bookHistosForBeamSpot(), bookHistosForHitProperties(), bookHistosForLScertification(), bookHistosForState(), bookHistosForTrackerSpecific(), conf_, doAllPlots_, doMeasurementStatePlots_, doTrackerSpecific_, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by TrackingMonitor::bookHistograms().

124 {
125 
126  bookHistosForHitProperties(ibooker);
127  bookHistosForBeamSpot(ibooker);
128  bookHistosForLScertification( ibooker);
129 
130  // book tracker specific related histograms
131  // ---------------------------------------------------------------------------------//
132  if(doTrackerSpecific_ || doAllPlots_) bookHistosForTrackerSpecific(ibooker);
133 
134  // book state related histograms
135  // ---------------------------------------------------------------------------------//
136  if (doMeasurementStatePlots_ || doAllPlots_) {
137 
138  std::string StateName = conf_.getParameter<std::string>("MeasurementState");
139 
140  if (StateName == "All") {
141  bookHistosForState("OuterSurface", ibooker);
142  bookHistosForState("InnerSurface", ibooker);
143  bookHistosForState("ImpactPoint" , ibooker);
144  } else if (
145  StateName != "OuterSurface" &&
146  StateName != "InnerSurface" &&
147  StateName != "ImpactPoint" &&
148  StateName != "default"
149  ) {
150  bookHistosForState("default", ibooker);
151 
152  } else {
153  bookHistosForState(StateName, ibooker);
154  }
155 
156  }
157 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackAnalyzer::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackAnalyzer.h:66
TrackAnalyzer::bookHistosForLScertification
void bookHistosForLScertification(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:359
TrackAnalyzer::conf_
edm::ParameterSet conf_
Definition: TrackAnalyzer.h:64
TrackAnalyzer::doMeasurementStatePlots_
bool doMeasurementStatePlots_
Definition: TrackAnalyzer.h:72
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackAnalyzer::bookHistosForHitProperties
void bookHistosForHitProperties(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:159
TrackAnalyzer::bookHistosForTrackerSpecific
void bookHistosForTrackerSpecific(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:1192
TrackAnalyzer::bookHistosForBeamSpot
void bookHistosForBeamSpot(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:398
TrackAnalyzer::bookHistosForState
void bookHistosForState(std::string sname, DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:754
void TrackAnalyzer::initHistos ( )
private

Definition at line 56 of file TrackAnalyzer.cc.

References algorithm, Chi2oNDF, Chi2oNDF_lumiFlag, Chi2oNDFVsEta, Chi2oNDFVsPhi, Chi2oNDFVsTheta, Chi2Prob, Chi2ProbVsEta, Chi2ProbVsPhi, DistanceOfClosestApproach, DistanceOfClosestApproachToBS, DistanceOfClosestApproachToBSVsPhi, DistanceOfClosestApproachVsEta, DistanceOfClosestApproachVsPhi, DistanceOfClosestApproachVsTheta, LongDCASig, NULL, NumberOfLayersPerTrack, NumberOfLayersVsPhiVsEtaPerTrack, NumberOfLostRecHitsPerTrack, NumberOfRecHitsPerTrack, NumberOfRecHitsPerTrack_lumiFlag, NumberOfRecHitsPerTrackVsEta, NumberOfRecHitsPerTrackVsPhi, NumberOfRecHitsPerTrackVsTheta, NumberOfRecHitVsPhiVsEtaPerTrack, NumberOfValidRecHitsPerTrack, NumberOfValidRecHitsPerTrackVsEta, NumberOfValidRecHitsPerTrackVsPhi, TESTDistanceOfClosestApproachToBS, TESTDistanceOfClosestApproachToBSVsPhi, TransDCASig, xPointOfClosestApproach, xPointOfClosestApproachVsZ0wrt000, xPointOfClosestApproachVsZ0wrtBS, yPointOfClosestApproach, yPointOfClosestApproachVsZ0wrt000, yPointOfClosestApproachVsZ0wrtBS, zPointOfClosestApproach, and zPointOfClosestApproachVsPhi.

Referenced by TrackAnalyzer().

57 {
58  Chi2 = NULL;
59  Chi2Prob = NULL;
60  Chi2ProbVsPhi = NULL;
61  Chi2ProbVsEta = NULL;
62  Chi2oNDF = NULL;
63  Chi2oNDFVsEta = NULL;
64  Chi2oNDFVsPhi = NULL;
65  Chi2oNDFVsTheta = NULL;
66  Chi2oNDFVsTheta = NULL;
67  Chi2oNDFVsPhi = NULL;
68  Chi2oNDFVsEta = NULL;
69 
70  NumberOfRecHitsPerTrack = NULL;
71  NumberOfValidRecHitsPerTrack = NULL;
72  NumberOfLostRecHitsPerTrack = NULL;
73 
74  NumberOfRecHitsPerTrackVsPhi = NULL;
75  NumberOfRecHitsPerTrackVsTheta = NULL;
76  NumberOfRecHitsPerTrackVsEta = NULL;
77 
78  NumberOfRecHitVsPhiVsEtaPerTrack = NULL;
79 
80  NumberOfValidRecHitsPerTrackVsPhi = NULL;
81  NumberOfValidRecHitsPerTrackVsEta = NULL;
82 
83  NumberOfLayersPerTrack = NULL;
84  NumberOfLayersVsPhiVsEtaPerTrack = NULL;
85 
86  DistanceOfClosestApproach = NULL;
87  DistanceOfClosestApproachToBS = NULL;
88  DistanceOfClosestApproachVsTheta = NULL;
89  DistanceOfClosestApproachVsPhi = NULL;
90  DistanceOfClosestApproachToBSVsPhi = NULL;
91  DistanceOfClosestApproachVsEta = NULL;
92  xPointOfClosestApproach = NULL;
93  xPointOfClosestApproachVsZ0wrt000 = NULL;
94  xPointOfClosestApproachVsZ0wrtBS = NULL;
95  yPointOfClosestApproach = NULL;
96  yPointOfClosestApproachVsZ0wrt000 = NULL;
97  yPointOfClosestApproachVsZ0wrtBS = NULL;
98  zPointOfClosestApproach = NULL;
99  zPointOfClosestApproachVsPhi = NULL;
100  algorithm = NULL;
101  // TESTING
102  TESTDistanceOfClosestApproachToBS = NULL;
103  TESTDistanceOfClosestApproachToBSVsPhi = NULL;
104 
105 // by Mia in order to deal w/ LS transitions
106  Chi2oNDF_lumiFlag = NULL;
107  NumberOfRecHitsPerTrack_lumiFlag = NULL;
108 
110  //special Plots for HI DQM //SHOULD I ADD THE BOOL HERE??
112  LongDCASig = NULL;
113  TransDCASig = NULL;
114 
115 
116 
117 }
TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack
MonitorElement * NumberOfRecHitVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:204
TrackAnalyzer::NumberOfValidRecHitsPerTrack
MonitorElement * NumberOfValidRecHitsPerTrack
Definition: TrackAnalyzer.h:198
TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:258
TrackAnalyzer::NumberOfLostRecHitsPerTrack
MonitorElement * NumberOfLostRecHitsPerTrack
Definition: TrackAnalyzer.h:199
TrackAnalyzer::Chi2oNDFVsPhi
MonitorElement * Chi2oNDFVsPhi
Definition: TrackAnalyzer.h:224
TrackAnalyzer::Chi2ProbVsPhi
MonitorElement * Chi2ProbVsPhi
Definition: TrackAnalyzer.h:228
TrackAnalyzer::DistanceOfClosestApproachVsPhi
MonitorElement * DistanceOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:235
NULL
#define NULL
Definition: scimark2.h:8
TrackAnalyzer::NumberOfRecHitsPerTrackVsTheta
MonitorElement * NumberOfRecHitsPerTrackVsTheta
Definition: TrackAnalyzer.h:202
TrackAnalyzer::algorithm
MonitorElement * algorithm
Definition: TrackAnalyzer.h:252
TrackAnalyzer::DistanceOfClosestApproach
MonitorElement * DistanceOfClosestApproach
Definition: TrackAnalyzer.h:231
TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:259
TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:197
TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi
MonitorElement * TESTDistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:255
TrackAnalyzer::NumberOfValidRecHitsPerTrackVsEta
MonitorElement * NumberOfValidRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:208
TrackAnalyzer::TransDCASig
MonitorElement * TransDCASig
Definition: TrackAnalyzer.h:263
TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000
MonitorElement * xPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:241
TrackAnalyzer::xPointOfClosestApproach
MonitorElement * xPointOfClosestApproach
Definition: TrackAnalyzer.h:239
TrackAnalyzer::Chi2oNDFVsTheta
MonitorElement * Chi2oNDFVsTheta
Definition: TrackAnalyzer.h:225
TrackAnalyzer::NumberOfRecHitsPerTrackVsPhi
MonitorElement * NumberOfRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:201
TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS
MonitorElement * xPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:242
TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPhi
MonitorElement * NumberOfValidRecHitsPerTrackVsPhi
Definition: TrackAnalyzer.h:206
TrackAnalyzer::DistanceOfClosestApproachVsEta
MonitorElement * DistanceOfClosestApproachVsEta
Definition: TrackAnalyzer.h:238
TrackAnalyzer::zPointOfClosestApproachVsPhi
MonitorElement * zPointOfClosestApproachVsPhi
Definition: TrackAnalyzer.h:251
TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS
MonitorElement * yPointOfClosestApproachVsZ0wrtBS
Definition: TrackAnalyzer.h:247
TrackAnalyzer::NumberOfLayersPerTrack
MonitorElement * NumberOfLayersPerTrack
Definition: TrackAnalyzer.h:211
TrackAnalyzer::DistanceOfClosestApproachVsTheta
MonitorElement * DistanceOfClosestApproachVsTheta
Definition: TrackAnalyzer.h:234
TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi
MonitorElement * DistanceOfClosestApproachToBSVsPhi
Definition: TrackAnalyzer.h:236
TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000
MonitorElement * yPointOfClosestApproachVsZ0wrt000
Definition: TrackAnalyzer.h:246
TrackAnalyzer::TESTDistanceOfClosestApproachToBS
MonitorElement * TESTDistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:254
TrackAnalyzer::NumberOfRecHitsPerTrackVsEta
MonitorElement * NumberOfRecHitsPerTrackVsEta
Definition: TrackAnalyzer.h:203
TrackAnalyzer::yPointOfClosestApproach
MonitorElement * yPointOfClosestApproach
Definition: TrackAnalyzer.h:244
TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack
MonitorElement * NumberOfLayersVsPhiVsEtaPerTrack
Definition: TrackAnalyzer.h:217
TrackAnalyzer::Chi2Prob
MonitorElement * Chi2Prob
Definition: TrackAnalyzer.h:220
Chi2
Definition: Chi2.h:17
TrackAnalyzer::zPointOfClosestApproach
MonitorElement * zPointOfClosestApproach
Definition: TrackAnalyzer.h:249
TrackAnalyzer::Chi2ProbVsEta
MonitorElement * Chi2ProbVsEta
Definition: TrackAnalyzer.h:227
TrackAnalyzer::DistanceOfClosestApproachToBS
MonitorElement * DistanceOfClosestApproachToBS
Definition: TrackAnalyzer.h:232
TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:221
TrackAnalyzer::Chi2oNDFVsEta
MonitorElement * Chi2oNDFVsEta
Definition: TrackAnalyzer.h:223
TrackAnalyzer::LongDCASig
MonitorElement * LongDCASig
Definition: TrackAnalyzer.h:262
void TrackAnalyzer::setLumiFlag ( )

Definition at line 1330 of file TrackAnalyzer.cc.

References Chi2oNDF_lumiFlag, and NumberOfRecHitsPerTrack_lumiFlag.

Referenced by TrackingMonitor::bookHistograms().

1330  {
1331 
1332  TkParameterMEs tkmes;
1333  if ( Chi2oNDF_lumiFlag ) Chi2oNDF_lumiFlag -> setLumiFlag();
1334  if ( NumberOfRecHitsPerTrack_lumiFlag ) NumberOfRecHitsPerTrack_lumiFlag -> setLumiFlag();
1335 }
TrackAnalyzer::Chi2oNDF_lumiFlag
MonitorElement * Chi2oNDF_lumiFlag
Definition: TrackAnalyzer.h:258
TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
MonitorElement * NumberOfRecHitsPerTrack_lumiFlag
Definition: TrackAnalyzer.h:259
void TrackAnalyzer::undoSoftReset ( DQMStore *  dqmStore_)

Definition at line 1355 of file TrackAnalyzer.cc.

References Chi2oNDF, DQMStore::disableSoftReset(), and NumberOfRecHitsPerTrack.

1355  {
1356  TkParameterMEs tkmes;
1357  dqmStore_->disableSoftReset(Chi2oNDF);
1358  dqmStore_->disableSoftReset(NumberOfRecHitsPerTrack);
1359 }
TrackAnalyzer::NumberOfRecHitsPerTrack
MonitorElement * NumberOfRecHitsPerTrack
Definition: TrackAnalyzer.h:197
DQMStore::disableSoftReset
void disableSoftReset(MonitorElement *me)
Definition: DQMStore.cc:3371
TrackAnalyzer::Chi2oNDF
MonitorElement * Chi2oNDF
Definition: TrackAnalyzer.h:221

Member Data Documentation

MonitorElement* TrackAnalyzer::algorithm
private

Definition at line 252 of file TrackAnalyzer.h.

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

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

Definition at line 61 of file TrackAnalyzer.h.

Referenced by analyze(), and TrackAnalyzer().

MonitorElement* TrackAnalyzer::Chi2
private

Definition at line 219 of file TrackAnalyzer.h.

MonitorElement* TrackAnalyzer::Chi2oNDF
private

Definition at line 221 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::Chi2oNDF_lumiFlag
private

Definition at line 258 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::Chi2oNDFVsEta
private

Definition at line 223 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::Chi2oNDFVsPhi
private

Definition at line 224 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::Chi2oNDFVsTheta
private

Definition at line 225 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::Chi2Prob
private

Definition at line 220 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::Chi2ProbVsEta
private

Definition at line 227 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::Chi2ProbVsPhi
private

Definition at line 228 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::Chi2ProbVsTheta
private

Definition at line 229 of file TrackAnalyzer.h.

edm::ParameterSet TrackAnalyzer::conf_
private

Definition at line 64 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproach
private

Definition at line 231 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachToBS
private

Definition at line 232 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachToBSVsPhi
private

Definition at line 236 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachToPV
private

Definition at line 233 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachToPVVsPhi
private

Definition at line 237 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachVsEta
private

Definition at line 238 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachVsPhi
private

Definition at line 235 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::DistanceOfClosestApproachVsTheta
private

Definition at line 234 of file TrackAnalyzer.h.

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

bool TrackAnalyzer::doAllPlots_
private

Definition at line 67 of file TrackAnalyzer.h.

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

bool TrackAnalyzer::doBSPlots_
private

Definition at line 68 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool TrackAnalyzer::doDCAPlots_
private

Definition at line 70 of file TrackAnalyzer.h.

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

bool TrackAnalyzer::doDCAwrt000Plots_
private

Definition at line 88 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool TrackAnalyzer::doDCAwrtPVPlots_
private

Definition at line 87 of file TrackAnalyzer.h.

bool TrackAnalyzer::doGeneralPropertiesPlots_
private

Definition at line 71 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool TrackAnalyzer::doHIPlots_
private

Definition at line 96 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool TrackAnalyzer::doHitPropertiesPlots_
private

Definition at line 73 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool TrackAnalyzer::doLayersVsPhiVsEtaPerTrack_
private

Definition at line 76 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool TrackAnalyzer::doLumiAnalysis_
private

Definition at line 90 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForLScertification().

bool TrackAnalyzer::doMeasurementStatePlots_
private

Definition at line 72 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool TrackAnalyzer::doPVPlots_
private

Definition at line 69 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool TrackAnalyzer::doRecHitsPerTrackProfile_
private

Definition at line 80 of file TrackAnalyzer.h.

bool TrackAnalyzer::doRecHitVsPhiVsEtaPerTrack_
private

Definition at line 74 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForHitProperties().

bool TrackAnalyzer::doTestPlots_
private

Definition at line 93 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

bool TrackAnalyzer::doThetaPlots_
private

Definition at line 83 of file TrackAnalyzer.h.

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

bool TrackAnalyzer::doTrack2DChi2Plots_
private

Definition at line 79 of file TrackAnalyzer.h.

bool TrackAnalyzer::doTrackerSpecific_
private

Definition at line 66 of file TrackAnalyzer.h.

Referenced by analyze(), and initHisto().

bool TrackAnalyzer::doTrackLayersVsPhiVsEtaPerTrack_
private

Definition at line 78 of file TrackAnalyzer.h.

bool TrackAnalyzer::doTrackPxPyPlots_
private

Definition at line 84 of file TrackAnalyzer.h.

Referenced by bookHistosForState(), and fillHistosForState().

bool TrackAnalyzer::doTrackRecHitVsPhiVsEtaPerTrack_
private

Definition at line 77 of file TrackAnalyzer.h.

std::string TrackAnalyzer::histname
private

Definition at line 281 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::LongDCASig
private

Definition at line 262 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfLayersPerTrack
private

Definition at line 211 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfLayersPerTrackVsEta
private

Definition at line 215 of file TrackAnalyzer.h.

MonitorElement* TrackAnalyzer::NumberOfLayersPerTrackVsPhi
private

Definition at line 213 of file TrackAnalyzer.h.

MonitorElement* TrackAnalyzer::NumberOfLayersPerTrackVsTheta
private

Definition at line 214 of file TrackAnalyzer.h.

MonitorElement* TrackAnalyzer::NumberOfLayersVsPhiVsEtaPerTrack
private

Definition at line 217 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfLostRecHitsPerTrack
private

Definition at line 199 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfRecHitsPerTrack
private

Definition at line 197 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfRecHitsPerTrack_lumiFlag
private

Definition at line 259 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfRecHitsPerTrackVsEta
private

Definition at line 203 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::NumberOfRecHitsPerTrackVsPhi
private

Definition at line 201 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::NumberOfRecHitsPerTrackVsTheta
private

Definition at line 202 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::NumberOfRecHitVsPhiVsEtaPerTrack
private

Definition at line 204 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfValidRecHitsPerTrack
private

Definition at line 198 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::NumberOfValidRecHitsPerTrackVsEta
private

Definition at line 208 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::NumberOfValidRecHitsPerTrackVsPhi
private

Definition at line 206 of file TrackAnalyzer.h.

Referenced by initHistos().

MonitorElement* TrackAnalyzer::NumberOfValidRecHitsPerTrackVsTheta
private

Definition at line 207 of file TrackAnalyzer.h.

MonitorElement* TrackAnalyzer::NumberOfValidRecHitVsPhiVsEtaPerTrack
private

Definition at line 209 of file TrackAnalyzer.h.

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

Definition at line 62 of file TrackAnalyzer.h.

Referenced by analyze(), and TrackAnalyzer().

MonitorElement* TrackAnalyzer::TESTDistanceOfClosestApproachToBS
private

Definition at line 254 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::TESTDistanceOfClosestApproachToBSVsPhi
private

Definition at line 255 of file TrackAnalyzer.h.

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

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

Definition at line 194 of file TrackAnalyzer.h.

Referenced by bookHistosForState(), and fillHistosForState().

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

Definition at line 277 of file TrackAnalyzer.h.

Referenced by bookHistosForTrackerSpecific(), and fillHistosForTrackerSpecific().

std::string TrackAnalyzer::TopFolder_
private

Definition at line 59 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::TransDCASig
private

Definition at line 263 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::xPointOfClosestApproach
private

Definition at line 239 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::xPointOfClosestApproachToPV
private

Definition at line 240 of file TrackAnalyzer.h.

Referenced by bookHistosForHitProperties().

MonitorElement* TrackAnalyzer::xPointOfClosestApproachVsZ0wrt000
private

Definition at line 241 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::xPointOfClosestApproachVsZ0wrtBS
private

Definition at line 242 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::xPointOfClosestApproachVsZ0wrtPV
private

Definition at line 243 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* TrackAnalyzer::yPointOfClosestApproach
private

Definition at line 244 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::yPointOfClosestApproachToPV
private

Definition at line 245 of file TrackAnalyzer.h.

Referenced by bookHistosForHitProperties().

MonitorElement* TrackAnalyzer::yPointOfClosestApproachVsZ0wrt000
private

Definition at line 246 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::yPointOfClosestApproachVsZ0wrtBS
private

Definition at line 247 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::yPointOfClosestApproachVsZ0wrtPV
private

Definition at line 248 of file TrackAnalyzer.h.

Referenced by analyze(), and bookHistosForBeamSpot().

MonitorElement* TrackAnalyzer::zPointOfClosestApproach
private

Definition at line 249 of file TrackAnalyzer.h.

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

MonitorElement* TrackAnalyzer::zPointOfClosestApproachToPV
private

Definition at line 250 of file TrackAnalyzer.h.

Referenced by bookHistosForHitProperties().

MonitorElement* TrackAnalyzer::zPointOfClosestApproachVsPhi
private

Definition at line 251 of file TrackAnalyzer.h.

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

Generated for CMSSW Reference Manual by doxygen 1.8.5