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  : dqmStore_( edm::Service<DQMStore>().operator->() )
42  , conf_ ( iConfig )
43  , theTrackBuildingAnalyzer( new TrackBuildingAnalyzer(conf_) )
44  , NumberOfTracks(NULL)
45  , NumberOfMeanRecHitsPerTrack(NULL)
46  , NumberOfMeanLayersPerTrack(NULL)
47  // , NumberOfGoodTracks(NULL)
48  , FractionOfGoodTracks(NULL)
49  , NumberOfSeeds(NULL)
50  , NumberOfSeeds_lumiFlag(NULL)
51  , NumberOfTrackCandidates(NULL)
52  // , NumberOfGoodTrkVsClus(NULL)
53  , NumberOfTracksVsLS(NULL)
54  // , NumberOfGoodTracksVsLS(NULL)
55  , GoodTracksFractionVsLS(NULL)
56  // , GoodTracksNumberOfRecHitsPerTrackVsLS(NULL)
57  // ADD by Mia for PU monitoring
58  // vertex plots to be moved in ad hoc class
59  , NumberOfTracksVsGoodPVtx(NULL)
60  , NumberOfTracksVsBXlumi(NULL)
61 
62  , NumberOfTracks_lumiFlag(NULL)
63  // , NumberOfGoodTracks_lumiFlag(NULL)
64 
65  , builderName ( conf_.getParameter<std::string>("TTRHBuilder"))
66  , doTrackerSpecific_ ( conf_.getParameter<bool>("doTrackerSpecific") )
67  , doLumiAnalysis ( conf_.getParameter<bool>("doLumiAnalysis"))
68  , doProfilesVsLS_ ( conf_.getParameter<bool>("doProfilesVsLS"))
69  , doAllPlots ( conf_.getParameter<bool>("doAllPlots"))
70  , doGeneralPropertiesPlots_( conf_.getParameter<bool>("doGeneralPropertiesPlots"))
71  , doHitPropertiesPlots_ ( conf_.getParameter<bool>("doHitPropertiesPlots"))
72  , doPUmonitoring_ ( conf_.getParameter<bool>("doPUmonitoring") )
73  , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig,consumesCollector()))
74 {
75 
76  edm::ConsumesCollector c{ consumesCollector() };
77  theTrackAnalyzer = new TrackAnalyzer( conf_,c );
78 
79  // input tags for collections from the configuration
80  bsSrc_ = conf_.getParameter<edm::InputTag>("beamSpot");
81  pvSrc_ = conf_.getParameter<edm::InputTag>("primaryVertex");
82  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
83  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
84 
85  edm::InputTag alltrackProducer = conf_.getParameter<edm::InputTag>("allTrackProducer");
86  edm::InputTag trackProducer = conf_.getParameter<edm::InputTag>("TrackProducer");
87  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
88  edm::InputTag seedProducer = conf_.getParameter<edm::InputTag>("SeedProducer");
89  allTrackToken_ = consumes<reco::TrackCollection>(alltrackProducer);
90  trackToken_ = consumes<reco::TrackCollection>(trackProducer);
91  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
92  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
93 
94  edm::InputTag stripClusterInputTag_ = conf_.getParameter<edm::InputTag>("stripCluster");
95  edm::InputTag pixelClusterInputTag_ = conf_.getParameter<edm::InputTag>("pixelCluster");
96  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> > (stripClusterInputTag_);
97  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> > (pixelClusterInputTag_);
98 
99  doFractionPlot_ = true;
100  if (alltrackProducer.label()==trackProducer.label()) doFractionPlot_ = false;
101 
102  Quality_ = conf_.getParameter<std::string>("Quality");
103  AlgoName_ = conf_.getParameter<std::string>("AlgoName");
104 
105 
106  if ( doPUmonitoring_ ) {
107 
108  // get flag from the configuration
109  doPlotsVsBXlumi_ = conf_.getParameter<bool>("doPlotsVsBXlumi");
110  doPlotsVsGoodPVtx_ = conf_.getParameter<bool>("doPlotsVsGoodPVtx");
111 
112  if ( doPlotsVsBXlumi_ )
113  theLumiDetails_ = new GetLumi( iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c );
114 
115  std::vector<edm::InputTag> primaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
116  std::vector<edm::InputTag> selPrimaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
117  std::vector<std::string> pvLabels = conf_.getParameter<std::vector<std::string> > ("pvLabels");
118 
119  if (primaryVertexInputTags.size()==pvLabels.size() and primaryVertexInputTags.size()==selPrimaryVertexInputTags.size()) {
120  // for (auto const& tag : primaryVertexInputTags) {
121  for (size_t i=0; i<primaryVertexInputTags.size(); i++) {
122  edm::InputTag iPVinputTag = primaryVertexInputTags[i];
123  edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
124  std::string iPVlabel = pvLabels[i];
125 
126  theVertexMonitor.push_back(new VertexMonitor(conf_,iPVinputTag,iSelPVinputTag,iPVlabel,c) );
127  }
128  }
129  }
130 
131 }
132 
133 
134 TrackingMonitor::~TrackingMonitor()
135 {
136  if (theTrackAnalyzer) delete theTrackAnalyzer;
137  if (theTrackBuildingAnalyzer) delete theTrackBuildingAnalyzer;
138  if ( doPUmonitoring_ )
139  for (size_t i=0; i<theVertexMonitor.size(); i++)
140  if (theVertexMonitor[i]) delete theVertexMonitor[i];
141  if (genTriggerEventFlag_) delete genTriggerEventFlag_;
142 }
143 
144 
145 void TrackingMonitor::beginJob(void)
146 {
147 
148 
149 }
150 
151 // -- BeginRun
152 //---------------------------------------------------------------------------------//
153 void TrackingMonitor::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
154 {
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  dqmStore_->setCurrentFolder(MEFolderName);
210 
211  // book the General Property histograms
212  // ---------------------------------------------------------------------------------//
213 
214  if (doGeneralPropertiesPlots_ || doAllPlots){
215 
216  dqmStore_->setCurrentFolder(MEFolderName+"/GeneralProperties");
217 
218  histname = "NumberOfTracks_" + CategoryName;
219  // MODIFY by Mia in order to cope w/ high multiplicity
220  NumberOfTracks = dqmStore_->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 = dqmStore_->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 = dqmStore_->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 = dqmStore_->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  dqmStore_->setCurrentFolder(MEFolderName+"/LSanalysis");
245 
246  histname = "NumberOfTracks_lumiFlag_" + CategoryName;
247  NumberOfTracks_lumiFlag = dqmStore_->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  dqmStore_->setCurrentFolder(MEFolderName+"/GeneralProperties");
260 
261  histname = "NumberOfTracksVsLS_"+ CategoryName;
262  NumberOfTracksVsLS = dqmStore_->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 = dqmStore_->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 = dqmStore_->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]->beginJob(dqmStore_);
289 
290  dqmStore_->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 = dqmStore_->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 = dqmStore_->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->beginRun(dqmStore_);
323 
324  // book the Seed Property histograms
325  // ---------------------------------------------------------------------------------//
326 
327  dqmStore_->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  dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
341  histname = "NumberOfSeeds_"+ seedProducer.label() + "_"+ CategoryName;
342  NumberOfSeeds = dqmStore_->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  dqmStore_->setCurrentFolder(MEFolderName+"/LSanalysis");
348  histname = "NumberOfSeeds_lumiFlag_"+ seedProducer.label() + "_"+ CategoryName;
349  NumberOfSeeds_lumiFlag = dqmStore_->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  dqmStore_->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*>(dqmStore_->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  dqmStore_->setCurrentFolder(MEFolderName+"/TrackBuilding");
388 
389  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
390 
391  histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
392  NumberOfTrackCandidates = dqmStore_->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->beginRun(dqmStore_);
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  dqmStore_->setCurrentFolder(MEFolderName+"/HitProperties");
434 
435  for (uint i=0; i<ClusterLabels.size(); i++){
436 
437  dqmStore_->setCurrentFolder(MEFolderName+"/HitProperties");
438  histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
439  NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(dqmStore_->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 // - BeginLumi
456 // ---------------------------------------------------------------------------------//
457 void TrackingMonitor::beginLuminosityBlock(const edm::LuminosityBlock& lumi, const edm::EventSetup& eSetup) {
458 
459  if (doLumiAnalysis) {
460  if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> Reset();
461  theTrackAnalyzer->doReset(dqmStore_);
462  }
463  if(doAllSeedPlots || doSeedNumberPlot) {
464  if ( doSeedLumiAnalysis_ )
465  NumberOfSeeds_lumiFlag->Reset();
466  }
467 }
468 
469 // -- Analyse
470 // ---------------------------------------------------------------------------------//
471 void TrackingMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
472 {
473  // Filter out events if Trigger Filtering is requested
474  if (genTriggerEventFlag_->on()&& ! genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
475 
476  // Analyse the tracks
477  // if the collection is empty, do not fill anything
478  // ---------------------------------------------------------------------------------//
479 
480  // get the track collection
481  edm::Handle<reco::TrackCollection> trackHandle;
482  iEvent.getByToken(trackToken_, trackHandle);
483 
484  int numberOfAllTracks = 0;
485  edm::Handle<reco::TrackCollection> allTrackHandle;
486  iEvent.getByToken(allTrackToken_,allTrackHandle);
487  if (allTrackHandle.isValid()) {
488  numberOfAllTracks = allTrackHandle->size();
489  }
490 
491  if (trackHandle.isValid()) {
492 
493  int numberOfTracks = trackHandle->size();
494 
495  reco::TrackCollection trackCollection = *trackHandle;
496  // calculate the mean # rechits and layers
497  int totalRecHits = 0, totalLayers = 0;
498 
499  for (reco::TrackCollection::const_iterator track = trackCollection.begin();
500  track!=trackCollection.end(); ++track) {
501 
502  if ( doProfilesVsLS_ || doAllPlots)
503  NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),track->recHitsSize());
504 
505  totalRecHits += track->numberOfValidHits();
506  totalLayers += track->hitPattern().trackerLayersWithMeasurement();
507 
508  // do analysis per track
509  theTrackAnalyzer->analyze(iEvent, iSetup, *track);
510  }
511 
512  double frac = -1.;
513  if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
514 
515  if (doGeneralPropertiesPlots_ || doAllPlots){
516  NumberOfTracks -> Fill(numberOfTracks);
517  if (doFractionPlot_)
518  FractionOfGoodTracks -> Fill(frac);
519 
520  if( numberOfTracks > 0 ) {
521  double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
522  double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
523  NumberOfMeanRecHitsPerTrack -> Fill(meanRecHits);
524  NumberOfMeanLayersPerTrack -> Fill(meanLayers);
525  }
526  }
527 
528  if ( doProfilesVsLS_ || doAllPlots) {
529  NumberOfTracksVsLS ->Fill(static_cast<double>(iEvent.id().luminosityBlock()),numberOfTracks);
530  if (doFractionPlot_)
531  GoodTracksFractionVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),frac);
532  }
533 
534  if ( doLumiAnalysis ) {
535  NumberOfTracks_lumiFlag -> Fill(numberOfTracks);
536  }
537 
538 
539  // Analyse the Track Building variables
540  // if the collection is empty, do not fill anything
541  // ---------------------------------------------------------------------------------//
542 
543 
544  // fill the TrackCandidate info
545  if (doTkCandPlots) {
546  // magnetic field
547  edm::ESHandle<MagneticField> theMF;
548  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
549 
550  // get the candidate collection
551  edm::Handle<TrackCandidateCollection> theTCHandle;
552  iEvent.getByToken( trackCandidateToken_, theTCHandle );
553  const TrackCandidateCollection& theTCCollection = *theTCHandle;
554 
555  if (theTCHandle.isValid()) {
556 
557  // get the beam spot
558  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
559  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
560  const reco::BeamSpot& bs = *recoBeamSpotHandle;
561 
562  NumberOfTrackCandidates->Fill(theTCCollection.size());
563  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
564  for( TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end(); ++cand) {
565 
566  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
567  }
568  } else {
569  edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event. Not filling associated histograms";
570  }
571  }
572 
573  //plots for trajectory seeds
574 
575  if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
576 
577  // get the seed collection
578  edm::Handle<edm::View<TrajectorySeed> > seedHandle;
579  iEvent.getByToken(seedToken_, seedHandle );
580  const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
581 
582  // fill the seed info
583  if (seedHandle.isValid()) {
584 
585  if(doAllSeedPlots || doSeedNumberPlot) {
586  NumberOfSeeds->Fill(seedCollection.size());
587  if ( doSeedLumiAnalysis_ )
588  NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
589  }
590 
591  if(doAllSeedPlots || doSeedVsClusterPlot){
592 
593  std::vector<int> NClus;
594  setNclus(iEvent,NClus);
595  for (uint i=0; i< ClusterLabels.size(); i++){
596  SeedsVsClusters[i]->Fill(NClus[i],seedCollection.size());
597  }
598  }
599 
600  if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed){
601 
602  //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
603  // magnetic field
604  edm::ESHandle<MagneticField> theMF;
605  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
606 
607  // get the beam spot
608  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
609  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
610  const reco::BeamSpot& bs = *recoBeamSpotHandle;
611 
612  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
613  for(size_t i=0; i < seedHandle->size(); ++i) {
614 
615  edm::RefToBase<TrajectorySeed> seed(seedHandle, i);
616  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *seed, bs, theMF, theTTRHBuilder);
617  }
618  }
619 
620  } else {
621  edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event. Not filling associated histograms";
622  }
623  }
624 
625 
626  if (doTrackerSpecific_ || doAllPlots) {
627 
628  std::vector<int> NClus;
629  setNclus(iEvent,NClus);
630  for (uint i=0; i< ClusterLabels.size(); i++) {
631  NumberOfTrkVsClusters[i]->Fill(NClus[i],numberOfTracks);
632  }
633  }
634 
635  if ( doPUmonitoring_ ) {
636 
637  // do vertex monitoring
638  for (size_t i=0; i<theVertexMonitor.size(); i++)
639  theVertexMonitor[i]->analyze(iEvent, iSetup);
640 
641  if ( doPlotsVsGoodPVtx_ ) {
642 
643  size_t totalNumGoodPV = 0;
644  edm::Handle< reco::VertexCollection > pvHandle;
645  iEvent.getByToken(pvSrcToken_, pvHandle );
646  if (pvHandle.isValid()) {
647 
648  for (reco::VertexCollection::const_iterator pv = pvHandle->begin();
649  pv != pvHandle->end(); ++pv) {
650 
651  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
652  if (pv->isFake() || pv->tracksSize()==0) continue;
653 
654  // definition of goodOfflinePrimaryVertex
655  if (pv->ndof() < 4. || pv->z() > 24.) continue;
656  totalNumGoodPV++;
657  }
658 
659  NumberOfTracksVsGoodPVtx -> Fill( totalNumGoodPV, numberOfTracks );
660  }
661  }
662 
663  if ( doPlotsVsBXlumi_ ) {
664  double bxlumi = theLumiDetails_->getValue(iEvent);
665  NumberOfTracksVsBXlumi -> Fill( bxlumi, numberOfTracks );
666  }
667 
668  } // PU monitoring
669 
670  } // trackHandle is valid
671 
672 }
673 
674 
675 void TrackingMonitor::endRun(const edm::Run&, const edm::EventSetup&)
676 {
677 }
678 
679 void TrackingMonitor::endJob(void)
680 {
681  bool outputMEsInRootFile = conf_.getParameter<bool>("OutputMEsInRootFile");
682  std::string outputFileName = conf_.getParameter<std::string>("OutputFileName");
683  if(outputMEsInRootFile)
684  {
685  dqmStore_->showDirStructure();
686  dqmStore_->save(outputFileName);
687  }
688 }
689 
690 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)
691 {
692  arrayMin.resize(ClusterLabels.size());
693  arrayMax.resize(ClusterLabels.size());
694  arrayBin.resize(ClusterLabels.size());
695 
696  for (uint i=0; i<ClusterLabels.size(); ++i) {
697 
698  if (ClusterLabels[i].compare("Pix")==0 ) {arrayMin[i]=pmin; arrayMax[i]=pmax; arrayBin[i]=pbin;}
699  else if(ClusterLabels[i].compare("Strip")==0) {arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
700  else if(ClusterLabels[i].compare("Tot")==0 ) {arrayMin[i]=smin; arrayMax[i]=smax+pmax; arrayBin[i]=sbin;}
701  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined, using strip parameters ";
702  arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
703 
704  }
705 
706 }
707 
708 void TrackingMonitor::setNclus(const edm::Event& iEvent,std::vector<int> &arrayNclus)
709 {
710 
711  int ncluster_pix=-1;
712  int ncluster_strip=-1;
713 
714  edm::Handle< edmNew::DetSetVector<SiStripCluster> > strip_clusters;
715  iEvent.getByToken(stripClustersToken_, strip_clusters );
716  edm::Handle< edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
717  iEvent.getByToken(pixelClustersToken_, pixel_clusters );
718 
719  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
720  ncluster_pix = (*pixel_clusters).dataSize();
721  ncluster_strip = (*strip_clusters).dataSize();
722  }
723 
724  arrayNclus.resize(ClusterLabels.size());
725  for (uint i=0; i<ClusterLabels.size(); ++i){
726 
727  if (ClusterLabels[i].compare("Pix")==0 ) arrayNclus[i]=ncluster_pix ;
728  else if(ClusterLabels[i].compare("Strip")==0) arrayNclus[i]=ncluster_strip;
729  else if(ClusterLabels[i].compare("Tot")==0 ) arrayNclus[i]=ncluster_pix+ncluster_strip;
730  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined using stri parametrs ";
731  arrayNclus[i]=ncluster_strip ;}
732  }
733 
734 }
735 DEFINE_FWK_MODULE(TrackingMonitor);
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:84
i
int i
Definition: DBlmapReader.cc:9
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:119
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:106
TrackingMonitor::dqmStore_
DQMStore * dqmStore_
Definition: TrackingMonitor.h:70
TrackingMonitor::setMaxMinBin
virtual void setMaxMinBin(std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
Definition: TrackingMonitor.cc:690
TrackingMonitor::theTrackAnalyzer
TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:95
TrackingMonitor::conf_
edm::ParameterSet conf_
Definition: TrackingMonitor.h:72
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:708
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< reco::TrackCollection > allTrackToken_
Definition: TrackingMonitor.h:80
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:98
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
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
TrackingMonitor::beginRun
virtual void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:153
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:10
TrackAnalyzer::doReset
void doReset(DQMStore *dqmStore_)
Definition: TrackAnalyzer.cc:1296
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:76
NULL
#define NULL
Definition: scimark2.h:8
TrackingMonitor::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:471
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:102
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:130
edm::EventID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:43
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:126
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:161
compare_using_db.compare
compare
Definition: compare_using_db.py:36
GetLumi::getValue
double getValue(const edm::Event &)
Definition: GetLumi.cc:65
dumpDBToFile_GT_ttrig_cfg.outputFileName
tuple outputFileName
Definition: dumpDBToFile_GT_ttrig_cfg.py:31
TrackingMonitor::Quality_
std::string Quality_
Definition: TrackingMonitor.h:91
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:75
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:109
iEvent
int iEvent
Definition: GenABIO.cc:243
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:66
TrackingMonitor::endJob
virtual void endJob(void)
Definition: TrackingMonitor.cc:679
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:217
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:125
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1491
DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", const uint32_t run=0, SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE")
Definition: DQMStore.cc:2296
DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1186
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:151
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:111
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:127
TrackingMonitor::endRun
virtual void endRun(const edm::Run &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:675
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:68
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:97
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:131
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:86
TrackAnalyzer::beginRun
virtual void beginRun(DQMStore *dqmStore_)
Definition: TrackAnalyzer.cc:119
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:145
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:96
TrackAnalyzer::analyze
virtual void analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::Track &track)
Definition: TrackAnalyzer.cc:569
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:92
TrackingMonitor::trackToken_
edm::EDGetTokenT< reco::TrackCollection > trackToken_
Definition: TrackingMonitor.h:82
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:83
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:103
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
TrackBuildingAnalyzer::beginRun
virtual void beginRun(DQMStore *dqmStore_)
Definition: TrackBuildingAnalyzer.cc:40
edm::View::size
size_type size() const
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:158
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:87
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:110
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:137
TrackingMonitor::beginJob
virtual void beginJob(void)
Definition: TrackingMonitor.cc:145
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:116
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:89
HcalObjRepresent::Reset
void Reset(std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:620
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:88
DQMStore::showDirStructure
void showDirStructure(void) const
Definition: DQMStore.cc:2961
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:145
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1000
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:134
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:928
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:434
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:77
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:101
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:78
edm::Run
Definition: Run.h:41
TrackingMonitor::beginLuminosityBlock
virtual void beginLuminosityBlock(const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup)
Definition: TrackingMonitor.cc:457
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:112
TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:136
Generated for CMSSW Reference Manual by doxygen 1.8.5