CMS 3D CMS Logo
List of all members | Public Member Functions | Private Attributes
MuonTrackValidator Class Reference

#include <MuonTrackValidator.h>

Inheritance diagram for MuonTrackValidator:
DQMEDAnalyzer MuonTrackValidatorBase edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Public Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 Method called before the event loop. More...
 
void bookHistograms (DQMEDAnalyzer::DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 Method called at the end of the event loop. More...
 
 MuonTrackValidator (const edm::ParameterSet &pset)
 Constructor. More...
 
 ~MuonTrackValidator () override
 Destructor. More...
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
void endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

Private Attributes

edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > _simHitTpMapTag
 
edm::InputTag associatormap
 
bool BiDirectional_RecoToSim_association
 
CosmicTrackingParticleSelector cosmictpSelector
 
std::string dirName_
 
bool MABH
 
edm::EDGetTokenT< reco::RecoToSimCollection > recoToSimCollection_Token
 
edm::EDGetTokenT< reco::SimToRecoCollection > simToRecoCollection_Token
 
TrackingParticleSelector tpSelector
 
bool UseAssociators
 
bool useGEMs_
 
bool useME0_
 

Additional Inherited Members

- Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache RunSummaryCache
 
- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCache > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 
- Protected Member Functions inherited from MuonTrackValidatorBase
void BinLogX (TH1 *h)
 
void doProfileX (MonitorElement *th2m, MonitorElement *me)
 
void doProfileX (TH2 *th2, MonitorElement *me)
 
template<typename T >
void fillPlotNoFlow (MonitorElement *h, T val)
 
double getEta (double eta)
 
double getPt (double pt)
 
 MuonTrackValidatorBase (const edm::ParameterSet &pset)
 
 MuonTrackValidatorBase (const edm::ParameterSet &pset, edm::ConsumesCollector iC)
 Constructor. More...
 
virtual ~MuonTrackValidatorBase () noexcept(false)
 Destructor. More...
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::EDPutTokenT< DQMToken > runToken_
 
unsigned int streamId_
 
- Protected Attributes inherited from MuonTrackValidatorBase
std::vector< std::string > associators
 
edm::InputTag bsSrc
 
edm::EDGetTokenT< reco::BeamSpot > bsSrc_Token
 
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
 
bool do_MUOhitsPlots
 
bool do_TRKhitsPlots
 
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
 
int etaRes_nbin
 
double etaRes_rangeMax
 
double etaRes_rangeMin
 
std::vector< MonitorElement * > etares_vs_eta
 
std::vector< MonitorElement * > h_assoc2dxy
 
std::vector< MonitorElement * > h_assoc2dz
 
std::vector< MonitorElement * > h_assoc2eta
 
std::vector< MonitorElement * > h_assoc2hit
 
std::vector< MonitorElement * > h_assoc2phi
 
std::vector< MonitorElement * > h_assoc2pT
 
std::vector< MonitorElement * > h_assoc2pu
 
std::vector< MonitorElement * > h_assocdxy
 
std::vector< MonitorElement * > h_assocdz
 
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_assocphi
 
std::vector< MonitorElement * > h_assocpT
 
std::vector< MonitorElement * > h_assocpu
 
std::vector< MonitorElement * > h_assocRpos
 
std::vector< MonitorElement * > h_assocSharedHit
 
std::vector< MonitorElement * > h_assocZpos
 
std::vector< MonitorElement * > h_charge
 
std::vector< MonitorElement * > h_dxypull
 
std::vector< MonitorElement * > h_dxypulleta
 
std::vector< MonitorElement * > h_dzpull
 
std::vector< MonitorElement * > h_dzpulleta
 
std::vector< MonitorElement * > h_etaRes
 
std::vector< MonitorElement * > h_fakes
 
std::vector< MonitorElement * > h_losthits
 
std::vector< MonitorElement * > h_misiddxy
 
std::vector< MonitorElement * > h_misiddz
 
std::vector< MonitorElement * > h_misideta
 
std::vector< MonitorElement * > h_misidhit
 
std::vector< MonitorElement * > h_misidphi
 
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_nhits
 
std::vector< MonitorElement * > h_nlosthits
 
std::vector< MonitorElement * > h_nmisslayers_inner
 
std::vector< MonitorElement * > h_nmisslayers_outer
 
std::vector< MonitorElement * > h_phipull
 
std::vector< MonitorElement * > h_phipulleta
 
std::vector< MonitorElement * > h_phipullphi
 
std::vector< MonitorElement * > h_ptpull
 
std::vector< MonitorElement * > h_ptpulleta
 
std::vector< MonitorElement * > h_ptpullphi
 
std::vector< MonitorElement * > h_PurityVsQuality
 
std::vector< MonitorElement * > h_qoverppull
 
std::vector< MonitorElement * > h_recodxy
 
std::vector< MonitorElement * > h_recodz
 
std::vector< MonitorElement * > h_recoeta
 
std::vector< MonitorElement * > h_recohit
 
std::vector< MonitorElement * > h_recophi
 
std::vector< MonitorElement * > h_recopT
 
std::vector< MonitorElement * > h_recopu
 
std::vector< MonitorElement * > h_simuldxy
 
std::vector< MonitorElement * > h_simuldz
 
std::vector< MonitorElement * > h_simuleta
 
std::vector< MonitorElement * > h_simulhit
 
std::vector< MonitorElement * > h_simulphi
 
std::vector< MonitorElement * > h_simulpT
 
std::vector< MonitorElement * > h_simulpu
 
std::vector< MonitorElement * > h_simulRpos
 
std::vector< MonitorElement * > h_simulZpos
 
std::vector< MonitorElement * > h_thetapull
 
std::vector< MonitorElement * > h_thetapulleta
 
std::vector< MonitorElement * > h_thetapullphi
 
std::vector< MonitorElement * > h_tracks
 
bool ignoremissingtkcollection_
 
std::vector< edm::InputTag > label
 
edm::InputTag label_pileupinfo
 
edm::InputTag label_tp_effic
 
edm::InputTag label_tp_fake
 
double maxCSCHit
 
double maxDTHit
 
double maxDxy
 
double maxDz
 
double maxEta
 
double maxLayers
 
double maxNHit
 
double maxPhi
 
double maxPixels
 
double maxPt
 
double maxPU
 
double maxRPCHit
 
double maxRpos
 
double maxZpos
 
double minCSCHit
 
double minDTHit
 
double minDxy
 
double minDz
 
double minEta
 
double minLayers
 
double minNHit
 
double minPhi
 
double minPixels
 
double minPt
 
double minPU
 
double minRPCHit
 
double minRpos
 
double minZpos
 
edm::ParameterSet muonHistoParameters
 
std::vector< MonitorElement * > nCSChits_vs_eta
 
std::vector< MonitorElement * > nDThits_vs_eta
 
std::vector< MonitorElement * > nGEMhits_vs_eta
 
std::vector< MonitorElement * > nhits_vs_eta
 
std::vector< MonitorElement * > nhits_vs_phi
 
int nintCSCHit
 
int nintDTHit
 
int nintDxy
 
int nintDz
 
int nintEta
 
int nintLayers
 
int nintNHit
 
int nintPhi
 
int nintPixels
 
int nintPt
 
int nintPU
 
int nintRPCHit
 
int nintRpos
 
int nintZpos
 
std::vector< MonitorElement * > nlosthits_vs_eta
 
std::vector< MonitorElement * > nME0hits_vs_eta
 
std::vector< MonitorElement * > nPixel_LayersWithMeas_vs_eta
 
std::vector< MonitorElement * > nRecHits_vs_nSimHits
 
std::vector< MonitorElement * > nRPChits_vs_eta
 
std::vector< MonitorElement * > nTRK_LayersWithMeas_vs_eta
 
std::string out
 
std::string parametersDefiner
 
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
 
edm::EDGetTokenT< std::vector< PileupSummaryInfo > > pileupinfo_Token
 
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
 
edm::ESHandle< MagneticField > theMF
 
std::vector< MonitorElement * > thetaCotres_vs_eta
 
std::vector< MonitorElement * > thetaCotres_vs_pt
 
std::vector< MonitorElement * > thetapull_vs_eta
 
std::vector< MonitorElement * > thetapull_vs_phi
 
edm::EDGetTokenT< TrackingParticleCollection > tp_effic_Token
 
edm::EDGetTokenT< TrackingParticleCollection > tp_fake_Token
 
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > track_Collection_Token
 
bool useFabsEta
 
bool useInvPt
 
bool useLogPt
 
bool usemuon
 
bool usetracker
 

Detailed Description

Class that produces histograms to validate Muon Track Reconstruction performances

Definition at line 17 of file MuonTrackValidator.h.

Constructor & Destructor Documentation

◆ MuonTrackValidator()

MuonTrackValidator::MuonTrackValidator ( const edm::ParameterSet &  pset)
inline

Constructor.

Definition at line 20 of file MuonTrackValidator.h.

20  : MuonTrackValidatorBase(pset) {
21  dirName_ = pset.getParameter<std::string>("dirName");
22  associatormap = pset.getParameter<edm::InputTag>("associatormap");
23  UseAssociators = pset.getParameter<bool>("UseAssociators");
24  useGEMs_ = pset.getParameter<bool>("useGEMs");
25  useME0_ = pset.getParameter<bool>("useME0");
26  edm::ParameterSet tpset = pset.getParameter<edm::ParameterSet>("muonTPSelector");
27  tpSelector = TrackingParticleSelector(tpset.getParameter<double>("ptMin"),
28  tpset.getParameter<double>("ptMax"),
29  tpset.getParameter<double>("minRapidity"),
30  tpset.getParameter<double>("maxRapidity"),
31  tpset.getParameter<double>("tip"),
32  tpset.getParameter<double>("lip"),
33  tpset.getParameter<int>("minHit"),
34  tpset.getParameter<bool>("signalOnly"),
35  tpset.getParameter<bool>("intimeOnly"),
36  tpset.getParameter<bool>("chargedOnly"),
37  tpset.getParameter<bool>("stableOnly"),
38  tpset.getParameter<std::vector<int> >("pdgId"));
39 
40  cosmictpSelector = CosmicTrackingParticleSelector(tpset.getParameter<double>("ptMin"),
41  tpset.getParameter<double>("minRapidity"),
42  tpset.getParameter<double>("maxRapidity"),
43  tpset.getParameter<double>("tip"),
44  tpset.getParameter<double>("lip"),
45  tpset.getParameter<int>("minHit"),
46  tpset.getParameter<bool>("chargedOnly"),
47  tpset.getParameter<std::vector<int> >("pdgId"));
48 
49  BiDirectional_RecoToSim_association = pset.getParameter<bool>("BiDirectional_RecoToSim_association");
50 
51  // dump cfg parameters
52  edm::LogVerbatim("MuonTrackValidator") << "constructing MuonTrackValidator: " << pset.dump();
53 
54  // Declare consumes (also for the base class)
55  bsSrc_Token = consumes<reco::BeamSpot>(bsSrc);
56  tp_effic_Token = consumes<TrackingParticleCollection>(label_tp_effic);
57  tp_fake_Token = consumes<TrackingParticleCollection>(label_tp_fake);
58  pileupinfo_Token = consumes<std::vector<PileupSummaryInfo> >(label_pileupinfo);
59  for (unsigned int www = 0; www < label.size(); www++) {
60  track_Collection_Token.push_back(consumes<edm::View<reco::Track> >(label[www]));
61  }
62  simToRecoCollection_Token = consumes<reco::SimToRecoCollection>(associatormap);
63  recoToSimCollection_Token = consumes<reco::RecoToSimCollection>(associatormap);
64 
65  _simHitTpMapTag = mayConsume<SimHitTPAssociationProducer::SimHitTPAssociationList>(
66  pset.getParameter<edm::InputTag>("simHitTpMapTag"));
67 
68  MABH = false;
69  if (!UseAssociators) {
70  // flag MuonAssociatorByHits
71  if (associators[0] == "MuonAssociationByHits")
72  MABH = true;
73  // reset string associators to the map label
74  associators.clear();
75  associators.push_back(associatormap.label());
76  edm::LogVerbatim("MuonTrackValidator") << "--> associators reset to: " << associators[0];
77  } else {
78  for (auto const& associator : associators) {
79  consumes<reco::TrackToTrackingParticleAssociator>(edm::InputTag(associator));
80  }
81  }
82 
83  // inform on which SimHits will be counted
84  if (usetracker)
85  edm::LogVerbatim("MuonTrackValidator") << "\n usetracker = TRUE : Tracker SimHits WILL be counted";
86  else
87  edm::LogVerbatim("MuonTrackValidator") << "\n usetracker = FALSE : Tracker SimHits WILL NOT be counted";
88  if (usemuon)
89  edm::LogVerbatim("MuonTrackValidator") << " usemuon = TRUE : Muon SimHits WILL be counted";
90  else
91  edm::LogVerbatim("MuonTrackValidator") << " usemuon = FALSE : Muon SimHits WILL NOT be counted" << std::endl;
92 
93  // loop over the reco::Track collections to validate: check for inconsistent input settings
94  for (unsigned int www = 0; www < label.size(); www++) {
95  std::string recoTracksLabel = label[www].label();
96  std::string recoTracksInstance = label[www].instance();
97 
98  // tracks with hits only on tracker
99  if (recoTracksLabel == "generalTracks" || (recoTracksLabel.find("cutsRecoTracks") != std::string::npos) ||
100  recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || recoTracksLabel == "hltL3TkTracksFromL2" ||
101  (recoTracksLabel == "hltL3Muons" && recoTracksInstance == "L2Seeded")) {
102  if (usemuon) {
103  edm::LogWarning("MuonTrackValidator")
104  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == true"
105  << "\n ---> please change to usemuon == false ";
106  }
107  if (!usetracker) {
108  edm::LogWarning("MuonTrackValidator")
109  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == false"
110  << "\n ---> please change to usetracker == true ";
111  }
112  }
113 
114  // tracks with hits only on muon detectors
115  else if (recoTracksLabel == "standAloneMuons" || recoTracksLabel == "standAloneSETMuons" ||
116  recoTracksLabel == "cosmicMuons" || recoTracksLabel == "hltL2Muons") {
117  if (usetracker) {
118  edm::LogWarning("MuonTrackValidator")
119  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == true"
120  << "\n ---> please change to usetracker == false ";
121  }
122  if (!usemuon) {
123  edm::LogWarning("MuonTrackValidator")
124  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == false"
125  << "\n ---> please change to usemuon == true ";
126  }
127  }
128 
129  } // for (unsigned int www=0;www<label.size();www++)
130  }

References _simHitTpMapTag, ctfWithMaterialTrackMCMatch_cfi::associator, associatormap, MuonTrackValidatorBase::associators, BiDirectional_RecoToSim_association, MuonTrackValidatorBase::bsSrc, MuonTrackValidatorBase::bsSrc_Token, cosmictpSelector, dirName_, edm::InputTag::label(), MuonTrackValidatorBase::label, MuonTrackValidatorBase::label_pileupinfo, MuonTrackValidatorBase::label_tp_effic, MuonTrackValidatorBase::label_tp_fake, MABH, MuonTrackValidatorBase::pileupinfo_Token, muonDTDigis_cfi::pset, recoToSimCollection_Token, simToRecoCollection_Token, AlCaHLTBitMon_QueryRunRegistry::string, MuonTrackValidatorBase::tp_effic_Token, MuonTrackValidatorBase::tp_fake_Token, tpSelector, MuonTrackValidatorBase::track_Collection_Token, UseAssociators, useGEMs_, useME0_, MuonTrackValidatorBase::usemuon, and MuonTrackValidatorBase::usetracker.

◆ ~MuonTrackValidator()

MuonTrackValidator::~MuonTrackValidator ( )
inlineoverride

Destructor.

Definition at line 133 of file MuonTrackValidator.h.

133 {}

Member Function Documentation

◆ analyze()

void MuonTrackValidator::analyze ( const edm::Event &  event,
const edm::EventSetup &  setup 
)
overridevirtual

Method called before the event loop.

Method called once per event

Reimplemented from DQMEDAnalyzer.

Definition at line 358 of file MuonTrackValidator.cc.

358  {
359  using namespace reco;
360 
361  edm::LogInfo("MuonTrackValidator") << "\n===================================================="
362  << "\n"
363  << "Analyzing new event"
364  << "\n"
365  << "====================================================\n"
366  << "\n";
367 
368  edm::Handle<std::vector<PileupSummaryInfo> > puinfoH;
369  int PU_NumInteractions(-1);
370 
371  edm::ESHandle<ParametersDefinerForTP> Lhc_parametersDefinerTP;
372  std::unique_ptr<ParametersDefinerForTP> Cosmic_parametersDefinerTP;
373 
374  if (parametersDefiner == "LhcParametersDefinerForTP") {
375  setup.get<TrackAssociatorRecord>().get(parametersDefiner, Lhc_parametersDefinerTP);
376 
377  // PileupSummaryInfo is contained only in collision events
378  event.getByToken(pileupinfo_Token, puinfoH);
379  for (std::vector<PileupSummaryInfo>::const_iterator puInfoIt = puinfoH->begin(); puInfoIt != puinfoH->end();
380  ++puInfoIt) {
381  if (puInfoIt->getBunchCrossing() == 0) {
382  PU_NumInteractions = puInfoIt->getPU_NumInteractions();
383  break;
384  }
385  }
386 
387  } else if (parametersDefiner == "CosmicParametersDefinerForTP") {
388  edm::ESHandle<CosmicParametersDefinerForTP> _Cosmic_parametersDefinerTP;
389  setup.get<TrackAssociatorRecord>().get(parametersDefiner, _Cosmic_parametersDefinerTP);
390 
391  //Since we modify the object, we must clone it
392  Cosmic_parametersDefinerTP = _Cosmic_parametersDefinerTP->clone();
393 
394  edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
395  //warning: make sure the TP collection used in the map is the same used here
396  event.getByToken(_simHitTpMapTag, simHitsTPAssoc);
397  Cosmic_parametersDefinerTP->initEvent(simHitsTPAssoc);
398  cosmictpSelector.initEvent(simHitsTPAssoc);
399  } else {
400  edm::LogError("MuonTrackValidator") << "Unexpected label: parametersDefiner = " << parametersDefiner.c_str()
401  << "\n";
402  }
403 
404  edm::Handle<TrackingParticleCollection> TPCollectionHeff;
405  event.getByToken(tp_effic_Token, TPCollectionHeff);
406  TrackingParticleCollection const& tPCeff = *(TPCollectionHeff.product());
407 
408  edm::Handle<TrackingParticleCollection> TPCollectionHfake;
409  event.getByToken(tp_fake_Token, TPCollectionHfake);
410 
411  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
412  event.getByToken(bsSrc_Token, recoBeamSpotHandle);
413  reco::BeamSpot bs = *recoBeamSpotHandle;
414 
415  std::vector<const reco::TrackToTrackingParticleAssociator*> associator;
416  if (UseAssociators) {
417  edm::Handle<reco::TrackToTrackingParticleAssociator> theAssociator;
418  for (auto const& associatorName : associators) {
419  event.getByLabel(associatorName, theAssociator);
420  associator.push_back(theAssociator.product());
421  }
422  }
423 
424  int w = 0;
425  for (unsigned int ww = 0; ww < associators.size(); ww++) {
426  for (unsigned int www = 0; www < label.size(); www++) {
427  //
428  //get collections from the event
429  //
430  edm::Handle<edm::View<Track> > trackCollection;
431  unsigned int trackCollectionSize = 0;
432 
433  reco::RecoToSimCollection recSimColl;
434  reco::SimToRecoCollection simRecColl;
435 
436  // account for missing track collections (HLT case)
437  if (!event.getByToken(track_Collection_Token[www], trackCollection) && ignoremissingtkcollection_) {
438  recSimColl.post_insert();
439  simRecColl.post_insert();
440  }
441 
442  //associate tracks to TrackingParticles
443  else {
444  trackCollectionSize = trackCollection->size();
445 
446  if (UseAssociators) {
447  edm::LogVerbatim("MuonTrackValidator")
448  << "Analyzing " << label[www].process() << ":" << label[www].label() << ":" << label[www].instance()
449  << " with " << associators[ww].c_str() << "\n";
450 
451  LogTrace("MuonTrackValidator") << "Calling associateRecoToSim method"
452  << "\n";
453  recSimColl = associator[ww]->associateRecoToSim(trackCollection, TPCollectionHfake);
454  LogTrace("MuonTrackValidator") << "Calling associateSimToReco method"
455  << "\n";
456  simRecColl = associator[ww]->associateSimToReco(trackCollection, TPCollectionHeff);
457  } else {
458  edm::LogVerbatim("MuonTrackValidator")
459  << "Analyzing " << label[www].process() << ":" << label[www].label() << ":" << label[www].instance()
460  << " with " << associatormap.process() << ":" << associatormap.label() << ":" << associatormap.instance()
461  << "\n";
462 
463  Handle<reco::SimToRecoCollection> simtorecoCollectionH;
464  event.getByToken(simToRecoCollection_Token, simtorecoCollectionH);
465  simRecColl = *simtorecoCollectionH.product();
466 
467  Handle<reco::RecoToSimCollection> recotosimCollectionH;
468  event.getByToken(recoToSimCollection_Token, recotosimCollectionH);
469  recSimColl = *recotosimCollectionH.product();
470  }
471  }
472 
473  //
474  //fill simulation histograms
475  //
476  edm::LogVerbatim("MuonTrackValidator") << "\n# of TrackingParticles: " << tPCeff.size() << "\n";
477  int ats = 0;
478  int st = 0;
479  for (TrackingParticleCollection::size_type i = 0; i < tPCeff.size(); i++) {
480  bool TP_is_matched = false;
481  bool isChargeOK = true;
482  double quality = 0.;
483 
484  TrackingParticleRef tpr(TPCollectionHeff, i);
485  TrackingParticle* tp = const_cast<TrackingParticle*>(tpr.get());
486 
487  TrackingParticle::Vector momentumTP;
488  TrackingParticle::Point vertexTP;
489  double dxySim = 0;
490  double dzSim = 0;
491 
492  //If the TrackingParticle is collision-like, get the momentum and vertex at production state
493  //and the impact parameters w.r.t. PCA
494  if (parametersDefiner == "LhcParametersDefinerForTP") {
495  LogTrace("MuonTrackValidator") << "TrackingParticle " << i;
496  if (!tpSelector(*tp))
497  continue;
498  momentumTP = tp->momentum();
499  vertexTP = tp->vertex();
500  TrackingParticle::Vector momentum = Lhc_parametersDefinerTP->momentum(event, setup, tpr);
501  TrackingParticle::Point vertex = Lhc_parametersDefinerTP->vertex(event, setup, tpr);
502  dxySim = TrackingParticleIP::dxy(vertex, momentum, bs.position());
503  dzSim = TrackingParticleIP::dz(vertex, momentum, bs.position());
504  }
505  //for cosmics get the momentum and vertex at PCA
506  else if (parametersDefiner == "CosmicParametersDefinerForTP") {
507  edm::LogVerbatim("MuonTrackValidator") << "TrackingParticle " << i;
508  if (!cosmictpSelector(tpr, &bs, event, setup))
509  continue;
510  momentumTP = Cosmic_parametersDefinerTP->momentum(event, setup, tpr);
511  vertexTP = Cosmic_parametersDefinerTP->vertex(event, setup, tpr);
512  dxySim = TrackingParticleIP::dxy(vertexTP, momentumTP, bs.position());
513  dzSim = TrackingParticleIP::dz(vertexTP, momentumTP, bs.position());
514  }
515  edm::LogVerbatim("MuonTrackValidator") << "--------------------Selected TrackingParticle #" << tpr.key();
516  edm::LogVerbatim("MuonTrackValidator")
517  << "momentumTP: pt = " << sqrt(momentumTP.perp2()) << ", pz = " << momentumTP.z()
518  << ", \t vertexTP: radius = " << sqrt(vertexTP.perp2()) << ", z = " << vertexTP.z() << "\n";
519  st++;
520 
521  double TPeta = momentumTP.eta();
522  double xTPeta = getEta(TPeta); // may be |eta| in histos according to useFabsEta
523  double TPpt = sqrt(momentumTP.perp2());
524  double xTPpt = getPt(TPpt); // may be 1/pt in histos according to useInvPt
525  double TPphi = momentumTP.phi();
526  double TPrpos = sqrt(vertexTP.perp2());
527  double TPzpos = vertexTP.z();
528 
529  // Number of counted SimHits depend on the selection of tracker and muon detectors (via cfg parameters)
530  int nSimHits = 0;
531  if (usetracker && usemuon) {
532  nSimHits = tpr.get()->numberOfHits();
533  } else if (!usetracker && usemuon) {
534  nSimHits = tpr.get()->numberOfHits() - tpr.get()->numberOfTrackerHits();
535  } else if (usetracker && !usemuon) {
536  nSimHits = tpr.get()->numberOfTrackerHits();
537  }
538  edm::LogVerbatim("MuonTrackValidator") << "\t N simhits = " << nSimHits << "\n";
539 
540  int assoc_recoTrack_NValidHits = 0;
541  if (simRecColl.find(tpr) != simRecColl.end()) {
542  auto const& rt = simRecColl[tpr];
543  if (!rt.empty()) {
544  RefToBase<Track> assoc_recoTrack = rt.begin()->first;
545  edm::LogVerbatim("MuonTrackValidator")
546  << "-----------------------------associated Track #" << assoc_recoTrack.key();
547  TP_is_matched = true;
548  ats++;
549  if (assoc_recoTrack->charge() != tpr->charge())
550  isChargeOK = false;
551  quality = rt.begin()->second;
552  assoc_recoTrack_NValidHits = assoc_recoTrack->numberOfValidHits();
553  edm::LogVerbatim("MuonTrackValidator")
554  << "TrackingParticle #" << tpr.key() << " with pt=" << sqrt(momentumTP.perp2())
555  << " associated with quality:" << quality << "\n";
556  }
557  } else {
558  edm::LogVerbatim("MuonTrackValidator")
559  << "TrackingParticle #" << tpr.key() << " with pt,eta,phi: " << sqrt(momentumTP.perp2()) << " , "
560  << momentumTP.eta() << " , " << momentumTP.phi() << " , "
561  << " NOT associated to any reco::Track"
562  << "\n";
563  }
564 
565  // histos for efficiency vs eta
566 
567  fillPlotNoFlow(h_simuleta[w], xTPeta);
568  if (TP_is_matched) {
569  fillPlotNoFlow(h_assoceta[w], xTPeta);
570  if (!isChargeOK)
571  fillPlotNoFlow(h_misideta[w], xTPeta);
572  }
573 
574  // histos for efficiency vs phi
575  fillPlotNoFlow(h_simulphi[w], TPphi);
576  if (TP_is_matched) {
577  fillPlotNoFlow(h_assocphi[w], TPphi);
578  if (!isChargeOK)
579  fillPlotNoFlow(h_misidphi[w], TPphi);
580  }
581 
582  // histos for efficiency vs pT
583  fillPlotNoFlow(h_simulpT[w], xTPpt);
584  if (TP_is_matched) {
585  fillPlotNoFlow(h_assocpT[w], xTPpt);
586  if (!isChargeOK)
587  fillPlotNoFlow(h_misidpT[w], xTPpt);
588  }
589 
590  // histos for efficiency vs dxy
591  fillPlotNoFlow(h_simuldxy[w], dxySim);
592  if (TP_is_matched) {
593  fillPlotNoFlow(h_assocdxy[w], dxySim);
594  if (!isChargeOK)
595  fillPlotNoFlow(h_misiddxy[w], dxySim);
596  }
597 
598  // histos for efficiency vs dz
599  fillPlotNoFlow(h_simuldz[w], dzSim);
600  if (TP_is_matched) {
601  fillPlotNoFlow(h_assocdz[w], dzSim);
602  if (!isChargeOK)
603  fillPlotNoFlow(h_misiddz[w], dzSim);
604  }
605 
606  // histos for efficiency vs Radius
607  fillPlotNoFlow(h_simulRpos[w], TPrpos);
608  if (TP_is_matched)
609  fillPlotNoFlow(h_assocRpos[w], TPrpos);
610 
611  // histos for efficiency vs z position
612  fillPlotNoFlow(h_simulZpos[w], TPzpos);
613  if (TP_is_matched)
614  fillPlotNoFlow(h_assocZpos[w], TPzpos);
615 
616  // histos for efficiency vs Number of Hits
617  fillPlotNoFlow(h_simulhit[w], nSimHits);
618  if (TP_is_matched) {
619  fillPlotNoFlow(h_assochit[w], nSimHits);
620  nRecHits_vs_nSimHits[w]->Fill(nSimHits, assoc_recoTrack_NValidHits);
621 
622  // charge misid is more useful w.r.t. nRecHits (filled after)
623  //if (!isChargeOK) fillPlotNoFlow(h_misidhit[w], nSimHits);
624  }
625 
626  // histos for efficiency vs PileUp
627  fillPlotNoFlow(h_simulpu[w], PU_NumInteractions);
628  if (TP_is_matched) {
629  fillPlotNoFlow(h_assocpu[w], PU_NumInteractions);
630  if (!isChargeOK)
631  fillPlotNoFlow(h_misidpu[w], PU_NumInteractions);
632  }
633 
634  } // End for (TrackingParticleCollection::size_type i=0; i<tPCeff.size(); i++){
635 
636  //
637  //fill reconstructed track histograms
638  //
639  edm::LogVerbatim("MuonTrackValidator")
640  << "\n# of reco::Tracks with " << label[www].process() << ":" << label[www].label() << ":"
641  << label[www].instance() << ": " << trackCollectionSize << "\n";
642 
643  int at = 0;
644  int rT = 0;
645  for (edm::View<Track>::size_type i = 0; i < trackCollectionSize; ++i) {
646  bool Track_is_matched = false;
647  bool isChargeOK = true;
648  RefToBase<Track> track(trackCollection, i);
649  rT++;
650 
651  std::vector<std::pair<TrackingParticleRef, double> > tp;
652  TrackingParticleRef tpr;
653 
654  // new logic (bidirectional)
655  if (BiDirectional_RecoToSim_association) {
656  edm::LogVerbatim("MuonTrackValidator") << "----------------------------------------Track #" << track.key();
657 
658  if (recSimColl.find(track) != recSimColl.end()) {
659  tp = recSimColl[track];
660  if (!tp.empty()) {
661  tpr = tp.begin()->first;
662  // RtS and StR must associate the same pair !
663  if (simRecColl.find(tpr) != simRecColl.end()) {
664  auto const& assoc_track_checkback = simRecColl[tpr].begin()->first;
665 
666  if (assoc_track_checkback.key() == track.key()) {
667  edm::LogVerbatim("MuonTrackValidator")
668  << "------------------associated TrackingParticle #" << tpr.key();
669  Track_is_matched = true;
670  at++;
671  if (track->charge() != tpr->charge())
672  isChargeOK = false;
673  double Purity = tp.begin()->second;
674  double Quality = simRecColl[tpr].begin()->second;
675  edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt()
676  << " associated with purity:" << Purity << "\n";
677  if (MABH)
678  h_PurityVsQuality[w]->Fill(Quality, Purity);
679  }
680  }
681  }
682  }
683 
684  if (!Track_is_matched)
685  edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt()
686  << " NOT associated to any TrackingParticle"
687  << "\n";
688  }
689  // old logic, valid for cosmics 2-legs reco (bugged for collision scenario)
690  else {
691  if (recSimColl.find(track) != recSimColl.end()) {
692  tp = recSimColl[track];
693  if (!tp.empty()) {
694  tpr = tp.begin()->first;
695  Track_is_matched = true;
696  at++;
697  if (track->charge() != tpr->charge())
698  isChargeOK = false;
699  edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt()
700  << " associated with quality:" << tp.begin()->second << "\n";
701  }
702  } else {
703  edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt()
704  << " NOT associated to any TrackingParticle"
705  << "\n";
706  }
707  }
708 
709  //
710  int nRecHits = track->numberOfValidHits();
711  edm::LogVerbatim("MuonTrackValidator") << "\t N valid rechits = " << nRecHits << "\n";
712 
713  double etaRec = track->eta();
714  double xetaRec = getEta(etaRec);
715 
716  double ptRec = track->pt();
717  double xptRec = getPt(ptRec);
718 
719  double qoverpRec = track->qoverp();
720  double phiRec = track->phi();
721  double thetaRec = track->theta();
722  double dxyRec = track->dxy(bs.position());
723  double dzRec = track->dz(bs.position());
724 
725  double qoverpError = track->qoverpError();
726  double ptError = track->ptError();
727  double thetaError = track->thetaError();
728  double phiError = track->phiError();
729  double dxyError = track->dxyError();
730  double dzError = track->dzError();
731 
732  // histos for fake rate vs eta
733  fillPlotNoFlow(h_recoeta[w], xetaRec);
734  if (Track_is_matched) {
735  fillPlotNoFlow(h_assoc2eta[w], xetaRec);
736  }
737 
738  // histos for fake rate vs phi
739  fillPlotNoFlow(h_recophi[w], phiRec);
740  if (Track_is_matched) {
741  fillPlotNoFlow(h_assoc2phi[w], phiRec);
742  }
743 
744  // histos for fake rate vs pT
745  fillPlotNoFlow(h_recopT[w], xptRec);
746  if (Track_is_matched) {
747  fillPlotNoFlow(h_assoc2pT[w], xptRec);
748  }
749 
750  // histos for fake rate vs dxy
751  fillPlotNoFlow(h_recodxy[w], dxyRec);
752  if (Track_is_matched) {
753  fillPlotNoFlow(h_assoc2dxy[w], dxyRec);
754  }
755 
756  // histos for fake rate vs dz
757  fillPlotNoFlow(h_recodz[w], dzRec);
758  if (Track_is_matched) {
759  fillPlotNoFlow(h_assoc2dz[w], dzRec);
760  }
761 
762  // histos for fake rate vs Number of RecHits in track
763  fillPlotNoFlow(h_recohit[w], nRecHits);
764  if (Track_is_matched) {
765  fillPlotNoFlow(h_assoc2hit[w], nRecHits);
766  // charge misid w.r.t. nRecHits
767  if (!isChargeOK)
768  fillPlotNoFlow(h_misidhit[w], nRecHits);
769  }
770 
771  // histos for fake rate vs Number of PU interactions
772  fillPlotNoFlow(h_recopu[w], PU_NumInteractions);
773  if (Track_is_matched) {
774  fillPlotNoFlow(h_assoc2pu[w], PU_NumInteractions);
775  }
776 
777  // Fill other histos
778  TrackingParticle* tpp = const_cast<TrackingParticle*>(tpr.get());
779  // TrackingParticle parameters at point of closest approach to the beamline
780  TrackingParticle::Vector momentumTP;
781  TrackingParticle::Point vertexTP;
782 
783  if (parametersDefiner == "LhcParametersDefinerForTP") {
784  // following reco plots are made only from tracks associated to selected signal TPs
785  if (!(Track_is_matched && tpSelector(*tpp)))
786  continue;
787  else {
788  momentumTP = Lhc_parametersDefinerTP->momentum(event, setup, tpr);
789  vertexTP = Lhc_parametersDefinerTP->vertex(event, setup, tpr);
790  }
791  } else if (parametersDefiner == "CosmicParametersDefinerForTP") {
792  // following reco plots are made only from tracks associated to selected signal TPs
793  if (!(Track_is_matched && cosmictpSelector(tpr, &bs, event, setup)))
794  continue;
795  else {
796  momentumTP = Cosmic_parametersDefinerTP->momentum(event, setup, tpr);
797  vertexTP = Cosmic_parametersDefinerTP->vertex(event, setup, tpr);
798  }
799  }
800 
801  if (associators[ww] == "trackAssociatorByChi2") {
802  //association chi2
803  double assocChi2 = -tp.begin()->second; //in association map is stored -chi2
804  h_assochi2[www]->Fill(assocChi2);
805  h_assochi2_prob[www]->Fill(TMath::Prob((assocChi2)*5, 5));
806  } else if (associators[ww] == "trackAssociatorByHits") {
807  double fraction = tp.begin()->second;
808  h_assocFraction[www]->Fill(fraction);
809  h_assocSharedHit[www]->Fill(fraction * nRecHits);
810  }
811 
812  h_charge[w]->Fill(track->charge());
813 
814  // Hits
815  h_nhits[w]->Fill(nRecHits);
816  nhits_vs_eta[w]->Fill(xetaRec, nRecHits);
817  nhits_vs_phi[w]->Fill(phiRec, nRecHits);
818 
819  if (do_MUOhitsPlots) {
820  nDThits_vs_eta[w]->Fill(xetaRec, track->hitPattern().numberOfValidMuonDTHits());
821  nCSChits_vs_eta[w]->Fill(xetaRec, track->hitPattern().numberOfValidMuonCSCHits());
822  nRPChits_vs_eta[w]->Fill(xetaRec, track->hitPattern().numberOfValidMuonRPCHits());
823  if (useGEMs_)
824  nGEMhits_vs_eta[w]->Fill(xetaRec, track->hitPattern().numberOfValidMuonGEMHits());
825  if (useME0_)
826  nME0hits_vs_eta[w]->Fill(xetaRec, track->hitPattern().numberOfValidMuonME0Hits());
827  }
828 
829  if (do_TRKhitsPlots) {
830  nTRK_LayersWithMeas_vs_eta[w]->Fill(xetaRec, track->hitPattern().trackerLayersWithMeasurement());
831  nPixel_LayersWithMeas_vs_eta[w]->Fill(xetaRec, track->hitPattern().pixelLayersWithMeasurement());
832  h_nlosthits[w]->Fill(track->numberOfLostHits());
833  h_nmisslayers_inner[w]->Fill(track->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS));
834  h_nmisslayers_outer[w]->Fill(track->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS));
835  nlosthits_vs_eta[w]->Fill(xetaRec, track->numberOfLostHits());
836  }
837 
838  // normalized chi2
839  h_nchi2[w]->Fill(track->normalizedChi2());
840  h_nchi2_prob[w]->Fill(TMath::Prob(track->chi2(), (int)track->ndof()));
841  chi2_vs_nhits[w]->Fill(nRecHits, track->normalizedChi2());
842  chi2_vs_eta[w]->Fill(xetaRec, track->normalizedChi2());
843  chi2_vs_phi[w]->Fill(phiRec, track->normalizedChi2());
844 
845  double ptSim = sqrt(momentumTP.perp2());
846  double xptSim = getPt(ptSim);
847  double qoverpSim = tpr->charge() / sqrt(momentumTP.x() * momentumTP.x() + momentumTP.y() * momentumTP.y() +
848  momentumTP.z() * momentumTP.z());
849  double etaSim = momentumTP.eta();
850  double thetaSim = momentumTP.theta();
851  double phiSim = momentumTP.phi();
852  double dxySim = TrackingParticleIP::dxy(vertexTP, momentumTP, bs.position());
853  double dzSim = TrackingParticleIP::dz(vertexTP, momentumTP, bs.position());
854 
855  double etares = etaRec - etaSim;
856  double ptRelRes = (ptRec - ptSim) / ptSim; // relative residual -> resolution
857  double ptPull = (ptRec - ptSim) / ptError;
858  double qoverpPull = (qoverpRec - qoverpSim) / qoverpError;
859  double thetaPull = (thetaRec - thetaSim) / thetaError;
860  double phiDiff = phiRec - phiSim;
861  if (abs(phiDiff) > M_PI) {
862  if (phiDiff > 0.)
863  phiDiff = phiDiff - 2. * M_PI;
864  else
865  phiDiff = phiDiff + 2. * M_PI;
866  }
867  double phiPull = phiDiff / phiError;
868  double dxyPull = (dxyRec - dxySim) / dxyError;
869  double dzPull = (dzRec - dzSim) / dzError;
870 
871  h_etaRes[w]->Fill(etares);
872  etares_vs_eta[w]->Fill(xetaRec, etares);
873 
874  ptres_vs_eta[w]->Fill(xetaRec, ptRelRes);
875  ptres_vs_pt[w]->Fill(xptSim, ptRelRes);
876  ptres_vs_phi[w]->Fill(phiRec, ptRelRes);
877  h_ptpull[w]->Fill(ptPull);
878  ptpull_vs_eta[w]->Fill(xetaRec, ptPull);
879  ptpull_vs_phi[w]->Fill(phiRec, ptPull);
880  h_qoverppull[w]->Fill(qoverpPull);
881 
882  thetaCotres_vs_eta[w]->Fill(xetaRec, cos(thetaRec) / sin(thetaRec) - cos(thetaSim) / sin(thetaSim));
883  thetaCotres_vs_pt[w]->Fill(xptSim, cos(thetaRec) / sin(thetaRec) - cos(thetaSim) / sin(thetaSim));
884  h_thetapull[w]->Fill(thetaPull);
885  thetapull_vs_eta[w]->Fill(xetaRec, thetaPull);
886  thetapull_vs_phi[w]->Fill(phiRec, thetaPull);
887 
888  phires_vs_eta[w]->Fill(xetaRec, phiDiff);
889  phires_vs_pt[w]->Fill(xptSim, phiDiff);
890  phires_vs_phi[w]->Fill(phiRec, phiDiff);
891  h_phipull[w]->Fill(phiPull);
892  phipull_vs_eta[w]->Fill(xetaRec, phiPull);
893  phipull_vs_phi[w]->Fill(phiRec, phiPull);
894 
895  dxyres_vs_eta[w]->Fill(xetaRec, dxyRec - dxySim);
896  dxyres_vs_pt[w]->Fill(xptSim, dxyRec - dxySim);
897  h_dxypull[w]->Fill(dxyPull);
898  dxypull_vs_eta[w]->Fill(xetaRec, dxyPull);
899 
900  dzres_vs_eta[w]->Fill(xetaRec, dzRec - dzSim);
901  dzres_vs_pt[w]->Fill(xptSim, dzRec - dzSim);
902  h_dzpull[w]->Fill(dzPull);
903  dzpull_vs_eta[w]->Fill(xetaRec, dzPull);
904 
905  double contrib_Qoverp = qoverpPull * qoverpPull / 5;
906  double contrib_dxy = dxyPull * dxyPull / 5;
907  double contrib_dz = dzPull * dzPull / 5;
908  double contrib_theta = thetaPull * thetaPull / 5;
909  double contrib_phi = phiPull * phiPull / 5;
910  double assoChi2 = contrib_Qoverp + contrib_dxy + contrib_dz + contrib_theta + contrib_phi;
911 
912  edm::LogVerbatim("MuonTrackValidator") << "normalized Chi2 (track 5-dofs matching) = " << assoChi2 << "\n"
913  << "\t contrib_Qoverp = " << contrib_Qoverp << "\n"
914  << "\t contrib_theta = " << contrib_theta << "\n"
915  << "\t contrib_phi = " << contrib_phi << "\n"
916  << "\t contrib_dxy = " << contrib_dxy << "\n"
917  << "\t contrib_dz = " << contrib_dz << "\n";
918 
919  edm::LogVerbatim("MuonTrackValidator") << "ptRec = " << ptRec << "\n"
920  << "etaRec = " << etaRec << "\n"
921  << "qoverpRec = " << qoverpRec << "\n"
922  << "thetaRec = " << thetaRec << "\n"
923  << "phiRec = " << phiRec << "\n"
924  << "dxyRec = " << dxyRec << "\n"
925  << "dzRec = " << dzRec << "\n"
926  << ""
927  << "\n"
928  << "qoverpError = " << qoverpError << "\n"
929  << "thetaError = " << thetaError << "\n"
930  << "phiError = " << phiError << "\n"
931  << "dxyError = " << dxyError << "\n"
932  << "dzError = " << dzError << "\n"
933  << ""
934  << "\n"
935  << "ptSim = " << ptSim << "\n"
936  << "etaSim = " << etaSim << "\n"
937  << "qoverpSim = " << qoverpSim << "\n"
938  << "thetaSim = " << thetaSim << "\n"
939  << "phiSim = " << phiSim << "\n"
940  << "dxySim = " << dxySim << "\n"
941  << "dzSim = " << dzSim << "\n";
942  } // End of for(edm::View<Track>::size_type i=0; i<trackCollectionSize; ++i) {
943 
944  h_tracks[w]->Fill(at);
945  h_fakes[w]->Fill(rT - at);
946  edm::LogVerbatim("MuonTrackValidator") << "Total Simulated: " << st << "\n"
947  << "Total Associated (simToReco): " << ats << "\n"
948  << "Total Reconstructed: " << rT << "\n"
949  << "Total Associated (recoToSim): " << at << "\n"
950  << "Total Fakes: " << rT - at << "\n";
951  w++;
952  } // End of for (unsigned int www=0;www<label.size();www++){
953  } //END of for (unsigned int ww=0;ww<associators.size();ww++){
954 }

References funct::abs(), ctfWithMaterialTrackMCMatch_cfi::associator, muonValidationHeavyIons_cff::associatormap, MuonErrorMatrixAnalyzer_cfi::associatorName, simPFProducer_cfi::associators, edm::AssociationMap< Tag >::begin(), MuonTrackValidator_cfi::BiDirectional_RecoToSim_association, cms::cuda::bs, reco::TrackBase::charge(), CosmicParametersDefinerForTP::clone(), funct::cos(), histoParameters_cff::do_MUOhitsPlots, histoParameters_cff::do_TRKhitsPlots, TrackingParticleIP::dxy(), TrackingParticleIP::dz(), edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), HLT_2018_cff::fraction, get, edm::Ref< C, T, F >::get(), mps_fire::i, createfilelist::int, edm::RefToBase< T >::key(), edm::Ref< C, T, F >::key(), label, LogTrace, M_PI, associators_cff::MABH, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, ParametersDefinerForTP::momentum(), reco::TrackBase::numberOfValidHits(), MuonTrackValidator_cfi::parametersDefiner, muonME0PseudoDigis_cfi::phiError, edm::AssociationMap< Tag >::post_insert(), edm::Handle< T >::product(), qcdUeDQM_cfi::quality, hcal_runs::rt, singleTopDQM_cfi::setup, funct::sin(), mathSSE::sqrt(), cmsswSequenceInfo::tp, RecoMuonValidator_cfi::tpSelector, HLT_2018_cff::track, duplicaterechits_cfi::trackCollection, TrackAlgoCompareUtil_cfi::UseAssociators, histoParameters_cff::usemuon, histoParameters_cff::usetracker, bphysicsOniaDQM_cfi::vertex, ParametersDefinerForTP::vertex(), and w.

◆ bookHistograms()

void MuonTrackValidator::bookHistograms ( DQMEDAnalyzer::DQMStore::IBooker &  ibooker,
edm::Run const &  ,
edm::EventSetup const &  setup 
)
overridevirtual

Method called at the end of the event loop.

Implements DQMEDAnalyzer.

Definition at line 24 of file MuonTrackValidator.cc.

26  {
27  for (unsigned int ww = 0; ww < associators.size(); ww++) {
28  for (unsigned int www = 0; www < label.size(); www++) {
29  ibooker.cd();
30  InputTag algo = label[www];
31  string dirName = dirName_;
32 
33  auto setBinLogX = [this](TH1* th1) {
34  if (this->useLogPt) {
35  BinLogX(th1);
36  }
37  };
38 
39  if (!algo.process().empty())
40  dirName += algo.process() + "_";
41  if (!algo.label().empty())
42  dirName += algo.label();
43  if (!algo.instance().empty())
44  dirName += ("_" + algo.instance());
45  if (dirName.find("Tracks") < dirName.length()) {
46  dirName.replace(dirName.find("Tracks"), 6, "Trks");
47  }
48  if (dirName.find("UpdatedAtVtx") < dirName.length()) {
49  dirName.replace(dirName.find("UpdatedAtVtx"), 12, "UpdAtVtx");
50  }
51  string assoc = associators[ww];
52  if (assoc.find("tpToTkmuTrackAssociation") < assoc.length()) {
53  dirName += "_TkAsso";
54  }
55  std::replace(dirName.begin(), dirName.end(), ':', '_');
56  ibooker.setCurrentFolder(dirName);
57 
58  h_tracks.push_back(ibooker.book1D("Ntracks", "Number of reconstructed tracks", 100, -0.5, 99.5));
59  h_fakes.push_back(ibooker.book1D("Nfakes", "Number of fake reco tracks", 20, -0.5, 19.5));
60  h_charge.push_back(ibooker.book1D("Ncharge", "track charge", 3, -1.5, 1.5));
61 
62  h_recoeta.push_back(ibooker.book1D("num_reco_eta", "N of reco track vs eta", nintEta, minEta, maxEta));
63  h_assoceta.push_back(ibooker.book1D(
64  "num_assoSimToReco_eta", "N of associated tracks (simToReco) vs eta", nintEta, minEta, maxEta));
65  h_assoc2eta.push_back(ibooker.book1D(
66  "num_assoRecoToSim_eta", "N of associated (recoToSim) tracks vs eta", nintEta, minEta, maxEta));
67  h_simuleta.push_back(ibooker.book1D("num_simul_eta", "N of simulated tracks vs eta", nintEta, minEta, maxEta));
68  h_misideta.push_back(ibooker.book1D("num_chargemisid_eta",
69  "N of associated (simToReco) tracks with charge misID vs eta",
70  nintEta,
71  minEta,
72  maxEta));
73 
74  h_recopT.push_back(ibooker.book1D("num_reco_pT", "N of reco track vs pT", nintPt, minPt, maxPt, setBinLogX));
75  h_assocpT.push_back(ibooker.book1D(
76  "num_assoSimToReco_pT", "N of associated tracks (simToReco) vs pT", nintPt, minPt, maxPt, setBinLogX));
77  h_assoc2pT.push_back(ibooker.book1D(
78  "num_assoRecoToSim_pT", "N of associated (recoToSim) tracks vs pT", nintPt, minPt, maxPt, setBinLogX));
79  h_simulpT.push_back(
80  ibooker.book1D("num_simul_pT", "N of simulated tracks vs pT", nintPt, minPt, maxPt, setBinLogX));
81  h_misidpT.push_back(ibooker.book1D("num_chargemisid_pT",
82  "N of associated (simToReco) tracks with charge misID vs pT",
83  nintPt,
84  minPt,
85  maxPt,
86  setBinLogX));
87 
88  h_recophi.push_back(ibooker.book1D("num_reco_phi", "N of reco track vs phi", nintPhi, minPhi, maxPhi));
89  h_assocphi.push_back(ibooker.book1D(
90  "num_assoSimToReco_phi", "N of associated tracks (simToReco) vs phi", nintPhi, minPhi, maxPhi));
91  h_assoc2phi.push_back(ibooker.book1D(
92  "num_assoRecoToSim_phi", "N of associated (recoToSim) tracks vs phi", nintPhi, minPhi, maxPhi));
93  h_simulphi.push_back(ibooker.book1D("num_simul_phi", "N of simulated tracks vs phi", nintPhi, minPhi, maxPhi));
94  h_misidphi.push_back(ibooker.book1D("num_chargemisid_phi",
95  "N of associated (simToReco) tracks with charge misID vs phi",
96  nintPhi,
97  minPhi,
98  maxPhi));
99 
100  h_recohit.push_back(ibooker.book1D("num_reco_hit", "N of reco tracks vs N SimHits", nintNHit, minNHit, maxNHit));
101  h_assochit.push_back(ibooker.book1D(
102  "num_assoSimToReco_hit", "N of associated tracks (simToReco) vs N SimHits", nintNHit, minNHit, maxNHit));
103  h_assoc2hit.push_back(ibooker.book1D(
104  "num_assoRecoToSim_hit", "N of associated (recoToSim) tracks vs N Rechits", nintNHit, minNHit, maxNHit));
105  h_simulhit.push_back(
106  ibooker.book1D("num_simul_hit", "N of simulated tracks vs N SimHits", nintNHit, minNHit, maxNHit));
107  h_misidhit.push_back(ibooker.book1D("num_chargemisid_hit",
108  "N of associated (recoToSim) tracks with charge misID vs N RecHits",
109  nintNHit,
110  minNHit,
111  maxNHit));
112 
113  h_recodxy.push_back(ibooker.book1D("num_reco_dxy", "N of reco track vs dxy", nintDxy, minDxy, maxDxy));
114  h_assocdxy.push_back(ibooker.book1D(
115  "num_assoSimToReco_dxy", "N of associated tracks (simToReco) vs dxy", nintDxy, minDxy, maxDxy));
116  h_assoc2dxy.push_back(ibooker.book1D(
117  "num_assoRecoToSim_dxy", "N of associated (recoToSim) tracks vs dxy", nintDxy, minDxy, maxDxy));
118  h_simuldxy.push_back(ibooker.book1D("num_simul_dxy", "N of simulated tracks vs dxy", nintDxy, minDxy, maxDxy));
119  h_misiddxy.push_back(ibooker.book1D("num_chargemisid_dxy",
120  "N of associated (simToReco) tracks with charge misID vs dxy",
121  nintDxy,
122  minDxy,
123  maxDxy));
124  h_recodz.push_back(ibooker.book1D("num_reco_dz", "N of reco track vs dz", nintDz, minDz, maxDz));
125  h_assocdz.push_back(
126  ibooker.book1D("num_assoSimToReco_dz", "N of associated tracks (simToReco) vs dz", nintDz, minDz, maxDz));
127  h_assoc2dz.push_back(
128  ibooker.book1D("num_assoRecoToSim_dz", "N of associated (recoToSim) tracks vs dz", nintDz, minDz, maxDz));
129  h_simuldz.push_back(ibooker.book1D("num_simul_dz", "N of simulated tracks vs dz", nintDz, minDz, maxDz));
130  h_misiddz.push_back(ibooker.book1D(
131  "num_chargemisid_dz", "N of associated (simToReco) tracks with charge misID vs dz", nintDz, minDz, maxDz));
132 
133  h_assocRpos.push_back(ibooker.book1D(
134  "num_assoSimToReco_Rpos", "N of associated tracks (simToReco) vs Radius", nintRpos, minRpos, maxRpos));
135  h_simulRpos.push_back(
136  ibooker.book1D("num_simul_Rpos", "N of simulated tracks vs Radius", nintRpos, minRpos, maxRpos));
137 
138  h_assocZpos.push_back(ibooker.book1D(
139  "num_assoSimToReco_Zpos", "N of associated tracks (simToReco) vs Z", nintZpos, minZpos, maxZpos));
140  h_simulZpos.push_back(ibooker.book1D("num_simul_Zpos", "N of simulated tracks vs Z", nintZpos, minZpos, maxZpos));
141 
142  h_recopu.push_back(ibooker.book1D("num_reco_pu", "N of reco track vs pu", nintPU, minPU, maxPU));
143  h_assocpu.push_back(
144  ibooker.book1D("num_assoSimToReco_pu", "N of associated tracks (simToReco) vs pu", nintPU, minPU, maxPU));
145  h_assoc2pu.push_back(
146  ibooker.book1D("num_assoRecoToSim_pu", "N of associated (recoToSim) tracks vs pu", nintPU, minPU, maxPU));
147  h_simulpu.push_back(ibooker.book1D("num_simul_pu", "N of simulated tracks vs pu", nintPU, minPU, maxPU));
148  h_misidpu.push_back(ibooker.book1D(
149  "num_chargemisid_pu", "N of associated (simToReco) charge misIDed tracks vs pu", nintPU, minPU, maxPU));
150 
151  h_nchi2.push_back(ibooker.book1D("chi2", "Track normalized #chi^{2}", 80, 0., 20.));
152  h_nchi2_prob.push_back(ibooker.book1D("chi2prob", "Probability of track normalized #chi^{2}", 100, 0., 1.));
153 
154  chi2_vs_nhits.push_back(
155  ibooker.book2D("chi2_vs_nhits", "#chi^{2} vs nhits", nintNHit, minNHit, maxNHit, 20, 0., 10.));
156  chi2_vs_eta.push_back(ibooker.book2D("chi2_vs_eta", "chi2_vs_eta", nintEta, minEta, maxEta, 40, 0., 20.));
157  chi2_vs_phi.push_back(ibooker.book2D("chi2_vs_phi", "#chi^{2} vs #phi", nintPhi, minPhi, maxPhi, 40, 0., 20.));
158 
159  h_nhits.push_back(ibooker.book1D("nhits", "Number of hits per track", nintNHit, minNHit, maxNHit));
160  nhits_vs_eta.push_back(
161  ibooker.book2D("nhits_vs_eta", "Number of Hits vs eta", nintEta, minEta, maxEta, nintNHit, minNHit, maxNHit));
162  nhits_vs_phi.push_back(
163  ibooker.book2D("nhits_vs_phi", "#hits vs #phi", nintPhi, minPhi, maxPhi, nintNHit, minNHit, maxNHit));
164 
165  if (do_MUOhitsPlots) {
166  nDThits_vs_eta.push_back(ibooker.book2D(
167  "nDThits_vs_eta", "Number of DT hits vs eta", nintEta, minEta, maxEta, nintDTHit, minDTHit, maxDTHit));
168  nCSChits_vs_eta.push_back(ibooker.book2D(
169  "nCSChits_vs_eta", "Number of CSC hits vs eta", nintEta, minEta, maxEta, nintCSCHit, minCSCHit, maxCSCHit));
170  nRPChits_vs_eta.push_back(ibooker.book2D(
171  "nRPChits_vs_eta", "Number of RPC hits vs eta", nintEta, minEta, maxEta, nintRPCHit, minRPCHit, maxRPCHit));
172  if (useGEMs_)
173  nGEMhits_vs_eta.push_back(ibooker.book2D(
174  "nGEMhits_vs_eta", "Number of GEM hits vs eta", nintEta, minEta, maxEta, nintNHit, minNHit, maxNHit));
175  if (useME0_)
176  nME0hits_vs_eta.push_back(ibooker.book2D(
177  "nME0hits_vs_eta", "Number of ME0 hits vs eta", nintEta, minEta, maxEta, nintNHit, minNHit, maxNHit));
178  }
179 
180  if (do_TRKhitsPlots) {
181  nTRK_LayersWithMeas_vs_eta.push_back(ibooker.book2D("nTRK_LayersWithMeas_vs_eta",
182  "# TRK Layers with measurement vs eta",
183  nintEta,
184  minEta,
185  maxEta,
186  nintLayers,
187  minLayers,
188  maxLayers));
189  nPixel_LayersWithMeas_vs_eta.push_back(ibooker.book2D("nPixel_LayersWithMeas_vs_eta",
190  "Number of Pixel Layers with measurement vs eta",
191  nintEta,
192  minEta,
193  maxEta,
194  nintPixels,
195  minPixels,
196  maxPixels));
197  h_nmisslayers_inner.push_back(ibooker.book1D(
198  "nTRK_misslayers_inner", "Number of missing inner TRK layers", nintLayers, minLayers, maxLayers));
199  h_nmisslayers_outer.push_back(ibooker.book1D(
200  "nTRK_misslayers_outer", "Number of missing outer TRK layers", nintLayers, minLayers, maxLayers));
201  h_nlosthits.push_back(ibooker.book1D("nlosthits", "Number of lost hits per track", 6, -0.5, 5.5));
202  nlosthits_vs_eta.push_back(ibooker.book2D(
203  "nlosthits_vs_eta", "Number of lost hits per track vs eta", nintEta, minEta, maxEta, 6, -0.5, 5.5));
204  }
205 
206  ptres_vs_eta.push_back(ibooker.book2D("ptres_vs_eta",
207  "p_{T} Relative Residual vs #eta",
208  nintEta,
209  minEta,
210  maxEta,
211  ptRes_nbin,
212  ptRes_rangeMin,
213  ptRes_rangeMax));
214  ptres_vs_phi.push_back(ibooker.book2D("ptres_vs_phi",
215  "p_{T} Relative Residual vs #phi",
216  nintPhi,
217  minPhi,
218  maxPhi,
219  ptRes_nbin,
220  ptRes_rangeMin,
221  ptRes_rangeMax));
222  ptres_vs_pt.push_back(ibooker.book2D("ptres_vs_pt",
223  "p_{T} Relative Residual vs p_{T}",
224  nintPt,
225  minPt,
226  maxPt,
227  ptRes_nbin,
228  ptRes_rangeMin,
229  ptRes_rangeMax,
230  setBinLogX));
231  h_ptpull.push_back(ibooker.book1D("ptpull", "p_{T} Pull", 100, -10., 10.));
232  ptpull_vs_eta.push_back(
233  ibooker.book2D("ptpull_vs_eta", "p_{T} Pull vs #eta", nintEta, minEta, maxEta, 100, -10., 10.));
234  ptpull_vs_phi.push_back(
235  ibooker.book2D("ptpull_vs_phi", "p_{T} Pull vs #phi", nintPhi, minPhi, maxPhi, 100, -10., 10.));
236  h_qoverppull.push_back(ibooker.book1D("qoverppull", "q/p Pull", 100, -10., 10.));
237 
238  h_etaRes.push_back(ibooker.book1D("etaRes", "#eta residual", etaRes_nbin, etaRes_rangeMin, etaRes_rangeMax));
239  etares_vs_eta.push_back(ibooker.book2D("etares_vs_eta",
240  "#eta Residual vs #eta",
241  nintEta,
242  minEta,
243  maxEta,
244  etaRes_nbin,
245  etaRes_rangeMin,
246  etaRes_rangeMax));
247 
248  thetaCotres_vs_eta.push_back(ibooker.book2D("thetaCotres_vs_eta",
249  "cot(#theta) Residual vs #eta",
250  nintEta,
251  minEta,
252  maxEta,
253  cotThetaRes_nbin,
254  cotThetaRes_rangeMin,
255  cotThetaRes_rangeMax));
256  thetaCotres_vs_pt.push_back(ibooker.book2D("thetaCotres_vs_pt",
257  "cot(#theta) Residual vs p_{T}",
258  nintPt,
259  minPt,
260  maxPt,
261  cotThetaRes_nbin,
262  cotThetaRes_rangeMin,
263  cotThetaRes_rangeMax,
264  setBinLogX));
265  h_thetapull.push_back(ibooker.book1D("thetapull", "#theta Pull", 100, -10., 10.));
266  thetapull_vs_eta.push_back(
267  ibooker.book2D("thetapull_vs_eta", "#theta Pull vs #eta", nintEta, minEta, maxEta, 100, -10, 10));
268  thetapull_vs_phi.push_back(
269  ibooker.book2D("thetapull_vs_phi", "#theta Pull vs #phi", nintPhi, minPhi, maxPhi, 100, -10, 10));
270 
271  phires_vs_eta.push_back(ibooker.book2D("phires_vs_eta",
272  "#phi Residual vs #eta",
273  nintEta,
274  minEta,
275  maxEta,
276  phiRes_nbin,
277  phiRes_rangeMin,
278  phiRes_rangeMax));
279  phires_vs_pt.push_back(ibooker.book2D("phires_vs_pt",
280  "#phi Residual vs p_{T}",
281  nintPt,
282  minPt,
283  maxPt,
284  phiRes_nbin,
285  phiRes_rangeMin,
286  phiRes_rangeMax,
287  setBinLogX));
288  phires_vs_phi.push_back(ibooker.book2D("phires_vs_phi",
289  "#phi Residual vs #phi",
290  nintPhi,
291  minPhi,
292  maxPhi,
293  phiRes_nbin,
294  phiRes_rangeMin,
295  phiRes_rangeMax));
296  h_phipull.push_back(ibooker.book1D("phipull", "#phi Pull", 100, -10., 10.));
297  phipull_vs_eta.push_back(
298  ibooker.book2D("phipull_vs_eta", "#phi Pull vs #eta", nintEta, minEta, maxEta, 100, -10, 10));
299  phipull_vs_phi.push_back(
300  ibooker.book2D("phipull_vs_phi", "#phi Pull vs #phi", nintPhi, minPhi, maxPhi, 100, -10, 10));
301 
302  dxyres_vs_eta.push_back(ibooker.book2D("dxyres_vs_eta",
303  "dxy Residual vs #eta",
304  nintEta,
305  minEta,
306  maxEta,
307  dxyRes_nbin,
308  dxyRes_rangeMin,
309  dxyRes_rangeMax));
310  dxyres_vs_pt.push_back(ibooker.book2D("dxyres_vs_pt",
311  "dxy Residual vs p_{T}",
312  nintPt,
313  minPt,
314  maxPt,
315  dxyRes_nbin,
316  dxyRes_rangeMin,
317  dxyRes_rangeMax,
318  setBinLogX));
319  h_dxypull.push_back(ibooker.book1D("dxypull", "dxy Pull", 100, -10., 10.));
320  dxypull_vs_eta.push_back(
321  ibooker.book2D("dxypull_vs_eta", "dxy Pull vs #eta", nintEta, minEta, maxEta, 100, -10, 10));
322 
323  dzres_vs_eta.push_back(ibooker.book2D(
324  "dzres_vs_eta", "dz Residual vs #eta", nintEta, minEta, maxEta, dzRes_nbin, dzRes_rangeMin, dzRes_rangeMax));
325  dzres_vs_pt.push_back(ibooker.book2D("dzres_vs_pt",
326  "dz Residual vs p_{T}",
327  nintPt,
328  minPt,
329  maxPt,
330  dzRes_nbin,
331  dzRes_rangeMin,
332  dzRes_rangeMax,
333  setBinLogX));
334  h_dzpull.push_back(ibooker.book1D("dzpull", "dz Pull", 100, -10., 10.));
335  dzpull_vs_eta.push_back(
336  ibooker.book2D("dzpull_vs_eta", "dz Pull vs #eta", nintEta, minEta, maxEta, 100, -10, 10));
337 
338  nRecHits_vs_nSimHits.push_back(ibooker.book2D(
339  "nRecHits_vs_nSimHits", "nRecHits vs nSimHits", nintNHit, minNHit, maxNHit, nintNHit, minNHit, maxNHit));
340 
341  if (MABH) {
342  h_PurityVsQuality.push_back(
343  ibooker.book2D("PurityVsQuality", "Purity vs Quality (MABH)", 20, 0.01, 1.01, 20, 0.01, 1.01));
344  }
345 
346  if (associators[ww] == "trackAssociatorByChi2") {
347  h_assochi2.push_back(ibooker.book1D("assocChi2", "track association #chi^{2}", 1000, 0., 100.));
348  h_assochi2_prob.push_back(ibooker.book1D("assocChi2_prob", "probability of association #chi^{2}", 100, 0., 1.));
349  } else if (associators[ww] == "trackAssociatorByHits") {
350  h_assocFraction.push_back(ibooker.book1D("assocFraction", "fraction of shared hits", 22, 0., 1.1));
351  h_assocSharedHit.push_back(ibooker.book1D("assocSharedHit", "number of shared hits", 41, -0.5, 40.5));
352  }
353 
354  } //for (unsigned int www=0;www<label.size();www++)
355  } //for (unsigned int ww=0;ww<associators.size();ww++)
356 }

References trackingPlots::assoc, simPFProducer_cfi::associators, dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::NavigatorBase::cd(), histoParameters_cff::cotThetaRes_nbin, histoParameters_cff::cotThetaRes_rangeMax, histoParameters_cff::cotThetaRes_rangeMin, TrackerOfflineValidation_Dqm_cff::dirName, histoParameters_cff::do_MUOhitsPlots, histoParameters_cff::do_TRKhitsPlots, histoParameters_cff::dxyRes_nbin, histoParameters_cff::dxyRes_rangeMax, histoParameters_cff::dxyRes_rangeMin, histoParameters_cff::dzRes_nbin, histoParameters_cff::dzRes_rangeMax, histoParameters_cff::dzRes_rangeMin, histoParameters_cff::etaRes_nbin, histoParameters_cff::etaRes_rangeMax, histoParameters_cff::etaRes_rangeMin, label, associators_cff::MABH, histoParameters_cff::maxCSCHit, histoParameters_cff::maxDTHit, gather_cfg::maxDxy, beam_dqm_sourceclient-live_cfg::maxDz, maxEta, histoParameters_cff::maxLayers, histoParameters_cff::maxNHit, HLT_2018_cff::maxPhi, histoParameters_cff::maxPixels, MuonErrorMatrixAnalyzer_cfi::maxPt, pileupFilter_cff::maxPU, histoParameters_cff::maxRPCHit, histoParameters_cff::maxRpos, HGVHistoProducerAlgoBlock_cfi::maxZpos, histoParameters_cff::minCSCHit, histoParameters_cff::minDTHit, histoParameters_cff::minDxy, pfMETCorrectionType0_cfi::minDz, EgHLTOffEleSelection_cfi::minEta, beam_dqm_sourceclient-live_cfg::minLayers, histoParameters_cff::minNHit, HLT_2018_cff::minPhi, histoParameters_cff::minPixels, beam_dqm_sourceclient-live_cfg::minPt, pileupFilter_cff::minPU, histoParameters_cff::minRPCHit, histoParameters_cff::minRpos, HGVHistoProducerAlgoBlock_cfi::minZpos, histoParameters_cff::nintCSCHit, histoParameters_cff::nintDTHit, histoParameters_cff::nintDxy, histoParameters_cff::nintDz, HGVHistoProducerAlgoBlock_cfi::nintEta, histoParameters_cff::nintLayers, histoParameters_cff::nintNHit, HGVHistoProducerAlgoBlock_cfi::nintPhi, histoParameters_cff::nintPixels, HGVHistoProducerAlgoBlock_cfi::nintPt, histoParameters_cff::nintPU, histoParameters_cff::nintRPCHit, histoParameters_cff::nintRpos, HGVHistoProducerAlgoBlock_cfi::nintZpos, histoParameters_cff::phiRes_nbin, histoParameters_cff::phiRes_rangeMax, histoParameters_cff::phiRes_rangeMin, histoParameters_cff::ptRes_nbin, histoParameters_cff::ptRes_rangeMax, histoParameters_cff::ptRes_rangeMin, python.rootplot.root2matplotlib::replace(), dqm::implementation::NavigatorBase::setCurrentFolder(), and TrackValidationHeavyIons_cff::useLogPt.

Member Data Documentation

◆ _simHitTpMapTag

edm::EDGetTokenT<SimHitTPAssociationProducer::SimHitTPAssociationList> MuonTrackValidator::_simHitTpMapTag
private

Definition at line 148 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ associatormap

edm::InputTag MuonTrackValidator::associatormap
private

Definition at line 145 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ BiDirectional_RecoToSim_association

bool MuonTrackValidator::BiDirectional_RecoToSim_association
private

Definition at line 160 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ cosmictpSelector

CosmicTrackingParticleSelector MuonTrackValidator::cosmictpSelector
private

Definition at line 157 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ dirName_

std::string MuonTrackValidator::dirName_
private

Definition at line 144 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ MABH

bool MuonTrackValidator::MABH
private

Definition at line 162 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ recoToSimCollection_Token

edm::EDGetTokenT<reco::RecoToSimCollection> MuonTrackValidator::recoToSimCollection_Token
private

Definition at line 147 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ simToRecoCollection_Token

edm::EDGetTokenT<reco::SimToRecoCollection> MuonTrackValidator::simToRecoCollection_Token
private

Definition at line 146 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ tpSelector

TrackingParticleSelector MuonTrackValidator::tpSelector
private

Definition at line 156 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ UseAssociators

bool MuonTrackValidator::UseAssociators
private

Definition at line 150 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ useGEMs_

bool MuonTrackValidator::useGEMs_
private

Definition at line 151 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ useME0_

bool MuonTrackValidator::useME0_
private

Definition at line 152 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

MuonTrackValidatorBase::h_misiddz
std::vector< MonitorElement * > h_misiddz
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::h_simulRpos
std::vector< MonitorElement * > h_simulRpos
Definition: MuonTrackValidatorBase.h:275
MuonTrackValidatorBase::chi2_vs_eta
std::vector< MonitorElement * > chi2_vs_eta
Definition: MuonTrackValidatorBase.h:291
MuonTrackValidatorBase::ptres_vs_phi
std::vector< MonitorElement * > ptres_vs_phi
Definition: MuonTrackValidatorBase.h:287
MuonTrackValidatorBase::ptRes_rangeMax
double ptRes_rangeMax
Definition: MuonTrackValidatorBase.h:248
reco::HitPattern::MISSING_OUTER_HITS
Definition: HitPattern.h:155
MuonTrackValidatorBase::ptres_vs_pt
std::vector< MonitorElement * > ptres_vs_pt
Definition: MuonTrackValidatorBase.h:295
MuonTrackValidatorBase::maxNHit
double maxNHit
Definition: MuonTrackValidatorBase.h:223
MuonTrackValidatorBase::h_assocpT
std::vector< MonitorElement * > h_assocpT
Definition: MuonTrackValidatorBase.h:268
MuonTrackValidatorBase::dzpull_vs_eta
std::vector< MonitorElement * > dzpull_vs_eta
Definition: MuonTrackValidatorBase.h:297
MuonTrackValidatorBase::h_assocZpos
std::vector< MonitorElement * > h_assocZpos
Definition: MuonTrackValidatorBase.h:275
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:173
mps_fire.i
i
Definition: mps_fire.py:355
MuonTrackValidatorBase::tp_fake_Token
edm::EDGetTokenT< TrackingParticleCollection > tp_fake_Token
Definition: MuonTrackValidatorBase.h:210
MuonTrackValidatorBase::h_misidphi
std::vector< MonitorElement * > h_misidphi
Definition: MuonTrackValidatorBase.h:270
MuonTrackValidatorBase::label
std::vector< edm::InputTag > label
Definition: MuonTrackValidatorBase.h:199
MuonTrackValidator::recoToSimCollection_Token
edm::EDGetTokenT< reco::RecoToSimCollection > recoToSimCollection_Token
Definition: MuonTrackValidator.h:147
MuonTrackValidatorBase::nintEta
int nintEta
Definition: MuonTrackValidatorBase.h:217
MuonTrackValidatorBase::h_misidpu
std::vector< MonitorElement * > h_misidpu
Definition: MuonTrackValidatorBase.h:273
edm::Handle::product
T const * product() const
Definition: Handle.h:70
MuonTrackValidatorBase::h_misideta
std::vector< MonitorElement * > h_misideta
Definition: MuonTrackValidatorBase.h:267
MuonTrackValidatorBase::nintNHit
int nintNHit
Definition: MuonTrackValidatorBase.h:224
MuonTrackValidatorBase::maxRPCHit
double maxRPCHit
Definition: MuonTrackValidatorBase.h:229
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37
MuonTrackValidatorBase::nintRpos
int nintRpos
Definition: MuonTrackValidatorBase.h:242
MuonTrackValidatorBase::minRpos
double minRpos
Definition: MuonTrackValidatorBase.h:241
MuonTrackValidatorBase::nintLayers
int nintLayers
Definition: MuonTrackValidatorBase.h:232
MuonTrackValidatorBase::label_tp_effic
edm::InputTag label_tp_effic
Definition: MuonTrackValidatorBase.h:201
MuonTrackValidatorBase::phires_vs_eta
std::vector< MonitorElement * > phires_vs_eta
Definition: MuonTrackValidatorBase.h:294
edm::RefToBase::key
size_t key() const
Definition: RefToBase.h:219
MuonTrackValidatorBase::maxZpos
double maxZpos
Definition: MuonTrackValidatorBase.h:243
MuonTrackValidatorBase::BinLogX
void BinLogX(TH1 *h)
Definition: MuonTrackValidatorBase.h:182
MuonTrackValidatorBase::minZpos
double minZpos
Definition: MuonTrackValidatorBase.h:243
MuonTrackValidator::UseAssociators
bool UseAssociators
Definition: MuonTrackValidator.h:150
MuonTrackValidatorBase::dxypull_vs_eta
std::vector< MonitorElement * > dxypull_vs_eta
Definition: MuonTrackValidatorBase.h:297
MuonTrackValidatorBase::etaRes_rangeMin
double etaRes_rangeMin
Definition: MuonTrackValidatorBase.h:250
MuonTrackValidatorBase::minDxy
double minDxy
Definition: MuonTrackValidatorBase.h:237
MuonTrackValidatorBase::nintZpos
int nintZpos
Definition: MuonTrackValidatorBase.h:244
MuonTrackValidatorBase::minPt
double minPt
Definition: MuonTrackValidatorBase.h:219
MuonTrackValidatorBase::maxPt
double maxPt
Definition: MuonTrackValidatorBase.h:219
MuonTrackValidatorBase::h_misidhit
std::vector< MonitorElement * > h_misidhit
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::h_assocpu
std::vector< MonitorElement * > h_assocpu
Definition: MuonTrackValidatorBase.h:273
MuonTrackValidatorBase::h_simulZpos
std::vector< MonitorElement * > h_simulZpos
Definition: MuonTrackValidatorBase.h:275
MuonTrackValidatorBase::h_recodxy
std::vector< MonitorElement * > h_recodxy
Definition: MuonTrackValidatorBase.h:271
hcal_runs.rt
rt
Definition: hcal_runs.py:76
MuonTrackValidatorBase::h_simulpT
std::vector< MonitorElement * > h_simulpT
Definition: MuonTrackValidatorBase.h:268
MuonTrackValidatorBase::useLogPt
bool useLogPt
Definition: MuonTrackValidatorBase.h:221
MuonTrackValidatorBase::minCSCHit
double minCSCHit
Definition: MuonTrackValidatorBase.h:227
edm::LogInfo
Definition: MessageLogger.h:254
MuonTrackValidatorBase::maxDTHit
double maxDTHit
Definition: MuonTrackValidatorBase.h:225
MuonTrackValidatorBase::cotThetaRes_nbin
int cotThetaRes_nbin
Definition: MuonTrackValidatorBase.h:255
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
MuonTrackValidatorBase::thetaCotres_vs_pt
std::vector< MonitorElement * > thetaCotres_vs_pt
Definition: MuonTrackValidatorBase.h:295
MuonTrackValidatorBase::h_recodz
std::vector< MonitorElement * > h_recodz
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::do_TRKhitsPlots
bool do_TRKhitsPlots
Definition: MuonTrackValidatorBase.h:262
MuonTrackValidatorBase::nME0hits_vs_eta
std::vector< MonitorElement * > nME0hits_vs_eta
Definition: MuonTrackValidatorBase.h:289
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
MuonTrackValidatorBase::maxRpos
double maxRpos
Definition: MuonTrackValidatorBase.h:241
MuonTrackValidatorBase::nlosthits_vs_eta
std::vector< MonitorElement * > nlosthits_vs_eta
Definition: MuonTrackValidatorBase.h:291
MuonTrackValidatorBase::nPixel_LayersWithMeas_vs_eta
std::vector< MonitorElement * > nPixel_LayersWithMeas_vs_eta
Definition: MuonTrackValidatorBase.h:292
edm::InputTag::process
std::string const & process() const
Definition: InputTag.h:40
MuonTrackValidatorBase::etares_vs_eta
std::vector< MonitorElement * > etares_vs_eta
Definition: MuonTrackValidatorBase.h:286
MuonTrackValidatorBase::h_nlosthits
std::vector< MonitorElement * > h_nlosthits
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidatorBase::do_MUOhitsPlots
bool do_MUOhitsPlots
Definition: MuonTrackValidatorBase.h:262
TrackingParticle::Vector
math::XYZVectorD Vector
point in the space
Definition: TrackingParticle.h:37
ParametersDefinerForTP::momentum
virtual TrackingParticle::Vector momentum(const edm::Event &iEvent, const edm::EventSetup &iSetup, const Charge ch, const Point &vtx, const LorentzVector &lv) const
Definition: ParametersDefinerForTP.cc:17
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
MuonTrackValidatorBase::h_nmisslayers_outer
std::vector< MonitorElement * > h_nmisslayers_outer
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidator::useME0_
bool useME0_
Definition: MuonTrackValidator.h:152
MuonTrackValidatorBase::h_assocRpos
std::vector< MonitorElement * > h_assocRpos
Definition: MuonTrackValidatorBase.h:275
edm::Handle
Definition: AssociativeIterator.h:50
MuonTrackValidatorBase::minPU
double minPU
Definition: MuonTrackValidatorBase.h:245
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:751
MuonTrackValidatorBase::getEta
double getEta(double eta)
Definition: MuonTrackValidatorBase.h:167
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
MuonTrackValidatorBase::dzRes_rangeMin
double dzRes_rangeMin
Definition: MuonTrackValidatorBase.h:258
MuonTrackValidatorBase::h_recopu
std::vector< MonitorElement * > h_recopu
Definition: MuonTrackValidatorBase.h:273
MuonTrackValidatorBase::nintDTHit
int nintDTHit
Definition: MuonTrackValidatorBase.h:226
edm::Ref< TrackingParticleCollection >
MuonTrackValidatorBase::maxPU
double maxPU
Definition: MuonTrackValidatorBase.h:245
MuonTrackValidatorBase::tp_effic_Token
edm::EDGetTokenT< TrackingParticleCollection > tp_effic_Token
Definition: MuonTrackValidatorBase.h:209
MuonTrackValidatorBase::h_assocFraction
std::vector< MonitorElement * > h_assocFraction
Definition: MuonTrackValidatorBase.h:281
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
MuonTrackValidatorBase::minRPCHit
double minRPCHit
Definition: MuonTrackValidatorBase.h:229
trackingPlots.assoc
assoc
Definition: trackingPlots.py:183
MuonTrackValidatorBase::maxPixels
double maxPixels
Definition: MuonTrackValidatorBase.h:233
MuonTrackValidatorBase::h_misidpT
std::vector< MonitorElement * > h_misidpT
Definition: MuonTrackValidatorBase.h:268
MuonTrackValidatorBase::minEta
double minEta
Definition: MuonTrackValidatorBase.h:216
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
cmsdt::algo
algo
Definition: constants.h:164
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:171
edm::AssociationMap::post_insert
void post_insert()
post insert action
Definition: AssociationMap.h:229
cms::cuda::bs
bs
Definition: HistoContainer.h:127
MuonTrackValidatorBase::h_recoeta
std::vector< MonitorElement * > h_recoeta
Definition: MuonTrackValidatorBase.h:267
trigger::size_type
uint16_t size_type
Definition: TriggerTypeDefs.h:18
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
TrackingParticleIP::dxy
auto dxy(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
Definition: TrackingParticleIP.h:11
MuonTrackValidator::useGEMs_
bool useGEMs_
Definition: MuonTrackValidator.h:151
MuonTrackValidatorBase::pileupinfo_Token
edm::EDGetTokenT< std::vector< PileupSummaryInfo > > pileupinfo_Token
Definition: MuonTrackValidatorBase.h:211
MuonTrackValidatorBase::dxyRes_rangeMin
double dxyRes_rangeMin
Definition: MuonTrackValidatorBase.h:256
MuonTrackValidatorBase::phipull_vs_phi
std::vector< MonitorElement * > phipull_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::nintPhi
int nintPhi
Definition: MuonTrackValidatorBase.h:236
MuonTrackValidatorBase::dxyRes_nbin
int dxyRes_nbin
Definition: MuonTrackValidatorBase.h:257
MuonTrackValidatorBase::phiRes_rangeMin
double phiRes_rangeMin
Definition: MuonTrackValidatorBase.h:252
MuonTrackValidator::_simHitTpMapTag
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > _simHitTpMapTag
Definition: MuonTrackValidator.h:148
MuonTrackValidatorBase::minNHit
double minNHit
Definition: MuonTrackValidatorBase.h:223
w
const double w
Definition: UKUtility.cc:23
MuonTrackValidatorBase::nintPU
int nintPU
Definition: MuonTrackValidatorBase.h:246
MuonTrackValidatorBase::h_assoc2pT
std::vector< MonitorElement * > h_assoc2pT
Definition: MuonTrackValidatorBase.h:268
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
MuonTrackValidatorBase::nCSChits_vs_eta
std::vector< MonitorElement * > nCSChits_vs_eta
Definition: MuonTrackValidatorBase.h:289
TrackingParticle
Monte Carlo truth information used for tracking validation.
Definition: TrackingParticle.h:29
reco::BeamSpot
Definition: BeamSpot.h:21
reco::modules::TrackingParticleSelector
SingleObjectSelector< TrackingParticleCollection, ::TrackingParticleSelector > TrackingParticleSelector
Definition: TrackingParticleSelector.cc:17
MuonTrackValidatorBase::h_recopT
std::vector< MonitorElement * > h_recopT
Definition: MuonTrackValidatorBase.h:268
TrackAssociatorRecord
Definition: TrackAssociatorRecord.h:18
MuonTrackValidatorBase::ptRes_nbin
int ptRes_nbin
Definition: MuonTrackValidatorBase.h:249
edm::ESHandle
Definition: DTSurvey.h:22
MuonTrackValidatorBase::h_assochi2
std::vector< MonitorElement * > h_assochi2
Definition: MuonTrackValidatorBase.h:280
dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:29
MuonTrackValidatorBase::nintDxy
int nintDxy
Definition: MuonTrackValidatorBase.h:238
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:581
MuonTrackValidatorBase::bsSrc_Token
edm::EDGetTokenT< reco::BeamSpot > bsSrc_Token
Definition: MuonTrackValidatorBase.h:208
MuonTrackValidatorBase::nintRPCHit
int nintRPCHit
Definition: MuonTrackValidatorBase.h:230
ctfWithMaterialTrackMCMatch_cfi.associator
associator
Definition: ctfWithMaterialTrackMCMatch_cfi.py:7
MuonTrackValidator::dirName_
std::string dirName_
Definition: MuonTrackValidator.h:144
MuonTrackValidatorBase::dzRes_rangeMax
double dzRes_rangeMax
Definition: MuonTrackValidatorBase.h:258
MuonTrackValidatorBase::h_assocdz
std::vector< MonitorElement * > h_assocdz
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::nRPChits_vs_eta
std::vector< MonitorElement * > nRPChits_vs_eta
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::thetaCotres_vs_eta
std::vector< MonitorElement * > thetaCotres_vs_eta
Definition: MuonTrackValidatorBase.h:294
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
MuonTrackValidatorBase::h_dzpull
std::vector< MonitorElement * > h_dzpull
Definition: MuonTrackValidatorBase.h:301
MuonTrackValidatorBase::h_phipull
std::vector< MonitorElement * > h_phipull
Definition: MuonTrackValidatorBase.h:301
MuonTrackValidator::associatormap
edm::InputTag associatormap
Definition: MuonTrackValidator.h:145
MuonTrackValidatorBase::h_assochi2_prob
std::vector< MonitorElement * > h_assochi2_prob
Definition: MuonTrackValidatorBase.h:280
MuonTrackValidatorBase::nintPt
int nintPt
Definition: MuonTrackValidatorBase.h:220
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::LogWarning
Definition: MessageLogger.h:141
MuonTrackValidatorBase::etaRes_nbin
int etaRes_nbin
Definition: MuonTrackValidatorBase.h:251
edm::View
Definition: CaloClusterFwd.h:14
reco::CosmicTrackingParticleSelector
ObjectSelector< CosmicTrackingParticleSelector > CosmicTrackingParticleSelector
Definition: CosmicTrackingParticleSelector.cc:16
MuonTrackValidatorBase::h_dxypull
std::vector< MonitorElement * > h_dxypull
Definition: MuonTrackValidatorBase.h:301
MuonTrackValidatorBase::chi2_vs_phi
std::vector< MonitorElement * > chi2_vs_phi
Definition: MuonTrackValidatorBase.h:287
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
edm::ParameterSet
Definition: ParameterSet.h:36
MuonTrackValidatorBase::maxDz
double maxDz
Definition: MuonTrackValidatorBase.h:239
MuonTrackValidatorBase::fillPlotNoFlow
void fillPlotNoFlow(MonitorElement *h, T val)
Definition: MuonTrackValidatorBase.h:150
edm::LogError
Definition: MessageLogger.h:183
MuonTrackValidatorBase::h_assoc2phi
std::vector< MonitorElement * > h_assoc2phi
Definition: MuonTrackValidatorBase.h:270
duplicaterechits_cfi.trackCollection
trackCollection
Definition: duplicaterechits_cfi.py:4
MuonTrackValidator::cosmictpSelector
CosmicTrackingParticleSelector cosmictpSelector
Definition: MuonTrackValidator.h:157
MuonTrackValidatorBase::etaRes_rangeMax
double etaRes_rangeMax
Definition: MuonTrackValidatorBase.h:250
MuonTrackValidatorBase::associators
std::vector< std::string > associators
Definition: MuonTrackValidatorBase.h:204
MuonTrackValidatorBase::h_etaRes
std::vector< MonitorElement * > h_etaRes
Definition: MuonTrackValidatorBase.h:276
MuonTrackValidatorBase::h_thetapull
std::vector< MonitorElement * > h_thetapull
Definition: MuonTrackValidatorBase.h:301
edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >
MuonTrackValidatorBase::minDz
double minDz
Definition: MuonTrackValidatorBase.h:239
MuonTrackValidatorBase::dxyres_vs_pt
std::vector< MonitorElement * > dxyres_vs_pt
Definition: MuonTrackValidatorBase.h:295
MuonTrackValidatorBase::phiRes_nbin
int phiRes_nbin
Definition: MuonTrackValidatorBase.h:253
MuonTrackValidatorBase::h_assochit
std::vector< MonitorElement * > h_assochit
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::h_assocdxy
std::vector< MonitorElement * > h_assocdxy
Definition: MuonTrackValidatorBase.h:271
MuonTrackValidatorBase::nintDz
int nintDz
Definition: MuonTrackValidatorBase.h:240
MuonTrackValidatorBase::minPhi
double minPhi
Definition: MuonTrackValidatorBase.h:235
MuonTrackValidatorBase::nGEMhits_vs_eta
std::vector< MonitorElement * > nGEMhits_vs_eta
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::h_simulpu
std::vector< MonitorElement * > h_simulpu
Definition: MuonTrackValidatorBase.h:273
MuonTrackValidatorBase::dzRes_nbin
int dzRes_nbin
Definition: MuonTrackValidatorBase.h:259
createfilelist.int
int
Definition: createfilelist.py:10
MuonTrackValidatorBase::h_simuleta
std::vector< MonitorElement * > h_simuleta
Definition: MuonTrackValidatorBase.h:267
MuonTrackValidatorBase::minPixels
double minPixels
Definition: MuonTrackValidatorBase.h:233
MuonTrackValidatorBase::dxyres_vs_eta
std::vector< MonitorElement * > dxyres_vs_eta
Definition: MuonTrackValidatorBase.h:294
MuonErrorMatrixAnalyzer_cfi.associatorName
associatorName
Definition: MuonErrorMatrixAnalyzer_cfi.py:28
MuonTrackValidatorBase::nintCSCHit
int nintCSCHit
Definition: MuonTrackValidatorBase.h:228
MuonTrackValidatorBase::phipull_vs_eta
std::vector< MonitorElement * > phipull_vs_eta
Definition: MuonTrackValidatorBase.h:297
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
edm::LogVerbatim
Definition: MessageLogger.h:297
MuonTrackValidatorBase::maxPhi
double maxPhi
Definition: MuonTrackValidatorBase.h:235
MuonTrackValidatorBase::h_nchi2_prob
std::vector< MonitorElement * > h_nchi2_prob
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::h_assoc2eta
std::vector< MonitorElement * > h_assoc2eta
Definition: MuonTrackValidatorBase.h:267
MuonTrackValidatorBase::nDThits_vs_eta
std::vector< MonitorElement * > nDThits_vs_eta
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::h_assoc2pu
std::vector< MonitorElement * > h_assoc2pu
Definition: MuonTrackValidatorBase.h:273
MuonTrackValidatorBase::usemuon
bool usemuon
Definition: MuonTrackValidatorBase.h:261
MuonTrackValidatorBase::h_PurityVsQuality
std::vector< MonitorElement * > h_PurityVsQuality
Definition: MuonTrackValidatorBase.h:285
MuonTrackValidatorBase::track_Collection_Token
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > track_Collection_Token
Definition: MuonTrackValidatorBase.h:207
MuonTrackValidatorBase::h_recohit
std::vector< MonitorElement * > h_recohit
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::parametersDefiner
std::string parametersDefiner
Definition: MuonTrackValidatorBase.h:206
get
#define get
MuonTrackValidatorBase::h_assoc2hit
std::vector< MonitorElement * > h_assoc2hit
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::h_fakes
std::vector< MonitorElement * > h_fakes
Definition: MuonTrackValidatorBase.h:266
MuonTrackValidatorBase::h_ptpull
std::vector< MonitorElement * > h_ptpull
Definition: MuonTrackValidatorBase.h:301
MuonTrackValidatorBase::h_misiddxy
std::vector< MonitorElement * > h_misiddxy
Definition: MuonTrackValidatorBase.h:271
MuonTrackValidatorBase::ptpull_vs_phi
std::vector< MonitorElement * > ptpull_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::ptRes_rangeMin
double ptRes_rangeMin
Definition: MuonTrackValidatorBase.h:248
MuonTrackValidatorBase::nhits_vs_eta
std::vector< MonitorElement * > nhits_vs_eta
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::h_assoc2dxy
std::vector< MonitorElement * > h_assoc2dxy
Definition: MuonTrackValidatorBase.h:271
MuonTrackValidator::simToRecoCollection_Token
edm::EDGetTokenT< reco::SimToRecoCollection > simToRecoCollection_Token
Definition: MuonTrackValidator.h:146
MuonTrackValidatorBase::cotThetaRes_rangeMin
double cotThetaRes_rangeMin
Definition: MuonTrackValidatorBase.h:254
MuonTrackValidatorBase::h_nmisslayers_inner
std::vector< MonitorElement * > h_nmisslayers_inner
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidatorBase::thetapull_vs_eta
std::vector< MonitorElement * > thetapull_vs_eta
Definition: MuonTrackValidatorBase.h:297
MuonTrackValidatorBase::phires_vs_phi
std::vector< MonitorElement * > phires_vs_phi
Definition: MuonTrackValidatorBase.h:287
MuonTrackValidatorBase::label_pileupinfo
edm::InputTag label_pileupinfo
Definition: MuonTrackValidatorBase.h:203
MuonTrackValidatorBase::dzres_vs_pt
std::vector< MonitorElement * > dzres_vs_pt
Definition: MuonTrackValidatorBase.h:295
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
MuonTrackValidatorBase::ignoremissingtkcollection_
bool ignoremissingtkcollection_
Definition: MuonTrackValidatorBase.h:263
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
MuonTrackValidatorBase::phiRes_rangeMax
double phiRes_rangeMax
Definition: MuonTrackValidatorBase.h:252
MuonTrackValidatorBase::h_nhits
std::vector< MonitorElement * > h_nhits
Definition: MuonTrackValidatorBase.h:266
MuonTrackValidatorBase::bsSrc
edm::InputTag bsSrc
Definition: MuonTrackValidatorBase.h:200
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
edm::AssociationMap::begin
const_iterator begin() const
first iterator over the map (read only)
Definition: AssociationMap.h:169
MuonTrackValidatorBase::maxEta
double maxEta
Definition: MuonTrackValidatorBase.h:216
MuonTrackValidatorBase::h_assocSharedHit
std::vector< MonitorElement * > h_assocSharedHit
Definition: MuonTrackValidatorBase.h:281
MuonTrackValidatorBase::usetracker
bool usetracker
Definition: MuonTrackValidatorBase.h:261
TrackerOfflineValidation_Dqm_cff.dirName
dirName
Definition: TrackerOfflineValidation_Dqm_cff.py:55
TrackingParticleCollection
std::vector< TrackingParticle > TrackingParticleCollection
Definition: TrackingParticleFwd.h:8
MuonTrackValidatorBase::maxCSCHit
double maxCSCHit
Definition: MuonTrackValidatorBase.h:227
MuonTrackValidator::BiDirectional_RecoToSim_association
bool BiDirectional_RecoToSim_association
Definition: MuonTrackValidator.h:160
edm::RefToBase
Definition: AssociativeIterator.h:54
MuonTrackValidatorBase::h_tracks
std::vector< MonitorElement * > h_tracks
Definition: MuonTrackValidatorBase.h:266
MuonTrackValidatorBase::h_assoceta
std::vector< MonitorElement * > h_assoceta
Definition: MuonTrackValidatorBase.h:267
MuonTrackValidatorBase::minLayers
double minLayers
Definition: MuonTrackValidatorBase.h:231
CosmicParametersDefinerForTP::clone
std::unique_ptr< ParametersDefinerForTP > clone() const override
Definition: CosmicParametersDefinerForTP.h:45
MuonTrackValidatorBase::label_tp_fake
edm::InputTag label_tp_fake
Definition: MuonTrackValidatorBase.h:202
MuonTrackValidatorBase::h_qoverppull
std::vector< MonitorElement * > h_qoverppull
Definition: MuonTrackValidatorBase.h:301
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
MuonTrackValidator::tpSelector
TrackingParticleSelector tpSelector
Definition: MuonTrackValidator.h:156
MuonTrackValidatorBase::nRecHits_vs_nSimHits
std::vector< MonitorElement * > nRecHits_vs_nSimHits
Definition: MuonTrackValidatorBase.h:284
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
MuonTrackValidatorBase::thetapull_vs_phi
std::vector< MonitorElement * > thetapull_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::nTRK_LayersWithMeas_vs_eta
std::vector< MonitorElement * > nTRK_LayersWithMeas_vs_eta
Definition: MuonTrackValidatorBase.h:292
MuonTrackValidatorBase::h_simuldz
std::vector< MonitorElement * > h_simuldz
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::dxyRes_rangeMax
double dxyRes_rangeMax
Definition: MuonTrackValidatorBase.h:256
MuonTrackValidatorBase::ptres_vs_eta
std::vector< MonitorElement * > ptres_vs_eta
Definition: MuonTrackValidatorBase.h:294
MuonTrackValidatorBase::cotThetaRes_rangeMax
double cotThetaRes_rangeMax
Definition: MuonTrackValidatorBase.h:254
MuonTrackValidatorBase::getPt
double getPt(double pt)
Definition: MuonTrackValidatorBase.h:175
MuonTrackValidatorBase::h_simuldxy
std::vector< MonitorElement * > h_simuldxy
Definition: MuonTrackValidatorBase.h:271
event
Definition: event.py:1
MuonTrackValidatorBase::h_simulhit
std::vector< MonitorElement * > h_simulhit
Definition: MuonTrackValidatorBase.h:269
TrackingParticle::Point
math::XYZPointD Point
point in the space
Definition: TrackingParticle.h:36
MuonTrackValidatorBase::h_nchi2
std::vector< MonitorElement * > h_nchi2
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::nhits_vs_phi
std::vector< MonitorElement * > nhits_vs_phi
Definition: MuonTrackValidatorBase.h:287
MuonTrackValidatorBase::h_assoc2dz
std::vector< MonitorElement * > h_assoc2dz
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::MuonTrackValidatorBase
MuonTrackValidatorBase(const edm::ParameterSet &pset, edm::ConsumesCollector iC)
Constructor.
Definition: MuonTrackValidatorBase.h:43
MuonTrackValidatorBase::ptpull_vs_eta
std::vector< MonitorElement * > ptpull_vs_eta
Definition: MuonTrackValidatorBase.h:297
MuonTrackValidatorBase::h_recophi
std::vector< MonitorElement * > h_recophi
Definition: MuonTrackValidatorBase.h:270
MuonTrackValidatorBase::h_charge
std::vector< MonitorElement * > h_charge
Definition: MuonTrackValidatorBase.h:266
HLT_2018_cff.fraction
fraction
Definition: HLT_2018_cff.py:51317
MuonTrackValidatorBase::chi2_vs_nhits
std::vector< MonitorElement * > chi2_vs_nhits
Definition: MuonTrackValidatorBase.h:286
MuonTrackValidatorBase::phires_vs_pt
std::vector< MonitorElement * > phires_vs_pt
Definition: MuonTrackValidatorBase.h:295
edm::InputTag
Definition: InputTag.h:15
MuonTrackValidatorBase::dzres_vs_eta
std::vector< MonitorElement * > dzres_vs_eta
Definition: MuonTrackValidatorBase.h:294
MuonTrackValidatorBase::minDTHit
double minDTHit
Definition: MuonTrackValidatorBase.h:225
edm::View::size_type
unsigned int size_type
Definition: View.h:90
MuonTrackValidatorBase::maxDxy
double maxDxy
Definition: MuonTrackValidatorBase.h:237
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
MuonTrackValidatorBase::h_simulphi
std::vector< MonitorElement * > h_simulphi
Definition: MuonTrackValidatorBase.h:270
MuonTrackValidatorBase::h_assocphi
std::vector< MonitorElement * > h_assocphi
Definition: MuonTrackValidatorBase.h:270
MuonTrackValidatorBase::nintPixels
int nintPixels
Definition: MuonTrackValidatorBase.h:234
muonME0PseudoDigis_cfi.phiError
phiError
Definition: muonME0PseudoDigis_cfi.py:9
ParametersDefinerForTP::vertex
virtual TrackingParticle::Point vertex(const edm::Event &iEvent, const edm::EventSetup &iSetup, const Charge ch, const Point &vtx, const LorentzVector &lv) const
Definition: ParametersDefinerForTP.cc:50
ecaldqm::Quality
Quality
Definition: DBWriterWorkers.cc:55
TrackingParticleIP::dz
auto dz(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
Definition: TrackingParticleIP.h:16
python.rootplot.root2matplotlib.replace
def replace(string, replacements)
Definition: root2matplotlib.py:444
MuonTrackValidator::MABH
bool MABH
Definition: MuonTrackValidator.h:162
MuonTrackValidatorBase::maxLayers
double maxLayers
Definition: MuonTrackValidatorBase.h:231
Generated for CMSSW Reference Manual by doxygen 1.8.16