CMS 3D CMS Logo
TrackingMonitor.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  **
4  * \author Suchandra Dutta , Giorgia Mila
5  */
6 
7 #include "DataFormats/TrackReco/interface/Track.h"
8 #include "DataFormats/TrackReco/interface/TrackFwd.h"
9 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
10 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
11 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
12 
13 #include "FWCore/MessageLogger/interface/MessageLogger.h"
14 #include "FWCore/Utilities/interface/InputTag.h"
15 #include "FWCore/Utilities/interface/transform.h"
16 #include "DQMServices/Core/interface/DQMStore.h"
17 #include "DQM/TrackingMonitor/interface/TrackBuildingAnalyzer.h"
18 #include "DQM/TrackingMonitor/interface/TrackAnalyzer.h"
19 #include "DQM/TrackingMonitor/interface/VertexMonitor.h"
20 #include "DQM/TrackingMonitor/interface/TrackingMonitor.h"
21 
22 #include "FWCore/ParameterSet/interface/Registry.h"
23 
24 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
25 #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h"
26 #include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"
27 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
28 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
29 #include "DataFormats/Common/interface/DetSetVectorNew.h"
30 
31 #include "DataFormats/Candidate/interface/Candidate.h"
32 #include "DataFormats/Candidate/interface/CandidateFwd.h"
33 
34 #include "DQM/TrackingMonitor/interface/GetLumi.h"
35 
36 #include <string>
37 
38 #ifdef VI_DEBUG
39 #define COUT(x) std::cout << x << ' '
40 #else
41 #define COUT(x) LogDebug(x)
42 #endif
43 
44 // TrackingMonitor
45 // ----------------------------------------------------------------------------------//
46 
47 TrackingMonitor::TrackingMonitor(const edm::ParameterSet& iConfig)
48  : confID_(iConfig.id()),
49  theTrackBuildingAnalyzer(new TrackBuildingAnalyzer(iConfig)),
50  NumberOfTracks(nullptr),
51  NumberOfMeanRecHitsPerTrack(nullptr),
52  NumberOfMeanLayersPerTrack(nullptr)
53  // , NumberOfGoodTracks(NULL)
54  ,
55  FractionOfGoodTracks(nullptr),
56  NumberOfTrackingRegions(nullptr),
57  NumberOfSeeds(nullptr),
58  NumberOfSeeds_lumiFlag(nullptr),
59  NumberOfTrackCandidates(nullptr),
60  FractionCandidatesOverSeeds(nullptr)
61  // , NumberOfGoodTrkVsClus(NULL)
62  ,
63  NumberEventsOfVsLS(nullptr),
64  NumberOfTracksVsLS(nullptr)
65  // , NumberOfGoodTracksVsLS(NULL)
66  ,
67  GoodTracksFractionVsLS(nullptr)
68  // , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
69  // ADD by Mia for PU monitoring
70  // vertex plots to be moved in ad hoc class
71  ,
72  NumberOfGoodPVtxVsLS(nullptr),
73  NumberOfGoodPVtxWO0VsLS(nullptr),
74  NumberEventsOfVsBX(nullptr),
75  NumberOfTracksVsBX(nullptr),
76  GoodTracksFractionVsBX(nullptr),
77  NumberOfRecHitsPerTrackVsBX(nullptr),
78  NumberOfGoodPVtxVsBX(nullptr),
79  NumberOfGoodPVtxWO0VsBX(nullptr),
80  NumberOfTracksVsBXlumi(nullptr),
81  NumberOfTracksVsGoodPVtx(nullptr),
82  NumberOfTracksVsPUPVtx(nullptr),
83  NumberEventsOfVsGoodPVtx(nullptr),
84  GoodTracksFractionVsGoodPVtx(nullptr),
85  NumberOfRecHitsPerTrackVsGoodPVtx(nullptr),
86  NumberOfPVtxVsGoodPVtx(nullptr),
87  NumberOfPixelClustersVsGoodPVtx(nullptr),
88  NumberOfStripClustersVsGoodPVtx(nullptr),
89  NumberEventsOfVsLUMI(nullptr),
90  NumberOfTracksVsLUMI(nullptr),
91  GoodTracksFractionVsLUMI(nullptr),
92  NumberOfRecHitsPerTrackVsLUMI(nullptr),
93  NumberOfGoodPVtxVsLUMI(nullptr),
94  NumberOfGoodPVtxWO0VsLUMI(nullptr),
95  NumberOfPixelClustersVsLUMI(nullptr),
96  NumberOfStripClustersVsLUMI(nullptr),
97  NumberOfTracks_lumiFlag(nullptr)
98  // , NumberOfGoodTracks_lumiFlag(NULL)
99 
100  ,
101  builderName(iConfig.getParameter<std::string>("TTRHBuilder")),
102  doTrackerSpecific_(iConfig.getParameter<bool>("doTrackerSpecific")),
103  doLumiAnalysis(iConfig.getParameter<bool>("doLumiAnalysis")),
104  doProfilesVsLS_(iConfig.getParameter<bool>("doProfilesVsLS")),
105  doAllSeedPlots(iConfig.getParameter<bool>("doSeedParameterHistos")),
106  doAllPlots(iConfig.getParameter<bool>("doAllPlots")),
107  doGeneralPropertiesPlots_(iConfig.getParameter<bool>("doGeneralPropertiesPlots")),
108  doHitPropertiesPlots_(iConfig.getParameter<bool>("doHitPropertiesPlots")),
109  doTkCandPlots(iConfig.getParameter<bool>("doTrackCandHistos")),
110  doPUmonitoring_(iConfig.getParameter<bool>("doPUmonitoring")),
111  genTriggerEventFlag_(new GenericTriggerEventFlag(
112  iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"), consumesCollector(), *this)),
113  numSelection_(iConfig.getParameter<std::string>("numCut")),
114  denSelection_(iConfig.getParameter<std::string>("denCut")),
115  pvNDOF_(iConfig.getParameter<int>("pvNDOF")),
116  forceSCAL_(iConfig.getParameter<bool>("forceSCAL")) {
117  edm::ConsumesCollector c{consumesCollector()};
118  theTrackAnalyzer = new tadqm::TrackAnalyzer(iConfig, c);
119 
120  // input tags for collections from the configuration
121  bsSrc_ = iConfig.getParameter<edm::InputTag>("beamSpot");
122  pvSrc_ = iConfig.getParameter<edm::InputTag>("primaryVertex");
123  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
124  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
125 
126  lumiscalersToken_ = consumes<LumiScalersCollection>(iConfig.getParameter<edm::InputTag>("scal"));
127  metaDataToken_ = consumes<OnlineLuminosityRecord>(iConfig.getParameter<edm::InputTag>("metadata"));
128 
129  edm::InputTag alltrackProducer = iConfig.getParameter<edm::InputTag>("allTrackProducer");
130  edm::InputTag trackProducer = iConfig.getParameter<edm::InputTag>("TrackProducer");
131  edm::InputTag tcProducer = iConfig.getParameter<edm::InputTag>("TCProducer");
132  edm::InputTag seedProducer = iConfig.getParameter<edm::InputTag>("SeedProducer");
133  allTrackToken_ = consumes<edm::View<reco::Track> >(alltrackProducer);
134  trackToken_ = consumes<edm::View<reco::Track> >(trackProducer);
135  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
136  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
137  seedStopInfoToken_ = consumes<std::vector<SeedStopInfo> >(tcProducer);
138 
139  doMVAPlots = iConfig.getParameter<bool>("doMVAPlots");
140  if (doMVAPlots) {
141  mvaQualityTokens_ = edm::vector_transform(
142  iConfig.getParameter<std::vector<std::string> >("MVAProducers"), [&](const std::string& tag) {
143  return std::make_tuple(consumes<MVACollection>(edm::InputTag(tag, "MVAValues")),
144  consumes<QualityMaskCollection>(edm::InputTag(tag, "QualityMasks")));
145  });
146  mvaTrackToken_ = consumes<edm::View<reco::Track> >(iConfig.getParameter<edm::InputTag>("TrackProducerForMVA"));
147  }
148 
149  doRegionPlots = iConfig.getParameter<bool>("doRegionPlots");
150  doRegionCandidatePlots = iConfig.getParameter<bool>("doRegionCandidatePlots");
151  if (doRegionPlots) {
152  const auto& regionTag = iConfig.getParameter<edm::InputTag>("RegionProducer");
153  if (!regionTag.label().empty()) {
154  regionToken_ = consumes<edm::OwnVector<TrackingRegion> >(regionTag);
155  }
156  const auto& regionLayersTag = iConfig.getParameter<edm::InputTag>("RegionSeedingLayersProducer");
157  if (!regionLayersTag.label().empty()) {
158  if (!regionToken_.isUninitialized()) {
159  throw cms::Exception("Configuration")
160  << "Only one of 'RegionProducer' and 'RegionSeedingLayersProducer' can be non-empty, now both are.";
161  }
162  regionLayerSetsToken_ = consumes<TrackingRegionsSeedingLayerSets>(regionLayersTag);
163  } else if (regionToken_.isUninitialized()) {
164  throw cms::Exception("Configuration") << "With doRegionPlots=True either 'RegionProducer' or "
165  "'RegionSeedingLayersProducer' must be non-empty, now both are empty.";
166  }
167 
168  if (doRegionCandidatePlots) {
169  regionCandidateToken_ = consumes<reco::CandidateView>(iConfig.getParameter<edm::InputTag>("RegionCandidates"));
170  }
171  }
172 
173  edm::InputTag stripClusterInputTag_ = iConfig.getParameter<edm::InputTag>("stripCluster");
174  edm::InputTag pixelClusterInputTag_ = iConfig.getParameter<edm::InputTag>("pixelCluster");
175  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> >(stripClusterInputTag_);
176  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> >(pixelClusterInputTag_);
177 
178  runTrackBuildingAnalyzerForSeed =
179  (doAllSeedPlots || iConfig.getParameter<bool>("doSeedPTHisto") || iConfig.getParameter<bool>("doSeedETAHisto") ||
180  iConfig.getParameter<bool>("doSeedPHIHisto") || iConfig.getParameter<bool>("doSeedPHIVsETAHisto") ||
181  iConfig.getParameter<bool>("doSeedThetaHisto") || iConfig.getParameter<bool>("doSeedQHisto") ||
182  iConfig.getParameter<bool>("doSeedDxyHisto") || iConfig.getParameter<bool>("doSeedDzHisto") ||
183  iConfig.getParameter<bool>("doSeedNRecHitsHisto") || iConfig.getParameter<bool>("doSeedNVsPhiProf") ||
184  iConfig.getParameter<bool>("doSeedNVsEtaProf"));
185 
186  if (doTkCandPlots || doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
187  magneticFieldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
188  transientTrackingRecHitBuilderToken_ =
189  esConsumes<TransientTrackingRecHitBuilder, TransientRecHitRecord>(edm::ESInputTag("", builderName));
190  }
191 
192  doFractionPlot_ = true;
193  if (alltrackProducer.label() == trackProducer.label())
194  doFractionPlot_ = false;
195 
196  Quality_ = iConfig.getParameter<std::string>("Quality");
197  AlgoName_ = iConfig.getParameter<std::string>("AlgoName");
198 
199  // get flag from the configuration
200  doPlotsVsBXlumi_ = iConfig.getParameter<bool>("doPlotsVsBXlumi");
201  if (doPlotsVsBXlumi_)
202  theLumiDetails_ = new GetLumi(iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c);
203  doPlotsVsGoodPVtx_ = iConfig.getParameter<bool>("doPlotsVsGoodPVtx");
204  doPlotsVsLUMI_ = iConfig.getParameter<bool>("doPlotsVsLUMI");
205  doPlotsVsBX_ = iConfig.getParameter<bool>("doPlotsVsBX");
206 
207  if (doPUmonitoring_) {
208  std::vector<edm::InputTag> primaryVertexInputTags =
209  iConfig.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
210  std::vector<edm::InputTag> selPrimaryVertexInputTags =
211  iConfig.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
212  std::vector<std::string> pvLabels = iConfig.getParameter<std::vector<std::string> >("pvLabels");
213 
214  if (primaryVertexInputTags.size() == pvLabels.size() and
215  primaryVertexInputTags.size() == selPrimaryVertexInputTags.size()) {
216  for (size_t i = 0; i < primaryVertexInputTags.size(); i++) {
217  edm::InputTag iPVinputTag = primaryVertexInputTags[i];
218  edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
219  std::string iPVlabel = pvLabels[i];
220 
221  theVertexMonitor.push_back(new VertexMonitor(iConfig, iPVinputTag, iSelPVinputTag, iPVlabel, c));
222  }
223  }
224  }
225 }
226 
227 TrackingMonitor::~TrackingMonitor() {
228  if (theTrackAnalyzer)
229  delete theTrackAnalyzer;
230  if (theTrackBuildingAnalyzer)
231  delete theTrackBuildingAnalyzer;
232  if (doPUmonitoring_)
233  for (size_t i = 0; i < theVertexMonitor.size(); i++)
234  if (theVertexMonitor[i])
235  delete theVertexMonitor[i];
236  if (genTriggerEventFlag_)
237  delete genTriggerEventFlag_;
238 }
239 
240 void TrackingMonitor::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) {
241  // parameters from the configuration
242  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
243  assert(conf != nullptr);
244  std::string Quality = conf->getParameter<std::string>("Quality");
245  std::string AlgoName = conf->getParameter<std::string>("AlgoName");
246  MEFolderName = conf->getParameter<std::string>("FolderName");
247  std::string Folder = MEFolderName.substr(0, 2);
248 
249  // test for the Quality veriable validity
250  if (!Quality_.empty()) {
251  if (Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
252  edm::LogWarning("TrackingMonitor") << "Qualty Name is invalid, using no quality criterea by default";
253  Quality_ = "";
254  }
255  }
256 
257  // use the AlgoName and Quality Name
258  std::string CategoryName = !Quality_.empty() ? AlgoName_ + "_" + Quality_ : AlgoName_;
259 
260  // get binning from the configuration
261  int TKNoBin = conf->getParameter<int>("TkSizeBin");
262  double TKNoMin = conf->getParameter<double>("TkSizeMin");
263  double TKNoMax = conf->getParameter<double>("TkSizeMax");
264 
265  int TCNoBin = conf->getParameter<int>("TCSizeBin");
266  double TCNoMin = conf->getParameter<double>("TCSizeMin");
267  double TCNoMax = conf->getParameter<double>("TCSizeMax");
268 
269  int TKNoSeedBin = conf->getParameter<int>("TkSeedSizeBin");
270  double TKNoSeedMin = conf->getParameter<double>("TkSeedSizeMin");
271  double TKNoSeedMax = conf->getParameter<double>("TkSeedSizeMax");
272 
273  //int RecHitBin = conf->getParameter<int>("RecHitBin");
274  double RecHitMin = conf->getParameter<double>("RecHitMin");
275  double RecHitMax = conf->getParameter<double>("RecHitMax");
276 
277  int MeanHitBin = conf->getParameter<int>("MeanHitBin");
278  double MeanHitMin = conf->getParameter<double>("MeanHitMin");
279  double MeanHitMax = conf->getParameter<double>("MeanHitMax");
280 
281  int MeanLayBin = conf->getParameter<int>("MeanLayBin");
282  double MeanLayMin = conf->getParameter<double>("MeanLayMin");
283  double MeanLayMax = conf->getParameter<double>("MeanLayMax");
284 
285  int LSBin = conf->getParameter<int>("LSBin");
286  int LSMin = conf->getParameter<double>("LSMin");
287  int LSMax = conf->getParameter<double>("LSMax");
288 
289  std::string StateName = conf->getParameter<std::string>("MeasurementState");
290  if (StateName != "OuterSurface" && StateName != "InnerSurface" && StateName != "ImpactPoint" &&
291  StateName != "default" && StateName != "All") {
292  // print warning
293  edm::LogWarning("TrackingMonitor") << "State Name is invalid, using 'ImpactPoint' by default";
294  }
295 
296  ibooker.setCurrentFolder(MEFolderName);
297 
298  // book the General Property histograms
299  // ---------------------------------------------------------------------------------//
300 
301  if (doGeneralPropertiesPlots_ || doAllPlots) {
302  ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");
303 
304  histname = "NumberOfTracks_" + CategoryName;
305  // MODIFY by Mia in order to cope w/ high multiplicity
306  NumberOfTracks = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
307  NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
308  NumberOfTracks->setAxisTitle("Number of Events", 2);
309 
310  if (Folder == "Tr") {
311  histname = "NumberOfTracks_PUvtx_" + CategoryName;
312  NumberOfTracks_PUvtx = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
313  NumberOfTracks_PUvtx->setAxisTitle("Number of Tracks per Event (matched a PU vertex)", 1);
314  NumberOfTracks_PUvtx->setAxisTitle("Number of Events", 2);
315 
316  histname = "NumberofTracks_Hardvtx_" + CategoryName;
317  NumberofTracks_Hardvtx =
318  ibooker.book1D(histname, histname, TKNoBin / 10, TKNoMin, ((TKNoMax - TKNoMin) / 10) - 0.5);
319  NumberofTracks_Hardvtx->setAxisTitle("Number of Tracks per Event (matched main vertex)", 1);
320  NumberofTracks_Hardvtx->setAxisTitle("Number of Events", 2);
321 
322  histname = "NumberofTracks_Hardvtx_PUvtx_" + CategoryName;
323  NumberofTracks_Hardvtx_PUvtx = ibooker.book1D(histname, histname, 2, 0., 2.);
324  NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks per PU/Hard vertex", 1);
325  NumberofTracks_Hardvtx_PUvtx->setAxisTitle("Number of Tracks", 2);
326  NumberofTracks_Hardvtx_PUvtx->setBinLabel(1, "PU_Vertex");
327  NumberofTracks_Hardvtx_PUvtx->setBinLabel(2, "Hard_Vertex");
328  }
329 
330  histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
331  NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
332  NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
333  NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
334 
335  histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
336  NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
337  NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
338  NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
339 
340  if (doFractionPlot_) {
341  histname = "FractionOfGoodTracks_" + CategoryName;
342  FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
343  FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
344  FractionOfGoodTracks->setAxisTitle("Entries", 2);
345  }
346  }
347 
348  if (doLumiAnalysis) {
349  // add by Mia in order to deal with LS transitions
350  ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
351  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
352 
353  histname = "NumberOfTracks_lumiFlag_" + CategoryName;
354  NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, TKNoBin, TKNoMin, TKNoMax);
355  NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
356  NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
357  }
358 
359  // book profile plots vs LS :
360  //---------------------------
361 
362  if (doProfilesVsLS_ || doAllPlots) {
363  ibooker.setCurrentFolder(MEFolderName + "/GeneralProperties");
364 
365  histname = "NumberOfTracksVsLS_" + CategoryName;
366  NumberOfTracksVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, TKNoMin, TKNoMax, "");
367  NumberOfTracksVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
368  NumberOfTracksVsLS->setAxisTitle("#Lumi section", 1);
369  NumberOfTracksVsLS->setAxisTitle("Number of Tracks", 2);
370 
371  histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
372  NumberOfRecHitsPerTrackVsLS =
373  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, RecHitMin, RecHitMax * 5, "");
374  NumberOfRecHitsPerTrackVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
375  NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section", 1);
376  NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of Valid RecHits per track", 2);
377 
378  histname = "NumberEventsVsLS_" + CategoryName;
379  NumberEventsOfVsLS = ibooker.book1D(histname, histname, LSBin, LSMin, LSMax);
380  NumberEventsOfVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
381  NumberEventsOfVsLS->setAxisTitle("#Lumi section", 1);
382  NumberEventsOfVsLS->setAxisTitle("Number of events", 2);
383 
384  edm::ParameterSet ParametersGoodPVtx = conf->getParameter<edm::ParameterSet>("GoodPVtx");
385 
386  double GoodPVtxMin = ParametersGoodPVtx.getParameter<double>("GoodPVtxMin");
387  double GoodPVtxMax = ParametersGoodPVtx.getParameter<double>("GoodPVtxMax");
388 
389  histname = "NumberOfGoodPVtxVsLS_" + CategoryName;
390  NumberOfGoodPVtxVsLS =
391  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
392  NumberOfGoodPVtxVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
393  NumberOfGoodPVtxVsLS->setAxisTitle("#Lumi section", 1);
394  NumberOfGoodPVtxVsLS->setAxisTitle("Mean number of good PV", 2);
395 
396  histname = "NumberOfGoodPVtxWO0VsLS_" + CategoryName;
397  NumberOfGoodPVtxWO0VsLS =
398  ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
399  NumberOfGoodPVtxWO0VsLS->setAxisTitle("#Lumi section", 1);
400  NumberOfGoodPVtxWO0VsLS->setAxisTitle("Mean number of good PV", 2);
401 
402  if (doFractionPlot_) {
403  histname = "GoodTracksFractionVsLS_" + CategoryName;
404  GoodTracksFractionVsLS = ibooker.bookProfile(histname, histname, LSBin, LSMin, LSMax, 0, 1.1, "");
405  GoodTracksFractionVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
406  GoodTracksFractionVsLS->setAxisTitle("#Lumi section", 1);
407  GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks", 2);
408  }
409 
410  if (doPlotsVsBX_ || doAllPlots) {
411  ibooker.setCurrentFolder(MEFolderName + "/BXanalysis");
412  int BXBin = 3564;
413  double BXMin = 0.5;
414  double BXMax = 3564.5;
415 
416  histname = "NumberEventsVsBX_" + CategoryName;
417  NumberEventsOfVsBX = ibooker.book1D(histname, histname, BXBin, BXMin, BXMax);
418  NumberEventsOfVsBX->setAxisTitle("BX", 1);
419  NumberEventsOfVsBX->setAxisTitle("Number of events", 2);
420 
421  histname = "NumberOfTracksVsBX_" + CategoryName;
422  NumberOfTracksVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, TKNoMin, TKNoMax * 3., "");
423  NumberOfTracksVsBX->setAxisTitle("BX", 1);
424  NumberOfTracksVsBX->setAxisTitle("Number of Tracks", 2);
425 
426  histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
427  NumberOfRecHitsPerTrackVsBX =
428  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, RecHitMin, RecHitMax * 5, "");
429  NumberOfRecHitsPerTrackVsBX->setAxisTitle("BX", 1);
430  NumberOfRecHitsPerTrackVsBX->setAxisTitle("Mean number of Valid RecHits per track", 2);
431 
432  histname = "NumberOfGoodPVtxVsBX_" + CategoryName;
433  NumberOfGoodPVtxVsBX =
434  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
435  NumberOfGoodPVtxVsBX->setAxisTitle("BX", 1);
436  NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV", 2);
437 
438  histname = "NumberOfGoodPVtxWO0VsBX_" + CategoryName;
439  NumberOfGoodPVtxWO0VsBX =
440  ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, GoodPVtxMin, 3. * GoodPVtxMax, "");
441  NumberOfGoodPVtxWO0VsBX->setAxisTitle("BX", 1);
442  NumberOfGoodPVtxWO0VsBX->setAxisTitle("Mean number of good PV", 2);
443 
444  if (doFractionPlot_) {
445  histname = "GoodTracksFractionVsBX_" + CategoryName;
446  GoodTracksFractionVsBX = ibooker.bookProfile(histname, histname, BXBin, BXMin, BXMax, 0, 1.1, "");
447  GoodTracksFractionVsBX->setAxisTitle("BX", 1);
448  GoodTracksFractionVsBX->setAxisTitle("Fraction of Good Tracks", 2);
449  }
450  }
451  }
452 
453  // book PU monitoring plots :
454  //---------------------------
455 
456  if (doPUmonitoring_) {
457  for (size_t i = 0; i < theVertexMonitor.size(); i++)
458  theVertexMonitor[i]->initHisto(ibooker);
459  }
460 
461  if (doPlotsVsGoodPVtx_) {
462  ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
463  // get binning from the configuration
464  int PVBin = conf->getParameter<int>("PVBin");
465  float PVMin = conf->getParameter<double>("PVMin");
466  float PVMax = conf->getParameter<double>("PVMax");
467 
468  histname = "NumberOfTracksVsGoodPVtx";
469  NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, TKNoMin, TKNoMax * 5., "");
470  NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV", 1);
471  NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event", 2);
472 
473  histname = "NumberOfTracksVsPUPVtx";
474  NumberOfTracksVsPUPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., TKNoMax * 5., "");
475  NumberOfTracksVsPUPVtx->setAxisTitle("Number of PU", 1);
476  NumberOfTracksVsPUPVtx->setAxisTitle("Mean number of Tracks per PUvtx", 2);
477 
478  histname = "NumberEventsVsGoodPVtx";
479  NumberEventsOfVsGoodPVtx = ibooker.book1D(histname, histname, PVBin, PVMin, PVMax);
480  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
481  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of events", 2);
482 
483  if (doFractionPlot_) {
484  histname = "GoodTracksFractionVsGoodPVtx";
485  GoodTracksFractionVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 1.1, "");
486  GoodTracksFractionVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
487  GoodTracksFractionVsGoodPVtx->setAxisTitle("Mean fraction of good tracks", 2);
488  }
489 
490  histname = "NumberOfRecHitsPerTrackVsGoodPVtx";
491  NumberOfRecHitsPerTrackVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 200., "");
492  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
493  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Mean number of valid rechits per Tracks", 2);
494 
495  histname = "NumberOfPVtxVsGoodPVtx";
496  NumberOfPVtxVsGoodPVtx = ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, 0., 3. * PVMax, "");
497  NumberOfPVtxVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
498  NumberOfPVtxVsGoodPVtx->setAxisTitle("Mean number of vertices", 2);
499 
500  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
501  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
502  histname = "NumberOfPixelClustersVsGoodPVtx";
503  NumberOfPixelClustersVsGoodPVtx =
504  ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusPxMin, 3. * NClusPxMax, "");
505  NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
506  NumberOfPixelClustersVsGoodPVtx->setAxisTitle("Mean number of pixel clusters", 2);
507 
508  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
509  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
510  histname = "NumberOfStripClustersVsGoodPVtx";
511  NumberOfStripClustersVsGoodPVtx =
512  ibooker.bookProfile(histname, histname, PVBin, PVMin, PVMax, NClusStrMin, 3. * NClusStrMax, "");
513  NumberOfStripClustersVsGoodPVtx->setAxisTitle("Number of good PV (PU)", 1);
514  NumberOfStripClustersVsGoodPVtx->setAxisTitle("Mean number of strip clusters", 2);
515  }
516 
517  if (doPlotsVsLUMI_ || doAllPlots) {
518  ibooker.setCurrentFolder(MEFolderName + "/LUMIanalysis");
519  int LUMIBin = conf->getParameter<int>("LUMIBin");
520  float LUMIMin = conf->getParameter<double>("LUMIMin");
521  float LUMIMax = conf->getParameter<double>("LUMIMax");
522 
523  histname = "NumberEventsVsLUMI";
524  NumberEventsOfVsLUMI = ibooker.book1D(histname, histname, LUMIBin, LUMIMin, LUMIMax);
525  NumberEventsOfVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
526  NumberEventsOfVsLUMI->setAxisTitle("Number of events", 2);
527 
528  histname = "NumberOfTracksVsLUMI";
529  NumberOfTracksVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, TKNoMin, TKNoMax * 3, "");
530  NumberOfTracksVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
531  NumberOfTracksVsLUMI->setAxisTitle("Mean number of vertices", 2);
532 
533  if (doFractionPlot_) {
534  histname = "GoodTracksFractionVsLUMI";
535  GoodTracksFractionVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, 0., 1.1, "");
536  GoodTracksFractionVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
537  GoodTracksFractionVsLUMI->setAxisTitle("Mean number of vertices", 2);
538  }
539 
540  histname = "NumberOfRecHitsPerTrackVsLUMI";
541  NumberOfRecHitsPerTrackVsLUMI =
542  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, RecHitMin, RecHitMax * 5, "");
543  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
544  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("Mean number of vertices", 2);
545 
546  double PVMin = conf->getParameter<double>("PVMin");
547  double PVMax = conf->getParameter<double>("PVMax");
548 
549  histname = "NumberOfGoodPVtxVsLUMI";
550  NumberOfGoodPVtxVsLUMI = ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
551  NumberOfGoodPVtxVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
552  NumberOfGoodPVtxVsLUMI->setAxisTitle("Mean number of vertices", 2);
553 
554  histname = "NumberOfGoodPVtxWO0VsLUMI";
555  NumberOfGoodPVtxWO0VsLUMI =
556  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, PVMin, 3. * PVMax, "");
557  NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
558  NumberOfGoodPVtxWO0VsLUMI->setAxisTitle("Mean number of vertices", 2);
559 
560  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
561  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
562  histname = "NumberOfPixelClustersVsGoodPVtx";
563  NumberOfPixelClustersVsLUMI =
564  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusPxMin, 3. * NClusPxMax, "");
565  NumberOfPixelClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
566  NumberOfPixelClustersVsLUMI->setAxisTitle("Mean number of pixel clusters", 2);
567 
568  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
569  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
570  histname = "NumberOfStripClustersVsLUMI";
571  NumberOfStripClustersVsLUMI =
572  ibooker.bookProfile(histname, histname, LUMIBin, LUMIMin, LUMIMax, NClusStrMin, 3. * NClusStrMax, "");
573  NumberOfStripClustersVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]", 1);
574  NumberOfStripClustersVsLUMI->setAxisTitle("Mean number of strip clusters", 2);
575  }
576 
577  if (doPlotsVsBXlumi_) {
578  ibooker.setCurrentFolder(MEFolderName + "/PUmonitoring");
579  // get binning from the configuration
580  edm::ParameterSet BXlumiParameters = conf->getParameter<edm::ParameterSet>("BXlumiSetup");
581  int BXlumiBin = BXlumiParameters.getParameter<int>("BXlumiBin");
582  double BXlumiMin = BXlumiParameters.getParameter<double>("BXlumiMin");
583  double BXlumiMax = BXlumiParameters.getParameter<double>("BXlumiMax");
584 
585  histname = "NumberOfTracksVsBXlumi_" + CategoryName;
586  NumberOfTracksVsBXlumi =
587  ibooker.bookProfile(histname, histname, BXlumiBin, BXlumiMin, BXlumiMax, TKNoMin, 3. * TKNoMax, "");
588  NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]", 1);
589  NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks", 2);
590  }
591 
592  if (doLumiAnalysis) {
593  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
594  theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
595  } else {
596  theTrackAnalyzer->initHisto(ibooker, iSetup, *conf);
597  }
598 
599  // book the Seed Property histograms
600  // ---------------------------------------------------------------------------------//
601 
602  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
603 
604  doSeedNumberPlot = conf->getParameter<bool>("doSeedNumberHisto");
605  doSeedLumiAnalysis_ = conf->getParameter<bool>("doSeedLumiAnalysis");
606  doSeedVsClusterPlot = conf->getParameter<bool>("doSeedVsClusterHisto");
607 
608  edm::InputTag seedProducer = conf->getParameter<edm::InputTag>("SeedProducer");
609 
610  if (doAllSeedPlots || doSeedNumberPlot) {
611  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
612  histname = "NumberOfSeeds_" + seedProducer.label() + "_" + CategoryName;
613  NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
614  NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
615  NumberOfSeeds->setAxisTitle("Number of Events", 2);
616 
617  if (doSeedLumiAnalysis_) {
618  ibooker.setCurrentFolder(MEFolderName + "/LSanalysis");
619  auto scope = DQMStore::IBooker::UseLumiScope(ibooker);
620  histname = "NumberOfSeeds_lumiFlag_" + seedProducer.label() + "_" + CategoryName;
621  NumberOfSeeds_lumiFlag = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
622  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
623  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
624  }
625  }
626 
627  if (doAllSeedPlots || doSeedVsClusterPlot) {
628  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
629 
630  ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");
631 
632  std::vector<double> histoMin, histoMax;
633  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
634 
635  int NClusPxBin = conf->getParameter<int>("NClusPxBin");
636  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
637  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
638 
639  int NClusStrBin = conf->getParameter<int>("NClusStrBin");
640  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
641  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
642 
643  setMaxMinBin(
644  histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);
645 
646  for (uint i = 0; i < ClusterLabels.size(); i++) {
647  histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
648  SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(
649  histname, histname, histoBin[i], histoMin[i], histoMax[i], TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
650  SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
651  SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
652  SeedsVsClusters[i]->getTH2F()->SetCanExtend(TH1::kAllAxes);
653  }
654  }
655 
656  if (doRegionPlots) {
657  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
658 
659  int regionBin = conf->getParameter<int>("RegionSizeBin");
660  double regionMin = conf->getParameter<double>("RegionSizeMin");
661  double regionMax = conf->getParameter<double>("RegionSizeMax");
662 
663  histname = "TrackingRegionsNumberOf_" + seedProducer.label() + "_" + CategoryName;
664  NumberOfTrackingRegions = ibooker.book1D(histname, histname, regionBin, regionMin, regionMax);
665  NumberOfTrackingRegions->setAxisTitle("Number of TrackingRegions per Event", 1);
666  NumberOfTrackingRegions->setAxisTitle("Number of Events", 2);
667  }
668 
669  if (doTkCandPlots) {
670  ibooker.setCurrentFolder(MEFolderName + "/TrackBuilding");
671 
672  edm::InputTag tcProducer = conf->getParameter<edm::InputTag>("TCProducer");
673 
674  histname = "NumberOfTrackCandidates_" + tcProducer.label() + "_" + CategoryName;
675  NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
676  NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
677  NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
678 
679  histname = "FractionOfCandOverSeeds_" + tcProducer.label() + "_" + CategoryName;
680  FractionCandidatesOverSeeds = ibooker.book1D(histname, histname, 101, 0., 1.01);
681  FractionCandidatesOverSeeds->setAxisTitle("Number of Track Candidates / Number of Seeds per Event", 1);
682  FractionCandidatesOverSeeds->setAxisTitle("Number of Event", 2);
683  }
684 
685  theTrackBuildingAnalyzer->initHisto(ibooker, *conf);
686 
687  if (doTrackerSpecific_ || doAllPlots) {
688  ClusterLabels = conf->getParameter<std::vector<std::string> >("ClusterLabels");
689 
690  std::vector<double> histoMin, histoMax;
691  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
692 
693  int NClusStrBin = conf->getParameter<int>("NClusStrBin");
694  double NClusStrMin = conf->getParameter<double>("NClusStrMin");
695  double NClusStrMax = conf->getParameter<double>("NClusStrMax");
696 
697  int NClusPxBin = conf->getParameter<int>("NClusPxBin");
698  double NClusPxMin = conf->getParameter<double>("NClusPxMin");
699  double NClusPxMax = conf->getParameter<double>("NClusPxMax");
700 
701  edm::ParameterSet ParametersNTrk2D = conf->getParameter<edm::ParameterSet>("NTrk2D");
702  int NTrk2DBin = ParametersNTrk2D.getParameter<int>("NTrk2DBin");
703  double NTrk2DMin = ParametersNTrk2D.getParameter<double>("NTrk2DMin");
704  double NTrk2DMax = ParametersNTrk2D.getParameter<double>("NTrk2DMax");
705 
706  setMaxMinBin(
707  histoMin, histoMax, histoBin, NClusStrMin, NClusStrMax, NClusStrBin, NClusPxMin, NClusPxMax, NClusPxBin);
708 
709  ibooker.setCurrentFolder(MEFolderName + "/HitProperties");
710 
711  for (uint i = 0; i < ClusterLabels.size(); i++) {
712  ibooker.setCurrentFolder(MEFolderName + "/HitProperties");
713  histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
714  NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(
715  ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i], NTrk2DBin, NTrk2DMin, NTrk2DMax)));
716  std::string title = "Number of " + ClusterLabels[i] + " Clusters";
717  if (ClusterLabels[i] == "Tot")
718  title = "# of Clusters in (Pixel+Strip) Detectors";
719  NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
720  NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
721  NumberOfTrkVsClusters[i]->getTH1()->SetCanExtend(TH1::kXaxis);
722  }
723  }
724 
725  // Initialize the GenericTriggerEventFlag
726  if (genTriggerEventFlag_->on())
727  genTriggerEventFlag_->initRun(iRun, iSetup);
728 }
729 
730 /*
731 // -- BeginRun
732 //---------------------------------------------------------------------------------//
733 void TrackingMonitor::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
734 {
735 
736 }
737 */
738 
739 // -- Analyse
740 // ---------------------------------------------------------------------------------//
741 void TrackingMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
742  // Filter out events if Trigger Filtering is requested
743  if (genTriggerEventFlag_->on() && !genTriggerEventFlag_->accept(iEvent, iSetup))
744  return;
745  auto const* conf = edm::pset::Registry::instance()->getMapped(confID_);
746  MEFolderName = conf->getParameter<std::string>("FolderName");
747  std::string Folder = MEFolderName.substr(0, 2);
748  float lumi = -1.;
749  if (forceSCAL_) {
750  edm::Handle<LumiScalersCollection> lumiScalers;
751  iEvent.getByToken(lumiscalersToken_, lumiScalers);
752  if (lumiScalers.isValid() && !lumiScalers->empty()) {
753  LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
754  lumi = scalit->instantLumi();
755  }
756  } else {
757  edm::Handle<OnlineLuminosityRecord> metaData;
758  iEvent.getByToken(metaDataToken_, metaData);
759  if (metaData.isValid())
760  lumi = metaData->instLumi();
761  }
762 
763  if (doPlotsVsLUMI_ || doAllPlots)
764  NumberEventsOfVsLUMI->Fill(lumi);
765 
766  // Analyse the tracks
767  // if the collection is empty, do not fill anything
768  // ---------------------------------------------------------------------------------//
769 
770  size_t bx = iEvent.bunchCrossing();
771  if (doPlotsVsBX_ || doAllPlots)
772  NumberEventsOfVsBX->Fill(bx);
773 
774  // get the track collection
775  edm::Handle<edm::View<reco::Track> > trackHandle;
776  iEvent.getByToken(trackToken_, trackHandle);
777 
778  int numberOfTracks_den = 0;
779  edm::Handle<edm::View<reco::Track> > allTrackHandle;
780  iEvent.getByToken(allTrackToken_, allTrackHandle);
781  if (allTrackHandle.isValid()) {
782  for (edm::View<reco::Track>::const_iterator track = allTrackHandle->begin(); track != allTrackHandle->end();
783  ++track) {
784  if (denSelection_(*track))
785  numberOfTracks_den++;
786  }
787  }
788 
789  edm::Handle<reco::VertexCollection> pvHandle;
790  iEvent.getByToken(pvSrcToken_, pvHandle);
791  reco::Vertex const* pv0 = nullptr;
792  if (pvHandle.isValid()) {
793  pv0 = &pvHandle->front();
794  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
795  if (pv0->isFake() ||
796  pv0->tracksSize() == 0
797  // definition of goodOfflinePrimaryVertex
798  || pv0->ndof() < pvNDOF_ || pv0->z() > 24.)
799  pv0 = nullptr;
800  }
801 
802  if (trackHandle.isValid()) {
803  int numberOfTracks = trackHandle->size();
804  int numberOfTracks_num = 0;
805  int numberOfTracks_pv0 = 0;
806 
807  const edm::View<reco::Track>& trackCollection = *trackHandle;
808  // calculate the mean # rechits and layers
809  int totalRecHits = 0, totalLayers = 0;
810 
811  theTrackAnalyzer->setNumberOfGoodVertices(iEvent);
812  theTrackAnalyzer->setBX(iEvent);
813  theTrackAnalyzer->setLumi(iEvent, iSetup);
814  for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
815  ++track) {
816  if (doPlotsVsBX_ || doAllPlots)
817  NumberOfRecHitsPerTrackVsBX->Fill(bx, track->numberOfValidHits());
818  if (numSelection_(*track)) {
819  numberOfTracks_num++;
820  if (pv0 && std::abs(track->dz(pv0->position())) < 0.15)
821  ++numberOfTracks_pv0;
822  }
823 
824  if (doProfilesVsLS_ || doAllPlots)
825  NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),
826  track->numberOfValidHits());
827 
828  if (doPlotsVsLUMI_ || doAllPlots)
829  NumberOfRecHitsPerTrackVsLUMI->Fill(lumi, track->numberOfValidHits());
830 
831  totalRecHits += track->numberOfValidHits();
832  totalLayers += track->hitPattern().trackerLayersWithMeasurement();
833 
834  // do analysis per track
835  theTrackAnalyzer->analyze(iEvent, iSetup, *track);
836  }
837 
838  double frac = -1.;
839  // if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
840  if (numberOfTracks_den > 0)
841  frac = static_cast<double>(numberOfTracks_num) / static_cast<double>(numberOfTracks_den);
842 
843  if (doGeneralPropertiesPlots_ || doAllPlots) {
844  NumberOfTracks->Fill(double(numberOfTracks));
845 
846  if (Folder == "Tr") {
847  NumberofTracks_Hardvtx->Fill(double(numberOfTracks_pv0));
848  NumberOfTracks_PUvtx->Fill(double(numberOfTracks - numberOfTracks_pv0));
849  NumberofTracks_Hardvtx_PUvtx->Fill(0.5, double(numberOfTracks_pv0));
850  NumberofTracks_Hardvtx_PUvtx->Fill(1.5, double(numberOfTracks - numberOfTracks_pv0));
851  }
852 
853  if (doPlotsVsBX_ || doAllPlots)
854  NumberOfTracksVsBX->Fill(bx, numberOfTracks);
855  if (doPlotsVsLUMI_ || doAllPlots)
856  NumberOfTracksVsLUMI->Fill(lumi, numberOfTracks);
857  if (doFractionPlot_) {
858  FractionOfGoodTracks->Fill(frac);
859 
860  if (doFractionPlot_) {
861  if (doPlotsVsBX_ || doAllPlots)
862  GoodTracksFractionVsBX->Fill(bx, frac);
863  if (doPlotsVsLUMI_ || doAllPlots)
864  GoodTracksFractionVsLUMI->Fill(lumi, frac);
865  }
866  }
867  if (numberOfTracks > 0) {
868  double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
869  double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
870  NumberOfMeanRecHitsPerTrack->Fill(meanRecHits);
871  NumberOfMeanLayersPerTrack->Fill(meanLayers);
872  }
873  }
874 
875  if (doProfilesVsLS_ || doAllPlots) {
876  float nLS = static_cast<double>(iEvent.id().luminosityBlock());
877  NumberEventsOfVsLS->Fill(nLS);
878  NumberOfTracksVsLS->Fill(nLS, numberOfTracks);
879  if (doFractionPlot_)
880  GoodTracksFractionVsLS->Fill(nLS, frac);
881  }
882 
883  if (doLumiAnalysis) {
884  NumberOfTracks_lumiFlag->Fill(numberOfTracks);
885  }
886 
887  // Analyse the Track Building variables
888  // if the collection is empty, do not fill anything
889  // ---------------------------------------------------------------------------------//
890 
891  // fill the TrackCandidate info
892  if (doTkCandPlots) {
893  // magnetic field
894  MagneticField const& theMF = iSetup.getData(magneticFieldToken_);
895 
896  // get the candidate collection
897  edm::Handle<TrackCandidateCollection> theTCHandle;
898  iEvent.getByToken(trackCandidateToken_, theTCHandle);
899  const TrackCandidateCollection& theTCCollection = *theTCHandle;
900 
901  if (theTCHandle.isValid()) {
902  // get the beam spot
903  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
904  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle);
905  const reco::BeamSpot& bs = *recoBeamSpotHandle;
906 
907  NumberOfTrackCandidates->Fill(theTCCollection.size());
908 
909  // get the seed collection
910  edm::Handle<edm::View<TrajectorySeed> > seedHandle;
911  iEvent.getByToken(seedToken_, seedHandle);
912  const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
913  if (seedHandle.isValid() && !seedCollection.empty())
914  FractionCandidatesOverSeeds->Fill(double(theTCCollection.size()) / double(seedCollection.size()));
915 
916  TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
917  for (TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end();
918  ++cand) {
919  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
920  }
921  } else {
922  edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event. Not filling associated histograms";
923  }
924 
925  if (doMVAPlots) {
926  // Get MVA and quality mask collections
927  std::vector<const MVACollection*> mvaCollections;
928  std::vector<const QualityMaskCollection*> qualityMaskCollections;
929 
930  edm::Handle<edm::View<reco::Track> > htracks;
931  iEvent.getByToken(mvaTrackToken_, htracks);
932 
933  edm::Handle<MVACollection> hmva;
934  edm::Handle<QualityMaskCollection> hqual;
935  for (const auto& tokenTpl : mvaQualityTokens_) {
936  iEvent.getByToken(std::get<0>(tokenTpl), hmva);
937  iEvent.getByToken(std::get<1>(tokenTpl), hqual);
938 
939  mvaCollections.push_back(hmva.product());
940  qualityMaskCollections.push_back(hqual.product());
941  }
942  theTrackBuildingAnalyzer->analyze(*htracks, mvaCollections, qualityMaskCollections);
943  }
944  }
945 
946  //plots for trajectory seeds
947 
948  if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
949  // get the seed collection
950  edm::Handle<edm::View<TrajectorySeed> > seedHandle;
951  iEvent.getByToken(seedToken_, seedHandle);
952 
953  // fill the seed info
954  if (seedHandle.isValid()) {
955  const auto& seedCollection = *seedHandle;
956 
957  if (doAllSeedPlots || doSeedNumberPlot) {
958  NumberOfSeeds->Fill(seedCollection.size());
959  if (doSeedLumiAnalysis_)
960  NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
961  }
962 
963  if (doAllSeedPlots || doSeedVsClusterPlot) {
964  std::vector<int> NClus;
965  setNclus(iEvent, NClus);
966  for (uint i = 0; i < ClusterLabels.size(); i++) {
967  SeedsVsClusters[i]->Fill(NClus[i], seedCollection.size());
968  }
969  }
970 
971  if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed) {
972  edm::Handle<std::vector<SeedStopInfo> > stopHandle;
973  iEvent.getByToken(seedStopInfoToken_, stopHandle);
974  const auto& seedStopInfo = *stopHandle;
975 
976  if (seedStopInfo.size() == seedCollection.size()) {
977  //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
978  // magnetic field
979  MagneticField const& theMF = iSetup.getData(magneticFieldToken_);
980 
981  // get the beam spot
982  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
983  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle);
984  const reco::BeamSpot& bs = *recoBeamSpotHandle;
985 
986  TransientTrackingRecHitBuilder const& theTTRHBuilder = iSetup.getData(transientTrackingRecHitBuilderToken_);
987  for (size_t i = 0; i < seedCollection.size(); ++i) {
988  theTrackBuildingAnalyzer->analyze(
989  iEvent, iSetup, seedCollection[i], seedStopInfo[i], bs, theMF, theTTRHBuilder);
990  }
991  } else {
992  edm::LogWarning("TrackingMonitor")
993  << "Seed collection size (" << seedCollection.size()
994  << ") differs from seed stop info collection size (" << seedStopInfo.size()
995  << "). This is a sign of inconsistency in the configuration. Not filling associated histograms.";
996  }
997  }
998 
999  } else {
1000  edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event. Not filling associated histograms";
1001  }
1002  }
1003 
1004  // plots for tracking regions
1005  if (doRegionPlots) {
1006  if (!regionToken_.isUninitialized()) {
1007  edm::Handle<edm::OwnVector<TrackingRegion> > hregions;
1008  iEvent.getByToken(regionToken_, hregions);
1009  const auto& regions = *hregions;
1010  NumberOfTrackingRegions->Fill(regions.size());
1011 
1012  theTrackBuildingAnalyzer->analyze(regions);
1013  } else if (!regionLayerSetsToken_.isUninitialized()) {
1014  edm::Handle<TrackingRegionsSeedingLayerSets> hregions;
1015  iEvent.getByToken(regionLayerSetsToken_, hregions);
1016  const auto& regions = *hregions;
1017  NumberOfTrackingRegions->Fill(regions.regionsSize());
1018 
1019  theTrackBuildingAnalyzer->analyze(regions);
1020  }
1021 
1022  if (doRegionCandidatePlots) {
1023  edm::Handle<reco::CandidateView> hcandidates;
1024  iEvent.getByToken(regionCandidateToken_, hcandidates);
1025  theTrackBuildingAnalyzer->analyze(*hcandidates);
1026  }
1027  }
1028 
1029  if (doTrackerSpecific_ || doAllPlots) {
1030  std::vector<int> NClus;
1031  setNclus(iEvent, NClus);
1032  for (uint i = 0; i < ClusterLabels.size(); i++) {
1033  NumberOfTrkVsClusters[i]->Fill(NClus[i], numberOfTracks);
1034  }
1035  }
1036 
1037  if (doPUmonitoring_) {
1038  // do vertex monitoring
1039  for (size_t i = 0; i < theVertexMonitor.size(); i++)
1040  theVertexMonitor[i]->analyze(iEvent, iSetup);
1041  }
1042  if (doPlotsVsGoodPVtx_) {
1043  size_t totalNumGoodPV = 0;
1044  if (pvHandle.isValid()) {
1045  for (reco::VertexCollection::const_iterator pv = pvHandle->begin(); pv != pvHandle->end(); ++pv) {
1046  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
1047  if (pv->isFake() || pv->tracksSize() == 0)
1048  continue;
1049 
1050  // definition of goodOfflinePrimaryVertex
1051  if (pv->ndof() < pvNDOF_ || pv->z() > 24.)
1052  continue;
1053  totalNumGoodPV++;
1054  }
1055 
1056  NumberEventsOfVsGoodPVtx->Fill(float(totalNumGoodPV));
1057  NumberOfTracksVsGoodPVtx->Fill(float(totalNumGoodPV), numberOfTracks);
1058  if (totalNumGoodPV > 1)
1059  NumberOfTracksVsPUPVtx->Fill(totalNumGoodPV - 1,
1060  double(numberOfTracks - numberOfTracks_pv0) / double(totalNumGoodPV - 1));
1061  NumberOfPVtxVsGoodPVtx->Fill(float(totalNumGoodPV), pvHandle->size());
1062 
1063  for (edm::View<reco::Track>::const_iterator track = trackCollection.begin(); track != trackCollection.end();
1064  ++track) {
1065  NumberOfRecHitsPerTrackVsGoodPVtx->Fill(float(totalNumGoodPV), track->numberOfValidHits());
1066  }
1067 
1068  if (doProfilesVsLS_ || doAllPlots)
1069  NumberOfGoodPVtxVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), totalNumGoodPV);
1070  if (doPlotsVsBX_ || doAllPlots)
1071  NumberOfGoodPVtxVsBX->Fill(bx, float(totalNumGoodPV));
1072 
1073  if (doFractionPlot_)
1074  GoodTracksFractionVsGoodPVtx->Fill(float(totalNumGoodPV), frac);
1075 
1076  if (doPlotsVsLUMI_ || doAllPlots)
1077  NumberOfGoodPVtxVsLUMI->Fill(lumi, float(totalNumGoodPV));
1078  }
1079 
1080  std::vector<int> NClus;
1081  setNclus(iEvent, NClus);
1082  std::ostringstream ss;
1083  ss << "VI stat " << totalNumGoodPV << ' ' << numberOfTracks;
1084  for (uint i = 0; i < ClusterLabels.size(); i++) {
1085  ss << ' ' << NClus[i];
1086  if (doPlotsVsLUMI_ || doAllPlots) {
1087  if (ClusterLabels[i] == "Pix")
1088  NumberOfPixelClustersVsLUMI->Fill(lumi, NClus[i]);
1089  if (ClusterLabels[i] == "Strip")
1090  NumberOfStripClustersVsLUMI->Fill(lumi, NClus[i]);
1091  }
1092  if (ClusterLabels[i] == "Pix")
1093  NumberOfPixelClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
1094  if (ClusterLabels[i] == "Strip")
1095  NumberOfStripClustersVsGoodPVtx->Fill(float(totalNumGoodPV), NClus[i]);
1096  }
1097  COUT(MEFolderName) << ss.str() << std::endl;
1098  if (doPlotsVsBXlumi_) {
1099  double bxlumi = theLumiDetails_->getValue(iEvent);
1100  NumberOfTracksVsBXlumi->Fill(bxlumi, numberOfTracks);
1101  }
1102 
1103  if (doProfilesVsLS_ || doAllPlots)
1104  if (totalNumGoodPV != 0)
1105  NumberOfGoodPVtxWO0VsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()), float(totalNumGoodPV));
1106  if (doPlotsVsBX_ || doAllPlots)
1107  if (totalNumGoodPV != 0)
1108  NumberOfGoodPVtxWO0VsBX->Fill(bx, float(totalNumGoodPV));
1109  if (doPlotsVsLUMI_ || doAllPlots)
1110  if (totalNumGoodPV != 0)
1111  NumberOfGoodPVtxWO0VsLUMI->Fill(lumi, float(totalNumGoodPV));
1112 
1113  } // PU monitoring
1114 
1115  } // trackHandle is valid
1116 }
1117 
1118 void TrackingMonitor::setMaxMinBin(std::vector<double>& arrayMin,
1119  std::vector<double>& arrayMax,
1120  std::vector<int>& arrayBin,
1121  double smin,
1122  double smax,
1123  int sbin,
1124  double pmin,
1125  double pmax,
1126  int pbin) {
1127  arrayMin.resize(ClusterLabels.size());
1128  arrayMax.resize(ClusterLabels.size());
1129  arrayBin.resize(ClusterLabels.size());
1130 
1131  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1132  if (ClusterLabels[i] == "Pix") {
1133  arrayMin[i] = pmin;
1134  arrayMax[i] = pmax;
1135  arrayBin[i] = pbin;
1136  } else if (ClusterLabels[i] == "Strip") {
1137  arrayMin[i] = smin;
1138  arrayMax[i] = smax;
1139  arrayBin[i] = sbin;
1140  } else if (ClusterLabels[i] == "Tot") {
1141  arrayMin[i] = smin;
1142  arrayMax[i] = smax + pmax;
1143  arrayBin[i] = sbin;
1144  } else {
1145  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1146  << " not defined, using strip parameters ";
1147  arrayMin[i] = smin;
1148  arrayMax[i] = smax;
1149  arrayBin[i] = sbin;
1150  }
1151  }
1152 }
1153 
1154 void TrackingMonitor::setNclus(const edm::Event& iEvent, std::vector<int>& arrayNclus) {
1155  int ncluster_pix = -1;
1156  int ncluster_strip = -1;
1157 
1158  edm::Handle<edmNew::DetSetVector<SiStripCluster> > strip_clusters;
1159  iEvent.getByToken(stripClustersToken_, strip_clusters);
1160  edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
1161  iEvent.getByToken(pixelClustersToken_, pixel_clusters);
1162 
1163  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
1164  ncluster_pix = (*pixel_clusters).dataSize();
1165  ncluster_strip = (*strip_clusters).dataSize();
1166  }
1167 
1168  arrayNclus.resize(ClusterLabels.size());
1169  for (uint i = 0; i < ClusterLabels.size(); ++i) {
1170  if (ClusterLabels[i] == "Pix")
1171  arrayNclus[i] = ncluster_pix;
1172  else if (ClusterLabels[i] == "Strip")
1173  arrayNclus[i] = ncluster_strip;
1174  else if (ClusterLabels[i] == "Tot")
1175  arrayNclus[i] = ncluster_pix + ncluster_strip;
1176  else {
1177  edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i]
1178  << " not defined using stri parametrs ";
1179  arrayNclus[i] = ncluster_strip;
1180  }
1181  }
1182 }
1183 DEFINE_FWK_MODULE(TrackingMonitor);
TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:200
edm::pset::Registry::instance
static Registry * instance()
Definition: Registry.cc:12
TSCBLBuilderNoMaterial.h
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:154
TrackingMonitor::doAllPlots
bool doAllPlots
Definition: TrackingMonitor.h:206
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
electrons_cff.bool
bool
Definition: electrons_cff.py:393
mps_fire.i
i
Definition: mps_fire.py:428
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:138
TrackingMonitor::doAllSeedPlots
bool doAllSeedPlots
Definition: TrackingMonitor.h:205
edm::ESInputTag
Definition: ESInputTag.h:87
TrackingMonitor::regionToken_
edm::EDGetTokenT< edm::OwnVector< TrackingRegion > > regionToken_
Definition: TrackingMonitor.h:103
MonitorTrackSTAMuons_cfi.RecHitMax
RecHitMax
Definition: MonitorTrackSTAMuons_cfi.py:110
TrackingMonitor::GoodTracksFractionVsGoodPVtx
MonitorElement * GoodTracksFractionVsGoodPVtx
Definition: TrackingMonitor.h:181
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11713
MessageLogger.h
MonitorTrackSTAMuons_cfi.MeanHitBin
MeanHitBin
Definition: MonitorTrackSTAMuons_cfi.py:114
edm::Handle::product
T const * product() const
Definition: Handle.h:70
TrackingMonitor::doPlotsVsBX_
bool doPlotsVsBX_
Definition: TrackingMonitor.h:223
MonitorTrackSTAMuons_cfi.NClusStrMin
NClusStrMin
Definition: MonitorTrackSTAMuons_cfi.py:331
TrackingMonitor::NumberOfRecHitsPerTrackVsBX
MonitorElement * NumberOfRecHitsPerTrackVsBX
Definition: TrackingMonitor.h:171
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:112
TrackingMonitor::NumberofTracks_Hardvtx_PUvtx
MonitorElement * NumberofTracks_Hardvtx_PUvtx
Definition: TrackingMonitor.h:133
L1TCSCTF_cfi.trackProducer
trackProducer
Run2: False; Run1: True.
Definition: L1TCSCTF_cfi.py:12
edm::Run
Definition: Run.h:45
reco::Vertex::z
double z() const
z coordinate
Definition: Vertex.h:120
TrackBuildingAnalyzer.h
tadqm::TrackAnalyzer
Definition: TrackAnalyzer.h:40
edm
HLT enums.
Definition: AlignableModifier.h:19
MonitorTrackSTAMuons_cfi.MeanHitMax
MeanHitMax
Definition: MonitorTrackSTAMuons_cfi.py:115
TrackingMonitor::NumberEventsOfVsBX
MonitorElement * NumberEventsOfVsBX
Definition: TrackingMonitor.h:168
V0Monitor_cfi.lumiScalers
lumiScalers
Definition: V0Monitor_cfi.py:9
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:86
tadqm::TrackAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::EventSetup &, const edm::ParameterSet &)
Definition: TrackAnalyzer.cc:194
TrackingMonitor::confID_
edm::ParameterSetID confID_
Definition: TrackingMonitor.h:90
MonitorTrackSTAMuons_cfi.NClusPxMin
NClusPxMin
Definition: MonitorTrackSTAMuons_cfi.py:326
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
TrackingMonitor::NumberEventsOfVsLS
MonitorElement * NumberEventsOfVsLS
Definition: TrackingMonitor.h:160
TrackingMonitor::doFractionPlot_
bool doFractionPlot_
Definition: TrackingMonitor.h:224
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
TrackingMonitor::doRegionCandidatePlots
bool doRegionCandidatePlots
Definition: TrackingMonitor.h:213
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:96
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:145
TrackerCollisionTrackingMonitor_cfi.selPrimaryVertexInputTags
selPrimaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:18
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:150
cms::cuda::assert
assert(be >=bs)
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
TrackingMonitor::doPlotsVsBXlumi_
bool doPlotsVsBXlumi_
Definition: TrackingMonitor.h:220
DQMStore.h
TrackingMonitor::NumberOfGoodPVtxWO0VsBX
MonitorElement * NumberOfGoodPVtxWO0VsBX
Definition: TrackingMonitor.h:173
TrackingMonitor::NumberOfGoodPVtxVsLS
MonitorElement * NumberOfGoodPVtxVsLS
Definition: TrackingMonitor.h:164
TrackingMonitor::NumberofTracks_Hardvtx
MonitorElement * NumberofTracks_Hardvtx
Definition: TrackingMonitor.h:132
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:114
TrackingMonitor::NumberOfMeanRecHitsPerTrack
MonitorElement * NumberOfMeanRecHitsPerTrack
Definition: TrackingMonitor.h:134
MonitorTrackSTAMuons_cfi.MeanLayMax
MeanLayMax
Definition: MonitorTrackSTAMuons_cfi.py:160
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:101
TransientTrack.h
BXlumiParameters_cfi.BXlumiMin
BXlumiMin
Definition: BXlumiParameters_cfi.py:18
TrackingMonitor::NumberOfGoodPVtxVsLUMI
MonitorElement * NumberOfGoodPVtxVsLUMI
Definition: TrackingMonitor.h:192
edm::Handle
Definition: AssociativeIterator.h:50
HLTSiStripMonitoring_cff.AlgoName
AlgoName
Definition: HLTSiStripMonitoring_cff.py:232
TrackingMonitor::theTrackAnalyzer
tadqm::TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:124
parallelization.uint
uint
Definition: parallelization.py:124
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:178
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
TrackingMonitor::metaDataToken_
edm::EDGetTokenT< OnlineLuminosityRecord > metaDataToken_
Definition: TrackingMonitor.h:108
TrackingMonitor::doPlotsVsGoodPVtx_
bool doPlotsVsGoodPVtx_
Definition: TrackingMonitor.h:221
tadqm::TrackAnalyzer::setLumi
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
Definition: TrackAnalyzer.cc:1119
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:208
TrackingMonitor::NumberOfTracksVsBX
MonitorElement * NumberOfTracksVsBX
Definition: TrackingMonitor.h:169
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:161
MonitorTrackSTAMuons_cfi.NClusStrBin
NClusStrBin
Definition: MonitorTrackSTAMuons_cfi.py:329
TrackingMonitor
Definition: TrackingMonitor.h:63
CandidateFwd.h
contentValuesCheck.ss
ss
Definition: contentValuesCheck.py:33
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
MonitorTrackSTAMuons_cfi.MeanHitMin
MeanHitMin
Definition: MonitorTrackSTAMuons_cfi.py:116
cms::cuda::bs
bs
Definition: HistoContainer.h:127
TrackingMonitor::NumberOfStripClustersVsGoodPVtx
MonitorElement * NumberOfStripClustersVsGoodPVtx
Definition: TrackingMonitor.h:185
TrackingMonitor::NumberOfGoodPVtxVsBX
MonitorElement * NumberOfGoodPVtxVsBX
Definition: TrackingMonitor.h:172
GetLumi
Definition: GetLumi.h:21
Track.h
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:76
TrackFwd.h
DivergingColor.frac
float frac
Definition: DivergingColor.py:175
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
BeamSpot.h
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:198
MonitorTrackSTAMuons_cfi.MeanLayBin
MeanLayBin
Definition: MonitorTrackSTAMuons_cfi.py:159
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
ElectronSeedTrackRefFix_cfi.seedCollection
seedCollection
Definition: ElectronSeedTrackRefFix_cfi.py:9
TrackingMonitor::regionLayerSetsToken_
edm::EDGetTokenT< TrackingRegionsSeedingLayerSets > regionLayerSetsToken_
Definition: TrackingMonitor.h:104
TrackingMonitor::NumberOfPixelClustersVsLUMI
MonitorElement * NumberOfPixelClustersVsLUMI
Definition: TrackingMonitor.h:194
tadqm::TrackAnalyzer::setBX
void setBX(const edm::Event &)
Definition: TrackAnalyzer.cc:1117
TrackingMonitor::NumberOfTracksVsLUMI
MonitorElement * NumberOfTracksVsLUMI
Definition: TrackingMonitor.h:189
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:95
GenericTriggerEventFlag.h
MonitorTrackInnerTrackMuons_cff.PVMin
PVMin
Definition: MonitorTrackInnerTrackMuons_cff.py:49
ValL1Emulator_cff.regionTag
regionTag
Definition: ValL1Emulator_cff.py:63
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
MonitorTrackSTAMuons_cfi.RecHitMin
RecHitMin
Definition: MonitorTrackSTAMuons_cfi.py:111
reco::BeamSpot
Definition: BeamSpot.h:21
TrackingMonitor::doLumiAnalysis
bool doLumiAnalysis
Definition: TrackingMonitor.h:203
TrackingMonitor::FractionCandidatesOverSeeds
MonitorElement * FractionCandidatesOverSeeds
Definition: TrackingMonitor.h:151
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
TrackingMonitor_cfi.LUMIMax
LUMIMax
Definition: TrackingMonitor_cfi.py:415
TrackingMonitor::transientTrackingRecHitBuilderToken_
edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > transientTrackingRecHitBuilderToken_
Definition: TrackingMonitor.h:119
TrackBuildingAnalyzer
Definition: TrackBuildingAnalyzer.h:36
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:146
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > allTrackToken_
Definition: TrackingMonitor.h:98
TrackingMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TrackingMonitor.cc:240
dqm::impl::MonitorElement::getTH1
virtual TH1 * getTH1()
Definition: MonitorElement.cc:969
TrackingMonitor::pvNDOF_
int pvNDOF_
Definition: TrackingMonitor.h:230
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:135
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI
MonitorElement * NumberOfRecHitsPerTrackVsLUMI
Definition: TrackingMonitor.h:191
siStripFEDCheck_cfi.LSBin
LSBin
Definition: siStripFEDCheck_cfi.py:32
edm::View
Definition: CaloClusterFwd.h:14
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:266
BXlumiParameters_cfi.BXlumiBin
BXlumiBin
Definition: BXlumiParameters_cfi.py:17
MonitorTrackSTAMuons_cfi.NClusPxMax
NClusPxMax
Definition: MonitorTrackSTAMuons_cfi.py:325
COUT
#define COUT(x)
Definition: TrackingMonitor.cc:41
TransientTrackBuilder.h
edm::ParameterSet
Definition: ParameterSet.h:47
TrackCandidateCollection
std::vector< TrackCandidate > TrackCandidateCollection
Definition: TrackCandidateCollection.h:7
MonitorTrackInnerTrackMuons_cff.PVBin
PVBin
Definition: MonitorTrackInnerTrackMuons_cff.py:48
duplicaterechits_cfi.trackCollection
trackCollection
Definition: duplicaterechits_cfi.py:4
TrackingMonitor::NumberEventsOfVsGoodPVtx
MonitorElement * NumberEventsOfVsGoodPVtx
Definition: TrackingMonitor.h:180
TrackingMonitor::mvaTrackToken_
edm::EDGetTokenT< edm::View< reco::Track > > mvaTrackToken_
Definition: TrackingMonitor.h:116
ParameterSet
Definition: Functions.h:16
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:42
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:94
TrackingMonitor::seedStopInfoToken_
edm::EDGetTokenT< std::vector< SeedStopInfo > > seedStopInfoToken_
Definition: TrackingMonitor.h:102
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:163
Folder
Definition: DQMStoreStats.h:134
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:127
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:144
cand
Definition: decayParser.h:32
createfilelist.int
int
Definition: createfilelist.py:10
VertexMonitor.h
reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:69
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackingMonitor::NumberOfPixelClustersVsGoodPVtx
MonitorElement * NumberOfPixelClustersVsGoodPVtx
Definition: TrackingMonitor.h:184
MonitorTrackSTAMuons_cfi.NClusPxBin
NClusPxBin
Definition: MonitorTrackSTAMuons_cfi.py:324
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:126
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:771
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMin
GoodPVtxMin
Definition: TrackerCollisionTrackingMonitor_cfi.py:83
TrackingMonitor::doRegionPlots
bool doRegionPlots
Definition: TrackingMonitor.h:212
MonitorTrackSTAMuons_cfi.NClusStrMax
NClusStrMax
Definition: MonitorTrackSTAMuons_cfi.py:330
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:113
dqm::implementation::IBooker::UseLumiScope
UseScope< MonitorElementData::Scope::LUMI > UseLumiScope
Definition: DQMStore.h:463
MonitorTrackSTAMuons_cfi.NTrk2DBin
NTrk2DBin
Definition: MonitorTrackSTAMuons_cfi.py:345
MonitorTrackSTAMuons_cfi.NTrk2DMax
NTrk2DMax
Definition: MonitorTrackSTAMuons_cfi.py:346
TrackingMonitor::NumberOfTrackingRegions
MonitorElement * NumberOfTrackingRegions
Definition: TrackingMonitor.h:141
beam_dqm_sourceclient-live_cfg.doAllPlots
doAllPlots
Definition: beam_dqm_sourceclient-live_cfg.py:173
edm::EventSetup
Definition: EventSetup.h:57
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:100
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
TransientTrackRecord.h
TSCPBuilderNoMaterial.h
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:162
GetLumi::getValue
double getValue(const edm::Event &)
Definition: GetLumi.cc:49
TrackingMonitor::doSeedVsClusterPlot
bool doSeedVsClusterPlot
Definition: TrackingMonitor.h:216
InputTag.h
TrackingMonitor::mvaQualityTokens_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityTokens_
Definition: TrackingMonitor.h:115
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:120
TrackingMonitor::regionCandidateToken_
edm::EDGetTokenT< reco::CandidateView > regionCandidateToken_
Definition: TrackingMonitor.h:105
TrackingMonitor::doTkCandPlots
bool doTkCandPlots
Definition: TrackingMonitor.h:210
TrackingMonitor::numSelection_
StringCutObjectSelector< reco::Track, true > numSelection_
Definition: TrackingMonitor.h:228
Registry.h
TrackingMonitor::doPlotsVsLUMI_
bool doPlotsVsLUMI_
Definition: TrackingMonitor.h:222
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:130
GetLumi.h
TrackingMonitor::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: TrackingMonitor.cc:741
TrackBuildingAnalyzer::analyze
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const TrajectorySeed &seed, const SeedStopInfo &stopInfo, const reco::BeamSpot &bs, const MagneticField &theMF, const TransientTrackingRecHitBuilder &theTTRHBuilder)
Definition: TrackBuildingAnalyzer.cc:495
TrackingMonitor::forceSCAL_
const bool forceSCAL_
Definition: TrackingMonitor.h:231
GenericTriggerEventFlag::on
bool on()
Definition: GenericTriggerEventFlag.h:135
std
Definition: JetResolutionObject.h:76
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:111
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:147
TrackingMonitor::GoodTracksFractionVsBX
MonitorElement * GoodTracksFractionVsBX
Definition: TrackingMonitor.h:170
TrackingMonitor::NumberOfTracksVsPUPVtx
MonitorElement * NumberOfTracksVsPUPVtx
Definition: TrackingMonitor.h:179
TrackingMonitor::trackToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
Definition: TrackingMonitor.h:99
TrackingMonitor::doProfilesVsLS_
bool doProfilesVsLS_
Definition: TrackingMonitor.h:204
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:1154
TrackingMonitor::GoodTracksFractionVsLUMI
MonitorElement * GoodTracksFractionVsLUMI
Definition: TrackingMonitor.h:190
TrackingMonitor::TrackingMonitor
TrackingMonitor(const edm::ParameterSet &)
Definition: TrackingMonitor.cc:47
TrackingMonitor::lumiscalersToken_
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackingMonitor.h:107
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
transform.h
TrackingMonitor::doSeedNumberPlot
bool doSeedNumberPlot
Definition: TrackingMonitor.h:214
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
TrackingMonitor::NumberOfStripClustersVsLUMI
MonitorElement * NumberOfStripClustersVsLUMI
Definition: TrackingMonitor.h:195
TrackingMonitor::doPUmonitoring_
bool doPUmonitoring_
Definition: TrackingMonitor.h:219
TrackerCollisionTrackingMonitor_cfi.primaryVertexInputTags
primaryVertexInputTags
Definition: TrackerCollisionTrackingMonitor_cfi.py:15
Exception
Definition: hltDiff.cc:246
TrackingMonitor::bsSrc_
edm::InputTag bsSrc_
Definition: TrackingMonitor.h:93
TrackingMonitor::doSeedLumiAnalysis_
bool doSeedLumiAnalysis_
Definition: TrackingMonitor.h:215
OnlineLuminosityRecord::instLumi
float instLumi() const
Return the luminosity for the current nibble.
Definition: OnlineLuminosityRecord.h:33
TrackingMonitor::setMaxMinBin
virtual void setMaxMinBin(std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
Definition: TrackingMonitor.cc:1118
TrackingMonitor::NumberOfPVtxVsGoodPVtx
MonitorElement * NumberOfPVtxVsGoodPVtx
Definition: TrackingMonitor.h:183
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:153
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TrajectoryStateTransform.h
TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx
MonitorElement * NumberOfRecHitsPerTrackVsGoodPVtx
Definition: TrackingMonitor.h:182
tadqm::TrackAnalyzer::setNumberOfGoodVertices
void setNumberOfGoodVertices(const edm::Event &)
Definition: TrackAnalyzer.cc:1105
dqm::implementation::IBooker
Definition: DQMStore.h:43
TrackingMonitor::magneticFieldToken_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magneticFieldToken_
Definition: TrackingMonitor.h:118
MonitorTrackSTAMuons_cfi.NTrk2DMin
NTrk2DMin
Definition: MonitorTrackSTAMuons_cfi.py:347
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
beam_dqm_sourceclient-live_cfg.doLumiAnalysis
doLumiAnalysis
Definition: beam_dqm_sourceclient-live_cfg.py:174
TrackingMonitor::NumberOfGoodPVtxWO0VsLS
MonitorElement * NumberOfGoodPVtxWO0VsLS
Definition: TrackingMonitor.h:165
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:110
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:175
AlignmentPI::regions
regions
Definition: AlignmentPayloadInspectorHelper.h:76
Candidate.h
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TrackingMonitor_cfi.LUMIBin
LUMIBin
Definition: TrackingMonitor_cfi.py:413
tadqm::TrackAnalyzer::analyze
void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
Definition: TrackAnalyzer.cc:1171
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:125
siStripFEDCheck_cfi.LSMin
LSMin
Definition: siStripFEDCheck_cfi.py:33
VertexMonitor
Definition: VertexMonitor.h:31
siStripFEDCheck_cfi.LSMax
LSMax
Definition: siStripFEDCheck_cfi.py:34
TrackingMonitor::NumberEventsOfVsLUMI
MonitorElement * NumberEventsOfVsLUMI
Definition: TrackingMonitor.h:188
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:122
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
edm::Event
Definition: Event.h:73
TrackingMonitor::Quality_
std::string Quality_
Definition: TrackingMonitor.h:121
TrackingMonitor::NumberOfGoodPVtxWO0VsLUMI
MonitorElement * NumberOfGoodPVtxWO0VsLUMI
Definition: TrackingMonitor.h:193
MagneticField
Definition: MagneticField.h:19
TrackingMonitor::~TrackingMonitor
~TrackingMonitor() override
Definition: TrackingMonitor.cc:227
lumi
Definition: LumiSectionData.h:20
TransientTrackingRecHitBuilder
Definition: TransientTrackingRecHitBuilder.h:6
TrackingMonitor::NumberOfTracks_PUvtx
MonitorElement * NumberOfTracks_PUvtx
Definition: TrackingMonitor.h:131
MonitorTrackSTAMuons_cfi.MeanLayMin
MeanLayMin
Definition: MonitorTrackSTAMuons_cfi.py:161
TrackingMonitor::doTrackerSpecific_
bool doTrackerSpecific_
Definition: TrackingMonitor.h:202
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:110
edm::pset::Registry::getMapped
bool getMapped(key_type const &k, value_type &result) const
Definition: Registry.cc:17
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
DetSetVectorNew.h
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
TrackingMonitor.h
BXlumiParameters_cfi.BXlumiMax
BXlumiMax
Definition: BXlumiParameters_cfi.py:19
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:226
reco::Vertex
Definition: Vertex.h:35
TrackingMonitor::doMVAPlots
bool doMVAPlots
Definition: TrackingMonitor.h:211
MonitorTrackInnerTrackMuons_cff.PVMax
PVMax
Definition: MonitorTrackInnerTrackMuons_cff.py:50
TrackingMonitor_cfi.LUMIMin
LUMIMin
Definition: TrackingMonitor_cfi.py:414
TrackAnalyzer.h
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
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h:229
ecaldqm::Quality
Quality
Definition: DBWriterWorkers.cc:55
TrackerCollisionTrackingMonitor_cfi.GoodPVtxMax
GoodPVtxMax
Definition: TrackerCollisionTrackingMonitor_cfi.py:84
TrackBuildingAnalyzer::initHisto
void initHisto(DQMStore::IBooker &ibooker, const edm::ParameterSet &)
Definition: TrackBuildingAnalyzer.cc:46
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:217
TrackingMonitor::MEFolderName
std::string MEFolderName
Definition: TrackingMonitor.h:85
TrackerCollisionTrackingMonitor_cfi.pvLabels
pvLabels
Definition: TrackerCollisionTrackingMonitor_cfi.py:21
Generated for CMSSW Reference Manual by doxygen 1.8.16