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
 
void bookHistograms (DQMEDAnalyzer::DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
 
 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
 
 EDProducer (const EDProducer &)=delete
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 
const EDProducer & operator= (const EDProducer &)=delete
 

Private Attributes

edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > _simHitTpMapTag
 
edm::InputTag associatormap
 
bool BiDirectional_RecoToSim_association
 
const edm::ESGetToken< CosmicParametersDefinerForTP, TrackAssociatorRecord > cosmictpDefinerEsToken
 
CosmicTrackingParticleSelector cosmictpSelector
 
std::string dirName_
 
bool MABH
 
edm::EDGetTokenT< reco::RecoToSimCollection > recoToSimCollection_Token
 
edm::EDGetTokenT< reco::SimToRecoCollection > simToRecoCollection_Token
 
const edm::ESGetToken< ParametersDefinerForTP, TrackAssociatorRecord > tpDefinerEsToken
 
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 >
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::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
 
bool label_tp_refvector
 
double maxCSCHit
 
double maxDTHit
 
double maxDxy
 
double maxDz
 
double maxEta
 
int maxFTracks
 
double maxLayers
 
double maxNHit
 
int maxNTracks
 
double maxPhi
 
double maxPixels
 
double maxPt
 
double maxPU
 
double maxRPCHit
 
double maxRpos
 
double maxZpos
 
double minCSCHit
 
double minDTHit
 
double minDxy
 
double minDz
 
double minEta
 
int minFTracks
 
double minLayers
 
double minNHit
 
int minNTracks
 
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 nintFTracks
 
int nintLayers
 
int nintNHit
 
int nintNTracks
 
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< TrackingParticleRefVector > tp_refvector_Token
 
edm::EDGetTokenT< TrackingParticleCollection > tp_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 26 of file MuonTrackValidator.h.

Constructor & Destructor Documentation

◆ MuonTrackValidator()

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

Constructor.

Definition at line 29 of file MuonTrackValidator.h.

30  : MuonTrackValidatorBase(pset),
31  tpDefinerEsToken(
32  esConsumes<ParametersDefinerForTP, TrackAssociatorRecord>(edm::ESInputTag("", parametersDefiner))),
33  cosmictpDefinerEsToken(
34  esConsumes<CosmicParametersDefinerForTP, TrackAssociatorRecord>(edm::ESInputTag("", parametersDefiner))) {
35  dirName_ = pset.getParameter<std::string>("dirName");
36  associatormap = pset.getParameter<edm::InputTag>("associatormap");
37  UseAssociators = pset.getParameter<bool>("UseAssociators");
38  useGEMs_ = pset.getParameter<bool>("useGEMs");
39  useME0_ = pset.getParameter<bool>("useME0");
40  edm::ParameterSet tpset = pset.getParameter<edm::ParameterSet>("muonTPSelector");
41  tpSelector = TrackingParticleSelector(tpset.getParameter<double>("ptMin"),
42  tpset.getParameter<double>("ptMax"),
43  tpset.getParameter<double>("minRapidity"),
44  tpset.getParameter<double>("maxRapidity"),
45  tpset.getParameter<double>("tip"),
46  tpset.getParameter<double>("lip"),
47  tpset.getParameter<int>("minHit"),
48  tpset.getParameter<bool>("signalOnly"),
49  tpset.getParameter<bool>("intimeOnly"),
50  tpset.getParameter<bool>("chargedOnly"),
51  tpset.getParameter<bool>("stableOnly"),
52  tpset.getParameter<std::vector<int> >("pdgId"));
53 
54  cosmictpSelector = CosmicTrackingParticleSelector(tpset.getParameter<double>("ptMin"),
55  tpset.getParameter<double>("minRapidity"),
56  tpset.getParameter<double>("maxRapidity"),
57  tpset.getParameter<double>("tip"),
58  tpset.getParameter<double>("lip"),
59  tpset.getParameter<int>("minHit"),
60  tpset.getParameter<bool>("chargedOnly"),
61  tpset.getParameter<std::vector<int> >("pdgId"));
62 
63  BiDirectional_RecoToSim_association = pset.getParameter<bool>("BiDirectional_RecoToSim_association");
64 
65  // dump cfg parameters
66  edm::LogVerbatim("MuonTrackValidator") << "constructing MuonTrackValidator: " << pset.dump();
67 
68  // Declare consumes (also for the base class)
69  bsSrc_Token = consumes<reco::BeamSpot>(bsSrc);
70  if (label_tp_refvector)
71  tp_refvector_Token = consumes<TrackingParticleRefVector>(label_tp);
72  else
73  tp_Token = consumes<TrackingParticleCollection>(label_tp);
74  pileupinfo_Token = consumes<std::vector<PileupSummaryInfo> >(label_pileupinfo);
75  for (unsigned int www = 0; www < label.size(); www++) {
76  track_Collection_Token.push_back(consumes<edm::View<reco::Track> >(label[www]));
77  }
78  simToRecoCollection_Token = consumes<reco::SimToRecoCollection>(associatormap);
79  recoToSimCollection_Token = consumes<reco::RecoToSimCollection>(associatormap);
80 
81  _simHitTpMapTag = mayConsume<SimHitTPAssociationProducer::SimHitTPAssociationList>(
82  pset.getParameter<edm::InputTag>("simHitTpMapTag"));
83 
84  MABH = false;
85  if (!UseAssociators) {
86  // flag MuonAssociatorByHits
87  if (associators[0] == "MuonAssociationByHits")
88  MABH = true;
89  // reset string associators to the map label
90  associators.clear();
91  associators.push_back(associatormap.label());
92  edm::LogVerbatim("MuonTrackValidator") << "--> associators reset to: " << associators[0];
93  } else {
94  for (auto const& associator : associators) {
95  consumes<reco::TrackToTrackingParticleAssociator>(edm::InputTag(associator));
96  }
97  }
98 
99  // inform on which SimHits will be counted
100  if (usetracker)
101  edm::LogVerbatim("MuonTrackValidator") << "\n usetracker = TRUE : Tracker SimHits WILL be counted";
102  else
103  edm::LogVerbatim("MuonTrackValidator") << "\n usetracker = FALSE : Tracker SimHits WILL NOT be counted";
104  if (usemuon)
105  edm::LogVerbatim("MuonTrackValidator") << " usemuon = TRUE : Muon SimHits WILL be counted";
106  else
107  edm::LogVerbatim("MuonTrackValidator") << " usemuon = FALSE : Muon SimHits WILL NOT be counted" << std::endl;
108 
109  // loop over the reco::Track collections to validate: check for inconsistent input settings
110  for (unsigned int www = 0; www < label.size(); www++) {
111  std::string recoTracksLabel = label[www].label();
112  std::string recoTracksInstance = label[www].instance();
113 
114  // tracks with hits only on tracker
115  if (recoTracksLabel == "generalTracks" || recoTracksLabel == "probeTracks" ||
116  recoTracksLabel == "displacedTracks" || recoTracksLabel == "extractGemMuons" ||
117  recoTracksLabel == "extractMe0Muons" || recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" ||
118  recoTracksLabel == "ctfWithMaterialTracksP5" ||
119  recoTracksLabel == "hltIterL3OIMuonTrackSelectionHighPurity" || recoTracksLabel == "hltIterL3MuonMerged" ||
120  recoTracksLabel == "hltIterL3MuonAndMuonFromL1Merged") {
121  if (usemuon) {
122  edm::LogWarning("MuonTrackValidator")
123  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == true"
124  << "\n ---> resetting to usemuon == false ";
125  usemuon = false;
126  }
127  if (!usetracker) {
128  edm::LogWarning("MuonTrackValidator")
129  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == false"
130  << "\n ---> resetting to usetracker == true ";
131  usetracker = true;
132  }
133  }
134 
135  // tracks with hits only on muon detectors
136  else if (recoTracksLabel == "seedsOfSTAmuons" || recoTracksLabel == "standAloneMuons" ||
137  recoTracksLabel == "seedsOfDisplacedSTAmuons" || recoTracksLabel == "displacedStandAloneMuons" ||
138  recoTracksLabel == "refittedStandAloneMuons" || recoTracksLabel == "cosmicMuons" ||
139  recoTracksLabel == "cosmicMuons1Leg" || recoTracksLabel == "hltL2Muons") {
140  if (usetracker) {
141  edm::LogWarning("MuonTrackValidator")
142  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == true"
143  << "\n ---> resetting to usetracker == false ";
144  usetracker = false;
145  }
146  if (!usemuon) {
147  edm::LogWarning("MuonTrackValidator")
148  << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == false"
149  << "\n ---> resetting to usemuon == true ";
150  usemuon = true;
151  }
152  }
153 
154  } // for (unsigned int www=0;www<label.size();www++)
155  }

References _simHitTpMapTag, LCToCPAssociation_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, MuonTrackValidatorBase::label_tp_refvector, MABH, MuonTrackValidatorBase::pileupinfo_Token, muonDTDigis_cfi::pset, recoToSimCollection_Token, simToRecoCollection_Token, AlCaHLTBitMon_QueryRunRegistry::string, MuonTrackValidatorBase::tp_refvector_Token, MuonTrackValidatorBase::tp_Token, tpSelector, MuonTrackValidatorBase::track_Collection_Token, UseAssociators, useGEMs_, useME0_, MuonTrackValidatorBase::usemuon, and MuonTrackValidatorBase::usetracker.

◆ ~MuonTrackValidator()

MuonTrackValidator::~MuonTrackValidator ( )
inlineoverride

Destructor.

Definition at line 158 of file MuonTrackValidator.h.

158 {}

Member Function Documentation

◆ analyze()

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

Reimplemented from DQMEDAnalyzer.

Definition at line 359 of file MuonTrackValidator.cc.

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

References funct::abs(), LCToCPAssociation_cfi::associator, muonValidationHeavyIons_cff::associatormap, MuonErrorMatrixAnalyzer_cfi::associatorName, trackTimeValueMapProducer_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_FULL_cff::fraction, edm::Ref< C, T, F >::get(), mps_fire::i, createfilelist::int, edm::RefToBase< T >::key(), edm::Ref< C, T, F >::key(), label, MuonTrackValidator_cfi::label_tp_refvector, 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(), edm::RefVector< C, T, F >::push_back(), quality, hcal_runs::rt, singleTopDQM_cfi::setup, funct::sin(), edm::RefVector< C, T, F >::size(), mathSSE::sqrt(), cmsswSequenceInfo::tp, RecoMuonValidator_cfi::tpSelector, HLT_FULL_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

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

References trackingPlots::assoc, trackTimeValueMapProducer_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::maxFTracks, histoParameters_cff::maxLayers, histoParameters_cff::maxNHit, HLT_FULL_cff::maxNTracks, HLT_FULL_cff::maxPhi, histoParameters_cff::maxPixels, L1TrackerEtMissProducer_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, histoParameters_cff::minFTracks, beam_dqm_sourceclient-live_cfg::minLayers, histoParameters_cff::minNHit, histoParameters_cff::minNTracks, HLT_FULL_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::nintFTracks, histoParameters_cff::nintLayers, histoParameters_cff::nintNHit, histoParameters_cff::nintNTracks, 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 168 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ associatormap

edm::InputTag MuonTrackValidator::associatormap
private

Definition at line 165 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ BiDirectional_RecoToSim_association

bool MuonTrackValidator::BiDirectional_RecoToSim_association
private

Definition at line 183 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ cosmictpDefinerEsToken

const edm::ESGetToken<CosmicParametersDefinerForTP, TrackAssociatorRecord> MuonTrackValidator::cosmictpDefinerEsToken
private

Definition at line 171 of file MuonTrackValidator.h.

◆ cosmictpSelector

CosmicTrackingParticleSelector MuonTrackValidator::cosmictpSelector
private

Definition at line 180 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ dirName_

std::string MuonTrackValidator::dirName_
private

Definition at line 164 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ MABH

bool MuonTrackValidator::MABH
private

Definition at line 185 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ recoToSimCollection_Token

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

Definition at line 167 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ simToRecoCollection_Token

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

Definition at line 166 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ tpDefinerEsToken

const edm::ESGetToken<ParametersDefinerForTP, TrackAssociatorRecord> MuonTrackValidator::tpDefinerEsToken
private

Definition at line 170 of file MuonTrackValidator.h.

◆ tpSelector

TrackingParticleSelector MuonTrackValidator::tpSelector
private

Definition at line 179 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ UseAssociators

bool MuonTrackValidator::UseAssociators
private

Definition at line 173 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ useGEMs_

bool MuonTrackValidator::useGEMs_
private

Definition at line 174 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

◆ useME0_

bool MuonTrackValidator::useME0_
private

Definition at line 175 of file MuonTrackValidator.h.

Referenced by MuonTrackValidator().

LCToCPAssociation_cfi.associator
associator
Definition: LCToCPAssociation_cfi.py:4
MuonTrackValidatorBase::h_misiddz
std::vector< MonitorElement * > h_misiddz
Definition: MuonTrackValidatorBase.h:283
MuonTrackValidatorBase::h_simulRpos
std::vector< MonitorElement * > h_simulRpos
Definition: MuonTrackValidatorBase.h:286
MuonTrackValidatorBase::chi2_vs_eta
std::vector< MonitorElement * > chi2_vs_eta
Definition: MuonTrackValidatorBase.h:302
MuonTrackValidatorBase::ptres_vs_phi
std::vector< MonitorElement * > ptres_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::ptRes_rangeMax
double ptRes_rangeMax
Definition: MuonTrackValidatorBase.h:259
reco::HitPattern::MISSING_OUTER_HITS
Definition: HitPattern.h:155
MuonTrackValidatorBase::ptres_vs_pt
std::vector< MonitorElement * > ptres_vs_pt
Definition: MuonTrackValidatorBase.h:306
MuonTrackValidatorBase::maxNHit
double maxNHit
Definition: MuonTrackValidatorBase.h:234
MuonTrackValidatorBase::h_assocpT
std::vector< MonitorElement * > h_assocpT
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidatorBase::dzpull_vs_eta
std::vector< MonitorElement * > dzpull_vs_eta
Definition: MuonTrackValidatorBase.h:308
MuonTrackValidatorBase::h_assocZpos
std::vector< MonitorElement * > h_assocZpos
Definition: MuonTrackValidatorBase.h:286
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:428
edm::ESInputTag
Definition: ESInputTag.h:87
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11724
MuonTrackValidatorBase::h_misidphi
std::vector< MonitorElement * > h_misidphi
Definition: MuonTrackValidatorBase.h:281
MuonTrackValidatorBase::label
std::vector< edm::InputTag > label
Definition: MuonTrackValidatorBase.h:208
MuonTrackValidator::recoToSimCollection_Token
edm::EDGetTokenT< reco::RecoToSimCollection > recoToSimCollection_Token
Definition: MuonTrackValidator.h:167
MuonTrackValidatorBase::nintEta
int nintEta
Definition: MuonTrackValidatorBase.h:228
MuonTrackValidatorBase::h_misidpu
std::vector< MonitorElement * > h_misidpu
Definition: MuonTrackValidatorBase.h:284
edm::Handle::product
T const * product() const
Definition: Handle.h:70
MuonTrackValidatorBase::h_misideta
std::vector< MonitorElement * > h_misideta
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::nintNHit
int nintNHit
Definition: MuonTrackValidatorBase.h:235
MuonTrackValidatorBase::maxRPCHit
double maxRPCHit
Definition: MuonTrackValidatorBase.h:240
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37
MuonTrackValidatorBase::nintRpos
int nintRpos
Definition: MuonTrackValidatorBase.h:253
MuonTrackValidatorBase::minRpos
double minRpos
Definition: MuonTrackValidatorBase.h:252
MuonTrackValidatorBase::nintLayers
int nintLayers
Definition: MuonTrackValidatorBase.h:243
MuonTrackValidatorBase::phires_vs_eta
std::vector< MonitorElement * > phires_vs_eta
Definition: MuonTrackValidatorBase.h:305
edm::RefToBase::key
size_t key() const
Definition: RefToBase.h:219
MuonTrackValidatorBase::maxZpos
double maxZpos
Definition: MuonTrackValidatorBase.h:254
MuonTrackValidatorBase::BinLogX
void BinLogX(TH1 *h)
Definition: MuonTrackValidatorBase.h:191
MuonTrackValidatorBase::minZpos
double minZpos
Definition: MuonTrackValidatorBase.h:254
MuonTrackValidator::UseAssociators
bool UseAssociators
Definition: MuonTrackValidator.h:173
MuonTrackValidatorBase::dxypull_vs_eta
std::vector< MonitorElement * > dxypull_vs_eta
Definition: MuonTrackValidatorBase.h:308
MuonTrackValidatorBase::etaRes_rangeMin
double etaRes_rangeMin
Definition: MuonTrackValidatorBase.h:261
MuonTrackValidatorBase::minDxy
double minDxy
Definition: MuonTrackValidatorBase.h:248
MuonTrackValidatorBase::nintZpos
int nintZpos
Definition: MuonTrackValidatorBase.h:255
MuonTrackValidatorBase::minPt
double minPt
Definition: MuonTrackValidatorBase.h:230
MuonTrackValidatorBase::maxPt
double maxPt
Definition: MuonTrackValidatorBase.h:230
MuonTrackValidatorBase::h_misidhit
std::vector< MonitorElement * > h_misidhit
Definition: MuonTrackValidatorBase.h:280
MuonTrackValidatorBase::h_assocpu
std::vector< MonitorElement * > h_assocpu
Definition: MuonTrackValidatorBase.h:284
MuonTrackValidatorBase::h_simulZpos
std::vector< MonitorElement * > h_simulZpos
Definition: MuonTrackValidatorBase.h:286
MuonTrackValidatorBase::h_recodxy
std::vector< MonitorElement * > h_recodxy
Definition: MuonTrackValidatorBase.h:282
hcal_runs.rt
rt
Definition: hcal_runs.py:76
MuonTrackValidatorBase::h_simulpT
std::vector< MonitorElement * > h_simulpT
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidatorBase::useLogPt
bool useLogPt
Definition: MuonTrackValidatorBase.h:232
MuonTrackValidatorBase::minCSCHit
double minCSCHit
Definition: MuonTrackValidatorBase.h:238
MuonTrackValidatorBase::maxDTHit
double maxDTHit
Definition: MuonTrackValidatorBase.h:236
MuonTrackValidatorBase::cotThetaRes_nbin
int cotThetaRes_nbin
Definition: MuonTrackValidatorBase.h:266
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:306
MuonTrackValidatorBase::h_recodz
std::vector< MonitorElement * > h_recodz
Definition: MuonTrackValidatorBase.h:283
MuonTrackValidatorBase::minFTracks
int minFTracks
Definition: MuonTrackValidatorBase.h:226
MuonTrackValidatorBase::do_TRKhitsPlots
bool do_TRKhitsPlots
Definition: MuonTrackValidatorBase.h:273
MuonTrackValidatorBase::nME0hits_vs_eta
std::vector< MonitorElement * > nME0hits_vs_eta
Definition: MuonTrackValidatorBase.h:300
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
MuonTrackValidatorBase::maxRpos
double maxRpos
Definition: MuonTrackValidatorBase.h:252
MuonTrackValidatorBase::nlosthits_vs_eta
std::vector< MonitorElement * > nlosthits_vs_eta
Definition: MuonTrackValidatorBase.h:302
MuonTrackValidatorBase::nPixel_LayersWithMeas_vs_eta
std::vector< MonitorElement * > nPixel_LayersWithMeas_vs_eta
Definition: MuonTrackValidatorBase.h:303
MuonTrackValidatorBase::tp_Token
edm::EDGetTokenT< TrackingParticleCollection > tp_Token
Definition: MuonTrackValidatorBase.h:218
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:297
MuonTrackValidatorBase::h_nlosthits
std::vector< MonitorElement * > h_nlosthits
Definition: MuonTrackValidatorBase.h:290
MuonTrackValidatorBase::do_MUOhitsPlots
bool do_MUOhitsPlots
Definition: MuonTrackValidatorBase.h:273
TrackingParticle::Vector
math::XYZVectorD Vector
point in the space
Definition: TrackingParticle.h:37
edm::RefVector< TrackingParticleCollection >
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:46
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
MuonTrackValidatorBase::h_nmisslayers_outer
std::vector< MonitorElement * > h_nmisslayers_outer
Definition: MuonTrackValidatorBase.h:290
MuonTrackValidator::useME0_
bool useME0_
Definition: MuonTrackValidator.h:175
MuonTrackValidatorBase::h_assocRpos
std::vector< MonitorElement * > h_assocRpos
Definition: MuonTrackValidatorBase.h:286
MuonTrackValidator::cosmictpDefinerEsToken
const edm::ESGetToken< CosmicParametersDefinerForTP, TrackAssociatorRecord > cosmictpDefinerEsToken
Definition: MuonTrackValidator.h:171
edm::Handle
Definition: AssociativeIterator.h:50
MuonTrackValidatorBase::minPU
double minPU
Definition: MuonTrackValidatorBase.h:256
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:798
MuonTrackValidatorBase::getEta
double getEta(double eta)
Definition: MuonTrackValidatorBase.h:176
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
singleTopDQM_cfi.setup
setup
Definition: singleTopDQM_cfi.py:37
MuonTrackValidatorBase::dzRes_rangeMin
double dzRes_rangeMin
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::h_recopu
std::vector< MonitorElement * > h_recopu
Definition: MuonTrackValidatorBase.h:284
MuonTrackValidatorBase::nintDTHit
int nintDTHit
Definition: MuonTrackValidatorBase.h:237
edm::Ref< TrackingParticleCollection >
MuonTrackValidatorBase::maxPU
double maxPU
Definition: MuonTrackValidatorBase.h:256
MuonTrackValidatorBase::h_assocFraction
std::vector< MonitorElement * > h_assocFraction
Definition: MuonTrackValidatorBase.h:292
quality
const uint32_t *__restrict__ Quality * quality
Definition: CAHitNtupletGeneratorKernelsImpl.h:122
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
MuonTrackValidatorBase::minRPCHit
double minRPCHit
Definition: MuonTrackValidatorBase.h:240
trackingPlots.assoc
assoc
Definition: trackingPlots.py:183
MuonTrackValidatorBase::maxPixels
double maxPixels
Definition: MuonTrackValidatorBase.h:244
MuonTrackValidatorBase::h_misidpT
std::vector< MonitorElement * > h_misidpT
Definition: MuonTrackValidatorBase.h:279
MuonTrackValidatorBase::minEta
double minEta
Definition: MuonTrackValidatorBase.h:227
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
cmsdt::algo
algo
Definition: constants.h:171
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:76
pixelTrack::Quality
Quality
Definition: TrackSoAHeterogeneousT.h:13
MuonTrackValidatorBase::h_recoeta
std::vector< MonitorElement * > h_recoeta
Definition: MuonTrackValidatorBase.h:278
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:174
MuonTrackValidatorBase::pileupinfo_Token
edm::EDGetTokenT< std::vector< PileupSummaryInfo > > pileupinfo_Token
Definition: MuonTrackValidatorBase.h:220
MuonTrackValidatorBase::dxyRes_rangeMin
double dxyRes_rangeMin
Definition: MuonTrackValidatorBase.h:267
MuonTrackValidatorBase::phipull_vs_phi
std::vector< MonitorElement * > phipull_vs_phi
Definition: MuonTrackValidatorBase.h:309
HLT_FULL_cff.fraction
fraction
Definition: HLT_FULL_cff.py:52823
MuonTrackValidatorBase::maxNTracks
int maxNTracks
Definition: MuonTrackValidatorBase.h:225
MuonTrackValidatorBase::nintPhi
int nintPhi
Definition: MuonTrackValidatorBase.h:247
MuonTrackValidatorBase::dxyRes_nbin
int dxyRes_nbin
Definition: MuonTrackValidatorBase.h:268
MuonTrackValidatorBase::phiRes_rangeMin
double phiRes_rangeMin
Definition: MuonTrackValidatorBase.h:263
MuonTrackValidator::_simHitTpMapTag
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > _simHitTpMapTag
Definition: MuonTrackValidator.h:168
MuonTrackValidatorBase::minNHit
double minNHit
Definition: MuonTrackValidatorBase.h:234
w
const double w
Definition: UKUtility.cc:23
MuonTrackValidatorBase::nintPU
int nintPU
Definition: MuonTrackValidatorBase.h:257
MuonTrackValidatorBase::h_assoc2pT
std::vector< MonitorElement * > h_assoc2pT
Definition: MuonTrackValidatorBase.h:279
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
MuonTrackValidatorBase::nCSChits_vs_eta
std::vector< MonitorElement * > nCSChits_vs_eta
Definition: MuonTrackValidatorBase.h:300
MuonTrackValidatorBase::tp_refvector_Token
edm::EDGetTokenT< TrackingParticleRefVector > tp_refvector_Token
Definition: MuonTrackValidatorBase.h:219
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:279
MuonTrackValidatorBase::ptRes_nbin
int ptRes_nbin
Definition: MuonTrackValidatorBase.h:260
edm::ESHandle
Definition: DTSurvey.h:22
MuonTrackValidatorBase::h_assochi2
std::vector< MonitorElement * > h_assochi2
Definition: MuonTrackValidatorBase.h:291
dqm::implementation::NavigatorBase::cd
virtual void cd()
Definition: DQMStore.cc:29
MuonTrackValidatorBase::nintDxy
int nintDxy
Definition: MuonTrackValidatorBase.h:249
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:596
MuonTrackValidatorBase::bsSrc_Token
edm::EDGetTokenT< reco::BeamSpot > bsSrc_Token
Definition: MuonTrackValidatorBase.h:217
MuonTrackValidatorBase::nintRPCHit
int nintRPCHit
Definition: MuonTrackValidatorBase.h:241
MuonTrackValidator::dirName_
std::string dirName_
Definition: MuonTrackValidator.h:164
MuonTrackValidatorBase::dzRes_rangeMax
double dzRes_rangeMax
Definition: MuonTrackValidatorBase.h:269
MuonTrackValidatorBase::h_assocdz
std::vector< MonitorElement * > h_assocdz
Definition: MuonTrackValidatorBase.h:283
MuonTrackValidatorBase::nRPChits_vs_eta
std::vector< MonitorElement * > nRPChits_vs_eta
Definition: MuonTrackValidatorBase.h:300
MuonTrackValidatorBase::thetaCotres_vs_eta
std::vector< MonitorElement * > thetaCotres_vs_eta
Definition: MuonTrackValidatorBase.h:305
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
MuonTrackValidatorBase::h_dzpull
std::vector< MonitorElement * > h_dzpull
Definition: MuonTrackValidatorBase.h:312
MuonTrackValidatorBase::h_phipull
std::vector< MonitorElement * > h_phipull
Definition: MuonTrackValidatorBase.h:312
MuonTrackValidator::associatormap
edm::InputTag associatormap
Definition: MuonTrackValidator.h:165
MuonTrackValidatorBase::h_assochi2_prob
std::vector< MonitorElement * > h_assochi2_prob
Definition: MuonTrackValidatorBase.h:291
MuonTrackValidatorBase::nintPt
int nintPt
Definition: MuonTrackValidatorBase.h:231
MuonTrackValidatorBase::etaRes_nbin
int etaRes_nbin
Definition: MuonTrackValidatorBase.h:262
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:312
MuonTrackValidatorBase::chi2_vs_phi
std::vector< MonitorElement * > chi2_vs_phi
Definition: MuonTrackValidatorBase.h:298
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
edm::ParameterSet
Definition: ParameterSet.h:47
MuonTrackValidatorBase::maxDz
double maxDz
Definition: MuonTrackValidatorBase.h:250
MuonTrackValidatorBase::fillPlotNoFlow
void fillPlotNoFlow(MonitorElement *h, T val)
Definition: MuonTrackValidatorBase.h:159
MuonTrackValidatorBase::h_assoc2phi
std::vector< MonitorElement * > h_assoc2phi
Definition: MuonTrackValidatorBase.h:281
duplicaterechits_cfi.trackCollection
trackCollection
Definition: duplicaterechits_cfi.py:4
MuonTrackValidatorBase::nintFTracks
int nintFTracks
Definition: MuonTrackValidatorBase.h:226
MuonTrackValidator::cosmictpSelector
CosmicTrackingParticleSelector cosmictpSelector
Definition: MuonTrackValidator.h:180
MuonTrackValidatorBase::etaRes_rangeMax
double etaRes_rangeMax
Definition: MuonTrackValidatorBase.h:261
MuonTrackValidatorBase::associators
std::vector< std::string > associators
Definition: MuonTrackValidatorBase.h:213
MuonTrackValidatorBase::h_etaRes
std::vector< MonitorElement * > h_etaRes
Definition: MuonTrackValidatorBase.h:287
MuonTrackValidatorBase::h_thetapull
std::vector< MonitorElement * > h_thetapull
Definition: MuonTrackValidatorBase.h:312
edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >
MuonTrackValidatorBase::minDz
double minDz
Definition: MuonTrackValidatorBase.h:250
MuonTrackValidatorBase::dxyres_vs_pt
std::vector< MonitorElement * > dxyres_vs_pt
Definition: MuonTrackValidatorBase.h:306
MuonTrackValidatorBase::phiRes_nbin
int phiRes_nbin
Definition: MuonTrackValidatorBase.h:264
MuonTrackValidatorBase::h_assochit
std::vector< MonitorElement * > h_assochit
Definition: MuonTrackValidatorBase.h:280
MuonTrackValidatorBase::h_assocdxy
std::vector< MonitorElement * > h_assocdxy
Definition: MuonTrackValidatorBase.h:282
MuonTrackValidatorBase::nintDz
int nintDz
Definition: MuonTrackValidatorBase.h:251
MuonTrackValidatorBase::minPhi
double minPhi
Definition: MuonTrackValidatorBase.h:246
MuonTrackValidatorBase::label_tp
edm::InputTag label_tp
Definition: MuonTrackValidatorBase.h:210
MuonTrackValidatorBase::nGEMhits_vs_eta
std::vector< MonitorElement * > nGEMhits_vs_eta
Definition: MuonTrackValidatorBase.h:300
MuonTrackValidatorBase::h_simulpu
std::vector< MonitorElement * > h_simulpu
Definition: MuonTrackValidatorBase.h:284
MuonTrackValidatorBase::dzRes_nbin
int dzRes_nbin
Definition: MuonTrackValidatorBase.h:270
MuonTrackValidatorBase::minNTracks
int minNTracks
Definition: MuonTrackValidatorBase.h:225
createfilelist.int
int
Definition: createfilelist.py:10
MuonTrackValidatorBase::h_simuleta
std::vector< MonitorElement * > h_simuleta
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::minPixels
double minPixels
Definition: MuonTrackValidatorBase.h:244
MuonTrackValidatorBase::nintNTracks
int nintNTracks
Definition: MuonTrackValidatorBase.h:225
MuonTrackValidatorBase::dxyres_vs_eta
std::vector< MonitorElement * > dxyres_vs_eta
Definition: MuonTrackValidatorBase.h:305
MuonErrorMatrixAnalyzer_cfi.associatorName
associatorName
Definition: MuonErrorMatrixAnalyzer_cfi.py:28
MuonTrackValidatorBase::nintCSCHit
int nintCSCHit
Definition: MuonTrackValidatorBase.h:239
MuonTrackValidatorBase::phipull_vs_eta
std::vector< MonitorElement * > phipull_vs_eta
Definition: MuonTrackValidatorBase.h:308
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
MuonTrackValidatorBase::maxPhi
double maxPhi
Definition: MuonTrackValidatorBase.h:246
MuonTrackValidatorBase::h_nchi2_prob
std::vector< MonitorElement * > h_nchi2_prob
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::h_assoc2eta
std::vector< MonitorElement * > h_assoc2eta
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::nDThits_vs_eta
std::vector< MonitorElement * > nDThits_vs_eta
Definition: MuonTrackValidatorBase.h:300
MuonTrackValidatorBase::h_assoc2pu
std::vector< MonitorElement * > h_assoc2pu
Definition: MuonTrackValidatorBase.h:284
MuonTrackValidatorBase::usemuon
bool usemuon
Definition: MuonTrackValidatorBase.h:272
MuonTrackValidatorBase::h_PurityVsQuality
std::vector< MonitorElement * > h_PurityVsQuality
Definition: MuonTrackValidatorBase.h:296
MuonTrackValidatorBase::track_Collection_Token
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > track_Collection_Token
Definition: MuonTrackValidatorBase.h:216
MuonTrackValidatorBase::h_recohit
std::vector< MonitorElement * > h_recohit
Definition: MuonTrackValidatorBase.h:280
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
MuonTrackValidatorBase::parametersDefiner
std::string parametersDefiner
Definition: MuonTrackValidatorBase.h:215
edm::RefVector::push_back
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:67
MuonTrackValidatorBase::h_assoc2hit
std::vector< MonitorElement * > h_assoc2hit
Definition: MuonTrackValidatorBase.h:280
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
MuonTrackValidatorBase::h_fakes
std::vector< MonitorElement * > h_fakes
Definition: MuonTrackValidatorBase.h:277
MuonTrackValidatorBase::h_ptpull
std::vector< MonitorElement * > h_ptpull
Definition: MuonTrackValidatorBase.h:312
MuonTrackValidatorBase::h_misiddxy
std::vector< MonitorElement * > h_misiddxy
Definition: MuonTrackValidatorBase.h:282
MuonTrackValidatorBase::ptpull_vs_phi
std::vector< MonitorElement * > ptpull_vs_phi
Definition: MuonTrackValidatorBase.h:309
MuonTrackValidatorBase::ptRes_rangeMin
double ptRes_rangeMin
Definition: MuonTrackValidatorBase.h:259
MuonTrackValidatorBase::nhits_vs_eta
std::vector< MonitorElement * > nhits_vs_eta
Definition: MuonTrackValidatorBase.h:300
MuonTrackValidatorBase::h_assoc2dxy
std::vector< MonitorElement * > h_assoc2dxy
Definition: MuonTrackValidatorBase.h:282
MuonTrackValidator::simToRecoCollection_Token
edm::EDGetTokenT< reco::SimToRecoCollection > simToRecoCollection_Token
Definition: MuonTrackValidator.h:166
MuonTrackValidatorBase::cotThetaRes_rangeMin
double cotThetaRes_rangeMin
Definition: MuonTrackValidatorBase.h:265
MuonTrackValidatorBase::h_nmisslayers_inner
std::vector< MonitorElement * > h_nmisslayers_inner
Definition: MuonTrackValidatorBase.h:290
MuonTrackValidatorBase::thetapull_vs_eta
std::vector< MonitorElement * > thetapull_vs_eta
Definition: MuonTrackValidatorBase.h:308
MuonTrackValidatorBase::phires_vs_phi
std::vector< MonitorElement * > phires_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::label_pileupinfo
edm::InputTag label_pileupinfo
Definition: MuonTrackValidatorBase.h:212
MuonTrackValidatorBase::dzres_vs_pt
std::vector< MonitorElement * > dzres_vs_pt
Definition: MuonTrackValidatorBase.h:306
MuonTrackValidator::tpDefinerEsToken
const edm::ESGetToken< ParametersDefinerForTP, TrackAssociatorRecord > tpDefinerEsToken
Definition: MuonTrackValidator.h:170
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
MuonTrackValidatorBase::ignoremissingtkcollection_
bool ignoremissingtkcollection_
Definition: MuonTrackValidatorBase.h:274
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:263
MuonTrackValidatorBase::h_nhits
std::vector< MonitorElement * > h_nhits
Definition: MuonTrackValidatorBase.h:277
MuonTrackValidatorBase::bsSrc
edm::InputTag bsSrc
Definition: MuonTrackValidatorBase.h:209
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:227
MuonTrackValidatorBase::label_tp_refvector
bool label_tp_refvector
Definition: MuonTrackValidatorBase.h:211
MuonTrackValidatorBase::h_assocSharedHit
std::vector< MonitorElement * > h_assocSharedHit
Definition: MuonTrackValidatorBase.h:292
MuonTrackValidatorBase::usetracker
bool usetracker
Definition: MuonTrackValidatorBase.h:272
TrackerOfflineValidation_Dqm_cff.dirName
dirName
Definition: TrackerOfflineValidation_Dqm_cff.py:55
MuonTrackValidatorBase::maxCSCHit
double maxCSCHit
Definition: MuonTrackValidatorBase.h:238
MuonTrackValidator::BiDirectional_RecoToSim_association
bool BiDirectional_RecoToSim_association
Definition: MuonTrackValidator.h:183
edm::RefToBase
Definition: AssociativeIterator.h:54
MuonTrackValidatorBase::h_tracks
std::vector< MonitorElement * > h_tracks
Definition: MuonTrackValidatorBase.h:277
MuonTrackValidatorBase::h_assoceta
std::vector< MonitorElement * > h_assoceta
Definition: MuonTrackValidatorBase.h:278
MuonTrackValidatorBase::minLayers
double minLayers
Definition: MuonTrackValidatorBase.h:242
CosmicParametersDefinerForTP::clone
std::unique_ptr< ParametersDefinerForTP > clone() const override
Definition: CosmicParametersDefinerForTP.h:52
MuonTrackValidatorBase::h_qoverppull
std::vector< MonitorElement * > h_qoverppull
Definition: MuonTrackValidatorBase.h:312
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
MuonTrackValidator::tpSelector
TrackingParticleSelector tpSelector
Definition: MuonTrackValidator.h:179
MuonTrackValidatorBase::nRecHits_vs_nSimHits
std::vector< MonitorElement * > nRecHits_vs_nSimHits
Definition: MuonTrackValidatorBase.h:295
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
MuonTrackValidatorBase::thetapull_vs_phi
std::vector< MonitorElement * > thetapull_vs_phi
Definition: MuonTrackValidatorBase.h:309
MuonTrackValidatorBase::nTRK_LayersWithMeas_vs_eta
std::vector< MonitorElement * > nTRK_LayersWithMeas_vs_eta
Definition: MuonTrackValidatorBase.h:303
MuonTrackValidatorBase::h_simuldz
std::vector< MonitorElement * > h_simuldz
Definition: MuonTrackValidatorBase.h:283
MuonTrackValidatorBase::dxyRes_rangeMax
double dxyRes_rangeMax
Definition: MuonTrackValidatorBase.h:267
TrackingParticleRef
edm::Ref< TrackingParticleCollection > TrackingParticleRef
Definition: TrackingParticleFwd.h:12
MuonTrackValidatorBase::ptres_vs_eta
std::vector< MonitorElement * > ptres_vs_eta
Definition: MuonTrackValidatorBase.h:305
MuonTrackValidatorBase::maxFTracks
int maxFTracks
Definition: MuonTrackValidatorBase.h:226
MuonTrackValidatorBase::cotThetaRes_rangeMax
double cotThetaRes_rangeMax
Definition: MuonTrackValidatorBase.h:265
MuonTrackValidatorBase::getPt
double getPt(double pt)
Definition: MuonTrackValidatorBase.h:184
MuonTrackValidatorBase::h_simuldxy
std::vector< MonitorElement * > h_simuldxy
Definition: MuonTrackValidatorBase.h:282
event
Definition: event.py:1
MuonTrackValidatorBase::h_simulhit
std::vector< MonitorElement * > h_simulhit
Definition: MuonTrackValidatorBase.h:280
TrackingParticle::Point
math::XYZPointD Point
point in the space
Definition: TrackingParticle.h:36
edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:102
MuonTrackValidatorBase::h_nchi2
std::vector< MonitorElement * > h_nchi2
Definition: MuonTrackValidatorBase.h:289
MuonTrackValidatorBase::nhits_vs_phi
std::vector< MonitorElement * > nhits_vs_phi
Definition: MuonTrackValidatorBase.h:298
MuonTrackValidatorBase::h_assoc2dz
std::vector< MonitorElement * > h_assoc2dz
Definition: MuonTrackValidatorBase.h:283
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:308
MuonTrackValidatorBase::h_recophi
std::vector< MonitorElement * > h_recophi
Definition: MuonTrackValidatorBase.h:281
MuonTrackValidatorBase::h_charge
std::vector< MonitorElement * > h_charge
Definition: MuonTrackValidatorBase.h:277
MuonTrackValidatorBase::chi2_vs_nhits
std::vector< MonitorElement * > chi2_vs_nhits
Definition: MuonTrackValidatorBase.h:297
MuonTrackValidatorBase::phires_vs_pt
std::vector< MonitorElement * > phires_vs_pt
Definition: MuonTrackValidatorBase.h:306
edm::InputTag
Definition: InputTag.h:15
MuonTrackValidatorBase::dzres_vs_eta
std::vector< MonitorElement * > dzres_vs_eta
Definition: MuonTrackValidatorBase.h:305
MuonTrackValidatorBase::minDTHit
double minDTHit
Definition: MuonTrackValidatorBase.h:236
edm::View::size_type
unsigned int size_type
Definition: View.h:90
MuonTrackValidatorBase::maxDxy
double maxDxy
Definition: MuonTrackValidatorBase.h:248
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:281
MuonTrackValidatorBase::h_assocphi
std::vector< MonitorElement * > h_assocphi
Definition: MuonTrackValidatorBase.h:281
MuonTrackValidatorBase::nintPixels
int nintPixels
Definition: MuonTrackValidatorBase.h:245
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
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:185
MuonTrackValidatorBase::maxLayers
double maxLayers
Definition: MuonTrackValidatorBase.h:242
Generated for CMSSW Reference Manual by doxygen 1.8.16