CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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 #include "MagneticField/Engine/interface/MagneticField.h"
13 
14 #include "FWCore/MessageLogger/interface/MessageLogger.h"
15 #include "FWCore/Utilities/interface/InputTag.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/Framework/interface/ESHandle.h"
23 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
24 
25 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
26 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"
27 #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h"
28 #include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"
29 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
30 #include "CommonTools/TriggerUtils/interface/GenericTriggerEventFlag.h"
31 #include "DataFormats/Common/interface/DetSetVectorNew.h"
32 
33 #include "DQM/TrackingMonitor/interface/GetLumi.h"
34 
35 #include <string>
36 
37 // TrackingMonitor
38 // ----------------------------------------------------------------------------------//
39 
40 TrackingMonitor::TrackingMonitor(const edm::ParameterSet& iConfig)
41  : conf_ ( iConfig )
42  , theTrackBuildingAnalyzer( new TrackBuildingAnalyzer(conf_) )
43  , NumberOfTracks(NULL)
44  , NumberOfMeanRecHitsPerTrack(NULL)
45  , NumberOfMeanLayersPerTrack(NULL)
46  // , NumberOfGoodTracks(NULL)
47  , FractionOfGoodTracks(NULL)
48  , NumberOfSeeds(NULL)
49  , NumberOfSeeds_lumiFlag(NULL)
50  , NumberOfTrackCandidates(NULL)
51  // , NumberOfGoodTrkVsClus(NULL)
52  , NumberOfTracksVsLS(NULL)
53  // , NumberOfGoodTracksVsLS(NULL)
54  , GoodTracksFractionVsLS(NULL)
55  // , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
56  // ADD by Mia for PU monitoring
57  // vertex plots to be moved in ad hoc class
58  , NumberOfTracksVsGoodPVtx(NULL)
59  , NumberOfTracksVsBXlumi(NULL)
60 
61  , NumberOfTracks_lumiFlag(NULL)
62  // , NumberOfGoodTracks_lumiFlag(NULL)
63 
64  , builderName ( conf_.getParameter<std::string>("TTRHBuilder"))
65  , doTrackerSpecific_ ( conf_.getParameter<bool>("doTrackerSpecific") )
66  , doLumiAnalysis ( conf_.getParameter<bool>("doLumiAnalysis"))
67  , doProfilesVsLS_ ( conf_.getParameter<bool>("doProfilesVsLS"))
68  , doAllPlots ( conf_.getParameter<bool>("doAllPlots"))
69  , doGeneralPropertiesPlots_( conf_.getParameter<bool>("doGeneralPropertiesPlots"))
70  , doHitPropertiesPlots_ ( conf_.getParameter<bool>("doHitPropertiesPlots"))
71  , doPUmonitoring_ ( conf_.getParameter<bool>("doPUmonitoring") )
72  , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig,consumesCollector()))
73  , numSelection_ (conf_.getParameter<std::string>("numCut"))
74  , denSelection_ (conf_.getParameter<std::string>("denCut"))
75 {
76 
77  edm::ConsumesCollector c{ consumesCollector() };
78  theTrackAnalyzer = new TrackAnalyzer( conf_,c );
79 
80  // input tags for collections from the configuration
81  bsSrc_ = conf_.getParameter<edm::InputTag>("beamSpot");
82  pvSrc_ = conf_.getParameter<edm::InputTag>("primaryVertex");
83  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
84  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
85 
86  edm::InputTag alltrackProducer = conf_.getParameter<edm::InputTag>("allTrackProducer");
87  edm::InputTag trackProducer = conf_.getParameter<edm::InputTag>("TrackProducer");
88  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
89  edm::InputTag seedProducer = conf_.getParameter<edm::InputTag>("SeedProducer");
90  allTrackToken_ = consumes<reco::TrackCollection>(alltrackProducer);
91  trackToken_ = consumes<reco::TrackCollection>(trackProducer);
92  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
93  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
94 
95  edm::InputTag stripClusterInputTag_ = conf_.getParameter<edm::InputTag>("stripCluster");
96  edm::InputTag pixelClusterInputTag_ = conf_.getParameter<edm::InputTag>("pixelCluster");
97  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> > (stripClusterInputTag_);
98  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> > (pixelClusterInputTag_);
99 
100  doFractionPlot_ = true;
101  if (alltrackProducer.label()==trackProducer.label()) doFractionPlot_ = false;
102 
103  Quality_ = conf_.getParameter<std::string>("Quality");
104  AlgoName_ = conf_.getParameter<std::string>("AlgoName");
105 
106 
107  if ( doPUmonitoring_ ) {
108 
109  // get flag from the configuration
110  doPlotsVsBXlumi_ = conf_.getParameter<bool>("doPlotsVsBXlumi");
111  doPlotsVsGoodPVtx_ = conf_.getParameter<bool>("doPlotsVsGoodPVtx");
112 
113  if ( doPlotsVsBXlumi_ )
114  theLumiDetails_ = new GetLumi( iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c );
115 
116  std::vector<edm::InputTag> primaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
117  std::vector<edm::InputTag> selPrimaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
118  std::vector<std::string> pvLabels = conf_.getParameter<std::vector<std::string> > ("pvLabels");
119 
120  if (primaryVertexInputTags.size()==pvLabels.size() and primaryVertexInputTags.size()==selPrimaryVertexInputTags.size()) {
121  // for (auto const& tag : primaryVertexInputTags) {
122  for (size_t i=0; i<primaryVertexInputTags.size(); i++) {
123  edm::InputTag iPVinputTag = primaryVertexInputTags[i];
124  edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
125  std::string iPVlabel = pvLabels[i];
126 
127  theVertexMonitor.push_back(new VertexMonitor(conf_,iPVinputTag,iSelPVinputTag,iPVlabel,c) );
128  }
129  }
130  }
131 
132 }
133 
134 
135 TrackingMonitor::~TrackingMonitor()
136 {
137  if (theTrackAnalyzer) delete theTrackAnalyzer;
138  if (theTrackBuildingAnalyzer) delete theTrackBuildingAnalyzer;
139  if ( doPUmonitoring_ )
140  for (size_t i=0; i<theVertexMonitor.size(); i++)
141  if (theVertexMonitor[i]) delete theVertexMonitor[i];
142  if (genTriggerEventFlag_) delete genTriggerEventFlag_;
143 }
144 
145 
146 void TrackingMonitor::beginJob(void)
147 {
148 
149 
150 }
151 
152 void TrackingMonitor::bookHistograms(DQMStore::IBooker & ibooker,
153  edm::Run const & iRun,
154  edm::EventSetup const & iSetup)
155 {
156  // parameters from the configuration
157  std::string Quality = conf_.getParameter<std::string>("Quality");
158  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
159  std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
160 
161  // test for the Quality veriable validity
162  if( Quality_ != "") {
163  if( Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
164  edm::LogWarning("TrackingMonitor") << "Qualty Name is invalid, using no quality criterea by default";
165  Quality_ = "";
166  }
167  }
168 
169  // use the AlgoName and Quality Name
170  std::string CategoryName = Quality_ != "" ? AlgoName_ + "_" + Quality_ : AlgoName_;
171 
172  // get binning from the configuration
173  int TKNoBin = conf_.getParameter<int>( "TkSizeBin");
174  double TKNoMin = conf_.getParameter<double>("TkSizeMin");
175  double TKNoMax = conf_.getParameter<double>("TkSizeMax");
176 
177  int TCNoBin = conf_.getParameter<int>( "TCSizeBin");
178  double TCNoMin = conf_.getParameter<double>("TCSizeMin");
179  double TCNoMax = conf_.getParameter<double>("TCSizeMax");
180 
181  int TKNoSeedBin = conf_.getParameter<int>( "TkSeedSizeBin");
182  double TKNoSeedMin = conf_.getParameter<double>("TkSeedSizeMin");
183  double TKNoSeedMax = conf_.getParameter<double>("TkSeedSizeMax");
184 
185  int MeanHitBin = conf_.getParameter<int>( "MeanHitBin");
186  double MeanHitMin = conf_.getParameter<double>("MeanHitMin");
187  double MeanHitMax = conf_.getParameter<double>("MeanHitMax");
188 
189  int MeanLayBin = conf_.getParameter<int>( "MeanLayBin");
190  double MeanLayMin = conf_.getParameter<double>("MeanLayMin");
191  double MeanLayMax = conf_.getParameter<double>("MeanLayMax");
192 
193  int LSBin = conf_.getParameter<int>( "LSBin");
194  int LSMin = conf_.getParameter<double>("LSMin");
195  int LSMax = conf_.getParameter<double>("LSMax");
196 
197  std::string StateName = conf_.getParameter<std::string>("MeasurementState");
198  if (
199  StateName != "OuterSurface" &&
200  StateName != "InnerSurface" &&
201  StateName != "ImpactPoint" &&
202  StateName != "default" &&
203  StateName != "All"
204  ) {
205  // print warning
206  edm::LogWarning("TrackingMonitor") << "State Name is invalid, using 'ImpactPoint' by default";
207  }
208 
209  ibooker.setCurrentFolder(MEFolderName);
210 
211  // book the General Property histograms
212  // ---------------------------------------------------------------------------------//
213 
214  if (doGeneralPropertiesPlots_ || doAllPlots){
215 
216  ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
217 
218  histname = "NumberOfTracks_" + CategoryName;
219  // MODIFY by Mia in order to cope w/ high multiplicity
220  NumberOfTracks = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
221  NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
222  NumberOfTracks->setAxisTitle("Number of Events", 2);
223 
224  histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
225  NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
226  NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
227  NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
228 
229  histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
230  NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
231  NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
232  NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
233 
234  if (doFractionPlot_) {
235  histname = "FractionOfGoodTracks_" + CategoryName;
236  FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
237  FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
238  FractionOfGoodTracks->setAxisTitle("Entries", 2);
239  }
240  }
241 
242  if ( doLumiAnalysis ) {
243  // add by Mia in order to deal with LS transitions
244  ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
245 
246  histname = "NumberOfTracks_lumiFlag_" + CategoryName;
247  NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
248  NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
249  NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
250 
251  }
252 
253  // book profile plots vs LS :
254  //---------------------------
255 
256 
257  if ( doProfilesVsLS_ || doAllPlots) {
258 
259  ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
260 
261  histname = "NumberOfTracksVsLS_"+ CategoryName;
262  NumberOfTracksVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax, TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
263  NumberOfTracksVsLS->getTH1()->SetBit(TH1::kCanRebin);
264  NumberOfTracksVsLS->setAxisTitle("#Lumi section",1);
265  NumberOfTracksVsLS->setAxisTitle("Number of Tracks",2);
266 
267  histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
268  NumberOfRecHitsPerTrackVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,0.,40.,"");
269  NumberOfRecHitsPerTrackVsLS->getTH1()->SetBit(TH1::kCanRebin);
270  NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section",1);
271  NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of RecHits per track",2);
272 
273  if (doFractionPlot_) {
274  histname = "GoodTracksFractionVsLS_"+ CategoryName;
275  GoodTracksFractionVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,0,1.1,"");
276  GoodTracksFractionVsLS->getTH1()->SetBit(TH1::kCanRebin);
277  GoodTracksFractionVsLS->setAxisTitle("#Lumi section",1);
278  GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks",2);
279  }
280  }
281 
282  // book PU monitoring plots :
283  //---------------------------
284 
285  if ( doPUmonitoring_ ) {
286 
287  for (size_t i=0; i<theVertexMonitor.size(); i++)
288  theVertexMonitor[i]->initHisto(ibooker);
289 
290  ibooker.setCurrentFolder(MEFolderName+"/PUmonitoring");
291 
292  if ( doPlotsVsGoodPVtx_ ) {
293  // get binning from the configuration
294  int GoodPVtxBin = conf_.getParameter<int>("GoodPVtxBin");
295  double GoodPVtxMin = conf_.getParameter<double>("GoodPVtxMin");
296  double GoodPVtxMax = conf_.getParameter<double>("GoodPVtxMax");
297 
298  histname = "NumberOfTracksVsGoodPVtx";
299  NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
300  NumberOfTracksVsGoodPVtx->getTH1()->SetBit(TH1::kCanRebin);
301  NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV",1);
302  NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event",2);
303 
304  }
305 
306  if ( doPlotsVsBXlumi_ ) {
307  // get binning from the configuration
308  edm::ParameterSet BXlumiParameters = conf_.getParameter<edm::ParameterSet>("BXlumiSetup");
309  int BXlumiBin = BXlumiParameters.getParameter<int>("BXlumiBin");
310  double BXlumiMin = BXlumiParameters.getParameter<double>("BXlumiMin");
311  double BXlumiMax = BXlumiParameters.getParameter<double>("BXlumiMax");
312 
313  histname = "NumberOfTracksVsBXlumi_"+ CategoryName;
314  NumberOfTracksVsBXlumi = ibooker.bookProfile(histname,histname, BXlumiBin,BXlumiMin,BXlumiMax, TKNoMin, TKNoMax,"");
315  NumberOfTracksVsBXlumi->getTH1()->SetBit(TH1::kCanRebin);
316  NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]",1);
317  NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks",2);
318 
319  }
320  }
321 
322  theTrackAnalyzer->initHisto(ibooker);
323 
324  // book the Seed Property histograms
325  // ---------------------------------------------------------------------------------//
326 
327  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
328 
329  doAllSeedPlots = conf_.getParameter<bool>("doSeedParameterHistos");
330  doSeedNumberPlot = conf_.getParameter<bool>("doSeedNumberHisto");
331  doSeedLumiAnalysis_ = conf_.getParameter<bool>("doSeedLumiAnalysis");
332  doSeedVsClusterPlot = conf_.getParameter<bool>("doSeedVsClusterHisto");
333  // if (doAllPlots) doAllSeedPlots=true;
334 
335  runTrackBuildingAnalyzerForSeed=(doAllSeedPlots || conf_.getParameter<bool>("doSeedPTHisto") ||conf_.getParameter<bool>("doSeedETAHisto") || conf_.getParameter<bool>("doSeedPHIHisto") || conf_.getParameter<bool>("doSeedPHIVsETAHisto") || conf_.getParameter<bool>("doSeedThetaHisto") || conf_.getParameter<bool>("doSeedQHisto") || conf_.getParameter<bool>("doSeedDxyHisto") || conf_.getParameter<bool>("doSeedDzHisto") || conf_.getParameter<bool>("doSeedNRecHitsHisto") || conf_.getParameter<bool>("doSeedNVsPhiProf")|| conf_.getParameter<bool>("doSeedNVsEtaProf"));
336 
337  edm::InputTag seedProducer = conf_.getParameter<edm::InputTag>("SeedProducer");
338 
339  if (doAllSeedPlots || doSeedNumberPlot){
340  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
341  histname = "NumberOfSeeds_"+ seedProducer.label() + "_"+ CategoryName;
342  NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
343  NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
344  NumberOfSeeds->setAxisTitle("Number of Events", 2);
345 
346  if ( doSeedLumiAnalysis_ ) {
347  ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
348  histname = "NumberOfSeeds_lumiFlag_"+ seedProducer.label() + "_"+ CategoryName;
349  NumberOfSeeds_lumiFlag = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
350  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
351  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
352  }
353 
354  }
355 
356  if (doAllSeedPlots || doSeedVsClusterPlot){
357  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
358 
359  ClusterLabels= conf_.getParameter<std::vector<std::string> >("ClusterLabels");
360 
361  std::vector<double> histoMin,histoMax;
362  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
363 
364  int NClusPxBin = conf_.getParameter<int>( "NClusPxBin");
365  double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
366  double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
367 
368  int NClusStrBin = conf_.getParameter<int>( "NClusStrBin");
369  double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
370  double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
371 
372  setMaxMinBin(histoMin,histoMax,histoBin,NClusStrMin,NClusStrMax,NClusStrBin,NClusPxMin,NClusPxMax,NClusPxBin);
373 
374  for (uint i=0; i<ClusterLabels.size(); i++){
375  histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
376  SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i],
377  TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
378  SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
379  SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
380  }
381  }
382 
383  doTkCandPlots=conf_.getParameter<bool>("doTrackCandHistos");
384  // if (doAllPlots) doTkCandPlots=true;
385 
386  if (doTkCandPlots){
387  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
388 
389  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
390 
391  histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
392  NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
393  NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
394  NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
395  }
396 
397  theTrackBuildingAnalyzer->initHisto(ibooker);
398 
399 
400  if (doLumiAnalysis) {
401  if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> setLumiFlag();
402  theTrackAnalyzer->setLumiFlag();
403  }
404 
405  if(doAllSeedPlots || doSeedNumberPlot){
406  if ( doSeedLumiAnalysis_ )
407  NumberOfSeeds_lumiFlag->setLumiFlag();
408  }
409 
410  if (doTrackerSpecific_ || doAllPlots) {
411 
412  ClusterLabels= conf_.getParameter<std::vector<std::string> >("ClusterLabels");
413 
414  std::vector<double> histoMin,histoMax;
415  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
416 
417  int NClusStrBin = conf_.getParameter<int>( "NClusStrBin");
418  double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
419  double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
420 
421  int NClusPxBin = conf_.getParameter<int>( "NClusPxBin");
422  double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
423  double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
424 
425  int NTrk2DBin = conf_.getParameter<int>( "NTrk2DBin");
426  double NTrk2DMin = conf_.getParameter<double>("NTrk2DMin");
427  double NTrk2DMax = conf_.getParameter<double>("NTrk2DMax");
428 
429  setMaxMinBin(histoMin,histoMax,histoBin,
430  NClusStrMin,NClusStrMax,NClusStrBin,
431  NClusPxMin, NClusPxMax, NClusPxBin);
432 
433  ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
434 
435  for (uint i=0; i<ClusterLabels.size(); i++){
436 
437  ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
438  histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
439  NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname,
440  histoBin[i], histoMin[i], histoMax[i],
441  NTrk2DBin,NTrk2DMin,NTrk2DMax
442  )));
443  std::string title = "Number of " + ClusterLabels[i] + " Clusters";
444  if(ClusterLabels[i].compare("Tot")==0)
445  title = "# of Clusters in (Pixel+Strip) Detectors";
446  NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
447  NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
448  }
449  }
450 
451  // Initialize the GenericTriggerEventFlag
452  if ( genTriggerEventFlag_->on() ) genTriggerEventFlag_->initRun( iRun, iSetup );
453 
454 }
455 
456 /*
457 // -- BeginRun
458 //---------------------------------------------------------------------------------//
459 void TrackingMonitor::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
460 {
461 
462 }
463 */
464 
465 // - BeginLumi
466 // ---------------------------------------------------------------------------------//
467 void TrackingMonitor::beginLuminosityBlock(const edm::LuminosityBlock& lumi, const edm::EventSetup& eSetup) {
468 
469  if (doLumiAnalysis) {
470  if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> Reset();
471  theTrackAnalyzer->doReset();
472  }
473  if(doAllSeedPlots || doSeedNumberPlot) {
474  if ( doSeedLumiAnalysis_ )
475  NumberOfSeeds_lumiFlag->Reset();
476  }
477 }
478 
479 // -- Analyse
480 // ---------------------------------------------------------------------------------//
481 void TrackingMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
482 {
483 
484  // Filter out events if Trigger Filtering is requested
485  if (genTriggerEventFlag_->on()&& ! genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
486 
487  // Analyse the tracks
488  // if the collection is empty, do not fill anything
489  // ---------------------------------------------------------------------------------//
490 
491  // get the track collection
492  edm::Handle<reco::TrackCollection> trackHandle;
493  iEvent.getByToken(trackToken_, trackHandle);
494 
495  // int numberOfAllTracks = 0;
496  int numberOfTracks_den = 0;
497  edm::Handle<reco::TrackCollection> allTrackHandle;
498  iEvent.getByToken(allTrackToken_,allTrackHandle);
499  if (allTrackHandle.isValid()) {
500  // numberOfAllTracks = allTrackHandle->size();
501  for (reco::TrackCollection::const_iterator track = allTrackHandle->begin();
502  track!=allTrackHandle->end(); ++track) {
503  if ( denSelection_(*track) )
504  numberOfTracks_den++;
505  }
506  }
507 
508  if (trackHandle.isValid()) {
509 
510  int numberOfTracks = trackHandle->size();
511  int numberOfTracks_num = 0;
512 
513  reco::TrackCollection trackCollection = *trackHandle;
514  // calculate the mean # rechits and layers
515  int totalRecHits = 0, totalLayers = 0;
516 
517  for (reco::TrackCollection::const_iterator track = trackCollection.begin();
518  track!=trackCollection.end(); ++track) {
519 
520  if ( numSelection_(*track) )
521  numberOfTracks_num++;
522 
523  if ( doProfilesVsLS_ || doAllPlots)
524  NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),track->recHitsSize());
525 
526  totalRecHits += track->numberOfValidHits();
527  totalLayers += track->hitPattern().trackerLayersWithMeasurement();
528 
529  // do analysis per track
530  theTrackAnalyzer->analyze(iEvent, iSetup, *track);
531  }
532 
533  double frac = -1.;
534  // if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
535  if (numberOfTracks_den > 0) frac = static_cast<double>(numberOfTracks_num)/static_cast<double>(numberOfTracks_den);
536 
537  if (doGeneralPropertiesPlots_ || doAllPlots){
538  NumberOfTracks -> Fill(numberOfTracks);
539  if (doFractionPlot_)
540  FractionOfGoodTracks -> Fill(frac);
541 
542  if( numberOfTracks > 0 ) {
543  double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
544  double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
545  NumberOfMeanRecHitsPerTrack -> Fill(meanRecHits);
546  NumberOfMeanLayersPerTrack -> Fill(meanLayers);
547  }
548  }
549 
550  if ( doProfilesVsLS_ || doAllPlots) {
551  NumberOfTracksVsLS ->Fill(static_cast<double>(iEvent.id().luminosityBlock()),numberOfTracks);
552  if (doFractionPlot_)
553  GoodTracksFractionVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),frac);
554  }
555 
556  if ( doLumiAnalysis ) {
557  NumberOfTracks_lumiFlag -> Fill(numberOfTracks);
558  }
559 
560 
561  // Analyse the Track Building variables
562  // if the collection is empty, do not fill anything
563  // ---------------------------------------------------------------------------------//
564 
565 
566  // fill the TrackCandidate info
567  if (doTkCandPlots) {
568  // magnetic field
569  edm::ESHandle<MagneticField> theMF;
570  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
571 
572  // get the candidate collection
573  edm::Handle<TrackCandidateCollection> theTCHandle;
574  iEvent.getByToken( trackCandidateToken_, theTCHandle );
575  const TrackCandidateCollection& theTCCollection = *theTCHandle;
576 
577  if (theTCHandle.isValid()) {
578 
579  // get the beam spot
580  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
581  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
582  const reco::BeamSpot& bs = *recoBeamSpotHandle;
583 
584  NumberOfTrackCandidates->Fill(theTCCollection.size());
585  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
586  for( TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end(); ++cand) {
587 
588  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
589  }
590  } else {
591  edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event. Not filling associated histograms";
592  }
593  }
594 
595  //plots for trajectory seeds
596 
597  if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
598 
599  // get the seed collection
600  edm::Handle<edm::View<TrajectorySeed> > seedHandle;
601  iEvent.getByToken(seedToken_, seedHandle );
602  const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
603 
604  // fill the seed info
605  if (seedHandle.isValid()) {
606 
607  if(doAllSeedPlots || doSeedNumberPlot) {
608  NumberOfSeeds->Fill(seedCollection.size());
609  if ( doSeedLumiAnalysis_ )
610  NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
611  }
612 
613  if(doAllSeedPlots || doSeedVsClusterPlot){
614 
615  std::vector<int> NClus;
616  setNclus(iEvent,NClus);
617  for (uint i=0; i< ClusterLabels.size(); i++){
618  SeedsVsClusters[i]->Fill(NClus[i],seedCollection.size());
619  }
620  }
621 
622  if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed){
623 
624  //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
625  // magnetic field
626  edm::ESHandle<MagneticField> theMF;
627  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
628 
629  // get the beam spot
630  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
631  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
632  const reco::BeamSpot& bs = *recoBeamSpotHandle;
633 
634  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
635  for(size_t i=0; i < seedHandle->size(); ++i) {
636 
637  edm::RefToBase<TrajectorySeed> seed(seedHandle, i);
638  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *seed, bs, theMF, theTTRHBuilder);
639  }
640  }
641 
642  } else {
643  edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event. Not filling associated histograms";
644  }
645  }
646 
647 
648  if (doTrackerSpecific_ || doAllPlots) {
649 
650  std::vector<int> NClus;
651  setNclus(iEvent,NClus);
652  for (uint i=0; i< ClusterLabels.size(); i++) {
653  NumberOfTrkVsClusters[i]->Fill(NClus[i],numberOfTracks);
654  }
655  }
656 
657  if ( doPUmonitoring_ ) {
658 
659  // do vertex monitoring
660  for (size_t i=0; i<theVertexMonitor.size(); i++)
661  theVertexMonitor[i]->analyze(iEvent, iSetup);
662 
663  if ( doPlotsVsGoodPVtx_ ) {
664 
665  size_t totalNumGoodPV = 0;
666  edm::Handle< reco::VertexCollection > pvHandle;
667  iEvent.getByToken(pvSrcToken_, pvHandle );
668  if (pvHandle.isValid()) {
669 
670  for (reco::VertexCollection::const_iterator pv = pvHandle->begin();
671  pv != pvHandle->end(); ++pv) {
672 
673  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
674  if (pv->isFake() || pv->tracksSize()==0) continue;
675 
676  // definition of goodOfflinePrimaryVertex
677  if (pv->ndof() < 4. || pv->z() > 24.) continue;
678  totalNumGoodPV++;
679  }
680 
681  NumberOfTracksVsGoodPVtx -> Fill( totalNumGoodPV, numberOfTracks );
682  }
683  }
684 
685  if ( doPlotsVsBXlumi_ ) {
686  double bxlumi = theLumiDetails_->getValue(iEvent);
687  NumberOfTracksVsBXlumi -> Fill( bxlumi, numberOfTracks );
688  }
689 
690  } // PU monitoring
691 
692  } // trackHandle is valid
693 
694 }
695 
696 
697 void TrackingMonitor::endRun(const edm::Run&, const edm::EventSetup&)
698 {
699 }
700 
701 void TrackingMonitor::setMaxMinBin(std::vector<double> &arrayMin, std::vector<double> &arrayMax, std::vector<int> &arrayBin, double smin, double smax, int sbin, double pmin, double pmax, int pbin)
702 {
703  arrayMin.resize(ClusterLabels.size());
704  arrayMax.resize(ClusterLabels.size());
705  arrayBin.resize(ClusterLabels.size());
706 
707  for (uint i=0; i<ClusterLabels.size(); ++i) {
708 
709  if (ClusterLabels[i].compare("Pix")==0 ) {arrayMin[i]=pmin; arrayMax[i]=pmax; arrayBin[i]=pbin;}
710  else if(ClusterLabels[i].compare("Strip")==0) {arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
711  else if(ClusterLabels[i].compare("Tot")==0 ) {arrayMin[i]=smin; arrayMax[i]=smax+pmax; arrayBin[i]=sbin;}
712  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined, using strip parameters ";
713  arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
714 
715  }
716 
717 }
718 
719 void TrackingMonitor::setNclus(const edm::Event& iEvent,std::vector<int> &arrayNclus)
720 {
721 
722  int ncluster_pix=-1;
723  int ncluster_strip=-1;
724 
725  edm::Handle< edmNew::DetSetVector<SiStripCluster> > strip_clusters;
726  iEvent.getByToken(stripClustersToken_, strip_clusters );
727  edm::Handle< edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
728  iEvent.getByToken(pixelClustersToken_, pixel_clusters );
729 
730  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
731  ncluster_pix = (*pixel_clusters).dataSize();
732  ncluster_strip = (*strip_clusters).dataSize();
733  }
734 
735  arrayNclus.resize(ClusterLabels.size());
736  for (uint i=0; i<ClusterLabels.size(); ++i){
737 
738  if (ClusterLabels[i].compare("Pix")==0 ) arrayNclus[i]=ncluster_pix ;
739  else if(ClusterLabels[i].compare("Strip")==0) arrayNclus[i]=ncluster_strip;
740  else if(ClusterLabels[i].compare("Tot")==0 ) arrayNclus[i]=ncluster_pix+ncluster_strip;
741  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined using stri parametrs ";
742  arrayNclus[i]=ncluster_strip ;}
743  }
744 
745 }
746 DEFINE_FWK_MODULE(TrackingMonitor);
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:85
i
int i
Definition: DBlmapReader.cc:9
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:120
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:107
TrackingMonitor::setMaxMinBin
virtual void setMaxMinBin(std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
Definition: TrackingMonitor.cc:701
TrackingMonitor::theTrackAnalyzer
TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:96
TrackingMonitor::conf_
edm::ParameterSet conf_
Definition: TrackingMonitor.h:74
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:719
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< reco::TrackCollection > allTrackToken_
Definition: TrackingMonitor.h:82
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:99
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:446
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
TrackCandidateCollection
std::vector< TrackCandidate > TrackCandidateCollection
Definition: TrackCandidateCollection.h:7
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:13
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:78
edm::View::size
size_type size() const
NULL
#define NULL
Definition: scimark2.h:8
TrackingMonitor::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:481
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:39
TrackingMonitor::NumberOfMeanRecHitsPerTrack
MonitorElement * NumberOfMeanRecHitsPerTrack
Definition: TrackingMonitor.h:103
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:131
edm::EventID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:40
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:127
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:164
compare_using_db.compare
compare
Definition: compare_using_db.py:36
GetLumi::getValue
double getValue(const edm::Event &)
Definition: GetLumi.cc:64
TrackingMonitor::Quality_
std::string Quality_
Definition: TrackingMonitor.h:92
TrackBuildingAnalyzer::analyze
virtual void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const TrajectorySeed &seed, const reco::BeamSpot &bs, const edm::ESHandle< MagneticField > &theMF, const edm::ESHandle< TransientTrackingRecHitBuilder > &theTTRHBuilder)
Definition: TrackBuildingAnalyzer.cc:265
TrackingMonitor::bsSrc_
edm::InputTag bsSrc_
Definition: TrackingMonitor.h:77
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:110
iEvent
int iEvent
Definition: GenABIO.cc:230
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:67
TrackingMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TrackingMonitor.cc:152
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:217
TrackBuildingAnalyzer::initHisto
virtual void initHisto(DQMStore::IBooker &ibooker)
Definition: TrackBuildingAnalyzer.cc:40
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:126
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1460
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:152
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:112
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:128
TrackingMonitor::endRun
virtual void endRun(const edm::Run &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:697
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:70
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:98
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:132
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:87
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:146
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:97
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:274
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
TrackAnalyzer::analyze
virtual void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
Definition: TrackAnalyzer.cc:602
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:93
TrackingMonitor::trackToken_
edm::EDGetTokenT< reco::TrackCollection > trackToken_
Definition: TrackingMonitor.h:83
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:84
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:104
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h:162
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackingMonitor::numSelection_
StringCutObjectSelector< reco::Track, true > numSelection_
Definition: TrackingMonitor.h:161
TrackAnalyzer::initHisto
virtual void initHisto(DQMStore::IBooker &ibooker)
Definition: TrackAnalyzer.cc:123
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:159
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:88
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:111
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:56
TrackingMonitor::TrackingMonitor
TrackingMonitor(const edm::ParameterSet &)
Definition: TrackingMonitor.cc:40
TrackingMonitor::theTTRHBuilder
edm::ESHandle< TransientTrackingRecHitBuilder > theTTRHBuilder
Definition: TrackingMonitor.h:138
TrackingMonitor::beginJob
virtual void beginJob(void)
Definition: TrackingMonitor.cc:146
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:117
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:90
HcalObjRepresent::Reset
void Reset(std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:620
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:89
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:129
MonitorElement::setLumiFlag
void setLumiFlag(void)
this ME is meant to be stored for each luminosity section
Definition: MonitorElement.h:148
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:135
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:957
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:463
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:79
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:102
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:80
edm::Run
Definition: Run.h:41
TrackingMonitor::beginLuminosityBlock
virtual void beginLuminosityBlock(const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup)
Definition: TrackingMonitor.cc:467
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:113
TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:137
Generated for CMSSW Reference Manual by doxygen 1.8.5