CMS 3D CMS Logo

List of all members | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes
MTVHistoProducerAlgoForTracker Class Reference

#include <MTVHistoProducerAlgoForTracker.h>

Public Member Functions

void bookMVAHistos (DQMStore::IBooker &ibook, size_t nMVAs)
 
void bookRecodEdxHistos (DQMStore::IBooker &ibook)
 
void bookRecoHistos (DQMStore::IBooker &ibook)
 
void bookRecoPVAssociationHistos (DQMStore::IBooker &ibook)
 
void bookSeedHistos (DQMStore::IBooker &ibook)
 
void bookSimHistos (DQMStore::IBooker &ibook)
 
void bookSimTrackHistos (DQMStore::IBooker &ibook)
 
void bookSimTrackPVAssociationHistos (DQMStore::IBooker &ibook)
 
void fill_dedx_recoTrack_histos (int count, const edm::RefToBase< reco::Track > &trackref, const std::vector< const edm::ValueMap< reco::DeDxData > * > &v_dEdx)
 
void fill_generic_recoTrack_histos (int count, const reco::Track &track, const TrackerTopology &ttopo, const math::XYZPoint &bsPosition, const math::XYZPoint *pvPosition, const TrackingVertex::LorentzVector *simPVPosition, bool isMatched, bool isSigMatched, bool isChargeMatched, int numAssocRecoTracks, int numVertices, int nSimHits, double sharedFraction, double dR, const std::vector< float > &mvas, unsigned int selectsLoose, unsigned int selectsHP)
 
void fill_generic_simTrack_histos (const TrackingParticle::Vector &, const TrackingParticle::Point &vertex, int bx)
 
void fill_recoAssociated_simTrack_histos (int count, const TrackingParticle &tp, const TrackingParticle::Vector &momentumTP, const TrackingParticle::Point &vertexTP, double dxy, double dz, double dxyPV, double dzPV, int nSimHits, int nSimLayers, int nSimPixelLayers, int nSimStripMonoAndStereoLayers, const reco::Track *track, int numVertices, double dR, const math::XYZPoint *pvPosition, const TrackingVertex::LorentzVector *simPVPosition, const std::vector< float > &mvas, unsigned int selectsLoose, unsigned int selectsHP)
 
void fill_recoAssociated_simTrack_histos (int count, const reco::GenParticle &tp, const TrackingParticle::Vector &momentumTP, const TrackingParticle::Point &vertexTP, double dxy, double dz, int nSimHits, const reco::Track *track, int numVertices)
 
void fill_ResoAndPull_recoTrack_histos (int count, const TrackingParticle::Vector &momentumTP, const TrackingParticle::Point &vertexTP, int chargeTP, const reco::Track &track, const math::XYZPoint &bsPosition)
 
void fill_seed_histos (int count, int seedsFitFailed, int seedsTotal)
 
void fill_simAssociated_recoTrack_histos (int count, const reco::Track &track)
 
void fill_simTrackBased_histos (int numSimTracks)
 
void fill_trackBased_histos (int count, int assTracks, int numRecoTracks, int numRecoTracksSelected, int numSimTracksSelected)
 
void init (const edm::Event &event, const edm::EventSetup &setup)
 
 MTVHistoProducerAlgoForTracker (const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, const bool doSeedPlots, edm::ConsumesCollector &&iC)
 
 MTVHistoProducerAlgoForTracker (const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, const bool doSeedPlots, edm::ConsumesCollector &iC)
 
 ~MTVHistoProducerAlgoForTracker ()
 

Static Public Member Functions

static std::unique_ptr< RecoTrackSelectorBasemakeRecoTrackSelectorFromTPSelectorParameters (const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, edm::ConsumesCollector &iC)
 
static std::unique_ptr< RecoTrackSelectorBasemakeRecoTrackSelectorFromTPSelectorParameters (const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, edm::ConsumesCollector &&iC)
 

Private Types

using SeedingLayerId = std::tuple< SeedingLayerSetsBuilder::SeedingLayerId, bool >
 
using SeedingLayerSetId = std::array< SeedingLayerId, 4 >
 

Private Member Functions

double getEta (double eta)
 
double getPt (double pt)
 
void getRecoMomentum (const reco::Track &track, double &pt, double &ptError, double &qoverp, double &qoverpError, double &lambda, double &lambdaError, double &phi, double &phiError) const
 retrieval of reconstructed momentum components from reco::Track (== mean values for GSF) More...
 
void getRecoMomentum (const reco::GsfTrack &gsfTrack, double &pt, double &ptError, double &qoverp, double &qoverpError, double &lambda, double &lambdaError, double &phi, double &phiError) const
 retrieval of reconstructed momentum components based on the mode of a reco::GsfTrack More...
 
unsigned int getSeedingLayerSetBin (const reco::Track &track, const TrackerTopology &ttopo)
 

Private Attributes

std::vector< MonitorElement * > chi2_vs_eta
 
std::vector< MonitorElement * > chi2_vs_nhits
 
std::vector< MonitorElement * > chi2_vs_phi
 
int cotThetaRes_nbin
 
double cotThetaRes_rangeMax
 
double cotThetaRes_rangeMin
 
std::vector< MonitorElement * > cotThetares_vs_eta
 
std::vector< MonitorElement * > cotThetares_vs_pt
 
const bool doSeedPlots_
 
double dxyDzZoom
 
std::vector< MonitorElement * > dxypull_vs_eta
 
int dxyRes_nbin
 
double dxyRes_rangeMax
 
double dxyRes_rangeMin
 
std::vector< MonitorElement * > dxyres_vs_eta
 
std::vector< MonitorElement * > dxyres_vs_pt
 
std::vector< MonitorElement * > dzpull_vs_eta
 
int dzRes_nbin
 
double dzRes_rangeMax
 
double dzRes_rangeMin
 
std::vector< MonitorElement * > dzres_vs_eta
 
std::vector< MonitorElement * > dzres_vs_pt
 
std::vector< MonitorElement * > etares_vs_eta
 
std::unique_ptr< GenParticleCustomSelectorgeneralGpSelector
 
std::unique_ptr< TrackingParticleSelectorgeneralTpSelector
 
std::unique_ptr< GenParticleCustomSelectorGpSelectorForEfficiencyVsEta
 
std::unique_ptr< GenParticleCustomSelectorGpSelectorForEfficiencyVsPhi
 
std::unique_ptr< GenParticleCustomSelectorGpSelectorForEfficiencyVsPt
 
std::unique_ptr< GenParticleCustomSelectorGpSelectorForEfficiencyVsVTXR
 
std::unique_ptr< GenParticleCustomSelectorGpSelectorForEfficiencyVsVTXZ
 
std::vector< MonitorElement * > h_algo
 
std::vector< MonitorElement * > h_assoc23Dlayer
 
std::vector< MonitorElement * > h_assoc2_dzpvcut
 
std::vector< MonitorElement * > h_assoc2_dzpvcut_pt
 
std::vector< MonitorElement * > h_assoc2_dzpvsigcut
 
std::vector< MonitorElement * > h_assoc2_dzpvsigcut_pt
 
std::vector< MonitorElement * > h_assoc2_itpu_eta
 
std::vector< MonitorElement * > h_assoc2_itpu_sig_eta
 
std::vector< MonitorElement * > h_assoc2_itpu_sig_vertcount
 
std::vector< MonitorElement * > h_assoc2_itpu_vertcount
 
std::vector< std::vector< MonitorElement * > > h_assoc2_mva
 
std::vector< std::vector< MonitorElement * > > h_assoc2_mva_hp
 
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut
 
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut_hp
 
std::vector< MonitorElement * > h_assoc2_ootpu_eta
 
std::vector< MonitorElement * > h_assoc2_ootpu_vertcount
 
std::vector< MonitorElement * > h_assoc2_seedingLayerSet
 
std::vector< MonitorElement * > h_assoc2_simpvz
 
std::vector< MonitorElement * > h_assoc2chi2
 
std::vector< MonitorElement * > h_assoc2dr
 
std::vector< MonitorElement * > h_assoc2dxy
 
std::vector< MonitorElement * > h_assoc2dxypv
 
std::vector< MonitorElement * > h_assoc2dxypvzoomed
 
std::vector< MonitorElement * > h_assoc2dz
 
std::vector< MonitorElement * > h_assoc2dzpv
 
std::vector< MonitorElement * > h_assoc2dzpvzoomed
 
std::vector< MonitorElement * > h_assoc2eta
 
std::vector< MonitorElement * > h_assoc2eta_sig
 
std::vector< MonitorElement * > h_assoc2hit
 
std::vector< MonitorElement * > h_assoc2layer
 
std::vector< MonitorElement * > h_assoc2phi
 
std::vector< MonitorElement * > h_assoc2pixellayer
 
std::vector< MonitorElement * > h_assoc2pT
 
std::vector< MonitorElement * > h_assoc2pu
 
std::vector< MonitorElement * > h_assoc2vertpos
 
std::vector< MonitorElement * > h_assoc2zpos
 
std::vector< MonitorElement * > h_assoc3Dlayer
 
std::vector< MonitorElement * > h_assoc_dzpvcut
 
std::vector< MonitorElement * > h_assoc_dzpvcut_pt
 
std::vector< MonitorElement * > h_assoc_dzpvsigcut
 
std::vector< MonitorElement * > h_assoc_dzpvsigcut_pt
 
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut
 
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut_hp
 
std::vector< MonitorElement * > h_assoc_simpvz
 
std::vector< MonitorElement * > h_assocdr
 
std::vector< MonitorElement * > h_assocdxy
 
std::vector< MonitorElement * > h_assocdxypv
 
std::vector< MonitorElement * > h_assocdxypvzoomed
 
std::vector< MonitorElement * > h_assocdz
 
std::vector< MonitorElement * > h_assocdzpv
 
std::vector< MonitorElement * > h_assocdzpvzoomed
 
std::vector< MonitorElement * > h_assoceta
 
std::vector< MonitorElement * > h_assocFraction
 
std::vector< MonitorElement * > h_assochi2
 
std::vector< MonitorElement * > h_assochi2_prob
 
std::vector< MonitorElement * > h_assochit
 
std::vector< MonitorElement * > h_assoclayer
 
std::vector< MonitorElement * > h_assocphi
 
std::vector< MonitorElement * > h_assocpixellayer
 
std::vector< MonitorElement * > h_assocpT
 
std::vector< MonitorElement * > h_assocpu
 
std::vector< MonitorElement * > h_assocSharedHit
 
std::vector< MonitorElement * > h_assocvertpos
 
std::vector< MonitorElement * > h_assoczpos
 
MonitorElementh_bunchxSIM
 
std::vector< MonitorElement * > h_charge
 
std::vector< MonitorElement * > h_con_eta
 
std::vector< MonitorElement * > h_con_vertcount
 
std::vector< MonitorElement * > h_con_zpos
 
std::vector< std::vector< MonitorElement * > > h_dedx_estim
 
std::vector< std::vector< MonitorElement * > > h_dedx_nom
 
std::vector< std::vector< MonitorElement * > > h_dedx_sat
 
std::vector< MonitorElement * > h_eta
 
MonitorElementh_etaSIM
 
std::vector< MonitorElement * > h_fakes
 
std::vector< MonitorElement * > h_hits
 
std::vector< MonitorElement * > h_looper3Dlayer
 
std::vector< MonitorElement * > h_looper_seedingLayerSet
 
std::vector< MonitorElement * > h_looperchi2
 
std::vector< MonitorElement * > h_looperdr
 
std::vector< MonitorElement * > h_looperdxy
 
std::vector< MonitorElement * > h_looperdxypv
 
std::vector< MonitorElement * > h_looperdxypvzoomed
 
std::vector< MonitorElement * > h_looperdz
 
std::vector< MonitorElement * > h_looperdzpv
 
std::vector< MonitorElement * > h_looperdzpvzoomed
 
std::vector< MonitorElement * > h_loopereta
 
std::vector< MonitorElement * > h_looperhit
 
std::vector< MonitorElement * > h_looperlayer
 
std::vector< MonitorElement * > h_looperphi
 
std::vector< MonitorElement * > h_looperpixellayer
 
std::vector< MonitorElement * > h_looperpT
 
std::vector< MonitorElement * > h_looperpu
 
std::vector< MonitorElement * > h_loopervertpos
 
std::vector< MonitorElement * > h_looperzpos
 
std::vector< MonitorElement * > h_losthits
 
std::vector< MonitorElement * > h_misid3Dlayer
 
std::vector< MonitorElement * > h_misidchi2
 
std::vector< MonitorElement * > h_misiddxy
 
std::vector< MonitorElement * > h_misiddxypv
 
std::vector< MonitorElement * > h_misiddxypvzoomed
 
std::vector< MonitorElement * > h_misiddz
 
std::vector< MonitorElement * > h_misiddzpv
 
std::vector< MonitorElement * > h_misiddzpvzoomed
 
std::vector< MonitorElement * > h_misideta
 
std::vector< MonitorElement * > h_misidhit
 
std::vector< MonitorElement * > h_misidlayer
 
std::vector< MonitorElement * > h_misidphi
 
std::vector< MonitorElement * > h_misidpixellayer
 
std::vector< MonitorElement * > h_misidpT
 
std::vector< MonitorElement * > h_misidpu
 
std::vector< MonitorElement * > h_nchi2
 
std::vector< MonitorElement * > h_nchi2_prob
 
std::vector< MonitorElement * > h_nmisslayers_inner
 
std::vector< MonitorElement * > h_nmisslayers_outer
 
std::vector< MonitorElement * > h_pileup3Dlayer
 
std::vector< MonitorElement * > h_pileup_dzpvcut
 
std::vector< MonitorElement * > h_pileup_dzpvcut_pt
 
std::vector< MonitorElement * > h_pileup_dzpvsigcut
 
std::vector< MonitorElement * > h_pileup_dzpvsigcut_pt
 
std::vector< MonitorElement * > h_pileup_seedingLayerSet
 
std::vector< MonitorElement * > h_pileup_simpvz
 
std::vector< MonitorElement * > h_pileupchi2
 
std::vector< MonitorElement * > h_pileupdr
 
std::vector< MonitorElement * > h_pileupdxy
 
std::vector< MonitorElement * > h_pileupdxypv
 
std::vector< MonitorElement * > h_pileupdxypvzoomed
 
std::vector< MonitorElement * > h_pileupdz
 
std::vector< MonitorElement * > h_pileupdzpv
 
std::vector< MonitorElement * > h_pileupdzpvzoomed
 
std::vector< MonitorElement * > h_pileupeta
 
std::vector< MonitorElement * > h_pileuphit
 
std::vector< MonitorElement * > h_pileuplayer
 
std::vector< MonitorElement * > h_pileupphi
 
std::vector< MonitorElement * > h_pileuppixellayer
 
std::vector< MonitorElement * > h_pileuppT
 
std::vector< MonitorElement * > h_pileuppu
 
std::vector< MonitorElement * > h_pileupvertpos
 
std::vector< MonitorElement * > h_pileupzpos
 
std::vector< MonitorElement * > h_pt
 
std::vector< MonitorElement * > h_ptshifteta
 
MonitorElementh_ptSIM
 
std::vector< MonitorElement * > h_pullDxy
 
std::vector< MonitorElement * > h_pullDz
 
std::vector< MonitorElement * > h_pullPhi
 
std::vector< MonitorElement * > h_pullQoverp
 
std::vector< MonitorElement * > h_pullTheta
 
std::vector< MonitorElement * > h_reco2eta
 
std::vector< MonitorElement * > h_reco2pT
 
std::vector< MonitorElement * > h_reco2pu
 
std::vector< MonitorElement * > h_reco3Dlayer
 
std::vector< MonitorElement * > h_reco_dzpvcut
 
std::vector< MonitorElement * > h_reco_dzpvcut_pt
 
std::vector< MonitorElement * > h_reco_dzpvsigcut
 
std::vector< MonitorElement * > h_reco_dzpvsigcut_pt
 
std::vector< std::vector< MonitorElement * > > h_reco_mva
 
std::vector< std::vector< MonitorElement * > > h_reco_mva_hp
 
std::vector< std::vector< MonitorElement * > > h_reco_mvacut
 
std::vector< std::vector< MonitorElement * > > h_reco_mvacut_hp
 
std::vector< MonitorElement * > h_reco_ootpu_eta
 
std::vector< MonitorElement * > h_reco_ootpu_vertcount
 
std::vector< MonitorElement * > h_reco_seedingLayerSet
 
std::vector< MonitorElement * > h_reco_simpvz
 
std::vector< MonitorElement * > h_recochi2
 
std::vector< MonitorElement * > h_recodr
 
std::vector< MonitorElement * > h_recodxy
 
std::vector< MonitorElement * > h_recodxypv
 
std::vector< MonitorElement * > h_recodxypvzoomed
 
std::vector< MonitorElement * > h_recodz
 
std::vector< MonitorElement * > h_recodzpv
 
std::vector< MonitorElement * > h_recodzpvzoomed
 
std::vector< MonitorElement * > h_recoeta
 
std::vector< MonitorElement * > h_recohit
 
std::vector< MonitorElement * > h_recolayer
 
std::vector< MonitorElement * > h_recophi
 
std::vector< MonitorElement * > h_recopixellayer
 
std::vector< MonitorElement * > h_recopT
 
std::vector< MonitorElement * > h_recopu
 
std::vector< MonitorElement * > h_recovertpos
 
std::vector< MonitorElement * > h_recozpos
 
std::vector< MonitorElement * > h_seedsFitFailed
 
std::vector< MonitorElement * > h_seedsFitFailedFraction
 
std::vector< MonitorElement * > h_simul2_dzpvcut
 
std::vector< MonitorElement * > h_simul2_dzpvcut_pt
 
std::vector< MonitorElement * > h_simul2_dzpvsigcut
 
std::vector< MonitorElement * > h_simul2_dzpvsigcut_pt
 
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut
 
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut_hp
 
std::vector< MonitorElement * > h_simul3Dlayer
 
std::vector< MonitorElement * > h_simul_dzpvcut
 
std::vector< MonitorElement * > h_simul_dzpvcut_pt
 
std::vector< MonitorElement * > h_simul_dzpvsigcut
 
std::vector< MonitorElement * > h_simul_dzpvsigcut_pt
 
std::vector< MonitorElement * > h_simul_simpvz
 
std::vector< MonitorElement * > h_simuldr
 
std::vector< MonitorElement * > h_simuldxy
 
std::vector< MonitorElement * > h_simuldxypv
 
std::vector< MonitorElement * > h_simuldxypvzoomed
 
std::vector< MonitorElement * > h_simuldz
 
std::vector< MonitorElement * > h_simuldzpv
 
std::vector< MonitorElement * > h_simuldzpvzoomed
 
std::vector< MonitorElement * > h_simuleta
 
std::vector< MonitorElement * > h_simulhit
 
std::vector< MonitorElement * > h_simullayer
 
std::vector< MonitorElement * > h_simulphi
 
std::vector< MonitorElement * > h_simulpixellayer
 
std::vector< MonitorElement * > h_simulpT
 
std::vector< MonitorElement * > h_simulpu
 
std::vector< MonitorElement * > h_simulvertpos
 
std::vector< MonitorElement * > h_simulzpos
 
std::vector< MonitorElement * > h_tracks
 
MonitorElementh_tracksSIM
 
MonitorElementh_vertposSIM
 
double maxChi2
 
double maxDeDx
 
double maxdr
 
double maxDxy
 
double maxDz
 
double maxDzpvCum
 
double maxDzpvsigCum
 
double maxEta
 
double maxHit
 
double maxLayers
 
double maxMVA
 
double maxPhi
 
double maxPt
 
double maxPu
 
double maxPVz
 
double maxTracks
 
double maxVertcount
 
double maxVertpos
 
double maxZpos
 
double minChi2
 
double minDeDx
 
double mindr
 
double minDxy
 
double minDz
 
double minEta
 
double minHit
 
double minLayers
 
double minMVA
 
double minPhi
 
double minPt
 
double minPu
 
double minPVz
 
double minTracks
 
double minVertcount
 
double minVertpos
 
double minZpos
 
std::vector< MonitorElement * > nhits_vs_eta
 
std::vector< MonitorElement * > nhits_vs_phi
 
int nintChi2
 
int nintDeDx
 
int nintdr
 
int nintDxy
 
int nintDz
 
int nintDzpvCum
 
int nintDzpvsigCum
 
int nintEta
 
int nintHit
 
int nintLayers
 
int nintMVA
 
int nintPhi
 
int nintPt
 
int nintPu
 
int nintPVz
 
int nintTracks
 
int nintVertcount
 
int nintVertpos
 
int nintZpos
 
std::vector< MonitorElement * > nLayersWithMeas_vs_eta
 
std::vector< MonitorElement * > nlosthits_vs_eta
 
std::vector< MonitorElement * > nPXBhits_vs_eta
 
std::vector< MonitorElement * > nPXFhits_vs_eta
 
std::vector< MonitorElement * > nPXLhits_vs_eta
 
std::vector< MonitorElement * > nPXLlayersWithMeas_vs_eta
 
std::vector< MonitorElement * > nrec_vs_nsim
 
std::vector< MonitorElement * > nrecHit_vs_nsimHit_rec2sim
 
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
 
std::vector< MonitorElement * > nSTRIPhits_vs_eta
 
std::vector< MonitorElement * > nSTRIPlayersWith1dMeas_vs_eta
 
std::vector< MonitorElement * > nSTRIPlayersWith2dMeas_vs_eta
 
std::vector< MonitorElement * > nSTRIPlayersWithMeas_vs_eta
 
std::vector< MonitorElement * > nTEChits_vs_eta
 
std::vector< MonitorElement * > nTIBhits_vs_eta
 
std::vector< MonitorElement * > nTIDhits_vs_eta
 
std::vector< MonitorElement * > nTOBhits_vs_eta
 
std::vector< MonitorElement * > phimean_vs_eta_phi
 
std::vector< MonitorElement * > phipull_vs_eta
 
std::vector< MonitorElement * > phipull_vs_phi
 
int phiRes_nbin
 
double phiRes_rangeMax
 
double phiRes_rangeMin
 
std::vector< MonitorElement * > phires_vs_eta
 
std::vector< MonitorElement * > phires_vs_phi
 
std::vector< MonitorElement * > phires_vs_pt
 
std::vector< MonitorElement * > ptmean_vs_eta_phi
 
std::vector< MonitorElement * > ptpull_vs_eta
 
std::vector< MonitorElement * > ptpull_vs_phi
 
int ptRes_nbin
 
double ptRes_rangeMax
 
double ptRes_rangeMin
 
std::vector< MonitorElement * > ptres_vs_eta
 
std::vector< MonitorElement * > ptres_vs_phi
 
std::vector< MonitorElement * > ptres_vs_pt
 
std::vector< std::string > seedingLayerSetNames
 
std::map< SeedingLayerSetId, unsigned int > seedingLayerSetToBin
 
std::vector< MonitorElement * > thetapull_vs_eta
 
std::vector< MonitorElement * > thetapull_vs_phi
 
std::unique_ptr< TrackingParticleSelectorTpSelectorForEfficiencyVsEta
 
std::unique_ptr< TrackingParticleSelectorTpSelectorForEfficiencyVsPhi
 
std::unique_ptr< TrackingParticleSelectorTpSelectorForEfficiencyVsPt
 
std::unique_ptr< TrackingParticleSelectorTpSelectorForEfficiencyVsVTXR
 
std::unique_ptr< TrackingParticleSelectorTpSelectorForEfficiencyVsVTXZ
 
std::unique_ptr< RecoTrackSelectorBasetrackSelectorVsEta
 
std::unique_ptr< RecoTrackSelectorBasetrackSelectorVsPhi
 
std::unique_ptr< RecoTrackSelectorBasetrackSelectorVsPt
 
bool useFabsEta
 
bool useInvPt
 
bool useLogPt
 

Detailed Description

Definition at line 32 of file MTVHistoProducerAlgoForTracker.h.

Member Typedef Documentation

Definition at line 186 of file MTVHistoProducerAlgoForTracker.h.

Definition at line 187 of file MTVHistoProducerAlgoForTracker.h.

Constructor & Destructor Documentation

MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker ( const edm::ParameterSet pset,
const edm::InputTag beamSpotTag,
const bool  doSeedPlots,
edm::ConsumesCollector &&  iC 
)
inline

Definition at line 34 of file MTVHistoProducerAlgoForTracker.h.

References AlignmentProducer_cff::beamSpotTag, MultiTrackValidator_cfi::doSeedPlots, and muonDTDigis_cfi::pset.

34  :
35  MTVHistoProducerAlgoForTracker(pset, beamSpotTag, doSeedPlots, iC) {}
MTVHistoProducerAlgoForTracker(const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, const bool doSeedPlots, edm::ConsumesCollector &&iC)
MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker ( const edm::ParameterSet pset,
const edm::InputTag beamSpotTag,
const bool  doSeedPlots,
edm::ConsumesCollector iC 
)

Definition at line 72 of file MTVHistoProducerAlgoForTracker.cc.

References cotThetaRes_nbin, cotThetaRes_rangeMax, cotThetaRes_rangeMin, dxyDzZoom, dxyRes_nbin, dxyRes_rangeMax, dxyRes_rangeMin, dzRes_nbin, dzRes_rangeMax, dzRes_rangeMin, Exception, generalGpSelector, generalTpSelector, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), GpSelectorForEfficiencyVsEta, GpSelectorForEfficiencyVsPhi, GpSelectorForEfficiencyVsPt, GpSelectorForEfficiencyVsVTXR, GpSelectorForEfficiencyVsVTXZ, mps_fire::i, GeomDetEnumerators::isTrackerStrip(), SeedingLayerSetsBuilder::layerNamesInSets(), reco::modules::make(), makeRecoTrackSelectorFromTPSelectorParameters(), maxChi2, maxDeDx, maxdr, maxDxy, maxDz, maxDzpvCum, maxDzpvsigCum, maxEta, maxHit, maxLayers, maxMVA, maxPhi, maxPt, maxPu, maxPVz, maxTracks, maxVertcount, maxVertpos, maxZpos, minDeDx, mindr, minDxy, minDz, minEta, minHit, minLayers, minMVA, minPhi, minPt, minPu, minPVz, minTracks, minVertcount, minVertpos, minZpos, dataset::name, SeedingLayerSetsBuilder::nameToEnumId(), nintChi2, nintDeDx, nintdr, nintDxy, nintDz, nintDzpvCum, nintDzpvsigCum, nintEta, nintHit, nintLayers, nintMVA, nintPhi, nintPt, nintPu, nintPVz, nintTracks, nintVertcount, nintVertpos, nintZpos, phiRes_nbin, phiRes_rangeMax, phiRes_rangeMin, ptRes_nbin, ptRes_rangeMax, ptRes_rangeMin, seedingLayerSetNames, seedingLayerSetToBin, TpSelectorForEfficiencyVsEta, TpSelectorForEfficiencyVsPhi, TpSelectorForEfficiencyVsPt, TpSelectorForEfficiencyVsVTXR, TpSelectorForEfficiencyVsVTXZ, trackSelectorVsEta, trackSelectorVsPhi, trackSelectorVsPt, useFabsEta, useInvPt, useLogPt, and relativeConstraints::value.

72  :
74  h_ptSIM(nullptr), h_etaSIM(nullptr), h_tracksSIM(nullptr), h_vertposSIM(nullptr), h_bunchxSIM(nullptr)
75 {
76  //parameters for _vs_eta plots
77  minEta = pset.getParameter<double>("minEta");
78  maxEta = pset.getParameter<double>("maxEta");
79  nintEta = pset.getParameter<int>("nintEta");
80  useFabsEta = pset.getParameter<bool>("useFabsEta");
81 
82  //parameters for _vs_pt plots
83  minPt = pset.getParameter<double>("minPt");
84  maxPt = pset.getParameter<double>("maxPt");
85  nintPt = pset.getParameter<int>("nintPt");
86  useInvPt = pset.getParameter<bool>("useInvPt");
87  useLogPt = pset.getUntrackedParameter<bool>("useLogPt",false);
88 
89  //parameters for _vs_Hit plots
90  minHit = pset.getParameter<double>("minHit");
91  maxHit = pset.getParameter<double>("maxHit");
92  nintHit = pset.getParameter<int>("nintHit");
93 
94  //parameters for _vs_Pu plots
95  minPu = pset.getParameter<double>("minPu");
96  maxPu = pset.getParameter<double>("maxPu");
97  nintPu = pset.getParameter<int>("nintPu");
98 
99  //parameters for _vs_Layer plots
100  minLayers = pset.getParameter<double>("minLayers");
101  maxLayers = pset.getParameter<double>("maxLayers");
102  nintLayers = pset.getParameter<int>("nintLayers");
103 
104  //parameters for _vs_phi plots
105  minPhi = pset.getParameter<double>("minPhi");
106  maxPhi = pset.getParameter<double>("maxPhi");
107  nintPhi = pset.getParameter<int>("nintPhi");
108 
109  //parameters for _vs_Dxy plots
110  minDxy = pset.getParameter<double>("minDxy");
111  maxDxy = pset.getParameter<double>("maxDxy");
112  nintDxy = pset.getParameter<int>("nintDxy");
113 
114  //parameters for _vs_Dz plots
115  minDz = pset.getParameter<double>("minDz");
116  maxDz = pset.getParameter<double>("maxDz");
117  nintDz = pset.getParameter<int>("nintDz");
118 
119  dxyDzZoom = pset.getParameter<double>("dxyDzZoom");
120 
121  //parameters for _vs_ProductionVertexTransvPosition plots
122  minVertpos = pset.getParameter<double>("minVertpos");
123  maxVertpos = pset.getParameter<double>("maxVertpos");
124  nintVertpos = pset.getParameter<int>("nintVertpos");
125 
126  //parameters for _vs_ProductionVertexZPosition plots
127  minZpos = pset.getParameter<double>("minZpos");
128  maxZpos = pset.getParameter<double>("maxZpos");
129  nintZpos = pset.getParameter<int>("nintZpos");
130 
131  //parameters for _vs_dR plots
132  mindr = pset.getParameter<double>("mindr");
133  maxdr = pset.getParameter<double>("maxdr");
134  nintdr = pset.getParameter<int>("nintdr");
135 
136  // paramers for _vs_chi2 plots
137  minChi2 = pset.getParameter<double>("minChi2");
138  maxChi2 = pset.getParameter<double>("maxChi2");
139  nintChi2 = pset.getParameter<int>("nintChi2");
140 
141  //parameters for dE/dx plots
142  minDeDx = pset.getParameter<double>("minDeDx");
143  maxDeDx = pset.getParameter<double>("maxDeDx");
144  nintDeDx = pset.getParameter<int>("nintDeDx");
145 
146  //parameters for Pileup plots
147  minVertcount = pset.getParameter<double>("minVertcount");
148  maxVertcount = pset.getParameter<double>("maxVertcount");
149  nintVertcount = pset.getParameter<int>("nintVertcount");
150 
151  //parameters for number of tracks plots
152  minTracks = pset.getParameter<double>("minTracks");
153  maxTracks = pset.getParameter<double>("maxTracks");
154  nintTracks = pset.getParameter<int>("nintTracks");
155 
156  //parameters for vs. PV z plots
157  minPVz = pset.getParameter<double>("minPVz");
158  maxPVz = pset.getParameter<double>("maxPVz");
159  nintPVz = pset.getParameter<int>("nintPVz");
160 
161  //parameters for vs. MVA plots
162  minMVA = pset.getParameter<double>("minMVA");
163  maxMVA = pset.getParameter<double>("maxMVA");
164  nintMVA = pset.getParameter<int>("nintMVA");
165 
166  //parameters for resolution plots
167  ptRes_rangeMin = pset.getParameter<double>("ptRes_rangeMin");
168  ptRes_rangeMax = pset.getParameter<double>("ptRes_rangeMax");
169  ptRes_nbin = pset.getParameter<int>("ptRes_nbin");
170 
171  phiRes_rangeMin = pset.getParameter<double>("phiRes_rangeMin");
172  phiRes_rangeMax = pset.getParameter<double>("phiRes_rangeMax");
173  phiRes_nbin = pset.getParameter<int>("phiRes_nbin");
174 
175  cotThetaRes_rangeMin = pset.getParameter<double>("cotThetaRes_rangeMin");
176  cotThetaRes_rangeMax = pset.getParameter<double>("cotThetaRes_rangeMax");
177  cotThetaRes_nbin = pset.getParameter<int>("cotThetaRes_nbin");
178 
179  dxyRes_rangeMin = pset.getParameter<double>("dxyRes_rangeMin");
180  dxyRes_rangeMax = pset.getParameter<double>("dxyRes_rangeMax");
181  dxyRes_nbin = pset.getParameter<int>("dxyRes_nbin");
182 
183  dzRes_rangeMin = pset.getParameter<double>("dzRes_rangeMin");
184  dzRes_rangeMax = pset.getParameter<double>("dzRes_rangeMax");
185  dzRes_nbin = pset.getParameter<int>("dzRes_nbin");
186 
187 
188  maxDzpvCum = pset.getParameter<double>("maxDzpvCumulative");
189  nintDzpvCum = pset.getParameter<int>("nintDzpvCumulative");
190 
191  maxDzpvsigCum = pset.getParameter<double>("maxDzpvsigCumulative");
192  nintDzpvsigCum = pset.getParameter<int>("nintDzpvsigCumulative");
193 
194  //--- tracking particle selectors for efficiency measurements
195  using namespace edm;
196  using namespace reco::modules;
197  auto initTPselector = [&](auto& sel, auto& name) {
198  sel = std::make_unique<TrackingParticleSelector>(ParameterAdapter<TrackingParticleSelector>::make(pset.getParameter<ParameterSet>(name), iC));
199  };
200  auto initTrackSelector = [&](auto& sel, auto& name) {
202  };
203  auto initGPselector = [&](auto& sel, auto& name) {
204  sel = std::make_unique<GenParticleCustomSelector>(ParameterAdapter<GenParticleCustomSelector>::make(pset.getParameter<ParameterSet>(name), iC));
205  };
206 
207  initTPselector(generalTpSelector, "generalTpSelector");
208  initTPselector(TpSelectorForEfficiencyVsEta, "TpSelectorForEfficiencyVsEta");
209  initTPselector(TpSelectorForEfficiencyVsPhi, "TpSelectorForEfficiencyVsPhi");
210  initTPselector(TpSelectorForEfficiencyVsPt, "TpSelectorForEfficiencyVsPt");
211  initTPselector(TpSelectorForEfficiencyVsVTXR, "TpSelectorForEfficiencyVsVTXR");
212  initTPselector(TpSelectorForEfficiencyVsVTXZ, "TpSelectorForEfficiencyVsVTXZ");
213 
214  initTrackSelector(trackSelectorVsEta, "TpSelectorForEfficiencyVsEta");
215  initTrackSelector(trackSelectorVsPhi, "TpSelectorForEfficiencyVsPhi");
216  initTrackSelector(trackSelectorVsPt, "TpSelectorForEfficiencyVsPt");
217 
218  initGPselector(generalGpSelector, "generalGpSelector");
219  initGPselector(GpSelectorForEfficiencyVsEta, "GpSelectorForEfficiencyVsEta");
220  initGPselector(GpSelectorForEfficiencyVsPhi, "GpSelectorForEfficiencyVsPhi");
221  initGPselector(GpSelectorForEfficiencyVsPt, "GpSelectorForEfficiencyVsPt");
222  initGPselector(GpSelectorForEfficiencyVsVTXR, "GpSelectorForEfficiencyVsVTXR");
223  initGPselector(GpSelectorForEfficiencyVsVTXZ, "GpSelectorForEfficiencyVsVTXZ");
224 
225  // SeedingLayerSets
226  // If enabled, use last bin to denote other or unknown cases
227  seedingLayerSetNames = pset.getParameter<std::vector<std::string> >("seedingLayerSets");
228  std::vector<std::pair<SeedingLayerSetId, std::string> > stripPairSets;
229  if(!seedingLayerSetNames.empty()) {
230  std::vector<std::vector<std::string>> layerSets = SeedingLayerSetsBuilder::layerNamesInSets(seedingLayerSetNames);
231  for(size_t i=0; i<layerSets.size(); ++i) {
232  const auto& layerSet = layerSets[i];
233  if(layerSet.size() > std::tuple_size<SeedingLayerSetId>::value) {
234  throw cms::Exception("Configuration") << "Got seedingLayerSet " << seedingLayerSetNames[i] << " with " << layerSet.size() << " elements, but I have a hard-coded maximum of " << std::tuple_size<SeedingLayerSetId>::value << ". Please increase the maximum in MTVHistoProducerAlgoForTracker.h";
235  }
236  SeedingLayerSetId setId;
237  for(size_t j=0; j<layerSet.size(); ++j) {
238  // It is a bit ugly to assume here that 'M' prefix stands for
239  // strip mono hits, as in the SeedingLayerSetsBuilder code any
240  // prefixes are arbitrary and their meaning is defined fully
241  // in the configuration. But, this is the easiest way.
242  bool isStripMono = !layerSet[j].empty() && layerSet[j][0] == 'M';
243  setId[j] = std::make_tuple(SeedingLayerSetsBuilder::nameToEnumId(layerSet[j]), isStripMono);
244  }
245  // Account for the fact that strip triplet seeding may give pairs
246  if(layerSet.size() == 3 && isTrackerStrip(std::get<GeomDetEnumerators::SubDetector>(std::get<0>(setId[0])))) {
247  SeedingLayerSetId pairId;
248  pairId[0] = setId[0];
249  pairId[1] = setId[1];
250  stripPairSets.emplace_back(pairId, layerSet[0]+"+"+layerSet[1]);
251  }
252 
253  auto inserted = seedingLayerSetToBin.insert(std::make_pair(setId, i));
254  if(!inserted.second)
255  throw cms::Exception("Configuration") << "SeedingLayerSet " << seedingLayerSetNames[i] << " is specified twice, while the set list should be unique.";
256  }
257 
258  // Add the "strip pairs from strip triplets" if they don't otherwise exist
259  for(const auto& setIdName: stripPairSets) {
260  auto inserted = seedingLayerSetToBin.insert(std::make_pair(setIdName.first, seedingLayerSetNames.size()));
261  if(inserted.second)
262  seedingLayerSetNames.push_back(setIdName.second);
263  }
264 
265  seedingLayerSetNames.emplace_back("Other/Unknown");
266  }
267 
268  // fix for the LogScale by Ryan
269  if(useLogPt){
270  maxPt=log10(maxPt);
271  if(minPt > 0){
272  minPt=log10(minPt);
273  }
274  else{
275  edm::LogWarning("MultiTrackValidator")
276  << "minPt = "
277  << minPt << " <= 0 out of range while requesting log scale. Using minPt = 0.1.";
278  minPt=log10(0.1);
279  }
280  }
281 
282 }
T getParameter(std::string const &) const
T getUntrackedParameter(std::string const &, T const &) const
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsPt
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsEta
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsVTXR
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsVTXR
std::map< SeedingLayerSetId, unsigned int > seedingLayerSetToBin
S make(const edm::ParameterSet &cfg)
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsVTXZ
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsPt
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPhi
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsPhi
static std::unique_ptr< RecoTrackSelectorBase > makeRecoTrackSelectorFromTPSelectorParameters(const edm::ParameterSet &pset, const edm::InputTag &beamSpotTag, edm::ConsumesCollector &iC)
bool isTrackerStrip(const GeomDetEnumerators::SubDetector m)
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsEta
std::unique_ptr< TrackingParticleSelector > generalTpSelector
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPt
static SeedingLayerId nameToEnumId(const std::string &name)
std::array< SeedingLayerId, 4 > SeedingLayerSetId
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsPhi
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsVTXZ
std::vector< std::string > seedingLayerSetNames
HLT enums.
std::unique_ptr< GenParticleCustomSelector > generalGpSelector
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsEta
static std::vector< std::vector< std::string > > layerNamesInSets(const std::vector< std::string > &namesPSet)
MTVHistoProducerAlgoForTracker::~MTVHistoProducerAlgoForTracker ( )

Definition at line 284 of file MTVHistoProducerAlgoForTracker.cc.

284 {}

Member Function Documentation

void MTVHistoProducerAlgoForTracker::bookMVAHistos ( DQMStore::IBooker ibook,
size_t  nMVAs 
)

Definition at line 757 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), h_assoc2_mva, h_assoc2_mva_hp, h_assoc2_mvacut, h_assoc2_mvacut_hp, h_assoc_mvacut, h_assoc_mvacut_hp, h_reco_mva, h_reco_mva_hp, h_reco_mvacut, h_reco_mvacut_hp, h_simul2_mvacut, h_simul2_mvacut_hp, mps_fire::i, maxMVA, minMVA, nintMVA, and AlCaHLTBitMon_QueryRunRegistry::string.

757  {
758  h_reco_mva.emplace_back();
759  h_assoc2_mva.emplace_back();
760 
761  h_reco_mvacut.emplace_back();
762  h_assoc_mvacut.emplace_back();
763  h_assoc2_mvacut.emplace_back();
764  h_simul2_mvacut.emplace_back();
765 
766  h_reco_mva_hp.emplace_back();
767  h_assoc2_mva_hp.emplace_back();
768 
769  h_reco_mvacut_hp.emplace_back();
770  h_assoc_mvacut_hp.emplace_back();
771  h_assoc2_mvacut_hp.emplace_back();
772  h_simul2_mvacut_hp.emplace_back();
773 
774  for(size_t i=1; i <= nMVAs; ++i) {
775  auto istr = std::to_string(i);
776  std::string pfix;
777 
778  if(i==1) {
779  h_reco_mva_hp.back().push_back(nullptr);
780  h_assoc2_mva_hp.back().push_back(nullptr);
781 
782  h_reco_mvacut_hp.back().push_back(nullptr);
783  h_assoc_mvacut_hp.back().push_back(nullptr);
784  h_assoc2_mvacut_hp.back().push_back(nullptr);
785  h_simul2_mvacut_hp.back().push_back(nullptr);
786  }
787  else {
788  pfix = " (not loose-selected)";
789  std::string pfix2 = " (not HP-selected)";
790 
791  h_reco_mva_hp.back().push_back(ibook.book1D("num_reco_mva"+istr+"_hp", "N of reco track after vs MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
792  h_assoc2_mva_hp.back().push_back(ibook.book1D("num_assoc(recoToSim)_mva"+istr+"_hp", "N of associated tracks (recoToSim) vs MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
793 
794  h_reco_mvacut_hp.back().push_back(ibook.book1D("num_reco_mva"+istr+"cut"+"_hp", "N of reco track vs cut on MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
795  h_assoc_mvacut_hp.back().push_back(ibook.book1D("num_assoc(simToReco)_mva"+istr+"cut_hp", "N of associated tracks (simToReco) vs cut on MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
796  h_assoc2_mvacut_hp.back().push_back(ibook.book1D("num_assoc(recoToSim)_mva"+istr+"cut_hp", "N of associated tracks (recoToSim) vs cut on MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
797  h_simul2_mvacut_hp.back().push_back(ibook.book1D("num_simul2_mva"+istr+"cut_hp", "N of simulated tracks (associated to any track) vs cut on MVA"+istr+pfix2, nintMVA, minMVA, maxMVA) );
798  }
799 
800  h_reco_mva.back().push_back(ibook.book1D("num_reco_mva"+istr, "N of reco track vs MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
801  h_assoc2_mva.back().push_back(ibook.book1D("num_assoc(recoToSim)_mva"+istr, "N of associated tracks (recoToSim) vs MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
802 
803  h_reco_mvacut.back().push_back(ibook.book1D("num_reco_mva"+istr+"cut", "N of reco track vs cut on MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
804  h_assoc_mvacut.back().push_back(ibook.book1D("num_assoc(simToReco)_mva"+istr+"cut", "N of associated tracks (simToReco) vs cut on MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
805  h_assoc2_mvacut.back().push_back(ibook.book1D("num_assoc(recoToSim)_mva"+istr+"cut", "N of associated tracks (recoToSim) vs cut on MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
806  h_simul2_mvacut.back().push_back(ibook.book1D("num_simul2_mva"+istr+"cut", "N of simulated tracks (associated to any track) vs cut on MVA"+istr+pfix, nintMVA, minMVA, maxMVA) );
807  }
808 }
std::vector< std::vector< MonitorElement * > > h_reco_mvacut
std::vector< std::vector< MonitorElement * > > h_assoc2_mva_hp
std::vector< std::vector< MonitorElement * > > h_assoc2_mva
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut_hp
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< std::vector< MonitorElement * > > h_reco_mva
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut_hp
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut_hp
std::vector< std::vector< MonitorElement * > > h_reco_mvacut_hp
std::vector< std::vector< MonitorElement * > > h_reco_mva_hp
void MTVHistoProducerAlgoForTracker::bookRecodEdxHistos ( DQMStore::IBooker ibook)

Definition at line 736 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), h_dedx_estim, h_dedx_nom, h_dedx_sat, maxDeDx, maxHit, minDeDx, minHit, nintDeDx, and nintHit.

736  {
737  // dE/dx stuff
738  h_dedx_estim.emplace_back(std::initializer_list<MonitorElement*>{
739  ibook.book1D("h_dedx_estim1","dE/dx estimator 1",nintDeDx,minDeDx,maxDeDx),
740  ibook.book1D("h_dedx_estim2","dE/dx estimator 2",nintDeDx,minDeDx,maxDeDx)
741  });
742  h_dedx_nom.emplace_back(std::initializer_list<MonitorElement*>{
743  ibook.book1D("h_dedx_nom1","dE/dx number of measurements",nintHit,minHit,maxHit),
744  ibook.book1D("h_dedx_nom2","dE/dx number of measurements",nintHit,minHit,maxHit)
745  });
746  h_dedx_sat.emplace_back(std::initializer_list<MonitorElement*>{
747  ibook.book1D("h_dedx_sat1","dE/dx number of measurements with saturation",nintHit,minHit,maxHit),
748  ibook.book1D("h_dedx_sat2","dE/dx number of measurements with saturation",nintHit,minHit,maxHit)
749  });
750 }
std::vector< std::vector< MonitorElement * > > h_dedx_estim
std::vector< std::vector< MonitorElement * > > h_dedx_sat
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< std::vector< MonitorElement * > > h_dedx_nom
void MTVHistoProducerAlgoForTracker::bookRecoHistos ( DQMStore::IBooker ibook)

these are needed to calculate efficiency during the harvesting for the automated validation

Definition at line 424 of file MTVHistoProducerAlgoForTracker.cc.

References reco::TrackBase::algoNames, reco::TrackBase::algoSize, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), DQMStore::IBooker::bookProfile2D(), chi2_vs_eta, chi2_vs_nhits, chi2_vs_phi, cotThetaRes_nbin, cotThetaRes_rangeMax, cotThetaRes_rangeMin, cotThetares_vs_eta, cotThetares_vs_pt, doSeedPlots_, dxypull_vs_eta, dxyRes_nbin, dxyRes_rangeMax, dxyRes_rangeMin, dxyres_vs_eta, dxyres_vs_pt, dzpull_vs_eta, dzRes_nbin, dzRes_rangeMax, dzRes_rangeMin, dzres_vs_eta, dzres_vs_pt, etares_vs_eta, h_algo, h_assoc23Dlayer, h_assoc2_seedingLayerSet, h_assoc2_simpvz, h_assoc2chi2, h_assoc2dr, h_assoc2dxy, h_assoc2dz, h_assoc2eta, h_assoc2hit, h_assoc2layer, h_assoc2phi, h_assoc2pixellayer, h_assoc2pT, h_assoc2pu, h_assoc2vertpos, h_assoc2zpos, h_assocFraction, h_assocSharedHit, h_charge, h_eta, h_fakes, h_hits, h_looper3Dlayer, h_looper_seedingLayerSet, h_looperchi2, h_looperdr, h_looperdxy, h_looperdz, h_loopereta, h_looperhit, h_looperlayer, h_looperphi, h_looperpixellayer, h_looperpT, h_looperpu, h_loopervertpos, h_looperzpos, h_losthits, h_misid3Dlayer, h_misidchi2, h_misiddxy, h_misiddz, h_misideta, h_misidhit, h_misidlayer, h_misidphi, h_misidpixellayer, h_misidpT, h_misidpu, h_nchi2, h_nchi2_prob, h_nmisslayers_inner, h_nmisslayers_outer, h_pileup3Dlayer, h_pileup_seedingLayerSet, h_pileup_simpvz, h_pileupchi2, h_pileupdr, h_pileupdxy, h_pileupdz, h_pileupeta, h_pileuphit, h_pileuplayer, h_pileupphi, h_pileuppixellayer, h_pileuppT, h_pileuppu, h_pileupvertpos, h_pileupzpos, h_pt, h_pullDxy, h_pullDz, h_pullPhi, h_pullQoverp, h_pullTheta, h_reco2eta, h_reco2pT, h_reco2pu, h_reco3Dlayer, h_reco_seedingLayerSet, h_reco_simpvz, h_recochi2, h_recodr, h_recodxy, h_recodz, h_recoeta, h_recohit, h_recolayer, h_recophi, h_recopixellayer, h_recopT, h_recopu, h_recovertpos, h_recozpos, h_tracks, maxChi2, maxdr, maxDxy, maxDz, maxEta, maxHit, maxLayers, maxPhi, maxPt, maxPu, maxPVz, maxTracks, maxVertpos, maxZpos, mindr, minDxy, minDz, minEta, minHit, minLayers, minPhi, minPt, minPu, minPVz, minTracks, minVertpos, minZpos, nhits_vs_eta, nhits_vs_phi, nintChi2, nintdr, nintDxy, nintDz, nintEta, nintHit, nintLayers, nintPhi, nintPt, nintPu, nintPVz, nintTracks, nintVertpos, nintZpos, nLayersWithMeas_vs_eta, nlosthits_vs_eta, nPXBhits_vs_eta, nPXFhits_vs_eta, nPXLhits_vs_eta, nPXLlayersWithMeas_vs_eta, nrec_vs_nsim, nrecHit_vs_nsimHit_rec2sim, nSTRIPhits_vs_eta, nSTRIPlayersWith1dMeas_vs_eta, nSTRIPlayersWith2dMeas_vs_eta, nSTRIPlayersWithMeas_vs_eta, nTEChits_vs_eta, nTIBhits_vs_eta, nTIDhits_vs_eta, nTOBhits_vs_eta, phimean_vs_eta_phi, phipull_vs_eta, phipull_vs_phi, phiRes_nbin, phiRes_rangeMax, phiRes_rangeMin, phires_vs_eta, phires_vs_phi, phires_vs_pt, ptmean_vs_eta_phi, ptpull_vs_eta, ptpull_vs_phi, ptRes_nbin, ptRes_rangeMax, ptRes_rangeMin, ptres_vs_eta, ptres_vs_phi, ptres_vs_pt, seedingLayerSetNames, HcalObjRepresent::setBinLabels(), findQualityFiles::size, thetapull_vs_eta, thetapull_vs_phi, and useLogPt.

424  {
425  h_tracks.push_back( ibook.book1D("tracks","number of reconstructed tracks", nintTracks, minTracks, maxTracks) );
426  h_fakes.push_back( ibook.book1D("fakes","number of fake reco tracks", nintTracks, minTracks, maxTracks) );
427  h_charge.push_back( ibook.book1D("charge","charge",3,-1.5,1.5) );
428 
429  h_hits.push_back( ibook.book1D("hits", "number of hits per track", nintHit,minHit,maxHit ) );
430  h_losthits.push_back( ibook.book1D("losthits", "number of lost hits per track", nintHit,minHit,maxHit) );
431  h_nchi2.push_back( ibook.book1D("chi2", "normalized #chi^{2}", 200, 0, 20 ) );
432  h_nchi2_prob.push_back( ibook.book1D("chi2_prob", "normalized #chi^{2} probability",100,0,1));
433 
434  h_nmisslayers_inner.push_back( ibook.book1D("missing_inner_layers", "number of missing inner layers", nintLayers,minLayers,maxLayers ) );
435  h_nmisslayers_outer.push_back( ibook.book1D("missing_outer_layers", "number of missing outer layers", nintLayers,minLayers,maxLayers ) );
436 
437  h_algo.push_back( ibook.book1D("h_algo","Tracks by algo",reco::TrackBase::algoSize, 0., double(reco::TrackBase::algoSize) ) );
438  for (size_t ibin=0; ibin<reco::TrackBase::algoSize-1; ibin++)
439  h_algo.back()->setBinLabel(ibin+1,reco::TrackBase::algoNames[ibin]);
440  // h_algo.setBinLabel(ibin+1,reco::TrackBase::algoNames[ibin]);
441 
443  h_recoeta.push_back( ibook.book1D("num_reco_eta","N of reco track vs eta",nintEta,minEta,maxEta) );
444  h_reco2eta.push_back( ibook.book1D("num_reco2_eta","N of selected reco track vs eta",nintEta,minEta,maxEta) );
445  h_assoc2eta.push_back( ibook.book1D("num_assoc(recoToSim)_eta","N of associated (recoToSim) tracks vs eta",nintEta,minEta,maxEta) );
446  h_loopereta.push_back( ibook.book1D("num_duplicate_eta","N of associated (recoToSim) duplicate tracks vs eta",nintEta,minEta,maxEta) );
447  if(!doSeedPlots_) h_misideta.push_back( ibook.book1D("num_chargemisid_eta","N of associated (recoToSim) charge misIDed tracks vs eta",nintEta,minEta,maxEta) );
448  h_pileupeta.push_back( ibook.book1D("num_pileup_eta","N of associated (recoToSim) pileup tracks vs eta",nintEta,minEta,maxEta) );
449  //
450  h_recopT.push_back( ibook.book1D("num_reco_pT","N of reco track vs pT",nintPt,minPt,maxPt) );
451  h_reco2pT.push_back( ibook.book1D("num_reco2_pT","N of selected reco track vs pT",nintPt,minPt,maxPt) );
452  h_assoc2pT.push_back( ibook.book1D("num_assoc(recoToSim)_pT","N of associated (recoToSim) tracks vs pT",nintPt,minPt,maxPt) );
453  h_looperpT.push_back( ibook.book1D("num_duplicate_pT","N of associated (recoToSim) duplicate tracks vs pT",nintPt,minPt,maxPt) );
454  if(!doSeedPlots_) h_misidpT.push_back( ibook.book1D("num_chargemisid_pT","N of associated (recoToSim) charge misIDed tracks vs pT",nintPt,minPt,maxPt) );
455  h_pileuppT.push_back( ibook.book1D("num_pileup_pT","N of associated (recoToSim) pileup tracks vs pT",nintPt,minPt,maxPt) );
456  //
457  h_recohit.push_back( ibook.book1D("num_reco_hit","N of reco track vs hit",nintHit,minHit,maxHit) );
458  h_assoc2hit.push_back( ibook.book1D("num_assoc(recoToSim)_hit","N of associated (recoToSim) tracks vs hit",nintHit,minHit,maxHit) );
459  h_looperhit.push_back( ibook.book1D("num_duplicate_hit","N of associated (recoToSim) duplicate tracks vs hit",nintHit,minHit,maxHit) );
460  if(!doSeedPlots_) h_misidhit.push_back( ibook.book1D("num_chargemisid_hit","N of associated (recoToSim) charge misIDed tracks vs hit",nintHit,minHit,maxHit) );
461  h_pileuphit.push_back( ibook.book1D("num_pileup_hit","N of associated (recoToSim) pileup tracks vs hit",nintHit,minHit,maxHit) );
462  //
463  h_recolayer.push_back( ibook.book1D("num_reco_layer","N of reco track vs layer",nintLayers,minLayers,maxLayers) );
464  h_assoc2layer.push_back( ibook.book1D("num_assoc(recoToSim)_layer","N of associated (recoToSim) tracks vs layer",nintLayers,minLayers,maxLayers) );
465  h_looperlayer.push_back( ibook.book1D("num_duplicate_layer","N of associated (recoToSim) duplicate tracks vs layer",nintLayers,minLayers,maxLayers) );
466  if(!doSeedPlots_) h_misidlayer.push_back( ibook.book1D("num_chargemisid_layer","N of associated (recoToSim) charge misIDed tracks vs layer",nintLayers,minLayers,maxLayers) );
467  h_pileuplayer.push_back( ibook.book1D("num_pileup_layer","N of associated (recoToSim) pileup tracks vs layer",nintLayers,minLayers,maxLayers) );
468  //
469  h_recopixellayer.push_back( ibook.book1D("num_reco_pixellayer","N of reco track vs pixellayer",nintLayers,minLayers,maxLayers) );
470  h_assoc2pixellayer.push_back( ibook.book1D("num_assoc(recoToSim)_pixellayer","N of associated (recoToSim) tracks vs pixellayer",nintLayers,minLayers,maxLayers) );
471  h_looperpixellayer.push_back( ibook.book1D("num_duplicate_pixellayer","N of associated (recoToSim) duplicate tracks vs pixellayer",nintLayers,minLayers,maxLayers) );
472  if(!doSeedPlots_) h_misidpixellayer.push_back( ibook.book1D("num_chargemisid_pixellayer","N of associated (recoToSim) charge misIDed tracks vs pixellayer",nintLayers,minLayers,maxLayers) );
473  h_pileuppixellayer.push_back( ibook.book1D("num_pileup_pixellayer","N of associated (recoToSim) pileup tracks vs pixellayer",nintLayers,minLayers,maxLayers) );
474  //
475  h_reco3Dlayer.push_back( ibook.book1D("num_reco_3Dlayer","N of reco track vs 3D layer",nintLayers,minLayers,maxLayers) );
476  h_assoc23Dlayer.push_back( ibook.book1D("num_assoc(recoToSim)_3Dlayer","N of associated (recoToSim) tracks vs 3D layer",nintLayers,minLayers,maxLayers) );
477  h_looper3Dlayer.push_back( ibook.book1D("num_duplicate_3Dlayer","N of associated (recoToSim) duplicate tracks vs 3D layer",nintLayers,minLayers,maxLayers) );
478  if(!doSeedPlots_) h_misid3Dlayer.push_back( ibook.book1D("num_chargemisid_3Dlayer","N of associated (recoToSim) charge misIDed tracks vs 3D layer",nintLayers,minLayers,maxLayers) );
479  h_pileup3Dlayer.push_back( ibook.book1D("num_pileup_3Dlayer","N of associated (recoToSim) pileup tracks vs 3D layer",nintLayers,minLayers,maxLayers) );
480  //
481  h_recopu.push_back( ibook.book1D("num_reco_pu","N of reco track vs pu",nintPu,minPu,maxPu) );
482  h_reco2pu.push_back( ibook.book1D("num_reco2_pu","N of selected reco track vs pu",nintPu,minPu,maxPu) );
483  h_assoc2pu.push_back( ibook.book1D("num_assoc(recoToSim)_pu","N of associated (recoToSim) tracks vs pu",nintPu,minPu,maxPu) );
484  h_looperpu.push_back( ibook.book1D("num_duplicate_pu","N of associated (recoToSim) duplicate tracks vs pu",nintPu,minPu,maxPu) );
485  if(!doSeedPlots_) h_misidpu.push_back( ibook.book1D("num_chargemisid_pu","N of associated (recoToSim) charge misIDed tracks vs pu",nintPu,minPu,maxPu) );
486  h_pileuppu.push_back( ibook.book1D("num_pileup_pu","N of associated (recoToSim) pileup tracks vs pu",nintPu,minPu,maxPu) );
487  //
488  h_recophi.push_back( ibook.book1D("num_reco_phi","N of reco track vs phi",nintPhi,minPhi,maxPhi) );
489  h_assoc2phi.push_back( ibook.book1D("num_assoc(recoToSim)_phi","N of associated (recoToSim) tracks vs phi",nintPhi,minPhi,maxPhi) );
490  h_looperphi.push_back( ibook.book1D("num_duplicate_phi","N of associated (recoToSim) duplicate tracks vs phi",nintPhi,minPhi,maxPhi) );
491  if(!doSeedPlots_) h_misidphi.push_back( ibook.book1D("num_chargemisid_phi","N of associated (recoToSim) charge misIDed tracks vs phi",nintPhi,minPhi,maxPhi) );
492  h_pileupphi.push_back( ibook.book1D("num_pileup_phi","N of associated (recoToSim) pileup tracks vs phi",nintPhi,minPhi,maxPhi) );
493 
494  h_recodxy.push_back( ibook.book1D("num_reco_dxy","N of reco track vs dxy",nintDxy,minDxy,maxDxy) );
495  h_assoc2dxy.push_back( ibook.book1D("num_assoc(recoToSim)_dxy","N of associated (recoToSim) tracks vs dxy",nintDxy,minDxy,maxDxy) );
496  h_looperdxy.push_back( ibook.book1D("num_duplicate_dxy","N of associated (recoToSim) looper tracks vs dxy",nintDxy,minDxy,maxDxy) );
497  if(!doSeedPlots_) h_misiddxy.push_back( ibook.book1D("num_chargemisid_dxy","N of associated (recoToSim) charge misIDed tracks vs dxy",nintDxy,minDxy,maxDxy) );
498  h_pileupdxy.push_back( ibook.book1D("num_pileup_dxy","N of associated (recoToSim) pileup tracks vs dxy",nintDxy,minDxy,maxDxy) );
499 
500  h_recodz.push_back( ibook.book1D("num_reco_dz","N of reco track vs dz",nintDz,minDz,maxDz) );
501  h_assoc2dz.push_back( ibook.book1D("num_assoc(recoToSim)_dz","N of associated (recoToSim) tracks vs dz",nintDz,minDz,maxDz) );
502  h_looperdz.push_back( ibook.book1D("num_duplicate_dz","N of associated (recoToSim) looper tracks vs dz",nintDz,minDz,maxDz) );
503  if(!doSeedPlots_) h_misiddz.push_back( ibook.book1D("num_chargemisid_versus_dz","N of associated (recoToSim) charge misIDed tracks vs dz",nintDz,minDz,maxDz) );
504  h_pileupdz.push_back( ibook.book1D("num_pileup_dz","N of associated (recoToSim) pileup tracks vs dz",nintDz,minDz,maxDz) );
505 
506  h_recovertpos.push_back( ibook.book1D("num_reco_vertpos","N of reconstructed tracks vs transverse ref point position",nintVertpos,minVertpos,maxVertpos) );
507  h_assoc2vertpos.push_back( ibook.book1D("num_assoc(recoToSim)_vertpos","N of associated (recoToSim) tracks vs transverse ref point position",nintVertpos,minVertpos,maxVertpos) );
508  h_loopervertpos.push_back( ibook.book1D("num_duplicate_vertpos","N of associated (recoToSim) looper tracks vs transverse ref point position",nintVertpos,minVertpos,maxVertpos) );
509  h_pileupvertpos.push_back( ibook.book1D("num_pileup_vertpos","N of associated (recoToSim) pileup tracks vs transverse ref point position",nintVertpos,minVertpos,maxVertpos) );
510 
511  h_recozpos.push_back( ibook.book1D("num_reco_zpos","N of reconstructed tracks vs transverse ref point position",nintZpos,minZpos,maxZpos) );
512  h_assoc2zpos.push_back( ibook.book1D("num_assoc(recoToSim)_zpos","N of associated (recoToSim) tracks vs transverse ref point position",nintZpos,minZpos,maxZpos) );
513  h_looperzpos.push_back( ibook.book1D("num_duplicate_zpos","N of associated (recoToSim) looper tracks vs transverse ref point position",nintZpos,minZpos,maxZpos) );
514  h_pileupzpos.push_back( ibook.book1D("num_pileup_zpos","N of associated (recoToSim) pileup tracks vs transverse ref point position",nintZpos,minZpos,maxZpos) );
515 
516  h_recodr.push_back( ibook.book1D("num_reco_dr","N of reconstructed tracks vs dR",nintdr,log10(mindr),log10(maxdr)) );
517  h_assoc2dr.push_back( ibook.book1D("num_assoc(recoToSim)_dr","N of associated tracks (recoToSim) vs dR",nintdr,log10(mindr),log10(maxdr)) );
518  h_looperdr.push_back( ibook.book1D("num_duplicate_dr","N of associated (recoToSim) looper tracks vs dR",nintdr,log10(mindr),log10(maxdr)) );
519  h_pileupdr.push_back( ibook.book1D("num_pileup_dr","N of associated (recoToSim) pileup tracks vs dR",nintdr,log10(mindr),log10(maxdr)) );
520  BinLogX(h_recodr.back()->getTH1F());
521  BinLogX(h_assoc2dr.back()->getTH1F());
522  BinLogX(h_looperdr.back()->getTH1F());
523  BinLogX(h_pileupdr.back()->getTH1F());
524 
525  h_reco_simpvz.push_back( ibook.book1D("num_reco_simpvz", "N of reco track vs. sim PV z", nintPVz, minPVz, maxPVz) );
526  h_assoc2_simpvz.push_back( ibook.book1D("num_assoc(recoToSim)_simpvz", "N of associated tracks (recoToSim) vs. sim PV z", nintPVz, minPVz, maxPVz) );
527  h_pileup_simpvz.push_back( ibook.book1D("num_pileup_simpvz", "N of associated (recoToSim) pileup tracks vs. sim PV z", nintPVz, minPVz, maxPVz) );
528 
529  h_recochi2.push_back( ibook.book1D("num_reco_chi2","N of reco track vs normalized #chi^{2}",nintChi2,minChi2,maxChi2) );
530  h_assoc2chi2.push_back( ibook.book1D("num_assoc(recoToSim)_chi2","N of associated (recoToSim) tracks vs normalized #chi^{2}",nintChi2,minChi2,maxChi2) );
531  h_looperchi2.push_back( ibook.book1D("num_duplicate_chi2","N of associated (recoToSim) looper tracks vs normalized #chi^{2}",nintChi2,minChi2,maxChi2) );
532  if(!doSeedPlots_) h_misidchi2.push_back( ibook.book1D("num_chargemisid_chi2","N of associated (recoToSim) charge misIDed tracks vs normalized #chi^{2}",nintChi2,minChi2,maxChi2) );
533  h_pileupchi2.push_back( ibook.book1D("num_pileup_chi2","N of associated (recoToSim) pileup tracks vs normalized #chi^{2}",nintChi2,minChi2,maxChi2) );
534 
535 
536  if(!seedingLayerSetNames.empty()) {
537  const auto size = seedingLayerSetNames.size();
538  h_reco_seedingLayerSet.push_back(ibook.book1D("num_reco_seedingLayerSet", "N of reco track vs. seedingLayerSet", size,0,size));
539  h_assoc2_seedingLayerSet.push_back(ibook.book1D("num_assoc(recoToSim)_seedingLayerSet", "N of associated track (recoToSim) tracks vs. seedingLayerSet", size,0,size));
540  h_looper_seedingLayerSet.push_back(ibook.book1D("num_duplicate_seedingLayerSet", "N of reco associated (recoToSim) looper vs. seedingLayerSet", size,0,size));
541  h_pileup_seedingLayerSet.push_back(ibook.book1D("num_pileup_seedingLayerSet", "N of reco associated (recoToSim) pileup vs. seedingLayerSet", size,0,size));
542 
547  }
548 
550 
551  h_eta.push_back( ibook.book1D("eta", "pseudorapidity residue", 1000, -0.1, 0.1 ) );
552  h_pt.push_back( ibook.book1D("pullPt", "pull of p_{t}", 100, -10, 10 ) );
553  h_pullTheta.push_back( ibook.book1D("pullTheta","pull of #theta parameter",250,-25,25) );
554  h_pullPhi.push_back( ibook.book1D("pullPhi","pull of #phi parameter",250,-25,25) );
555  h_pullDxy.push_back( ibook.book1D("pullDxy","pull of dxy parameter",250,-25,25) );
556  h_pullDz.push_back( ibook.book1D("pullDz","pull of dz parameter",250,-25,25) );
557  h_pullQoverp.push_back( ibook.book1D("pullQoverp","pull of qoverp parameter",250,-25,25) );
558 
559  /* TO BE FIXED -----------
560  if (associators[ww]=="TrackAssociatorByChi2"){
561  h_assochi2.push_back( ibook.book1D("assocChi2","track association #chi^{2}",1000000,0,100000) );
562  h_assochi2_prob.push_back(ibook.book1D("assocChi2_prob","probability of association #chi^{2}",100,0,1));
563  } else if (associators[ww]=="quickTrackAssociatorByHits"){
564  h_assocFraction.push_back( ibook.book1D("assocFraction","fraction of shared hits",200,0,2) );
565  h_assocSharedHit.push_back(ibook.book1D("assocSharedHit","number of shared hits",20,0,20));
566  }
567  */
568  h_assocFraction.push_back( ibook.book1D("assocFraction","fraction of shared hits",200,0,2) );
569  h_assocSharedHit.push_back(ibook.book1D("assocSharedHit","number of shared hits",41,-0.5,40.5));
570  // ----------------------
571 
572  // use the standard error of the mean as the errors in the profile
573  chi2_vs_nhits.push_back( ibook.bookProfile("chi2mean_vs_nhits","mean #chi^{2} vs nhits",nintHit,minHit,maxHit, 100,0,10, " ") );
574 
575  etares_vs_eta.push_back( ibook.book2D("etares_vs_eta","etaresidue vs eta",nintEta,minEta,maxEta,200,-0.1,0.1) );
576  nrec_vs_nsim.push_back( ibook.book2D("nrec_vs_nsim","Number of selected reco tracks vs. number of selected sim tracks;TrackingParticles;Reco tracks", nintTracks,minTracks,maxTracks, nintTracks,minTracks,maxTracks) );
577 
578  chi2_vs_eta.push_back( ibook.bookProfile("chi2mean","mean #chi^{2} vs #eta",nintEta,minEta,maxEta, 200, 0, 20, " " ));
579  chi2_vs_phi.push_back( ibook.bookProfile("chi2mean_vs_phi","mean #chi^{2} vs #phi",nintPhi,minPhi,maxPhi, 200, 0, 20, " " ) );
580 
581  nhits_vs_eta.push_back( ibook.bookProfile("hits_eta","mean hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
582  nPXBhits_vs_eta.push_back( ibook.bookProfile("PXBhits_vs_eta","mean # PXB its vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
583  nPXFhits_vs_eta.push_back( ibook.bookProfile("PXFhits_vs_eta","mean # PXF hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
584  nPXLhits_vs_eta.push_back( ibook.bookProfile("PXLhits_vs_eta","mean # PXL hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
585  nTIBhits_vs_eta.push_back( ibook.bookProfile("TIBhits_vs_eta","mean # TIB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
586  nTIDhits_vs_eta.push_back( ibook.bookProfile("TIDhits_vs_eta","mean # TID hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
587  nTOBhits_vs_eta.push_back( ibook.bookProfile("TOBhits_vs_eta","mean # TOB hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
588  nTEChits_vs_eta.push_back( ibook.bookProfile("TEChits_vs_eta","mean # TEC hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
589  nSTRIPhits_vs_eta.push_back( ibook.bookProfile("STRIPhits_vs_eta","mean # STRIP hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
590 
591  nLayersWithMeas_vs_eta.push_back( ibook.bookProfile("LayersWithMeas_eta","mean # Layers with measurement vs eta",
593  nPXLlayersWithMeas_vs_eta.push_back( ibook.bookProfile("PXLlayersWithMeas_vs_eta","mean # PXL Layers with measurement vs eta",
595  nSTRIPlayersWithMeas_vs_eta.push_back( ibook.bookProfile("STRIPlayersWithMeas_vs_eta","mean # STRIP Layers with measurement vs eta",
597  nSTRIPlayersWith1dMeas_vs_eta.push_back( ibook.bookProfile("STRIPlayersWith1dMeas_vs_eta","mean # STRIP Layers with 1D measurement vs eta",
599  nSTRIPlayersWith2dMeas_vs_eta.push_back( ibook.bookProfile("STRIPlayersWith2dMeas_vs_eta","mean # STRIP Layers with 2D measurement vs eta",
601 
602  nhits_vs_phi.push_back( ibook.bookProfile("hits_phi","mean # hits vs #phi",nintPhi,minPhi,maxPhi,nintHit,minHit,maxHit, " ") );
603 
604  nlosthits_vs_eta.push_back( ibook.bookProfile("losthits_vs_eta","mean # lost hits vs eta",nintEta,minEta,maxEta,nintHit,minHit,maxHit, " ") );
605 
606  //resolution of track parameters
607  // dPt/Pt cotTheta Phi TIP LIP
608  // log10(pt)<0.5 100,0.1 240,0.08 100,0.015 100,0.1000 150,0.3000
609  // 0.5<log10(pt)<1.5 100,0.1 120,0.01 100,0.003 100,0.0100 150,0.0500
610  // >1.5 100,0.3 100,0.005 100,0.0008 100,0.0060 120,0.0300
611 
612  ptres_vs_eta.push_back(ibook.book2D("ptres_vs_eta","ptres_vs_eta",
614 
615  ptres_vs_phi.push_back( ibook.book2D("ptres_vs_phi","p_{t} res vs #phi",
617 
618  ptres_vs_pt.push_back(ibook.book2D("ptres_vs_pt","ptres_vs_pt",nintPt,minPt,maxPt, ptRes_nbin, ptRes_rangeMin, ptRes_rangeMax));
619 
620  cotThetares_vs_eta.push_back(ibook.book2D("cotThetares_vs_eta","cotThetares_vs_eta",
622 
623 
624  cotThetares_vs_pt.push_back(ibook.book2D("cotThetares_vs_pt","cotThetares_vs_pt",
626 
627 
628  phires_vs_eta.push_back(ibook.book2D("phires_vs_eta","phires_vs_eta",
630 
631  phires_vs_pt.push_back(ibook.book2D("phires_vs_pt","phires_vs_pt",
633 
634  phires_vs_phi.push_back(ibook.book2D("phires_vs_phi","#phi res vs #phi",
636 
637  dxyres_vs_eta.push_back(ibook.book2D("dxyres_vs_eta","dxyres_vs_eta",
639 
640  dxyres_vs_pt.push_back( ibook.book2D("dxyres_vs_pt","dxyres_vs_pt",
642 
643  dzres_vs_eta.push_back(ibook.book2D("dzres_vs_eta","dzres_vs_eta",
645 
646  dzres_vs_pt.push_back(ibook.book2D("dzres_vs_pt","dzres_vs_pt",nintPt,minPt,maxPt,dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
647 
648  ptmean_vs_eta_phi.push_back(ibook.bookProfile2D("ptmean_vs_eta_phi","mean p_{t} vs #eta and #phi",
649  nintPhi,minPhi,maxPhi,nintEta,minEta,maxEta,1000,0,1000));
650  phimean_vs_eta_phi.push_back(ibook.bookProfile2D("phimean_vs_eta_phi","mean #phi vs #eta and #phi",
652 
653  //pulls of track params vs eta: to be used with fitslicesytool
654  dxypull_vs_eta.push_back(ibook.book2D("dxypull_vs_eta","dxypull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
655  ptpull_vs_eta.push_back(ibook.book2D("ptpull_vs_eta","ptpull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
656  dzpull_vs_eta.push_back(ibook.book2D("dzpull_vs_eta","dzpull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
657  phipull_vs_eta.push_back(ibook.book2D("phipull_vs_eta","phipull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
658  thetapull_vs_eta.push_back(ibook.book2D("thetapull_vs_eta","thetapull_vs_eta",nintEta,minEta,maxEta,100,-10,10));
659 
660  // h_ptshiftetamean.push_back( ibook.book1D("h_ptshifteta_Mean","<#deltapT/pT>[%] vs #eta",nintEta,minEta,maxEta) );
661 
662 
663  //pulls of track params vs phi
664  ptpull_vs_phi.push_back(ibook.book2D("ptpull_vs_phi","p_{t} pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
665  phipull_vs_phi.push_back(ibook.book2D("phipull_vs_phi","#phi pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
666  thetapull_vs_phi.push_back(ibook.book2D("thetapull_vs_phi","#theta pull vs #phi",nintPhi,minPhi,maxPhi,100,-10,10));
667 
668 
669  nrecHit_vs_nsimHit_rec2sim.push_back( ibook.book2D("nrecHit_vs_nsimHit_rec2sim","nrecHit vs nsimHit (Rec2simAssoc)",
671 
672  if(useLogPt){
673  BinLogX(dzres_vs_pt.back()->getTH2F());
674  BinLogX(dxyres_vs_pt.back()->getTH2F());
675  BinLogX(phires_vs_pt.back()->getTH2F());
676  BinLogX(cotThetares_vs_pt.back()->getTH2F());
677  BinLogX(ptres_vs_pt.back()->getTH2F());
678  BinLogX(h_looperpT.back()->getTH1F());
679  if(!doSeedPlots_) BinLogX(h_misidpT.back()->getTH1F());
680  BinLogX(h_recopT.back()->getTH1F());
681  BinLogX(h_reco2pT.back()->getTH1F());
682  BinLogX(h_assoc2pT.back()->getTH1F());
683  BinLogX(h_pileuppT.back()->getTH1F());
684  }
685 }
size
Write out results.
std::vector< MonitorElement * > h_looperhit
std::vector< MonitorElement * > h_assoc2hit
std::vector< MonitorElement * > h_recodxy
std::vector< MonitorElement * > h_looperzpos
std::vector< MonitorElement * > h_fakes
std::vector< MonitorElement * > h_nchi2_prob
std::vector< MonitorElement * > h_looperpT
std::vector< MonitorElement * > h_pullDz
std::vector< MonitorElement * > h_misidlayer
std::vector< MonitorElement * > ptpull_vs_phi
std::vector< MonitorElement * > h_looperchi2
std::vector< MonitorElement * > nPXFhits_vs_eta
std::vector< MonitorElement * > h_assoc2zpos
std::vector< MonitorElement * > nrecHit_vs_nsimHit_rec2sim
std::vector< MonitorElement * > h_assoc2pT
std::vector< MonitorElement * > h_nmisslayers_inner
std::vector< MonitorElement * > h_looperpixellayer
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
std::vector< MonitorElement * > h_pileuphit
std::vector< MonitorElement * > h_pileupdr
std::vector< MonitorElement * > nTEChits_vs_eta
std::vector< MonitorElement * > h_hits
std::vector< MonitorElement * > nLayersWithMeas_vs_eta
std::vector< MonitorElement * > h_pullPhi
std::vector< MonitorElement * > phipull_vs_phi
std::vector< MonitorElement * > nrec_vs_nsim
std::vector< MonitorElement * > h_pileuppT
std::vector< MonitorElement * > h_algo
std::vector< MonitorElement * > h_recovertpos
std::vector< MonitorElement * > nTIDhits_vs_eta
std::vector< MonitorElement * > phires_vs_eta
std::vector< MonitorElement * > h_pullDxy
std::vector< MonitorElement * > h_assoc2phi
std::vector< MonitorElement * > h_nchi2
std::vector< MonitorElement * > h_assoc2_seedingLayerSet
std::vector< MonitorElement * > h_assoc2pu
std::vector< MonitorElement * > h_pileup_seedingLayerSet
std::vector< MonitorElement * > h_reco2pu
std::vector< MonitorElement * > h_misidchi2
std::vector< MonitorElement * > h_looperdxy
std::vector< MonitorElement * > h_reco_simpvz
std::vector< MonitorElement * > h_looper3Dlayer
std::vector< MonitorElement * > h_reco3Dlayer
std::vector< MonitorElement * > h_loopervertpos
std::vector< MonitorElement * > h_looperdr
std::vector< MonitorElement * > h_pileupchi2
std::vector< MonitorElement * > h_assoc2dz
std::vector< MonitorElement * > chi2_vs_phi
std::vector< MonitorElement * > h_looper_seedingLayerSet
std::vector< MonitorElement * > phires_vs_phi
std::vector< MonitorElement * > dzres_vs_eta
std::vector< MonitorElement * > h_misideta
std::vector< MonitorElement * > nlosthits_vs_eta
std::vector< MonitorElement * > nSTRIPlayersWith1dMeas_vs_eta
std::vector< MonitorElement * > h_recohit
std::vector< MonitorElement * > h_looperlayer
std::vector< MonitorElement * > phires_vs_pt
std::vector< MonitorElement * > h_assoc2layer
std::vector< MonitorElement * > h_assoc23Dlayer
std::vector< MonitorElement * > nPXBhits_vs_eta
std::vector< MonitorElement * > h_looperpu
std::vector< MonitorElement * > h_assoc2dxy
std::vector< MonitorElement * > h_pullQoverp
std::vector< MonitorElement * > h_assoc2chi2
std::vector< MonitorElement * > h_misidhit
std::vector< MonitorElement * > nSTRIPlayersWithMeas_vs_eta
MonitorElement * bookProfile2D(Args &&...args)
Definition: DQMStore.h:163
std::vector< MonitorElement * > nTOBhits_vs_eta
std::vector< MonitorElement * > ptpull_vs_eta
std::vector< MonitorElement * > etares_vs_eta
std::vector< MonitorElement * > h_pileup_simpvz
std::vector< MonitorElement * > h_recozpos
std::vector< MonitorElement * > h_recophi
std::vector< MonitorElement * > nSTRIPlayersWith2dMeas_vs_eta
std::vector< MonitorElement * > h_tracks
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< MonitorElement * > nhits_vs_phi
std::vector< MonitorElement * > h_assoc2pixellayer
std::vector< MonitorElement * > h_misid3Dlayer
std::vector< MonitorElement * > phimean_vs_eta_phi
std::vector< MonitorElement * > h_charge
std::vector< MonitorElement * > h_misidpu
std::vector< MonitorElement * > h_loopereta
std::vector< MonitorElement * > h_misiddz
std::vector< MonitorElement * > h_assoc2_simpvz
std::vector< MonitorElement * > h_pileupvertpos
std::vector< MonitorElement * > h_pileupphi
std::vector< MonitorElement * > chi2_vs_nhits
std::vector< MonitorElement * > h_recodr
std::vector< MonitorElement * > h_assoc2vertpos
std::vector< MonitorElement * > dzpull_vs_eta
std::vector< MonitorElement * > h_misiddxy
std::vector< MonitorElement * > nPXLhits_vs_eta
std::vector< MonitorElement * > thetapull_vs_phi
std::vector< MonitorElement * > h_recolayer
std::vector< MonitorElement * > dxyres_vs_eta
std::vector< MonitorElement * > nSTRIPhits_vs_eta
std::vector< MonitorElement * > h_recopu
std::vector< MonitorElement * > h_misidpT
std::vector< MonitorElement * > h_nmisslayers_outer
std::vector< MonitorElement * > nPXLlayersWithMeas_vs_eta
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
std::vector< MonitorElement * > nTIBhits_vs_eta
std::vector< MonitorElement * > h_eta
std::vector< MonitorElement * > h_pt
std::vector< MonitorElement * > cotThetares_vs_pt
std::vector< MonitorElement * > h_pileuppixellayer
static const std::string algoNames[]
Definition: TrackBase.h:148
std::vector< MonitorElement * > h_pullTheta
std::vector< MonitorElement * > ptmean_vs_eta_phi
std::vector< MonitorElement * > h_looperphi
std::vector< std::string > seedingLayerSetNames
std::vector< MonitorElement * > h_assoc2dr
std::vector< MonitorElement * > dxypull_vs_eta
std::vector< MonitorElement * > ptres_vs_eta
std::vector< MonitorElement * > phipull_vs_eta
std::vector< MonitorElement * > h_recopixellayer
std::vector< MonitorElement * > h_recopT
std::vector< MonitorElement * > h_pileup3Dlayer
std::vector< MonitorElement * > h_looperdz
std::vector< MonitorElement * > h_pileupzpos
std::vector< MonitorElement * > h_misidpixellayer
std::vector< MonitorElement * > h_reco2eta
std::vector< MonitorElement * > h_pileuplayer
std::vector< MonitorElement * > cotThetares_vs_eta
std::vector< MonitorElement * > h_assocFraction
std::vector< MonitorElement * > h_pileupdxy
std::vector< MonitorElement * > h_recodz
void setBinLabels(std::vector< TH2F > &depth)
std::vector< MonitorElement * > ptres_vs_pt
std::vector< MonitorElement * > h_pileupdz
std::vector< MonitorElement * > h_reco_seedingLayerSet
std::vector< MonitorElement * > h_reco2pT
std::vector< MonitorElement * > h_recochi2
std::vector< MonitorElement * > ptres_vs_phi
std::vector< MonitorElement * > h_assocSharedHit
std::vector< MonitorElement * > nhits_vs_eta
std::vector< MonitorElement * > h_pileupeta
std::vector< MonitorElement * > h_recoeta
std::vector< MonitorElement * > thetapull_vs_eta
std::vector< MonitorElement * > chi2_vs_eta
std::vector< MonitorElement * > dxyres_vs_pt
std::vector< MonitorElement * > h_losthits
std::vector< MonitorElement * > h_assoc2eta
std::vector< MonitorElement * > h_misidphi
std::vector< MonitorElement * > dzres_vs_pt
std::vector< MonitorElement * > h_pileuppu
void MTVHistoProducerAlgoForTracker::bookRecoPVAssociationHistos ( DQMStore::IBooker ibook)

Definition at line 687 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), doSeedPlots_, dxyDzZoom, h_assoc2_dzpvcut, h_assoc2_dzpvcut_pt, h_assoc2_dzpvsigcut, h_assoc2_dzpvsigcut_pt, h_assoc2dxypv, h_assoc2dxypvzoomed, h_assoc2dzpv, h_assoc2dzpvzoomed, h_looperdxypv, h_looperdxypvzoomed, h_looperdzpv, h_looperdzpvzoomed, h_misiddxypv, h_misiddxypvzoomed, h_misiddzpv, h_misiddzpvzoomed, h_pileup_dzpvcut, h_pileup_dzpvcut_pt, h_pileup_dzpvsigcut, h_pileup_dzpvsigcut_pt, h_pileupdxypv, h_pileupdxypvzoomed, h_pileupdzpv, h_pileupdzpvzoomed, h_reco_dzpvcut, h_reco_dzpvcut_pt, h_reco_dzpvsigcut, h_reco_dzpvsigcut_pt, h_recodxypv, h_recodxypvzoomed, h_recodzpv, h_recodzpvzoomed, maxDxy, maxDz, maxDzpvCum, maxDzpvsigCum, minDxy, minDz, nintDxy, nintDz, nintDzpvCum, and nintDzpvsigCum.

687  {
688  h_recodxypv.push_back( ibook.book1D("num_reco_dxypv","N of reco track vs dxy(PV)",nintDxy,minDxy,maxDxy) );
689  h_assoc2dxypv.push_back( ibook.book1D("num_assoc(recoToSim)_dxypv","N of associated (recoToSim) tracks vs dxy(PV)",nintDxy,minDxy,maxDxy) );
690  h_looperdxypv.push_back( ibook.book1D("num_duplicate_dxypv","N of associated (recoToSim) looper tracks vs dxy(PV)",nintDxy,minDxy,maxDxy) );
691  if(!doSeedPlots_) h_misiddxypv.push_back( ibook.book1D("num_chargemisid_dxypv","N of associated (recoToSim) charge misIDed tracks vs dxy(PV)",nintDxy,minDxy,maxDxy) );
692  h_pileupdxypv.push_back( ibook.book1D("num_pileup_dxypv","N of associated (recoToSim) pileup tracks vs dxy(PV)",nintDxy,minDxy,maxDxy) );
693 
694  h_recodzpv.push_back( ibook.book1D("num_reco_dzpv","N of reco track vs dz(PV)",nintDz,minDz,maxDz) );
695  h_assoc2dzpv.push_back( ibook.book1D("num_assoc(recoToSim)_dzpv","N of associated (recoToSim) tracks vs dz(PV)",nintDz,minDz,maxDz) );
696  h_looperdzpv.push_back( ibook.book1D("num_duplicate_dzpv","N of associated (recoToSim) looper tracks vs dz(PV)",nintDz,minDz,maxDz) );
697  if(!doSeedPlots_) h_misiddzpv.push_back( ibook.book1D("num_chargemisid_versus_dzpv","N of associated (recoToSim) charge misIDed tracks vs dz(PV)",nintDz,minDz,maxDz) );
698  h_pileupdzpv.push_back( ibook.book1D("num_pileup_dzpv","N of associated (recoToSim) pileup tracks vs dz(PV)",nintDz,minDz,maxDz) );
699 
700  h_recodxypvzoomed.push_back( ibook.book1D("num_reco_dxypv_zoomed","N of reco track vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
701  h_assoc2dxypvzoomed.push_back( ibook.book1D("num_assoc(recoToSim)_dxypv_zoomed","N of associated (recoToSim) tracks vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
702  h_looperdxypvzoomed.push_back( ibook.book1D("num_duplicate_dxypv_zoomed","N of associated (recoToSim) looper tracks vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
703  if(!doSeedPlots_) h_misiddxypvzoomed.push_back( ibook.book1D("num_chargemisid_dxypv_zoomed","N of associated (recoToSim) charge misIDed tracks vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
704  h_pileupdxypvzoomed.push_back( ibook.book1D("num_pileup_dxypv_zoomed","N of associated (recoToSim) pileup tracks vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
705 
706  h_recodzpvzoomed.push_back( ibook.book1D("num_reco_dzpv_zoomed","N of reco track vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
707  h_assoc2dzpvzoomed.push_back( ibook.book1D("num_assoc(recoToSim)_dzpv_zoomed","N of associated (recoToSim) tracks vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
708  h_looperdzpvzoomed.push_back( ibook.book1D("num_duplicate_dzpv_zoomed","N of associated (recoToSim) looper tracks vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
709  if(!doSeedPlots_) h_misiddzpvzoomed.push_back( ibook.book1D("num_chargemisid_versus_dzpv_zoomed","N of associated (recoToSim) charge misIDed tracks vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
710  h_pileupdzpvzoomed.push_back( ibook.book1D("num_pileup_dzpv_zoomed","N of associated (recoToSim) pileup tracks vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
711 
712  h_reco_dzpvcut.push_back( ibook.book1D("num_reco_dzpvcut","N of reco track vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
713  h_assoc2_dzpvcut.push_back( ibook.book1D("num_assoc(recoToSim)_dzpvcut","N of associated (recoToSim) tracks vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
714  h_pileup_dzpvcut.push_back( ibook.book1D("num_pileup_dzpvcut", "N of associated (recoToSim) pileup tracks vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
715 
716  h_reco_dzpvcut_pt.push_back( ibook.book1D("num_reco_dzpvcut_pt","#sump_{T} of reco track vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
717  h_assoc2_dzpvcut_pt.push_back( ibook.book1D("num_assoc(recoToSim)_dzpvcut_pt","#sump_{T} of associated (recoToSim) tracks vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
718  h_pileup_dzpvcut_pt.push_back( ibook.book1D("num_pileup_dzpvcut_pt", "#sump_{T} of associated (recoToSim) pileup tracks vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
719  h_reco_dzpvcut_pt.back()->getTH1()->Sumw2();
720  h_assoc2_dzpvcut_pt.back()->getTH1()->Sumw2();
721  h_pileup_dzpvcut_pt.back()->getTH1()->Sumw2();
722 
723  h_reco_dzpvsigcut.push_back( ibook.book1D("num_reco_dzpvsigcut","N of reco track vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
724  h_assoc2_dzpvsigcut.push_back( ibook.book1D("num_assoc(recoToSim)_dzpvsigcut","N of associated (recoToSim) tracks vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
725  h_pileup_dzpvsigcut.push_back( ibook.book1D("num_pileup_dzpvsigcut","N of associated (recoToSim) pileup tracks vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
726 
727  h_reco_dzpvsigcut_pt.push_back( ibook.book1D("num_reco_dzpvsigcut_pt","#sump_{T} of reco track vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
728  h_assoc2_dzpvsigcut_pt.push_back( ibook.book1D("num_assoc(recoToSim)_dzpvsigcut_pt","#sump_{T} of associated (recoToSim) tracks vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
729  h_pileup_dzpvsigcut_pt.push_back( ibook.book1D("num_pileup_dzpvsigcut_pt","#sump_{T} of associated (recoToSim) pileup tracks vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
730  h_reco_dzpvsigcut_pt.back()->getTH1()->Sumw2();
731  h_assoc2_dzpvsigcut_pt.back()->getTH1()->Sumw2();
732  h_pileup_dzpvsigcut_pt.back()->getTH1()->Sumw2();
733 
734 }
std::vector< MonitorElement * > h_pileupdxypv
std::vector< MonitorElement * > h_misiddzpvzoomed
std::vector< MonitorElement * > h_assoc2dzpvzoomed
std::vector< MonitorElement * > h_recodxypvzoomed
std::vector< MonitorElement * > h_pileup_dzpvsigcut_pt
std::vector< MonitorElement * > h_assoc2_dzpvcut
std::vector< MonitorElement * > h_reco_dzpvcut
std::vector< MonitorElement * > h_assoc2_dzpvsigcut
std::vector< MonitorElement * > h_assoc2dxypv
std::vector< MonitorElement * > h_pileup_dzpvcut_pt
std::vector< MonitorElement * > h_reco_dzpvcut_pt
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< MonitorElement * > h_looperdxypv
std::vector< MonitorElement * > h_assoc2_dzpvsigcut_pt
std::vector< MonitorElement * > h_pileupdxypvzoomed
std::vector< MonitorElement * > h_looperdxypvzoomed
std::vector< MonitorElement * > h_reco_dzpvsigcut_pt
std::vector< MonitorElement * > h_pileupdzpvzoomed
std::vector< MonitorElement * > h_misiddzpv
std::vector< MonitorElement * > h_assoc2dxypvzoomed
std::vector< MonitorElement * > h_recodzpv
std::vector< MonitorElement * > h_pileup_dzpvcut
std::vector< MonitorElement * > h_looperdzpv
std::vector< MonitorElement * > h_recodxypv
std::vector< MonitorElement * > h_misiddxypvzoomed
std::vector< MonitorElement * > h_pileup_dzpvsigcut
std::vector< MonitorElement * > h_misiddxypv
std::vector< MonitorElement * > h_reco_dzpvsigcut
std::vector< MonitorElement * > h_assoc2_dzpvcut_pt
std::vector< MonitorElement * > h_pileupdzpv
std::vector< MonitorElement * > h_looperdzpvzoomed
std::vector< MonitorElement * > h_assoc2dzpv
std::vector< MonitorElement * > h_recodzpvzoomed
void MTVHistoProducerAlgoForTracker::bookSeedHistos ( DQMStore::IBooker ibook)

Definition at line 752 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), h_seedsFitFailed, h_seedsFitFailedFraction, maxTracks, minTracks, and nintTracks.

752  {
753  h_seedsFitFailed.push_back(ibook.book1D("seeds_fitFailed", "Number of seeds for which the fit failed", nintTracks, minTracks, maxTracks));
754  h_seedsFitFailedFraction.push_back(ibook.book1D("seeds_fitFailedFraction", "Fraction of seeds for which the fit failed", 100, 0, 1));
755 }
std::vector< MonitorElement * > h_seedsFitFailedFraction
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< MonitorElement * > h_seedsFitFailed
void MTVHistoProducerAlgoForTracker::bookSimHistos ( DQMStore::IBooker ibook)

Definition at line 315 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), Exception, MonitorElement::getTH1F(), h_bunchxSIM, h_etaSIM, h_ptSIM, h_tracksSIM, h_vertposSIM, maxEta, maxPt, maxTracks, maxVertpos, minEta, minPt, minTracks, minVertpos, nintEta, nintPt, nintTracks, nintVertpos, and useLogPt.

315  {
316  if(h_ptSIM != nullptr)
317  throw cms::Exception("LogicError") << "bookSimHistos() has already been called";
318 
319  h_ptSIM = ibook.book1D("ptSIM", "generated p_{t}", nintPt, minPt, maxPt);
320  h_etaSIM = ibook.book1D("etaSIM", "generated pseudorapidity", nintEta, minEta, maxEta);
321  h_tracksSIM = ibook.book1D("tracksSIM","number of simulated tracks", nintTracks, minTracks, maxTracks*10);
322  h_vertposSIM = ibook.book1D("vertposSIM","Transverse position of sim vertices", nintVertpos, minVertpos, maxVertpos);
323  h_bunchxSIM = ibook.book1D("bunchxSIM", "bunch crossing", 21, -15.5, 5.5 );
324 
325  if(useLogPt) {
326  BinLogX(h_ptSIM->getTH1F());
327  }
328 }
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TH1F * getTH1F(void) const
void MTVHistoProducerAlgoForTracker::bookSimTrackHistos ( DQMStore::IBooker ibook)

Definition at line 330 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), h_assoc3Dlayer, h_assoc_simpvz, h_assocdr, h_assocdxy, h_assocdz, h_assoceta, h_assochit, h_assoclayer, h_assocphi, h_assocpixellayer, h_assocpT, h_assocpu, h_assocvertpos, h_assoczpos, h_simul3Dlayer, h_simul_simpvz, h_simuldr, h_simuldxy, h_simuldz, h_simuleta, h_simulhit, h_simullayer, h_simulphi, h_simulpixellayer, h_simulpT, h_simulpu, h_simulvertpos, h_simulzpos, maxdr, maxDxy, maxDz, maxEta, maxHit, maxLayers, maxPhi, maxPt, maxPu, maxPVz, maxVertpos, maxZpos, mindr, minDxy, minDz, minEta, minHit, minLayers, minPhi, minPt, minPu, minPVz, minVertpos, minZpos, nintdr, nintDxy, nintDz, nintEta, nintHit, nintLayers, nintPhi, nintPt, nintPu, nintPVz, nintVertpos, nintZpos, nrecHit_vs_nsimHit_sim2rec, and useLogPt.

330  {
331  h_assoceta.push_back( ibook.book1D("num_assoc(simToReco)_eta","N of associated tracks (simToReco) vs eta",nintEta,minEta,maxEta) );
332  h_simuleta.push_back( ibook.book1D("num_simul_eta","N of simulated tracks vs eta",nintEta,minEta,maxEta) );
333 
334  h_assocpT.push_back( ibook.book1D("num_assoc(simToReco)_pT","N of associated tracks (simToReco) vs pT",nintPt,minPt,maxPt) );
335  h_simulpT.push_back( ibook.book1D("num_simul_pT","N of simulated tracks vs pT",nintPt,minPt,maxPt) );
336 
337  h_assochit.push_back( ibook.book1D("num_assoc(simToReco)_hit","N of associated tracks (simToReco) vs hit",nintHit,minHit,maxHit) );
338  h_simulhit.push_back( ibook.book1D("num_simul_hit","N of simulated tracks vs hit",nintHit,minHit,maxHit) );
339 
340  h_assoclayer.push_back( ibook.book1D("num_assoc(simToReco)_layer","N of associated tracks (simToReco) vs layer",nintLayers,minLayers,maxLayers) );
341  h_simullayer.push_back( ibook.book1D("num_simul_layer","N of simulated tracks vs layer",nintLayers,minLayers,maxLayers) );
342 
343  h_assocpixellayer.push_back( ibook.book1D("num_assoc(simToReco)_pixellayer","N of associated tracks (simToReco) vs pixel layer",nintLayers,minLayers,maxLayers) );
344  h_simulpixellayer.push_back( ibook.book1D("num_simul_pixellayer","N of simulated tracks vs pixel layer",nintLayers,minLayers,maxLayers) );
345 
346  h_assoc3Dlayer.push_back( ibook.book1D("num_assoc(simToReco)_3Dlayer","N of associated tracks (simToReco) vs 3D layer",nintLayers,minLayers,maxLayers) );
347  h_simul3Dlayer.push_back( ibook.book1D("num_simul_3Dlayer","N of simulated tracks vs 3D layer",nintLayers,minLayers,maxLayers) );
348 
349  h_assocpu.push_back( ibook.book1D("num_assoc(simToReco)_pu","N of associated tracks (simToReco) vs pu",nintPu,minPu,maxPu) );
350  h_simulpu.push_back( ibook.book1D("num_simul_pu","N of simulated tracks vs pu",nintPu,minPu,maxPu) );
351 
352  h_assocphi.push_back( ibook.book1D("num_assoc(simToReco)_phi","N of associated tracks (simToReco) vs phi",nintPhi,minPhi,maxPhi) );
353  h_simulphi.push_back( ibook.book1D("num_simul_phi","N of simulated tracks vs phi",nintPhi,minPhi,maxPhi) );
354 
355  h_assocdxy.push_back( ibook.book1D("num_assoc(simToReco)_dxy","N of associated tracks (simToReco) vs dxy",nintDxy,minDxy,maxDxy) );
356  h_simuldxy.push_back( ibook.book1D("num_simul_dxy","N of simulated tracks vs dxy",nintDxy,minDxy,maxDxy) );
357 
358  h_assocdz.push_back( ibook.book1D("num_assoc(simToReco)_dz","N of associated tracks (simToReco) vs dz",nintDz,minDz,maxDz) );
359  h_simuldz.push_back( ibook.book1D("num_simul_dz","N of simulated tracks vs dz",nintDz,minDz,maxDz) );
360 
361  h_assocvertpos.push_back( ibook.book1D("num_assoc(simToReco)_vertpos",
362  "N of associated tracks (simToReco) vs transverse vert position",
364  h_simulvertpos.push_back( ibook.book1D("num_simul_vertpos","N of simulated tracks vs transverse vert position",
366 
367  h_assoczpos.push_back( ibook.book1D("num_assoc(simToReco)_zpos","N of associated tracks (simToReco) vs z vert position",
369  h_simulzpos.push_back( ibook.book1D("num_simul_zpos","N of simulated tracks vs z vert position",nintZpos,minZpos,maxZpos) );
370 
371  h_assocdr.push_back( ibook.book1D("num_assoc(simToReco)_dr","N of associated tracks (simToReco) vs dR",nintdr,log10(mindr),log10(maxdr)) );
372  h_simuldr.push_back( ibook.book1D("num_simul_dr","N of simulated tracks vs dR",nintdr,log10(mindr),log10(maxdr)) );
373  BinLogX(h_assocdr.back()->getTH1F());
374  BinLogX(h_simuldr.back()->getTH1F());
375 
376  h_simul_simpvz.push_back( ibook.book1D("num_simul_simpvz", "N of simulated tracks vs. sim PV z", nintPVz, minPVz, maxPVz) );
377  h_assoc_simpvz.push_back( ibook.book1D("num_assoc(simToReco)_simpvz", "N of associated tracks (simToReco) vs. sim PV z", nintPVz, minPVz, maxPVz) );
378 
379  nrecHit_vs_nsimHit_sim2rec.push_back( ibook.book2D("nrecHit_vs_nsimHit_sim2rec","nrecHit vs nsimHit (Sim2RecAssoc)",
381 
382  if(useLogPt){
383  BinLogX(h_assocpT.back()->getTH1F());
384  BinLogX(h_simulpT.back()->getTH1F());
385  }
386 }
std::vector< MonitorElement * > h_assochit
std::vector< MonitorElement * > h_assoczpos
std::vector< MonitorElement * > h_simulzpos
std::vector< MonitorElement * > h_simulpT
std::vector< MonitorElement * > h_assocdz
std::vector< MonitorElement * > h_simuleta
std::vector< MonitorElement * > h_assoc_simpvz
std::vector< MonitorElement * > h_assoc3Dlayer
std::vector< MonitorElement * > h_assocphi
std::vector< MonitorElement * > h_assocpu
std::vector< MonitorElement * > h_simulpu
std::vector< MonitorElement * > h_simuldr
std::vector< MonitorElement * > h_assocpT
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< MonitorElement * > h_simul_simpvz
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
std::vector< MonitorElement * > h_simullayer
std::vector< MonitorElement * > h_simuldz
std::vector< MonitorElement * > h_simulvertpos
std::vector< MonitorElement * > h_simulpixellayer
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
std::vector< MonitorElement * > h_simulphi
std::vector< MonitorElement * > h_simulhit
std::vector< MonitorElement * > h_assocdxy
std::vector< MonitorElement * > h_assoclayer
std::vector< MonitorElement * > h_assoceta
std::vector< MonitorElement * > h_simul3Dlayer
std::vector< MonitorElement * > h_simuldxy
std::vector< MonitorElement * > h_assocdr
std::vector< MonitorElement * > h_assocvertpos
std::vector< MonitorElement * > h_assocpixellayer
void MTVHistoProducerAlgoForTracker::bookSimTrackPVAssociationHistos ( DQMStore::IBooker ibook)

Definition at line 388 of file MTVHistoProducerAlgoForTracker.cc.

References DQMStore::IBooker::book1D(), dxyDzZoom, h_assoc_dzpvcut, h_assoc_dzpvcut_pt, h_assoc_dzpvsigcut, h_assoc_dzpvsigcut_pt, h_assocdxypv, h_assocdxypvzoomed, h_assocdzpv, h_assocdzpvzoomed, h_simul2_dzpvcut, h_simul2_dzpvcut_pt, h_simul2_dzpvsigcut, h_simul2_dzpvsigcut_pt, h_simul_dzpvcut, h_simul_dzpvcut_pt, h_simul_dzpvsigcut, h_simul_dzpvsigcut_pt, h_simuldxypv, h_simuldxypvzoomed, h_simuldzpv, h_simuldzpvzoomed, maxDxy, maxDz, maxDzpvCum, maxDzpvsigCum, minDxy, minDz, nintDxy, nintDz, nintDzpvCum, and nintDzpvsigCum.

388  {
389  h_assocdxypv.push_back( ibook.book1D("num_assoc(simToReco)_dxypv","N of associated tracks (simToReco) vs dxy(PV)",nintDxy,minDxy,maxDxy) );
390  h_simuldxypv.push_back( ibook.book1D("num_simul_dxypv","N of simulated tracks vs dxy(PV)",nintDxy,minDxy,maxDxy) );
391 
392  h_assocdzpv.push_back( ibook.book1D("num_assoc(simToReco)_dzpv","N of associated tracks (simToReco) vs dz(PV)",nintDz,minDz,maxDz) );
393  h_simuldzpv.push_back( ibook.book1D("num_simul_dzpv","N of simulated tracks vs dz(PV)",nintDz,minDz,maxDz) );
394 
395  h_assocdxypvzoomed.push_back( ibook.book1D("num_assoc(simToReco)_dxypv_zoomed","N of associated tracks (simToReco) vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
396  h_simuldxypvzoomed.push_back( ibook.book1D("num_simul_dxypv_zoomed","N of simulated tracks vs dxy(PV)",nintDxy,minDxy/dxyDzZoom,maxDxy/dxyDzZoom) );
397 
398  h_assocdzpvzoomed.push_back( ibook.book1D("num_assoc(simToReco)_dzpv_zoomed","N of associated tracks (simToReco) vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
399  h_simuldzpvzoomed.push_back( ibook.book1D("num_simul_dzpv_zoomed","N of simulated tracks vs dz(PV)",nintDz,minDz/dxyDzZoom,maxDz/dxyDzZoom) );
400 
401  h_assoc_dzpvcut.push_back( ibook.book1D("num_assoc(simToReco)_dzpvcut","N of associated tracks (simToReco) vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
402  h_simul_dzpvcut.push_back( ibook.book1D("num_simul_dzpvcut","N of simulated tracks from sim PV",nintDzpvCum,0,maxDzpvCum) );
403  h_simul2_dzpvcut.push_back( ibook.book1D("num_simul2_dzpvcut","N of simulated tracks (associated to any track) from sim PV",nintDzpvCum,0,maxDzpvCum) );
404 
405  h_assoc_dzpvcut_pt.push_back( ibook.book1D("num_assoc(simToReco)_dzpvcut_pt","#sump_{T} of associated tracks (simToReco) vs dz(PV)",nintDzpvCum,0,maxDzpvCum) );
406  h_simul_dzpvcut_pt.push_back( ibook.book1D("num_simul_dzpvcut_pt","#sump_{T} of simulated tracks from sim PV",nintDzpvCum,0,maxDzpvCum) );
407  h_simul2_dzpvcut_pt.push_back( ibook.book1D("num_simul2_dzpvcut_pt","#sump_{T} of simulated tracks (associated to any track) from sim PV",nintDzpvCum,0,maxDzpvCum) );
408  h_assoc_dzpvcut_pt.back()->getTH1()->Sumw2();
409  h_simul_dzpvcut_pt.back()->getTH1()->Sumw2();
410  h_simul2_dzpvcut_pt.back()->getTH1()->Sumw2();
411 
412  h_assoc_dzpvsigcut.push_back( ibook.book1D("num_assoc(simToReco)_dzpvsigcut","N of associated tracks (simToReco) vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
413  h_simul_dzpvsigcut.push_back( ibook.book1D("num_simul_dzpvsigcut","N of simulated tracks from sim PV/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
414  h_simul2_dzpvsigcut.push_back( ibook.book1D("num_simul2_dzpvsigcut","N of simulated tracks (associated to any track) from sim PV/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
415 
416  h_assoc_dzpvsigcut_pt.push_back( ibook.book1D("num_assoc(simToReco)_dzpvsigcut_pt","#sump_{T} of associated tracks (simToReco) vs dz(PV)/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
417  h_simul_dzpvsigcut_pt.push_back( ibook.book1D("num_simul_dzpvsigcut_pt","#sump_{T} of simulated tracks from sim PV/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
418  h_simul2_dzpvsigcut_pt.push_back( ibook.book1D("num_simul2_dzpvsigcut_pt","#sump_{T} of simulated tracks (associated to any track) from sim PV/dzError",nintDzpvsigCum,0,maxDzpvsigCum) );
419  h_assoc_dzpvsigcut_pt.back()->getTH1()->Sumw2();
420  h_simul_dzpvsigcut_pt.back()->getTH1()->Sumw2();
421  h_simul2_dzpvsigcut_pt.back()->getTH1()->Sumw2();
422 }
std::vector< MonitorElement * > h_simul2_dzpvcut
std::vector< MonitorElement * > h_assoc_dzpvsigcut_pt
std::vector< MonitorElement * > h_simuldxypvzoomed
std::vector< MonitorElement * > h_simul_dzpvsigcut
std::vector< MonitorElement * > h_assoc_dzpvcut_pt
std::vector< MonitorElement * > h_simul_dzpvcut_pt
std::vector< MonitorElement * > h_simul2_dzpvsigcut_pt
std::vector< MonitorElement * > h_assocdzpv
std::vector< MonitorElement * > h_assocdxypvzoomed
std::vector< MonitorElement * > h_simul2_dzpvcut_pt
std::vector< MonitorElement * > h_assocdzpvzoomed
std::vector< MonitorElement * > h_simuldzpv
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
std::vector< MonitorElement * > h_simuldzpvzoomed
std::vector< MonitorElement * > h_simuldxypv
std::vector< MonitorElement * > h_simul_dzpvcut
std::vector< MonitorElement * > h_assoc_dzpvsigcut
std::vector< MonitorElement * > h_simul_dzpvsigcut_pt
std::vector< MonitorElement * > h_simul2_dzpvsigcut
std::vector< MonitorElement * > h_assoc_dzpvcut
std::vector< MonitorElement * > h_assocdxypv
void MTVHistoProducerAlgoForTracker::fill_dedx_recoTrack_histos ( int  count,
const edm::RefToBase< reco::Track > &  trackref,
const std::vector< const edm::ValueMap< reco::DeDxData > * > &  v_dEdx 
)

Definition at line 963 of file MTVHistoProducerAlgoForTracker.cc.

References KineDebug3::count(), reco::DeDxData::dEdx(), h_dedx_estim, h_dedx_nom, h_dedx_sat, mps_fire::i, reco::DeDxData::numberOfMeasurements(), and reco::DeDxData::numberOfSaturatedMeasurements().

963  {
964  for (unsigned int i=0; i<v_dEdx.size(); i++) {
965  const edm::ValueMap<reco::DeDxData>& dEdxTrack = *(v_dEdx[i]);
966  const reco::DeDxData& dedx = dEdxTrack[trackref];
967  h_dedx_estim[count][i]->Fill(dedx.dEdx());
968  h_dedx_nom[count][i]->Fill(dedx.numberOfMeasurements());
970  }
971 }
std::vector< std::vector< MonitorElement * > > h_dedx_estim
float dEdx() const
Definition: DeDxData.cc:26
unsigned int numberOfMeasurements() const
Definition: DeDxData.cc:37
std::vector< std::vector< MonitorElement * > > h_dedx_sat
std::vector< std::vector< MonitorElement * > > h_dedx_nom
int numberOfSaturatedMeasurements() const
Definition: DeDxData.cc:42
void MTVHistoProducerAlgoForTracker::fill_generic_recoTrack_histos ( int  count,
const reco::Track track,
const TrackerTopology ttopo,
const math::XYZPoint bsPosition,
const math::XYZPoint pvPosition,
const TrackingVertex::LorentzVector simPVPosition,
bool  isMatched,
bool  isSigMatched,
bool  isChargeMatched,
int  numAssocRecoTracks,
int  numVertices,
int  nSimHits,
double  sharedFraction,
double  dR,
const std::vector< float > &  mvas,
unsigned int  selectsLoose,
unsigned int  selectsHP 
)

Definition at line 974 of file MTVHistoProducerAlgoForTracker.cc.

References funct::abs(), reco::TrackBase::algo(), HiEvtPlane_cfi::chi2, KineDebug3::count(), doSeedPlots_, particleFlowDisplacedVertexCandidate_cfi::dxy, reco::TrackBase::dxy(), allConversions_cfi::dz, reco::TrackBase::dz(), reco::TrackBase::dzError(), stringResolutionProvider_cfi::eta, reco::Track::found(), getEta(), getPt(), getSeedingLayerSetBin(), h_algo, h_assoc23Dlayer, h_assoc2_dzpvcut, h_assoc2_dzpvcut_pt, h_assoc2_dzpvsigcut, h_assoc2_dzpvsigcut_pt, h_assoc2_mva, h_assoc2_mva_hp, h_assoc2_mvacut, h_assoc2_mvacut_hp, h_assoc2_seedingLayerSet, h_assoc2_simpvz, h_assoc2chi2, h_assoc2dr, h_assoc2dxy, h_assoc2dxypv, h_assoc2dxypvzoomed, h_assoc2dz, h_assoc2dzpv, h_assoc2dzpvzoomed, h_assoc2eta, h_assoc2hit, h_assoc2layer, h_assoc2phi, h_assoc2pixellayer, h_assoc2pT, h_assoc2pu, h_assoc2vertpos, h_assoc2zpos, h_assocFraction, h_assocSharedHit, h_looper3Dlayer, h_looper_seedingLayerSet, h_looperchi2, h_looperdr, h_looperdxy, h_looperdxypv, h_looperdxypvzoomed, h_looperdz, h_looperdzpv, h_looperdzpvzoomed, h_loopereta, h_looperhit, h_looperlayer, h_looperphi, h_looperpixellayer, h_looperpT, h_looperpu, h_loopervertpos, h_looperzpos, h_misid3Dlayer, h_misidchi2, h_misiddxy, h_misiddxypv, h_misiddxypvzoomed, h_misiddz, h_misiddzpv, h_misiddzpvzoomed, h_misideta, h_misidhit, h_misidlayer, h_misidphi, h_misidpixellayer, h_misidpT, h_misidpu, h_pileup3Dlayer, h_pileup_dzpvcut, h_pileup_dzpvcut_pt, h_pileup_dzpvsigcut, h_pileup_dzpvsigcut_pt, h_pileup_seedingLayerSet, h_pileup_simpvz, h_pileupchi2, h_pileupdr, h_pileupdxy, h_pileupdxypv, h_pileupdxypvzoomed, h_pileupdz, h_pileupdzpv, h_pileupdzpvzoomed, h_pileupeta, h_pileuphit, h_pileuplayer, h_pileupphi, h_pileuppixellayer, h_pileuppT, h_pileuppu, h_pileupvertpos, h_pileupzpos, h_reco2eta, h_reco2pT, h_reco2pu, h_reco3Dlayer, h_reco_dzpvcut, h_reco_dzpvcut_pt, h_reco_dzpvsigcut, h_reco_dzpvsigcut_pt, h_reco_mva, h_reco_mva_hp, h_reco_mvacut, h_reco_mvacut_hp, h_reco_seedingLayerSet, h_reco_simpvz, h_recochi2, h_recodr, h_recodxy, h_recodxypv, h_recodxypvzoomed, h_recodz, h_recodzpv, h_recodzpvzoomed, h_recoeta, h_recohit, h_recolayer, h_recophi, h_recopixellayer, h_recopT, h_recopu, h_recovertpos, h_recozpos, reco::TrackBase::hitPattern(), hpstanc_transforms::max, min(), reco::TrackBase::momentum(), nhits, nlayers, reco::TrackBase::normalizedChi2(), nrecHit_vs_nsimHit_rec2sim, reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), phi, reco::HitPattern::pixelLayersWithMeasurement(), EnergyCorrector::pt, reco::TrackBase::referencePoint(), seedingLayerSetNames, muonCosmicCompatibility_cfi::sharedHits, mathSSE::sqrt(), reco::HitPattern::trackerLayersWithMeasurement(), trackFromSeedFitFailed(), trackSelectorVsEta, trackSelectorVsPhi, and trackSelectorVsPt.

989  {
990 
991  //Fill track algo histogram
992  fillPlotNoFlow(h_algo[count],track.algo());
993  int sharedHits = sharedFraction * track.numberOfValidHits();
994 
995  //Compute fake rate vs eta
996  const auto eta = getEta(track.momentum().eta());
997  const auto phi = track.momentum().phi();
998  const auto pt = getPt(sqrt(track.momentum().perp2()));
999  const auto dxy = track.dxy(bsPosition);
1000  const auto dz = track.dz(bsPosition);
1001  const auto dxypv = pvPosition ? track.dxy(*pvPosition) : 0.0;
1002  const auto dzpv = pvPosition ? track.dz(*pvPosition) : 0.0;
1003  const auto dzpvsig = pvPosition ? dzpv / track.dzError() : 0.0;
1004  const auto nhits = track.found();
1005  const auto nlayers = track.hitPattern().trackerLayersWithMeasurement();
1006  const auto nPixelLayers = track.hitPattern().pixelLayersWithMeasurement();
1007  const auto n3DLayers = nPixelLayers + track.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
1008  const auto vertxy = std::sqrt(track.referencePoint().perp2());
1009  const auto vertz = track.referencePoint().z();
1010  const auto deltar = min(max(dR,h_recodr[count]->getTH1()->GetXaxis()->GetXmin()),h_recodr[count]->getTH1()->GetXaxis()->GetXmax());
1011  const auto chi2 = track.normalizedChi2();
1012  const bool fillSeedingLayerSets = !seedingLayerSetNames.empty();
1013  const unsigned int seedingLayerSetBin = fillSeedingLayerSets ? getSeedingLayerSetBin(track, ttopo) : 0;
1014  const auto simpvz = simPVPosition ? simPVPosition->z() : 0.0;
1015 
1016  const bool paramsValid = !trackFromSeedFitFailed(track);
1017 
1018  if(paramsValid) {
1019  fillPlotNoFlow(h_recoeta[count], eta);
1020  fillPlotNoFlow(h_recophi[count], phi);
1021  fillPlotNoFlow(h_recopT[count], pt);
1022  fillPlotNoFlow(h_recodxy[count], dxy);
1023  fillPlotNoFlow(h_recodz[count], dz);
1024  fillPlotNoFlow(h_recochi2[count], chi2);
1025  fillPlotNoFlow(h_recovertpos[count], vertxy);
1026  fillPlotNoFlow(h_recozpos[count], vertz);
1027  h_recodr[count]->Fill(deltar);
1028  if(fillSeedingLayerSets) h_reco_seedingLayerSet[count]->Fill(seedingLayerSetBin);
1029  if(pvPosition) {
1030  fillPlotNoFlow(h_recodxypv[count], dxypv);
1031  fillPlotNoFlow(h_recodzpv[count], dzpv);
1032  fillPlotNoFlow(h_recodxypvzoomed[count], dxypv);
1033  fillPlotNoFlow(h_recodzpvzoomed[count], dzpv);
1034 
1035  h_reco_dzpvcut[count]->Fill(std::abs(dzpv));
1036  h_reco_dzpvsigcut[count]->Fill(std::abs(dzpvsig));
1037  h_reco_dzpvcut_pt[count]->Fill(std::abs(dzpv), pt);
1038  h_reco_dzpvsigcut_pt[count]->Fill(std::abs(dzpvsig), pt);
1039  }
1040  if(simPVPosition) {
1041  h_reco_simpvz[count]->Fill(simpvz);
1042  }
1043  if((*trackSelectorVsEta)(track)) {
1044  fillPlotNoFlow(h_reco2eta[count], eta);
1045  }
1046  if((*trackSelectorVsPt)(track)) {
1047  fillPlotNoFlow(h_reco2pT[count], pt);
1048  }
1049  }
1050  fillPlotNoFlow(h_recohit[count], nhits);
1051  fillPlotNoFlow(h_recolayer[count], nlayers);
1052  fillPlotNoFlow(h_recopixellayer[count], nPixelLayers);
1053  fillPlotNoFlow(h_reco3Dlayer[count], n3DLayers);
1054  fillPlotNoFlow(h_recopu[count],numVertices);
1055  if((*trackSelectorVsPhi)(track)) {
1056  fillPlotNoFlow(h_reco2pu[count], numVertices);
1057  }
1058 
1059  fillMVAHistos(h_reco_mva[count], h_reco_mvacut[count], h_reco_mva_hp[count], h_reco_mvacut_hp[count], mvas, selectsLoose, selectsHP);
1060 
1061  if (isMatched) {
1062  if(paramsValid) {
1063  fillPlotNoFlow(h_assoc2eta[count], eta);
1064  fillPlotNoFlow(h_assoc2phi[count], phi);
1065  fillPlotNoFlow(h_assoc2pT[count], pt);
1066  fillPlotNoFlow(h_assoc2dxy[count], dxy);
1067  fillPlotNoFlow(h_assoc2dz[count], dz);
1068  fillPlotNoFlow(h_assoc2hit[count], nhits);
1069  fillPlotNoFlow(h_assoc2chi2[count], chi2);
1070  fillPlotNoFlow(h_assoc2vertpos[count], vertxy);
1071  fillPlotNoFlow(h_assoc2zpos[count], vertz);
1072  h_assoc2dr[count]->Fill(deltar);
1073  if(fillSeedingLayerSets) h_assoc2_seedingLayerSet[count]->Fill(seedingLayerSetBin);
1074  if(pvPosition) {
1075  fillPlotNoFlow(h_assoc2dxypv[count], dxypv);
1076  fillPlotNoFlow(h_assoc2dzpv[count], dzpv);
1077  fillPlotNoFlow(h_assoc2dxypvzoomed[count], dxypv);
1078  fillPlotNoFlow(h_assoc2dzpvzoomed[count], dzpv);
1079 
1080  h_assoc2_dzpvcut[count]->Fill(std::abs(dzpv));
1081  h_assoc2_dzpvsigcut[count]->Fill(std::abs(dzpvsig));
1082  h_assoc2_dzpvcut_pt[count]->Fill(std::abs(dzpv), pt);
1083  h_assoc2_dzpvsigcut_pt[count]->Fill(std::abs(dzpvsig), pt);
1084  }
1085  if(simPVPosition) {
1086  h_assoc2_simpvz[count]->Fill(simpvz);
1087  }
1088  }
1089  fillPlotNoFlow(h_assoc2layer[count], nlayers);
1090  fillPlotNoFlow(h_assoc2pixellayer[count], nPixelLayers);
1091  fillPlotNoFlow(h_assoc23Dlayer[count], n3DLayers);
1092  fillPlotNoFlow(h_assoc2pu[count],numVertices);
1093 
1094  fillMVAHistos(h_assoc2_mva[count], h_assoc2_mvacut[count], h_assoc2_mva_hp[count], h_assoc2_mvacut_hp[count], mvas, selectsLoose, selectsHP);
1095 
1096  nrecHit_vs_nsimHit_rec2sim[count]->Fill( track.numberOfValidHits(),nSimHits);
1097  h_assocFraction[count]->Fill( sharedFraction);
1098  h_assocSharedHit[count]->Fill( sharedHits);
1099 
1100  if (!doSeedPlots_ && !isChargeMatched) {
1101  fillPlotNoFlow(h_misideta[count], eta);
1102  fillPlotNoFlow(h_misidphi[count], phi);
1103  fillPlotNoFlow(h_misidpT[count], pt);
1104  fillPlotNoFlow(h_misiddxy[count], dxy);
1105  fillPlotNoFlow(h_misiddz[count], dz);
1106  fillPlotNoFlow(h_misidhit[count], nhits);
1107  fillPlotNoFlow(h_misidlayer[count], nlayers);
1108  fillPlotNoFlow(h_misidpixellayer[count], nPixelLayers);
1109  fillPlotNoFlow(h_misid3Dlayer[count], n3DLayers);
1110  fillPlotNoFlow(h_misidpu[count], numVertices);
1111  fillPlotNoFlow(h_misidchi2[count], chi2);
1112  if(pvPosition) {
1113  fillPlotNoFlow(h_misiddxypv[count], dxypv);
1114  fillPlotNoFlow(h_misiddzpv[count], dzpv);
1115  fillPlotNoFlow(h_misiddxypvzoomed[count], dxypv);
1116  fillPlotNoFlow(h_misiddzpvzoomed[count], dzpv);
1117  }
1118  }
1119 
1120  if (numAssocRecoTracks>1) {
1121  if(paramsValid) {
1122  fillPlotNoFlow(h_loopereta[count], eta);
1123  fillPlotNoFlow(h_looperphi[count], phi);
1124  fillPlotNoFlow(h_looperpT[count], pt);
1125  fillPlotNoFlow(h_looperdxy[count], dxy);
1126  fillPlotNoFlow(h_looperdz[count], dz);
1127  fillPlotNoFlow(h_looperchi2[count], chi2);
1128  fillPlotNoFlow(h_loopervertpos[count], vertxy);
1129  fillPlotNoFlow(h_looperzpos[count], vertz);
1130  h_looperdr[count]->Fill(deltar);
1131  if(fillSeedingLayerSets) h_looper_seedingLayerSet[count]->Fill(seedingLayerSetBin);
1132  if(pvPosition) {
1133  fillPlotNoFlow(h_looperdxypv[count], dxypv);
1134  fillPlotNoFlow(h_looperdzpv[count], dzpv);
1135  fillPlotNoFlow(h_looperdxypvzoomed[count], dxypv);
1136  fillPlotNoFlow(h_looperdzpvzoomed[count], dzpv);
1137  }
1138  }
1139  fillPlotNoFlow(h_looperhit[count], nhits);
1140  fillPlotNoFlow(h_looperlayer[count], nlayers);
1141  fillPlotNoFlow(h_looperpixellayer[count], nPixelLayers);
1142  fillPlotNoFlow(h_looper3Dlayer[count], n3DLayers);
1143  fillPlotNoFlow(h_looperpu[count], numVertices);
1144  }
1145  if(!isSigMatched) {
1146  if(paramsValid) {
1147  fillPlotNoFlow(h_pileupeta[count], eta);
1148  fillPlotNoFlow(h_pileupphi[count], phi);
1149  fillPlotNoFlow(h_pileuppT[count], pt);
1150  fillPlotNoFlow(h_pileupdxy[count], dxy);
1151  fillPlotNoFlow(h_pileupdz[count], dz);
1152  fillPlotNoFlow(h_pileupchi2[count], chi2);
1153  fillPlotNoFlow(h_pileupvertpos[count], vertxy);
1154  fillPlotNoFlow(h_pileupzpos[count], vertz);
1155  h_pileupdr[count]->Fill(deltar);
1156  if(fillSeedingLayerSets) h_pileup_seedingLayerSet[count]->Fill(seedingLayerSetBin);
1157  if(pvPosition) {
1158  fillPlotNoFlow(h_pileupdxypv[count], dxypv);
1159  fillPlotNoFlow(h_pileupdzpv[count], dzpv);
1160  fillPlotNoFlow(h_pileupdxypvzoomed[count], dxypv);
1161  fillPlotNoFlow(h_pileupdzpvzoomed[count], dzpv);
1162 
1163  h_pileup_dzpvcut[count]->Fill(std::abs(dzpv));
1164  h_pileup_dzpvsigcut[count]->Fill(std::abs(dzpvsig));
1165  h_pileup_dzpvcut_pt[count]->Fill(std::abs(dzpv), pt);
1166  h_pileup_dzpvsigcut_pt[count]->Fill(std::abs(dzpvsig), pt);
1167  }
1168  if(simPVPosition) {
1169  h_pileup_simpvz[count]->Fill(simpvz);
1170  }
1171  }
1172  fillPlotNoFlow(h_pileuphit[count], nhits);
1173  fillPlotNoFlow(h_pileuplayer[count], nlayers);
1174  fillPlotNoFlow(h_pileuppixellayer[count], nPixelLayers);
1175  fillPlotNoFlow(h_pileup3Dlayer[count], n3DLayers);
1176  fillPlotNoFlow(h_pileuppu[count], numVertices);
1177  }
1178  }
1179 }
std::vector< std::vector< MonitorElement * > > h_reco_mvacut
std::vector< std::vector< MonitorElement * > > h_assoc2_mva_hp
std::vector< MonitorElement * > h_looperhit
std::vector< MonitorElement * > h_assoc2hit
const Point & referencePoint() const
Reference point on the track.
Definition: TrackBase.h:676
std::vector< MonitorElement * > h_pileupdxypv
std::vector< MonitorElement * > h_recodxy
std::vector< MonitorElement * > h_looperzpos
std::vector< MonitorElement * > h_looperpT
std::vector< MonitorElement * > h_misidlayer
std::vector< MonitorElement * > h_looperchi2
bool trackFromSeedFitFailed(const reco::Track &track)
std::vector< MonitorElement * > h_assoc2zpos
std::vector< MonitorElement * > nrecHit_vs_nsimHit_rec2sim
std::vector< MonitorElement * > h_assoc2pT
std::vector< MonitorElement * > h_looperpixellayer
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:556
std::vector< MonitorElement * > h_pileuphit
std::vector< MonitorElement * > h_pileupdr
std::vector< MonitorElement * > h_misiddzpvzoomed
std::vector< MonitorElement * > h_assoc2dzpvzoomed
std::vector< MonitorElement * > h_recodxypvzoomed
std::vector< MonitorElement * > h_pileup_dzpvsigcut_pt
std::vector< MonitorElement * > h_pileuppT
std::vector< MonitorElement * > h_algo
std::vector< MonitorElement * > h_recovertpos
std::vector< MonitorElement * > h_assoc2phi
std::vector< MonitorElement * > h_assoc2_seedingLayerSet
std::vector< MonitorElement * > h_assoc2pu
std::vector< MonitorElement * > h_pileup_seedingLayerSet
std::vector< MonitorElement * > h_reco2pu
std::vector< MonitorElement * > h_misidchi2
std::vector< MonitorElement * > h_assoc2_dzpvcut
std::vector< MonitorElement * > h_looperdxy
std::vector< std::vector< MonitorElement * > > h_assoc2_mva
std::vector< MonitorElement * > h_reco_simpvz
std::vector< MonitorElement * > h_looper3Dlayer
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPhi
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:499
std::vector< MonitorElement * > h_reco_dzpvcut
const Vector & momentum() const
track momentum vector
Definition: TrackBase.h:670
std::vector< MonitorElement * > h_reco3Dlayer
std::vector< MonitorElement * > h_loopervertpos
std::vector< MonitorElement * > h_looperdr
std::vector< MonitorElement * > h_pileupchi2
std::vector< MonitorElement * > h_assoc2dz
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:518
std::vector< MonitorElement * > h_looper_seedingLayerSet
std::vector< MonitorElement * > h_misideta
std::vector< MonitorElement * > h_recohit
TrackAlgorithm algo() const
Definition: TrackBase.h:492
std::vector< MonitorElement * > h_looperlayer
std::vector< MonitorElement * > h_assoc2_dzpvsigcut
std::vector< MonitorElement * > h_assoc2layer
std::vector< MonitorElement * > h_assoc23Dlayer
int numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
Definition: HitPattern.cc:341
std::vector< MonitorElement * > h_looperpu
std::vector< MonitorElement * > h_assoc2dxypv
std::vector< MonitorElement * > h_assoc2dxy
std::vector< MonitorElement * > h_assoc2chi2
std::vector< MonitorElement * > h_misidhit
std::vector< MonitorElement * > h_pileup_dzpvcut_pt
std::vector< MonitorElement * > h_reco_dzpvcut_pt
T sqrt(T t)
Definition: SSEVec.h:18
std::vector< MonitorElement * > h_pileup_simpvz
std::vector< MonitorElement * > h_recozpos
std::vector< MonitorElement * > h_recophi
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPt
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
std::vector< MonitorElement * > h_assoc2pixellayer
std::vector< std::vector< MonitorElement * > > h_reco_mva
std::vector< MonitorElement * > h_misid3Dlayer
bool isMatched(TrackingRecHit const &hit)
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:815
T min(T a, T b)
Definition: MathUtil.h:58
std::vector< MonitorElement * > h_looperdxypv
std::vector< MonitorElement * > h_misidpu
std::vector< MonitorElement * > h_loopereta
std::vector< MonitorElement * > h_misiddz
std::vector< MonitorElement * > h_assoc2_simpvz
std::vector< MonitorElement * > h_pileupvertpos
std::vector< MonitorElement * > h_pileupphi
std::vector< MonitorElement * > h_recodr
std::vector< MonitorElement * > h_assoc2vertpos
std::vector< MonitorElement * > h_misiddxy
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:604
double dzError() const
error on dz
Definition: TrackBase.h:809
std::vector< MonitorElement * > h_recolayer
std::vector< MonitorElement * > h_assoc2_dzpvsigcut_pt
std::vector< MonitorElement * > h_pileupdxypvzoomed
std::vector< MonitorElement * > h_looperdxypvzoomed
std::vector< MonitorElement * > h_reco_dzpvsigcut_pt
std::vector< MonitorElement * > h_recopu
std::vector< MonitorElement * > h_misidpT
std::vector< MonitorElement * > h_pileupdzpvzoomed
std::vector< MonitorElement * > h_misiddzpv
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:445
std::vector< std::vector< MonitorElement * > > h_assoc2_mvacut_hp
Definition: deltar.py:1
std::vector< MonitorElement * > h_assoc2dxypvzoomed
std::vector< std::vector< MonitorElement * > > h_reco_mvacut_hp
std::vector< MonitorElement * > h_recodzpv
std::vector< MonitorElement * > h_pileuppixellayer
std::vector< MonitorElement * > h_pileup_dzpvcut
std::vector< MonitorElement * > h_looperdzpv
std::vector< MonitorElement * > h_looperphi
std::vector< std::string > seedingLayerSetNames
std::vector< MonitorElement * > h_recodxypv
std::vector< MonitorElement * > h_assoc2dr
unsigned short found() const
Number of valid hits on track.
Definition: Track.h:194
std::vector< MonitorElement * > h_misiddxypvzoomed
std::vector< MonitorElement * > h_recopixellayer
std::vector< MonitorElement * > h_pileup_dzpvsigcut
std::vector< MonitorElement * > h_recopT
std::vector< MonitorElement * > h_pileup3Dlayer
std::vector< MonitorElement * > h_looperdz
std::vector< MonitorElement * > h_pileupzpos
std::vector< MonitorElement * > h_misiddxypv
std::vector< MonitorElement * > h_misidpixellayer
std::vector< MonitorElement * > h_reco2eta
std::vector< MonitorElement * > h_pileuplayer
std::vector< MonitorElement * > h_assocFraction
std::vector< MonitorElement * > h_reco_dzpvsigcut
std::vector< MonitorElement * > h_assoc2_dzpvcut_pt
std::vector< MonitorElement * > h_pileupdxy
std::vector< MonitorElement * > h_recodz
std::vector< MonitorElement * > h_pileupdzpv
std::vector< MonitorElement * > h_pileupdz
std::vector< MonitorElement * > h_reco_seedingLayerSet
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsEta
std::vector< MonitorElement * > h_reco2pT
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:586
std::vector< MonitorElement * > h_recochi2
std::vector< MonitorElement * > h_assocSharedHit
std::vector< MonitorElement * > h_looperdzpvzoomed
std::vector< MonitorElement * > h_assoc2dzpv
std::vector< MonitorElement * > h_pileupeta
std::vector< std::vector< MonitorElement * > > h_reco_mva_hp
std::vector< MonitorElement * > h_recodzpvzoomed
std::vector< MonitorElement * > h_recoeta
unsigned int getSeedingLayerSetBin(const reco::Track &track, const TrackerTopology &ttopo)
std::vector< MonitorElement * > h_assoc2eta
std::vector< MonitorElement * > h_misidphi
std::vector< MonitorElement * > h_pileuppu
void MTVHistoProducerAlgoForTracker::fill_generic_simTrack_histos ( const TrackingParticle::Vector momentumTP,
const TrackingParticle::Point vertex,
int  bx 
)

Definition at line 810 of file MTVHistoProducerAlgoForTracker.cc.

References MonitorElement::Fill(), h_bunchxSIM, h_etaSIM, h_ptSIM, h_vertposSIM, and mathSSE::sqrt().

812  {
813  if(bx == 0) {
814  h_ptSIM->Fill(sqrt(momentumTP.perp2()));
815  h_etaSIM->Fill(momentumTP.eta());
816  h_vertposSIM->Fill(sqrt(vertexTP.perp2()));
817  }
818  h_bunchxSIM->Fill(bx);
819 }
void Fill(long long x)
T sqrt(T t)
Definition: SSEVec.h:18
void MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos ( int  count,
const TrackingParticle tp,
const TrackingParticle::Vector momentumTP,
const TrackingParticle::Point vertexTP,
double  dxy,
double  dz,
double  dxyPV,
double  dzPV,
int  nSimHits,
int  nSimLayers,
int  nSimPixelLayers,
int  nSimStripMonoAndStereoLayers,
const reco::Track track,
int  numVertices,
double  dR,
const math::XYZPoint pvPosition,
const TrackingVertex::LorentzVector simPVPosition,
const std::vector< float > &  mvas,
unsigned int  selectsLoose,
unsigned int  selectsHP 
)

Definition at line 823 of file MTVHistoProducerAlgoForTracker.cc.

References funct::abs(), KineDebug3::count(), reco::TrackBase::dz(), reco::TrackBase::dzError(), stringResolutionProvider_cfi::eta, getEta(), getPt(), h_assoc3Dlayer, h_assoc_dzpvcut, h_assoc_dzpvcut_pt, h_assoc_dzpvsigcut, h_assoc_dzpvsigcut_pt, h_assoc_mvacut, h_assoc_mvacut_hp, h_assoc_simpvz, h_assocdr, h_assocdxy, h_assocdxypv, h_assocdxypvzoomed, h_assocdz, h_assocdzpv, h_assocdzpvzoomed, h_assoceta, h_assochit, h_assoclayer, h_assocphi, h_assocpixellayer, h_assocpT, h_assocpu, h_assocvertpos, h_assoczpos, h_simul2_dzpvcut, h_simul2_dzpvcut_pt, h_simul2_dzpvsigcut, h_simul2_dzpvsigcut_pt, h_simul2_mvacut, h_simul2_mvacut_hp, h_simul3Dlayer, h_simul_dzpvcut, h_simul_dzpvcut_pt, h_simul_dzpvsigcut, h_simul_dzpvsigcut_pt, h_simul_simpvz, h_simuldr, h_simuldxy, h_simuldxypv, h_simuldxypvzoomed, h_simuldz, h_simuldzpv, h_simuldzpvzoomed, h_simuleta, h_simulhit, h_simullayer, h_simulphi, h_simulpixellayer, h_simulpT, h_simulpu, h_simulvertpos, h_simulzpos, mps_fire::i, trackerHitRTTI::isMatched(), maxMVA, nrecHit_vs_nsimHit_sim2rec, reco::TrackBase::numberOfValidHits(), phi, EnergyCorrector::pt, mathSSE::sqrt(), TpSelectorForEfficiencyVsEta, TpSelectorForEfficiencyVsPhi, TpSelectorForEfficiencyVsPt, TpSelectorForEfficiencyVsVTXR, TpSelectorForEfficiencyVsVTXZ, and HiIsolationCommonParameters_cff::track.

837  {
838  bool isMatched = track;
839  const auto eta = getEta(momentumTP.eta());
840  const auto phi = momentumTP.phi();
841  const auto pt = getPt(sqrt(momentumTP.perp2()));
842  const auto nSim3DLayers = nSimPixelLayers + nSimStripMonoAndStereoLayers;
843  const auto vertxy = sqrt(vertexTP.perp2());
844  const auto vertz = vertexTP.z();
845 
846  //efficiency vs. cut on MVA
847  //
848  // Note that this includes also pileup TPs, as "signalOnly"
849  // selection is applied only in the TpSelector*. Have to think if
850  // this is really what we want.
851  if(isMatched) {
852  for(size_t i=0; i<mvas.size(); ++i) {
853  if(i<=selectsLoose) {
854  h_simul2_mvacut[count][i]->Fill(maxMVA);
855  h_assoc_mvacut[count][i]->Fill(mvas[i]);
856  }
857  if(i>=1 && i<=selectsHP) {
858  h_simul2_mvacut_hp[count][i]->Fill(maxMVA);
859  h_assoc_mvacut_hp[count][i]->Fill(mvas[i]);
860  }
861  }
862  }
863 
864  if((*TpSelectorForEfficiencyVsEta)(tp)){
865  //effic vs eta
866  fillPlotNoFlow(h_simuleta[count], eta);
867  if (isMatched) fillPlotNoFlow(h_assoceta[count], eta);
868  }
869 
870  if((*TpSelectorForEfficiencyVsPhi)(tp)){
871  fillPlotNoFlow(h_simulphi[count], phi);
872  if (isMatched) fillPlotNoFlow(h_assocphi[count], phi);
873  //effic vs hits
874  fillPlotNoFlow(h_simulhit[count], nSimHits);
875  fillPlotNoFlow(h_simullayer[count], nSimLayers);
876  fillPlotNoFlow(h_simulpixellayer[count], nSimPixelLayers);
877  fillPlotNoFlow(h_simul3Dlayer[count], nSim3DLayers);
878  if(isMatched) {
879  fillPlotNoFlow(h_assochit[count], nSimHits);
880  fillPlotNoFlow(h_assoclayer[count], nSimLayers);
881  fillPlotNoFlow(h_assocpixellayer[count], nSimPixelLayers);
882  fillPlotNoFlow(h_assoc3Dlayer[count], nSim3DLayers);
883  nrecHit_vs_nsimHit_sim2rec[count]->Fill( track->numberOfValidHits(),nSimHits);
884  }
885  //effic vs pu
886  fillPlotNoFlow(h_simulpu[count], numVertices);
887  if(isMatched) fillPlotNoFlow(h_assocpu[count],numVertices);
888  //efficiency vs dR
889  fillPlotNoFlow(h_simuldr[count],dR);
890  if (isMatched) fillPlotNoFlow(h_assocdr[count],dR);
891  }
892 
893  if((*TpSelectorForEfficiencyVsPt)(tp)){
894  fillPlotNoFlow(h_simulpT[count], pt);
895  if (isMatched) fillPlotNoFlow(h_assocpT[count], pt);
896  }
897 
899  fillPlotNoFlow(h_simuldxy[count],dxySim);
900  if (isMatched) fillPlotNoFlow(h_assocdxy[count],dxySim);
901  if(pvPosition) {
902  fillPlotNoFlow(h_simuldxypv[count], dxyPVSim);
903  fillPlotNoFlow(h_simuldxypvzoomed[count], dxyPVSim);
904  if (isMatched) {
905  fillPlotNoFlow(h_assocdxypv[count], dxyPVSim);
906  fillPlotNoFlow(h_assocdxypvzoomed[count], dxyPVSim);
907  }
908  }
909 
910  fillPlotNoFlow(h_simulvertpos[count], vertxy);
911  if (isMatched) fillPlotNoFlow(h_assocvertpos[count], vertxy);
912  }
913 
914 
916  fillPlotNoFlow(h_simuldz[count],dzSim);
917  if (isMatched) fillPlotNoFlow(h_assocdz[count],dzSim);
918 
919  fillPlotNoFlow(h_simulzpos[count], vertz);
920  if (isMatched) fillPlotNoFlow(h_assoczpos[count], vertz);
921 
922  if(pvPosition) {
923  fillPlotNoFlow(h_simuldzpv[count], dzPVSim);
924  fillPlotNoFlow(h_simuldzpvzoomed[count], dzPVSim);
925 
926  h_simul_dzpvcut[count]->Fill(0);
927  h_simul_dzpvsigcut[count]->Fill(0);
928  h_simul_dzpvcut_pt[count]->Fill(0, pt);
929  h_simul_dzpvsigcut_pt[count]->Fill(0, pt);
930 
931  if(isMatched) {
932  fillPlotNoFlow(h_assocdzpv[count], dzPVSim);
933  fillPlotNoFlow(h_assocdzpvzoomed[count], dzPVSim);
934 
935  h_simul2_dzpvcut[count]->Fill(0);
936  h_simul2_dzpvsigcut[count]->Fill(0);
937  h_simul2_dzpvcut_pt[count]->Fill(0, pt);
938  h_simul2_dzpvsigcut_pt[count]->Fill(0, pt);
939  const double dzpvcut = std::abs(track->dz(*pvPosition));
940  const double dzpvsigcut = dzpvcut / track->dzError();
941  h_assoc_dzpvcut[count]->Fill(dzpvcut);
942  h_assoc_dzpvsigcut[count]->Fill(dzpvsigcut);
943  h_assoc_dzpvcut_pt[count]->Fill(dzpvcut, pt);
944  h_assoc_dzpvsigcut_pt[count]->Fill(dzpvsigcut, pt);
945  }
946  }
947  if(simPVPosition) {
948  const auto simpvz = simPVPosition->z();
949  h_simul_simpvz[count]->Fill(simpvz);
950  if(isMatched) {
951  h_assoc_simpvz[count]->Fill(simpvz);
952  }
953  }
954  }
955 
956 }
std::vector< MonitorElement * > h_simul2_dzpvcut
std::vector< MonitorElement * > h_assochit
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsPt
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsEta
std::vector< MonitorElement * > h_assoc_dzpvsigcut_pt
std::vector< MonitorElement * > h_assoczpos
std::vector< MonitorElement * > h_simuldxypvzoomed
std::vector< MonitorElement * > h_simulzpos
std::vector< MonitorElement * > h_simulpT
std::vector< MonitorElement * > h_simul_dzpvsigcut
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsVTXR
std::vector< MonitorElement * > h_assoc_dzpvcut_pt
std::vector< MonitorElement * > h_simul_dzpvcut_pt
std::vector< MonitorElement * > h_assocdz
std::vector< MonitorElement * > h_simuleta
std::vector< MonitorElement * > h_assoc_simpvz
std::vector< MonitorElement * > h_assoc3Dlayer
std::vector< MonitorElement * > h_simul2_dzpvsigcut_pt
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut
std::vector< MonitorElement * > h_assocdzpv
std::vector< MonitorElement * > h_assocdxypvzoomed
std::vector< MonitorElement * > h_assocphi
std::vector< MonitorElement * > h_simul2_dzpvcut_pt
std::vector< MonitorElement * > h_assocdzpvzoomed
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut
std::vector< MonitorElement * > h_assocpu
std::vector< MonitorElement * > h_simulpu
std::vector< MonitorElement * > h_simuldzpv
std::vector< MonitorElement * > h_simuldr
std::vector< std::vector< MonitorElement * > > h_assoc_mvacut_hp
T sqrt(T t)
Definition: SSEVec.h:18
std::vector< MonitorElement * > h_assocpT
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
std::vector< MonitorElement * > h_simul_simpvz
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
bool isMatched(TrackingRecHit const &hit)
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:815
std::vector< MonitorElement * > h_simuldzpvzoomed
std::vector< MonitorElement * > h_simullayer
std::vector< MonitorElement * > h_simuldz
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:604
double dzError() const
error on dz
Definition: TrackBase.h:809
std::vector< MonitorElement * > h_simulvertpos
std::vector< std::vector< MonitorElement * > > h_simul2_mvacut_hp
std::vector< MonitorElement * > h_simuldxypv
std::vector< MonitorElement * > h_simulpixellayer
std::vector< MonitorElement * > h_simul_dzpvcut
std::vector< MonitorElement * > h_assoc_dzpvsigcut
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsPhi
std::vector< MonitorElement * > h_simul_dzpvsigcut_pt
std::vector< MonitorElement * > h_simulphi
std::unique_ptr< TrackingParticleSelector > TpSelectorForEfficiencyVsVTXZ
std::vector< MonitorElement * > h_simul2_dzpvsigcut
std::vector< MonitorElement * > h_simulhit
std::vector< MonitorElement * > h_assocdxy
std::vector< MonitorElement * > h_assoclayer
std::vector< MonitorElement * > h_assoceta
std::vector< MonitorElement * > h_simul3Dlayer
std::vector< MonitorElement * > h_simuldxy
std::vector< MonitorElement * > h_assocdr
std::vector< MonitorElement * > h_assocvertpos
std::vector< MonitorElement * > h_assocpixellayer
std::vector< MonitorElement * > h_assoc_dzpvcut
std::vector< MonitorElement * > h_assocdxypv
void MTVHistoProducerAlgoForTracker::fill_recoAssociated_simTrack_histos ( int  count,
const reco::GenParticle tp,
const TrackingParticle::Vector momentumTP,
const TrackingParticle::Point vertexTP,
double  dxy,
double  dz,
int  nSimHits,
const reco::Track track,
int  numVertices 
)

Definition at line 1496 of file MTVHistoProducerAlgoForTracker.cc.

References KineDebug3::count(), getEta(), getPt(), GpSelectorForEfficiencyVsEta, GpSelectorForEfficiencyVsPhi, GpSelectorForEfficiencyVsPt, GpSelectorForEfficiencyVsVTXR, GpSelectorForEfficiencyVsVTXZ, h_assocdxy, h_assocdz, h_assoceta, h_assochit, h_assocphi, h_assocpT, h_assocpu, h_assocvertpos, h_assoczpos, h_simuldxy, h_simuldz, h_simuleta, h_simulhit, h_simulphi, h_simulpT, h_simulpu, h_simulvertpos, h_simulzpos, trackerHitRTTI::isMatched(), nrecHit_vs_nsimHit_sim2rec, reco::TrackBase::numberOfValidHits(), mathSSE::sqrt(), and HiIsolationCommonParameters_cff::track.

1502  {
1503 
1504  bool isMatched = track;
1505 
1506  if((*GpSelectorForEfficiencyVsEta)(tp)){
1507  //effic vs eta
1508  fillPlotNoFlow(h_simuleta[count],getEta(momentumTP.eta()));
1509  if (isMatched) fillPlotNoFlow(h_assoceta[count],getEta(momentumTP.eta()));
1510  }
1511 
1512  if((*GpSelectorForEfficiencyVsPhi)(tp)){
1513  fillPlotNoFlow(h_simulphi[count],momentumTP.phi());
1514  if (isMatched) fillPlotNoFlow(h_assocphi[count],momentumTP.phi());
1515  //effic vs hits
1516  fillPlotNoFlow(h_simulhit[count],(int)nSimHits);
1517  if(isMatched) {
1518  fillPlotNoFlow(h_assochit[count],(int)nSimHits);
1519  nrecHit_vs_nsimHit_sim2rec[count]->Fill( track->numberOfValidHits(),nSimHits);
1520  }
1521  //effic vs pu
1522  fillPlotNoFlow(h_simulpu[count],numVertices);
1523  if (isMatched) fillPlotNoFlow(h_assocpu[count],numVertices);
1524  //efficiency vs dR
1525  //not implemented for now
1526  }
1527 
1528  if((*GpSelectorForEfficiencyVsPt)(tp)){
1529  fillPlotNoFlow(h_simulpT[count],getPt(sqrt(momentumTP.perp2())));
1530  if (isMatched) fillPlotNoFlow(h_assocpT[count],getPt(sqrt(momentumTP.perp2())));
1531  }
1532 
1533  if((*GpSelectorForEfficiencyVsVTXR)(tp)){
1534  fillPlotNoFlow(h_simuldxy[count],dxySim);
1535  if (isMatched) fillPlotNoFlow(h_assocdxy[count],dxySim);
1536 
1537  fillPlotNoFlow(h_simulvertpos[count],sqrt(vertexTP.perp2()));
1538  if (isMatched) fillPlotNoFlow(h_assocvertpos[count],sqrt(vertexTP.perp2()));
1539  }
1540 
1541  if((*GpSelectorForEfficiencyVsVTXZ)(tp)){
1542  fillPlotNoFlow(h_simuldz[count],dzSim);
1543  if (isMatched) fillPlotNoFlow(h_assocdz[count],dzSim);
1544 
1545  fillPlotNoFlow(h_simulzpos[count],vertexTP.z());
1546  if (isMatched) fillPlotNoFlow(h_assoczpos[count],vertexTP.z());
1547  }
1548 
1549 }
std::vector< MonitorElement * > h_assochit
std::vector< MonitorElement * > h_assoczpos
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsVTXR
std::vector< MonitorElement * > h_simulzpos
std::vector< MonitorElement * > h_simulpT
std::vector< MonitorElement * > h_assocdz
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsVTXZ
std::vector< MonitorElement * > h_simuleta
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsPt
std::vector< MonitorElement * > h_assocphi
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsPhi
std::vector< MonitorElement * > h_assocpu
std::vector< MonitorElement * > h_simulpu
T sqrt(T t)
Definition: SSEVec.h:18
std::unique_ptr< GenParticleCustomSelector > GpSelectorForEfficiencyVsEta
std::vector< MonitorElement * > h_assocpT
std::vector< MonitorElement * > nrecHit_vs_nsimHit_sim2rec
bool isMatched(TrackingRecHit const &hit)
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:815
std::vector< MonitorElement * > h_simuldz
std::vector< MonitorElement * > h_simulvertpos
std::vector< MonitorElement * > h_simulphi
std::vector< MonitorElement * > h_simulhit
std::vector< MonitorElement * > h_assocdxy
std::vector< MonitorElement * > h_assoceta
std::vector< MonitorElement * > h_simuldxy
std::vector< MonitorElement * > h_assocvertpos
void MTVHistoProducerAlgoForTracker::fill_ResoAndPull_recoTrack_histos ( int  count,
const TrackingParticle::Vector momentumTP,
const TrackingParticle::Point vertexTP,
int  chargeTP,
const reco::Track track,
const math::XYZPoint bsPosition 
)

Definition at line 1238 of file MTVHistoProducerAlgoForTracker.cc.

References chi2_vs_phi, cotThetares_vs_eta, cotThetares_vs_pt, KineDebug3::count(), TrackingParticleIP::dxy(), reco::TrackBase::dxy(), reco::TrackBase::dxyError(), dxypull_vs_eta, dxyres_vs_eta, dxyres_vs_pt, TrackingParticleIP::dz(), reco::TrackBase::dz(), reco::TrackBase::dzError(), dzpull_vs_eta, dzres_vs_eta, dzres_vs_pt, reco::TrackBase::eta(), etares_vs_eta, getEta(), getPt(), getRecoMomentum(), h_eta, h_pt, h_pullDxy, h_pullDz, h_pullPhi, h_pullQoverp, h_pullTheta, LogTrace, M_PI, nhits_vs_phi, reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfValidHits(), phimean_vs_eta_phi, phipull_vs_eta, phipull_vs_phi, phires_vs_eta, phires_vs_phi, phires_vs_pt, ptmean_vs_eta_phi, ptpull_vs_eta, ptpull_vs_phi, ptres_vs_eta, ptres_vs_phi, ptres_vs_pt, mathSSE::sqrt(), funct::tan(), reco::TrackBase::theta(), thetapull_vs_eta, thetapull_vs_phi, and trackFromSeedFitFailed().

1243  {
1244  if(trackFromSeedFitFailed(track))
1245  return;
1246 
1247  // evaluation of TP parameters
1248  double qoverpSim = chargeTP/sqrt(momentumTP.x()*momentumTP.x()+momentumTP.y()*momentumTP.y()+momentumTP.z()*momentumTP.z());
1249  double lambdaSim = M_PI/2-momentumTP.theta();
1250  double phiSim = momentumTP.phi();
1251  double dxySim = TrackingParticleIP::dxy(vertexTP, momentumTP, bsPosition);
1252  double dzSim = TrackingParticleIP::dz(vertexTP, momentumTP, bsPosition);
1253 
1254 
1255  // reco::Track::ParameterVector rParameters = track.parameters(); // UNUSED
1256 
1257  double qoverpRec(0);
1258  double qoverpErrorRec(0);
1259  double ptRec(0);
1260  double ptErrorRec(0);
1261  double lambdaRec(0);
1262  double lambdaErrorRec(0);
1263  double phiRec(0);
1264  double phiErrorRec(0);
1265 
1266  /* TO BE FIXED LATER -----------
1267  //loop to decide whether to take gsfTrack (utilisation of mode-function) or common track
1268  const GsfTrack* gsfTrack(0);
1269  if(useGsf){
1270  gsfTrack = dynamic_cast<const GsfTrack*>(&(*track));
1271  if (gsfTrack==0) edm::LogInfo("TrackValidator") << "Trying to access mode for a non-GsfTrack";
1272  }
1273 
1274  if (gsfTrack) {
1275  // get values from mode
1276  getRecoMomentum(*gsfTrack, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1277  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1278  }
1279 
1280  else {
1281  // get values from track (without mode)
1282  getRecoMomentum(*track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1283  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1284  }
1285  */
1286  getRecoMomentum(track, ptRec, ptErrorRec, qoverpRec, qoverpErrorRec,
1287  lambdaRec,lambdaErrorRec, phiRec, phiErrorRec);
1288  // -------------
1289 
1290  double ptError = ptErrorRec;
1291  double ptres=ptRec-sqrt(momentumTP.perp2());
1292  double etares=track.eta()-momentumTP.Eta();
1293 
1294 
1295  double dxyRec = track.dxy(bsPosition);
1296  double dzRec = track.dz(bsPosition);
1297 
1298  const auto phiRes = phiRec-phiSim;
1299  const auto dxyRes = dxyRec-dxySim;
1300  const auto dzRes = dzRec-dzSim;
1301  const auto cotThetaRes = 1/tan(M_PI*0.5-lambdaRec)-1/tan(M_PI*0.5-lambdaSim);
1302 
1303  // eta residue; pt, k, theta, phi, dxy, dz pulls
1304  double qoverpPull=(qoverpRec-qoverpSim)/qoverpErrorRec;
1305  double thetaPull=(lambdaRec-lambdaSim)/lambdaErrorRec;
1306  double phiPull=phiRes/phiErrorRec;
1307  double dxyPull=dxyRes/track.dxyError();
1308  double dzPull=dzRes/track.dzError();
1309 
1310 #ifdef EDM_ML_DEBUG
1311  double contrib_Qoverp = ((qoverpRec-qoverpSim)/qoverpErrorRec)*
1312  ((qoverpRec-qoverpSim)/qoverpErrorRec)/5;
1313  double contrib_dxy = ((dxyRec-dxySim)/track.dxyError())*((dxyRec-dxySim)/track.dxyError())/5;
1314  double contrib_dz = ((dzRec-dzSim)/track.dzError())*((dzRec-dzSim)/track.dzError())/5;
1315  double contrib_theta = ((lambdaRec-lambdaSim)/lambdaErrorRec)*
1316  ((lambdaRec-lambdaSim)/lambdaErrorRec)/5;
1317  double contrib_phi = ((phiRec-phiSim)/phiErrorRec)*
1318  ((phiRec-phiSim)/phiErrorRec)/5;
1319 
1320  LogTrace("TrackValidatorTEST")
1321  //<< "assocChi2=" << tp.begin()->second << "\n"
1322  << "" << "\n"
1323  << "ptREC=" << ptRec << "\n" << "etaREC=" << track.eta() << "\n" << "qoverpREC=" << qoverpRec << "\n"
1324  << "dxyREC=" << dxyRec << "\n" << "dzREC=" << dzRec << "\n"
1325  << "thetaREC=" << track.theta() << "\n" << "phiREC=" << phiRec << "\n"
1326  << "" << "\n"
1327  << "qoverpError()=" << qoverpErrorRec << "\n" << "dxyError()=" << track.dxyError() << "\n"<< "dzError()="
1328  << track.dzError() << "\n"
1329  << "thetaError()=" << lambdaErrorRec << "\n" << "phiError()=" << phiErrorRec << "\n"
1330  << "" << "\n"
1331  << "ptSIM=" << sqrt(momentumTP.perp2()) << "\n"<< "etaSIM=" << momentumTP.Eta() << "\n"<< "qoverpSIM=" << qoverpSim << "\n"
1332  << "dxySIM=" << dxySim << "\n"<< "dzSIM=" << dzSim << "\n" << "thetaSIM=" << M_PI/2-lambdaSim << "\n"
1333  << "phiSIM=" << phiSim << "\n"
1334  << "" << "\n"
1335  << "contrib_Qoverp=" << contrib_Qoverp << "\n"<< "contrib_dxy=" << contrib_dxy << "\n"<< "contrib_dz=" << contrib_dz << "\n"
1336  << "contrib_theta=" << contrib_theta << "\n"<< "contrib_phi=" << contrib_phi << "\n"
1337  << "" << "\n"
1338  <<"chi2PULL="<<contrib_Qoverp+contrib_dxy+contrib_dz+contrib_theta+contrib_phi<<"\n";
1339 #endif
1340 
1341  h_pullQoverp[count]->Fill(qoverpPull);
1342  h_pullTheta[count]->Fill(thetaPull);
1343  h_pullPhi[count]->Fill(phiPull);
1344  h_pullDxy[count]->Fill(dxyPull);
1345  h_pullDz[count]->Fill(dzPull);
1346 
1347  const auto etaSim = getEta(momentumTP.eta());
1348  const auto ptSim = getPt(sqrt(momentumTP.perp2()));
1349 
1350  h_pt[count]->Fill(ptres/ptError);
1351  h_eta[count]->Fill(etares);
1352  //etares_vs_eta[count]->Fill(getEta(track.eta()),etares);
1353  etares_vs_eta[count]->Fill(etaSim, etares);
1354 
1355  //resolution of track params: fill 2D histos
1356  dxyres_vs_eta[count]->Fill(etaSim, dxyRes);
1357  ptres_vs_eta[count]->Fill(etaSim, ptres/ptRec);
1358  dzres_vs_eta[count]->Fill(etaSim, dzRes);
1359  phires_vs_eta[count]->Fill(etaSim, phiRes);
1360  cotThetares_vs_eta[count]->Fill(etaSim, cotThetaRes);
1361 
1362  //same as before but vs pT
1363  dxyres_vs_pt[count]->Fill(ptSim, dxyRes);
1364  ptres_vs_pt[count]->Fill(ptSim, ptres/ptRec);
1365  dzres_vs_pt[count]->Fill(ptSim, dzRes);
1366  phires_vs_pt[count]->Fill(ptSim, phiRes);
1367  cotThetares_vs_pt[count]->Fill(ptSim, cotThetaRes);
1368 
1369  //pulls of track params vs eta: fill 2D histos
1370  dxypull_vs_eta[count]->Fill(etaSim, dxyPull);
1371  ptpull_vs_eta[count]->Fill(etaSim, ptres/ptError);
1372  dzpull_vs_eta[count]->Fill(etaSim, dzPull);
1373  phipull_vs_eta[count]->Fill(etaSim, phiPull);
1374  thetapull_vs_eta[count]->Fill(etaSim, thetaPull);
1375 
1376  //plots vs phi
1377  nhits_vs_phi[count]->Fill(phiRec,track.numberOfValidHits());
1378  chi2_vs_phi[count]->Fill(phiRec,track.normalizedChi2());
1379  ptmean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),ptRec);
1380  phimean_vs_eta_phi[count]->Fill(phiRec,getEta(track.eta()),phiRec);
1381 
1382  ptres_vs_phi[count]->Fill(phiSim, ptres/ptRec);
1383  phires_vs_phi[count]->Fill(phiSim, phiRes);
1384  ptpull_vs_phi[count]->Fill(phiSim, ptres/ptError);
1385  phipull_vs_phi[count]->Fill(phiSim, phiPull);
1386  thetapull_vs_phi[count]->Fill(phiSim, thetaPull);
1387 
1388 
1389 }
std::vector< MonitorElement * > h_pullDz
std::vector< MonitorElement * > ptpull_vs_phi
bool trackFromSeedFitFailed(const reco::Track &track)
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:556
void getRecoMomentum(const reco::Track &track, double &pt, double &ptError, double &qoverp, double &qoverpError, double &lambda, double &lambdaError, double &phi, double &phiError) const
retrieval of reconstructed momentum components from reco::Track (== mean values for GSF) ...
double theta() const
polar angle
Definition: TrackBase.h:574
double dxyError() const
error on dxy
Definition: TrackBase.h:791
std::vector< MonitorElement * > h_pullPhi
std::vector< MonitorElement * > phipull_vs_phi
std::vector< MonitorElement * > phires_vs_eta
std::vector< MonitorElement * > h_pullDxy
std::vector< MonitorElement * > chi2_vs_phi
std::vector< MonitorElement * > phires_vs_phi
std::vector< MonitorElement * > dzres_vs_eta
std::vector< MonitorElement * > phires_vs_pt
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:646
std::vector< MonitorElement * > h_pullQoverp
auto dz(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
T sqrt(T t)
Definition: SSEVec.h:18
std::vector< MonitorElement * > ptpull_vs_eta
std::vector< MonitorElement * > etares_vs_eta
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
std::vector< MonitorElement * > nhits_vs_phi
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:815
std::vector< MonitorElement * > phimean_vs_eta_phi
#define LogTrace(id)
std::vector< MonitorElement * > dzpull_vs_eta
#define M_PI
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:604
double dzError() const
error on dz
Definition: TrackBase.h:809
std::vector< MonitorElement * > thetapull_vs_phi
std::vector< MonitorElement * > dxyres_vs_eta
std::vector< MonitorElement * > h_eta
std::vector< MonitorElement * > h_pt
std::vector< MonitorElement * > cotThetares_vs_pt
std::vector< MonitorElement * > h_pullTheta
std::vector< MonitorElement * > ptmean_vs_eta_phi
std::vector< MonitorElement * > dxypull_vs_eta
auto dxy(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
std::vector< MonitorElement * > ptres_vs_eta
std::vector< MonitorElement * > phipull_vs_eta
std::vector< MonitorElement * > cotThetares_vs_eta
std::vector< MonitorElement * > ptres_vs_pt
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:586
std::vector< MonitorElement * > ptres_vs_phi
std::vector< MonitorElement * > thetapull_vs_eta
std::vector< MonitorElement * > dxyres_vs_pt
std::vector< MonitorElement * > dzres_vs_pt
void MTVHistoProducerAlgoForTracker::fill_seed_histos ( int  count,
int  seedsFitFailed,
int  seedsTotal 
)

Definition at line 1551 of file MTVHistoProducerAlgoForTracker.cc.

References KineDebug3::count(), h_seedsFitFailed, and h_seedsFitFailedFraction.

1553  {
1554  fillPlotNoFlow(h_seedsFitFailed[count], seedsFitFailed);
1555  h_seedsFitFailedFraction[count]->Fill(static_cast<double>(seedsFitFailed)/seedsTotal);
1556 }
std::vector< MonitorElement * > h_seedsFitFailedFraction
std::vector< MonitorElement * > h_seedsFitFailed
void MTVHistoProducerAlgoForTracker::fill_simAssociated_recoTrack_histos ( int  count,
const reco::Track track 
)

Definition at line 1182 of file MTVHistoProducerAlgoForTracker.cc.

References reco::TrackBase::charge(), reco::TrackBase::chi2(), chi2_vs_eta, chi2_vs_nhits, KineDebug3::count(), stringResolutionProvider_cfi::eta, reco::TrackBase::eta(), getEta(), h_charge, h_hits, h_losthits, h_nchi2, h_nchi2_prob, h_nmisslayers_inner, h_nmisslayers_outer, reco::TrackBase::hitPattern(), createfilelist::int, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, reco::TrackBase::ndof(), nhits_vs_eta, nLayersWithMeas_vs_eta, nlosthits_vs_eta, reco::TrackBase::normalizedChi2(), nPXBhits_vs_eta, nPXFhits_vs_eta, nPXLhits_vs_eta, nPXLlayersWithMeas_vs_eta, nSTRIPhits_vs_eta, nSTRIPlayersWith1dMeas_vs_eta, nSTRIPlayersWith2dMeas_vs_eta, nSTRIPlayersWithMeas_vs_eta, nTEChits_vs_eta, nTIBhits_vs_eta, nTIDhits_vs_eta, nTOBhits_vs_eta, reco::HitPattern::numberOfHits(), reco::TrackBase::numberOfLostHits(), reco::TrackBase::numberOfValidHits(), reco::HitPattern::numberOfValidPixelBarrelHits(), reco::HitPattern::numberOfValidPixelEndcapHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), reco::HitPattern::numberOfValidStripTECHits(), reco::HitPattern::numberOfValidStripTIBHits(), reco::HitPattern::numberOfValidStripTIDHits(), reco::HitPattern::numberOfValidStripTOBHits(), reco::HitPattern::pixelLayersWithMeasurement(), reco::HitPattern::stripLayersWithMeasurement(), reco::HitPattern::trackerLayersWithMeasurement(), and trackFromSeedFitFailed().

1183  {
1184  //nchi2 and hits global distributions
1185  h_hits[count]->Fill(track.numberOfValidHits());
1186  h_losthits[count]->Fill(track.numberOfLostHits());
1189  if(trackFromSeedFitFailed(track))
1190  return;
1191 
1192  h_nchi2[count]->Fill(track.normalizedChi2());
1193  h_nchi2_prob[count]->Fill(TMath::Prob(track.chi2(),(int)track.ndof()));
1194  chi2_vs_nhits[count]->Fill(track.numberOfValidHits(),track.normalizedChi2());
1195  h_charge[count]->Fill( track.charge() );
1196 
1197  //chi2 and #hit vs eta: fill 2D histos
1198  const auto eta = getEta(track.eta());
1199  chi2_vs_eta[count]->Fill(eta, track.normalizedChi2());
1200  nhits_vs_eta[count]->Fill(eta, track.numberOfValidHits());
1201  const auto pxbHits = track.hitPattern().numberOfValidPixelBarrelHits();
1202  const auto pxfHits = track.hitPattern().numberOfValidPixelEndcapHits();
1203  const auto tibHits = track.hitPattern().numberOfValidStripTIBHits();
1204  const auto tidHits = track.hitPattern().numberOfValidStripTIDHits();
1205  const auto tobHits = track.hitPattern().numberOfValidStripTOBHits();
1206  const auto tecHits = track.hitPattern().numberOfValidStripTECHits();
1207  nPXBhits_vs_eta[count]->Fill(eta, pxbHits);
1208  nPXFhits_vs_eta[count]->Fill(eta, pxfHits);
1209  nPXLhits_vs_eta[count]->Fill(eta, pxbHits+pxfHits);
1210  nTIBhits_vs_eta[count]->Fill(eta, tibHits);
1211  nTIDhits_vs_eta[count]->Fill(eta, tidHits);
1212  nTOBhits_vs_eta[count]->Fill(eta, tobHits);
1213  nTEChits_vs_eta[count]->Fill(eta, tecHits);
1214  nSTRIPhits_vs_eta[count]->Fill(eta, tibHits+tidHits+tobHits+tecHits);
1217  int LayersAll = track.hitPattern().stripLayersWithMeasurement();
1218  int Layers2D = track.hitPattern().numberOfValidStripLayersWithMonoAndStereo();
1219  int Layers1D = LayersAll - Layers2D;
1220  nSTRIPlayersWithMeas_vs_eta[count]->Fill(eta, LayersAll);
1221  nSTRIPlayersWith1dMeas_vs_eta[count]->Fill(eta, Layers1D);
1222  nSTRIPlayersWith2dMeas_vs_eta[count]->Fill(eta, Layers2D);
1223 
1224  nlosthits_vs_eta[count]->Fill(eta, track.numberOfLostHits());
1225 }
std::vector< MonitorElement * > h_nchi2_prob
std::vector< MonitorElement * > nPXFhits_vs_eta
bool trackFromSeedFitFailed(const reco::Track &track)
std::vector< MonitorElement * > h_nmisslayers_inner
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:556
std::vector< MonitorElement * > nTEChits_vs_eta
std::vector< MonitorElement * > h_hits
std::vector< MonitorElement * > nLayersWithMeas_vs_eta
std::vector< MonitorElement * > nTIDhits_vs_eta
std::vector< MonitorElement * > h_nchi2
unsigned short numberOfLostHits() const
number of cases where track crossed a layer without getting a hit.
Definition: TrackBase.h:821
int pixelLayersWithMeasurement() const
Definition: HitPattern.cc:499
int trackerLayersWithMeasurement() const
Definition: HitPattern.cc:518
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:868
std::vector< MonitorElement * > nlosthits_vs_eta
std::vector< MonitorElement * > nSTRIPlayersWith1dMeas_vs_eta
std::vector< MonitorElement * > nPXBhits_vs_eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:646
int numberOfValidStripLayersWithMonoAndStereo(uint16_t stripdet, uint16_t layer) const
Definition: HitPattern.cc:341
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:843
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:544
std::vector< MonitorElement * > nSTRIPlayersWithMeas_vs_eta
std::vector< MonitorElement * > nTOBhits_vs_eta
double ndof() const
number of degrees of freedom of the fit
Definition: TrackBase.h:550
std::vector< MonitorElement * > nSTRIPlayersWith2dMeas_vs_eta
int numberOfValidStripTIDHits() const
Definition: HitPattern.h:863
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:815
int numberOfValidStripTECHits() const
Definition: HitPattern.h:873
std::vector< MonitorElement * > h_charge
std::vector< MonitorElement * > chi2_vs_nhits
std::vector< MonitorElement * > nPXLhits_vs_eta
std::vector< MonitorElement * > nSTRIPhits_vs_eta
std::vector< MonitorElement * > h_nmisslayers_outer
std::vector< MonitorElement * > nPXLlayersWithMeas_vs_eta
std::vector< MonitorElement * > nTIBhits_vs_eta
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:445
int stripLayersWithMeasurement() const
Definition: HitPattern.h:1035
int numberOfValidStripTIBHits() const
Definition: HitPattern.h:858
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:848
int charge() const
track electric charge
Definition: TrackBase.h:562
std::vector< MonitorElement * > nhits_vs_eta
std::vector< MonitorElement * > chi2_vs_eta
int numberOfHits(HitCategory category) const
Definition: HitPattern.h:807
std::vector< MonitorElement * > h_losthits
void MTVHistoProducerAlgoForTracker::fill_simTrackBased_histos ( int  numSimTracks)

Definition at line 958 of file MTVHistoProducerAlgoForTracker.cc.

References MonitorElement::Fill(), and h_tracksSIM.

958  {
959  h_tracksSIM->Fill(numSimTracks);
960 }
void Fill(long long x)
void MTVHistoProducerAlgoForTracker::fill_trackBased_histos ( int  count,
int  assTracks,
int  numRecoTracks,
int  numRecoTracksSelected,
int  numSimTracksSelected 
)

Definition at line 1228 of file MTVHistoProducerAlgoForTracker.cc.

References KineDebug3::count(), h_fakes, h_tracks, and nrec_vs_nsim.

1228  {
1229 
1230  h_tracks[count]->Fill(assTracks);
1231  h_fakes[count]->Fill(numRecoTracks-assTracks);
1232  nrec_vs_nsim[count]->Fill(numSimTracksSelected, numRecoTracksSelected);
1233 
1234 }
std::vector< MonitorElement * > h_fakes
std::vector< MonitorElement * > nrec_vs_nsim
std::vector< MonitorElement * > h_tracks
double MTVHistoProducerAlgoForTracker::getEta ( double  eta)
private
double MTVHistoProducerAlgoForTracker::getPt ( double  pt)
private
void MTVHistoProducerAlgoForTracker::getRecoMomentum ( const reco::Track track,
double &  pt,
double &  ptError,
double &  qoverp,
double &  qoverpError,
double &  lambda,
double &  lambdaError,
double &  phi,
double &  phiError 
) const
private

retrieval of reconstructed momentum components from reco::Track (== mean values for GSF)

Definition at line 1394 of file MTVHistoProducerAlgoForTracker.cc.

References reco::TrackBase::lambda(), reco::TrackBase::lambdaError(), reco::TrackBase::phi(), reco::TrackBase::phiError(), reco::TrackBase::pt(), reco::TrackBase::ptError(), reco::TrackBase::qoverp(), and reco::TrackBase::qoverpError().

Referenced by fill_ResoAndPull_recoTrack_histos().

1396  {
1397  pt = track.pt();
1398  ptError = track.ptError();
1399  qoverp = track.qoverp();
1400  qoverpError = track.qoverpError();
1401  lambda = track.lambda();
1402  lambdaError = track.lambdaError();
1403  phi = track.phi();
1404  phiError = track.phiError();
1405  // cout <<"test1" << endl;
1406 
1407 
1408 
1409 }
double qoverp() const
q / p
Definition: TrackBase.h:568
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:640
double pt() const
track transverse momentum
Definition: TrackBase.h:616
double ptError() const
error on Pt (set to 1000 TeV if charge==0 for safety)
Definition: TrackBase.h:758
double phiError() const
error on phi
Definition: TrackBase.h:785
double lambda() const
Lambda angle.
Definition: TrackBase.h:580
double qoverpError() const
error on signed transverse curvature
Definition: TrackBase.h:752
double lambdaError() const
error on lambda
Definition: TrackBase.h:773
void MTVHistoProducerAlgoForTracker::getRecoMomentum ( const reco::GsfTrack gsfTrack,
double &  pt,
double &  ptError,
double &  qoverp,
double &  qoverpError,
double &  lambda,
double &  lambdaError,
double &  phi,
double &  phiError 
) const
private

retrieval of reconstructed momentum components based on the mode of a reco::GsfTrack

Definition at line 1412 of file MTVHistoProducerAlgoForTracker.cc.

References reco::GsfTrack::lambdaMode(), reco::GsfTrack::lambdaModeError(), reco::GsfTrack::phiMode(), reco::GsfTrack::phiModeError(), reco::GsfTrack::ptMode(), reco::GsfTrack::ptModeError(), reco::GsfTrack::qoverpMode(), and reco::GsfTrack::qoverpModeError().

1414  {
1415 
1416  pt = gsfTrack.ptMode();
1417  ptError = gsfTrack.ptModeError();
1418  qoverp = gsfTrack.qoverpMode();
1419  qoverpError = gsfTrack.qoverpModeError();
1420  lambda = gsfTrack.lambdaMode();
1421  lambdaError = gsfTrack.lambdaModeError();
1422  phi = gsfTrack.phiMode();
1423  phiError = gsfTrack.phiModeError();
1424  // cout <<"test2" << endl;
1425 
1426 }
double phiModeError() const
error on phi from mode
Definition: GsfTrack.h:94
double lambdaMode() const
Lambda angle from mode.
Definition: GsfTrack.h:45
double qoverpMode() const
q/p from mode
Definition: GsfTrack.h:41
double ptModeError() const
error on Pt (set to 1000 TeV if charge==0 for safety) from mode
Definition: GsfTrack.h:81
double qoverpModeError() const
error on signed transverse curvature from mode
Definition: GsfTrack.h:79
double phiMode() const
azimuthal angle of momentum vector from mode
Definition: GsfTrack.h:57
double lambdaModeError() const
error on lambda from mode
Definition: GsfTrack.h:90
double ptMode() const
track transverse momentum from mode
Definition: GsfTrack.h:49
unsigned int MTVHistoProducerAlgoForTracker::getSeedingLayerSetBin ( const reco::Track track,
const TrackerTopology ttopo 
)
private

Definition at line 1440 of file MTVHistoProducerAlgoForTracker.cc.

References ctfseeding::SeedingLayer::Barrel, DetId::det(), SoftLeptonByDistance_cfi::distance, Exception, runEdmFileComparison::found, mps_fire::i, edm::RefToBase< T >::isAvailable(), edm::RefToBase< T >::isNull(), trackerHitRTTI::isSingle(), TrackerTopology::layer(), LogDebug, ctfseeding::SeedingLayer::NegEndcap, nhits, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GeomDetEnumerators::PixelEndcap, ctfseeding::SeedingLayer::PosEndcap, DetId::rawId(), TrajectorySeed::recHits(), SurveyInfoScenario_cff::seed, seedingLayerSetNames, seedingLayerSetToBin, reco::Track::seedRef(), TrackerTopology::side(), DetId::subdetId(), GeomDetEnumerators::TEC, StripSubdetector::TEC, GeomDetEnumerators::TIB, StripSubdetector::TIB, GeomDetEnumerators::TID, StripSubdetector::TID, GeomDetEnumerators::TOB, StripSubdetector::TOB, DetId::Tracker, and relativeConstraints::value.

Referenced by fill_generic_recoTrack_histos().

1440  {
1441  if(track.seedRef().isNull() || !track.seedRef().isAvailable())
1442  return seedingLayerSetNames.size()-1;
1443 
1444  const TrajectorySeed& seed = *(track.seedRef());
1445  const auto hitRange = seed.recHits();
1446  SeedingLayerSetId searchId;
1447  const int nhits = std::distance(hitRange.first, hitRange.second);
1448  if(nhits > static_cast<int>(std::tuple_size<SeedingLayerSetId>::value)) {
1449  LogDebug("TrackValidator") << "Got seed with " << nhits << " hits, but I have a hard-coded maximum of " << std::tuple_size<SeedingLayerSetId>::value << ", classifying the seed as 'unknown'. Please increase the maximum in MTVHistoProducerAlgoForTracker.h if needed.";
1450  return seedingLayerSetNames.size()-1;
1451  }
1452  int i=0;
1453  for(auto iHit = hitRange.first; iHit != hitRange.second; ++iHit, ++i) {
1454  DetId detId = iHit->geographicalId();
1455 
1456  if(detId.det() != DetId::Tracker) {
1457  throw cms::Exception("LogicError") << "Encountered seed hit detId " << detId.rawId() << " not from Tracker, but " << detId.det();
1458  }
1459 
1461  bool subdetStrip = false;
1462  switch(detId.subdetId()) {
1465  case StripSubdetector::TIB: subdet = GeomDetEnumerators::TIB; subdetStrip = true; break;
1466  case StripSubdetector::TID: subdet = GeomDetEnumerators::TID; subdetStrip = true; break;
1467  case StripSubdetector::TOB: subdet = GeomDetEnumerators::TOB; subdetStrip = true; break;
1468  case StripSubdetector::TEC: subdet = GeomDetEnumerators::TEC; subdetStrip = true; break;
1469  default: throw cms::Exception("LogicError") << "Unknown subdetId " << detId.subdetId();
1470  };
1471 
1473  switch(ttopo.side(detId)) {
1474  case 0: side = ctfseeding::SeedingLayer::Barrel; break;
1475  case 1: side = ctfseeding::SeedingLayer::NegEndcap; break;
1476  case 2: side = ctfseeding::SeedingLayer::PosEndcap; break;
1477  default: throw cms::Exception("LogicError") << "Unknown side " << ttopo.side(detId);
1478  };
1479 
1480  // This is an ugly assumption, but a generic solution would
1481  // require significantly more effort
1482  // The "if hit is strip mono or not" is checked only for the last hit
1483  bool isStripMono = false;
1484  if(i == nhits-1 && subdetStrip) {
1485  isStripMono = trackerHitRTTI::isSingle(*iHit);
1486  }
1487  searchId[i] = SeedingLayerId(SeedingLayerSetsBuilder::SeedingLayerId(subdet, side, ttopo.layer(detId)), isStripMono);
1488  }
1489  auto found = seedingLayerSetToBin.find(searchId);
1490  if(found == seedingLayerSetToBin.end()) {
1491  return seedingLayerSetNames.size()-1;
1492  }
1493  return found->second;
1494 }
#define LogDebug(id)
const edm::RefToBase< TrajectorySeed > & seedRef() const
Definition: Track.h:213
bool isAvailable() const
Definition: RefToBase.h:114
std::map< SeedingLayerSetId, unsigned int > seedingLayerSetToBin
unsigned int side(const DetId &id) const
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
std::tuple< SeedingLayerSetsBuilder::SeedingLayerId, bool > SeedingLayerId
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
std::array< SeedingLayerId, 4 > SeedingLayerSetId
Definition: DetId.h:18
bool isSingle(TrackingRecHit const &hit)
bool isNull() const
Checks for null.
Definition: RefToBase.h:328
range recHits() const
unsigned int layer(const DetId &id) const
std::vector< std::string > seedingLayerSetNames
std::tuple< GeomDetEnumerators::SubDetector, ctfseeding::SeedingLayer::Side, int > SeedingLayerId
Detector det() const
get the detector field from this detid
Definition: DetId.h:35
void MTVHistoProducerAlgoForTracker::init ( const edm::Event event,
const edm::EventSetup setup 
)

Definition at line 309 of file MTVHistoProducerAlgoForTracker.cc.

References trackSelectorVsEta, trackSelectorVsPhi, and trackSelectorVsPt.

309  {
310  trackSelectorVsEta->init(event, setup);
311  trackSelectorVsPhi->init(event, setup);
312  trackSelectorVsPt->init(event, setup);
313 }
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPhi
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsPt
std::unique_ptr< RecoTrackSelectorBase > trackSelectorVsEta
std::unique_ptr< RecoTrackSelectorBase > MTVHistoProducerAlgoForTracker::makeRecoTrackSelectorFromTPSelectorParameters ( const edm::ParameterSet pset,
const edm::InputTag beamSpotTag,
edm::ConsumesCollector iC 
)
static

Definition at line 286 of file MTVHistoProducerAlgoForTracker.cc.

References edm::ParameterSet::addParameter(), edm::ParameterSet::copyForModify(), and edm::ParameterSet::eraseSimpleParameter().

Referenced by MTVHistoProducerAlgoForTracker(), and MultiTrackValidator::MultiTrackValidator().

286  {
287  edm::ParameterSet psetTrack;
288  psetTrack.copyForModify(pset);
289  psetTrack.eraseSimpleParameter("minHit");
290  psetTrack.eraseSimpleParameter("signalOnly");
291  psetTrack.eraseSimpleParameter("intimeOnly");
292  psetTrack.eraseSimpleParameter("chargedOnly");
293  psetTrack.eraseSimpleParameter("stableOnly");
294  psetTrack.addParameter("maxChi2", 1e10);
295  psetTrack.addParameter("minHit", 0);
296  psetTrack.addParameter("minPixelHit", 0);
297  psetTrack.addParameter("minLayer", 0);
298  psetTrack.addParameter("min3DLayer", 0);
299  psetTrack.addParameter("usePV", false);
300  psetTrack.addParameter("beamSpot", beamSpotTag);
301  psetTrack.addParameter("quality", std::vector<std::string>{});
302  psetTrack.addParameter("algorithm", std::vector<std::string>{});
303  psetTrack.addParameter("originalAlgorithm", std::vector<std::string>{});
304  psetTrack.addParameter("algorithmMaskContains", std::vector<std::string>{});
305 
306  return std::make_unique<RecoTrackSelectorBase>(psetTrack, iC);
307 }
void addParameter(std::string const &name, T const &value)
Definition: ParameterSet.h:144
void eraseSimpleParameter(std::string const &name)
void copyForModify(ParameterSet const &other)
static std::unique_ptr<RecoTrackSelectorBase> MTVHistoProducerAlgoForTracker::makeRecoTrackSelectorFromTPSelectorParameters ( const edm::ParameterSet pset,
const edm::InputTag beamSpotTag,
edm::ConsumesCollector &&  iC 
)
inlinestatic

Member Data Documentation

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::chi2_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::chi2_vs_nhits
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::chi2_vs_phi
private
int MTVHistoProducerAlgoForTracker::cotThetaRes_nbin
private
double MTVHistoProducerAlgoForTracker::cotThetaRes_rangeMax
private
double MTVHistoProducerAlgoForTracker::cotThetaRes_rangeMin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::cotThetares_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::cotThetares_vs_pt
private
const bool MTVHistoProducerAlgoForTracker::doSeedPlots_
private
double MTVHistoProducerAlgoForTracker::dxyDzZoom
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dxypull_vs_eta
private
int MTVHistoProducerAlgoForTracker::dxyRes_nbin
private
double MTVHistoProducerAlgoForTracker::dxyRes_rangeMax
private
double MTVHistoProducerAlgoForTracker::dxyRes_rangeMin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dxyres_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dxyres_vs_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dzpull_vs_eta
private
int MTVHistoProducerAlgoForTracker::dzRes_nbin
private
double MTVHistoProducerAlgoForTracker::dzRes_rangeMax
private
double MTVHistoProducerAlgoForTracker::dzRes_rangeMin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dzres_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::dzres_vs_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::etares_vs_eta
private
std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::generalGpSelector
private

Definition at line 147 of file MTVHistoProducerAlgoForTracker.h.

Referenced by MTVHistoProducerAlgoForTracker().

std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::generalTpSelector
private

Definition at line 136 of file MTVHistoProducerAlgoForTracker.h.

Referenced by MTVHistoProducerAlgoForTracker().

std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsEta
private
std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsPhi
private
std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsPt
private
std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsVTXR
private
std::unique_ptr<GenParticleCustomSelector> MTVHistoProducerAlgoForTracker::GpSelectorForEfficiencyVsVTXZ
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_algo
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc23Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_dzpvsigcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_itpu_eta
private

Definition at line 215 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_itpu_sig_eta
private

Definition at line 215 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_itpu_sig_vertcount
private

Definition at line 216 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_itpu_vertcount
private

Definition at line 216 of file MTVHistoProducerAlgoForTracker.h.

std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc2_mva
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc2_mva_hp
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc2_mvacut
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc2_mvacut_hp
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_eta
private

Definition at line 217 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_ootpu_vertcount
private

Definition at line 217 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_seedingLayerSet
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2_simpvz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2chi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2dzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2eta_sig
private

Definition at line 215 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2hit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2layer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2phi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2pixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2pT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2pu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2vertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc2zpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc_dzpvsigcut_pt
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc_mvacut
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_assoc_mvacut_hp
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoc_simpvz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocdzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoceta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocFraction
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assochi2
private

Definition at line 271 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assochi2_prob
private

Definition at line 271 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assochit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoclayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocphi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocpixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocpT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocpu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocSharedHit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assocvertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_assoczpos
private
MonitorElement * MTVHistoProducerAlgoForTracker::h_bunchxSIM
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_charge
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_con_eta
private

Definition at line 219 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_con_vertcount
private

Definition at line 219 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_con_zpos
private

Definition at line 219 of file MTVHistoProducerAlgoForTracker.h.

std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_dedx_estim
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_dedx_nom
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_dedx_sat
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_eta
private
MonitorElement * MTVHistoProducerAlgoForTracker::h_etaSIM
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_fakes
private

Definition at line 194 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookRecoHistos(), and fill_trackBased_histos().

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_hits
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looper3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looper_seedingLayerSet
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperchi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperdzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_loopereta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperhit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperphi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperpixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperpT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperpu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_loopervertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_looperzpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_losthits
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misid3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidchi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misiddzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misideta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidhit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidphi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidpixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidpT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_misidpu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_nchi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_nchi2_prob
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_nmisslayers_inner
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_nmisslayers_outer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_dzpvsigcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_seedingLayerSet
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileup_simpvz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupchi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupdzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupeta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileuphit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileuplayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupphi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileuppixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileuppT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileuppu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupvertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pileupzpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_ptshifteta
private

Definition at line 264 of file MTVHistoProducerAlgoForTracker.h.

MonitorElement* MTVHistoProducerAlgoForTracker::h_ptSIM
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pullDxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pullDz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pullPhi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pullQoverp
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_pullTheta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco2eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco2pT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco2pu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_dzpvsigcut_pt
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_reco_mva
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_reco_mva_hp
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_reco_mvacut
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_reco_mvacut_hp
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_ootpu_eta
private

Definition at line 218 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_ootpu_vertcount
private

Definition at line 218 of file MTVHistoProducerAlgoForTracker.h.

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_seedingLayerSet
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_reco_simpvz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recochi2
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recodzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recoeta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recohit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recolayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recophi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recopixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recopT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recopu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recovertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_recozpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_seedsFitFailed
private

Definition at line 194 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookSeedHistos(), and fill_seed_histos().

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_seedsFitFailedFraction
private

Definition at line 194 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookSeedHistos(), and fill_seed_histos().

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul2_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul2_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul2_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul2_dzpvsigcut_pt
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_simul2_mvacut
private
std::vector<std::vector<MonitorElement*> > MTVHistoProducerAlgoForTracker::h_simul2_mvacut_hp
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul3Dlayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul_dzpvcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul_dzpvcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul_dzpvsigcut
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul_dzpvsigcut_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simul_simpvz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldr
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldxy
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldxypv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldxypvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldz
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldzpv
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuldzpvzoomed
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simuleta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulhit
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simullayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulphi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulpixellayer
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulpT
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulpu
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulvertpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_simulzpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::h_tracks
private

Definition at line 194 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookRecoHistos(), and fill_trackBased_histos().

MonitorElement * MTVHistoProducerAlgoForTracker::h_tracksSIM
private

Definition at line 191 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookSimHistos(), and fill_simTrackBased_histos().

MonitorElement * MTVHistoProducerAlgoForTracker::h_vertposSIM
private
double MTVHistoProducerAlgoForTracker::maxChi2
private
double MTVHistoProducerAlgoForTracker::maxDeDx
private
double MTVHistoProducerAlgoForTracker::maxdr
private
double MTVHistoProducerAlgoForTracker::maxDxy
private
double MTVHistoProducerAlgoForTracker::maxDz
private
double MTVHistoProducerAlgoForTracker::maxDzpvCum
private
double MTVHistoProducerAlgoForTracker::maxDzpvsigCum
private
double MTVHistoProducerAlgoForTracker::maxEta
private
double MTVHistoProducerAlgoForTracker::maxHit
private
double MTVHistoProducerAlgoForTracker::maxLayers
private
double MTVHistoProducerAlgoForTracker::maxMVA
private
double MTVHistoProducerAlgoForTracker::maxPhi
private
double MTVHistoProducerAlgoForTracker::maxPt
private
double MTVHistoProducerAlgoForTracker::maxPu
private
double MTVHistoProducerAlgoForTracker::maxPVz
private
double MTVHistoProducerAlgoForTracker::maxTracks
private
double MTVHistoProducerAlgoForTracker::maxVertcount
private

Definition at line 168 of file MTVHistoProducerAlgoForTracker.h.

Referenced by MTVHistoProducerAlgoForTracker().

double MTVHistoProducerAlgoForTracker::maxVertpos
private
double MTVHistoProducerAlgoForTracker::maxZpos
private
double MTVHistoProducerAlgoForTracker::minChi2
private

Definition at line 166 of file MTVHistoProducerAlgoForTracker.h.

double MTVHistoProducerAlgoForTracker::minDeDx
private
double MTVHistoProducerAlgoForTracker::mindr
private
double MTVHistoProducerAlgoForTracker::minDxy
private
double MTVHistoProducerAlgoForTracker::minDz
private
double MTVHistoProducerAlgoForTracker::minEta
private
double MTVHistoProducerAlgoForTracker::minHit
private
double MTVHistoProducerAlgoForTracker::minLayers
private
double MTVHistoProducerAlgoForTracker::minMVA
private
double MTVHistoProducerAlgoForTracker::minPhi
private
double MTVHistoProducerAlgoForTracker::minPt
private
double MTVHistoProducerAlgoForTracker::minPu
private
double MTVHistoProducerAlgoForTracker::minPVz
private
double MTVHistoProducerAlgoForTracker::minTracks
private
double MTVHistoProducerAlgoForTracker::minVertcount
private

Definition at line 168 of file MTVHistoProducerAlgoForTracker.h.

Referenced by MTVHistoProducerAlgoForTracker().

double MTVHistoProducerAlgoForTracker::minVertpos
private
double MTVHistoProducerAlgoForTracker::minZpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nhits_vs_phi
private
int MTVHistoProducerAlgoForTracker::nintChi2
private
int MTVHistoProducerAlgoForTracker::nintDeDx
private
int MTVHistoProducerAlgoForTracker::nintdr
private
int MTVHistoProducerAlgoForTracker::nintDxy
private
int MTVHistoProducerAlgoForTracker::nintDz
private
int MTVHistoProducerAlgoForTracker::nintDzpvCum
private
int MTVHistoProducerAlgoForTracker::nintDzpvsigCum
private
int MTVHistoProducerAlgoForTracker::nintEta
private
int MTVHistoProducerAlgoForTracker::nintHit
private
int MTVHistoProducerAlgoForTracker::nintLayers
private
int MTVHistoProducerAlgoForTracker::nintMVA
private
int MTVHistoProducerAlgoForTracker::nintPhi
private
int MTVHistoProducerAlgoForTracker::nintPt
private
int MTVHistoProducerAlgoForTracker::nintPu
private
int MTVHistoProducerAlgoForTracker::nintPVz
private
int MTVHistoProducerAlgoForTracker::nintTracks
private
int MTVHistoProducerAlgoForTracker::nintVertcount
private

Definition at line 168 of file MTVHistoProducerAlgoForTracker.h.

Referenced by MTVHistoProducerAlgoForTracker().

int MTVHistoProducerAlgoForTracker::nintVertpos
private
int MTVHistoProducerAlgoForTracker::nintZpos
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nLayersWithMeas_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nlosthits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nPXBhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nPXFhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nPXLhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nPXLlayersWithMeas_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nrec_vs_nsim
private

Definition at line 242 of file MTVHistoProducerAlgoForTracker.h.

Referenced by bookRecoHistos(), and fill_trackBased_histos().

std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nrecHit_vs_nsimHit_rec2sim
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nrecHit_vs_nsimHit_sim2rec
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nSTRIPhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nSTRIPlayersWith1dMeas_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nSTRIPlayersWith2dMeas_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nSTRIPlayersWithMeas_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nTEChits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nTIBhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nTIDhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::nTOBhits_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phimean_vs_eta_phi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phipull_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phipull_vs_phi
private
int MTVHistoProducerAlgoForTracker::phiRes_nbin
private
double MTVHistoProducerAlgoForTracker::phiRes_rangeMax
private
double MTVHistoProducerAlgoForTracker::phiRes_rangeMin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phires_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phires_vs_phi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::phires_vs_pt
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptmean_vs_eta_phi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptpull_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptpull_vs_phi
private
int MTVHistoProducerAlgoForTracker::ptRes_nbin
private
double MTVHistoProducerAlgoForTracker::ptRes_rangeMax
private
double MTVHistoProducerAlgoForTracker::ptRes_rangeMin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptres_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptres_vs_phi
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::ptres_vs_pt
private
std::vector<std::string> MTVHistoProducerAlgoForTracker::seedingLayerSetNames
private
std::map<SeedingLayerSetId, unsigned int> MTVHistoProducerAlgoForTracker::seedingLayerSetToBin
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::thetapull_vs_eta
private
std::vector<MonitorElement*> MTVHistoProducerAlgoForTracker::thetapull_vs_phi
private
std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsEta
private
std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsPhi
private
std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsPt
private
std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsVTXR
private
std::unique_ptr<TrackingParticleSelector> MTVHistoProducerAlgoForTracker::TpSelectorForEfficiencyVsVTXZ
private
std::unique_ptr<RecoTrackSelectorBase> MTVHistoProducerAlgoForTracker::trackSelectorVsEta
private
std::unique_ptr<RecoTrackSelectorBase> MTVHistoProducerAlgoForTracker::trackSelectorVsPhi
private
std::unique_ptr<RecoTrackSelectorBase> MTVHistoProducerAlgoForTracker::trackSelectorVsPt
private
bool MTVHistoProducerAlgoForTracker::useFabsEta
private

Definition at line 154 of file MTVHistoProducerAlgoForTracker.h.

Referenced by getEta(), and MTVHistoProducerAlgoForTracker().

bool MTVHistoProducerAlgoForTracker::useInvPt
private

Definition at line 155 of file MTVHistoProducerAlgoForTracker.h.

Referenced by getPt(), and MTVHistoProducerAlgoForTracker().

bool MTVHistoProducerAlgoForTracker::useLogPt
private