test
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  , NumberEventsOfVsLS(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  , NumberOfGoodPVtxVsLS(NULL)
60  , NumberEventsOfVsBX (NULL)
61  , NumberOfTracksVsBX(NULL)
62  , GoodTracksFractionVsBX(NULL)
63  , NumberOfRecHitsPerTrackVsBX(NULL)
64  , NumberOfGoodPVtxVsBX(NULL)
65  , NumberOfTracksVsBXlumi(NULL)
66  , NumberOfTracksVsGoodPVtx(NULL)
67  , NumberOfTracksVsPUPVtx(NULL)
68  , NumberEventsOfVsGoodPVtx(NULL)
69  , GoodTracksFractionVsGoodPVtx(NULL)
70  , NumberOfRecHitsPerTrackVsGoodPVtx(NULL)
71  , NumberOfPVtxVsGoodPVtx(NULL)
72  , NumberEventsOfVsLUMI(NULL)
73  , NumberOfTracksVsLUMI(NULL)
74  , GoodTracksFractionVsLUMI(NULL)
75  , NumberOfRecHitsPerTrackVsLUMI(NULL)
76  , NumberOfGoodPVtxVsLUMI(NULL)
77  , NumberOfTracks_lumiFlag(NULL)
78  // , NumberOfGoodTracks_lumiFlag(NULL)
79 
80  , builderName ( conf_.getParameter<std::string>("TTRHBuilder"))
81  , doTrackerSpecific_ ( conf_.getParameter<bool>("doTrackerSpecific") )
82  , doLumiAnalysis ( conf_.getParameter<bool>("doLumiAnalysis"))
83  , doProfilesVsLS_ ( conf_.getParameter<bool>("doProfilesVsLS"))
84  , doAllPlots ( conf_.getParameter<bool>("doAllPlots"))
85  , doGeneralPropertiesPlots_( conf_.getParameter<bool>("doGeneralPropertiesPlots"))
86  , doHitPropertiesPlots_ ( conf_.getParameter<bool>("doHitPropertiesPlots"))
87  , doPUmonitoring_ ( conf_.getParameter<bool>("doPUmonitoring") )
88  , genTriggerEventFlag_(new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("genericTriggerEventPSet"),consumesCollector(), *this))
89  , numSelection_ (conf_.getParameter<std::string>("numCut"))
90  , denSelection_ (conf_.getParameter<std::string>("denCut"))
91  , pvNDOF_ ( conf_.getParameter<int> ("pvNDOF") )
92 {
93 
94  edm::ConsumesCollector c{ consumesCollector() };
95  theTrackAnalyzer = new TrackAnalyzer( conf_,c );
96 
97  // input tags for collections from the configuration
98  bsSrc_ = conf_.getParameter<edm::InputTag>("beamSpot");
99  pvSrc_ = conf_.getParameter<edm::InputTag>("primaryVertex");
100  bsSrcToken_ = consumes<reco::BeamSpot>(bsSrc_);
101  pvSrcToken_ = mayConsume<reco::VertexCollection>(pvSrc_);
102 
103  lumiscalersToken_ = consumes<LumiScalersCollection>(conf_.getParameter<edm::InputTag>("scal") );
104 
105  edm::InputTag alltrackProducer = conf_.getParameter<edm::InputTag>("allTrackProducer");
106  edm::InputTag trackProducer = conf_.getParameter<edm::InputTag>("TrackProducer");
107  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
108  edm::InputTag seedProducer = conf_.getParameter<edm::InputTag>("SeedProducer");
109  allTrackToken_ = consumes<reco::TrackCollection>(alltrackProducer);
110  trackToken_ = consumes<reco::TrackCollection>(trackProducer);
111  trackCandidateToken_ = consumes<TrackCandidateCollection>(tcProducer);
112  seedToken_ = consumes<edm::View<TrajectorySeed> >(seedProducer);
113 
114  edm::InputTag stripClusterInputTag_ = conf_.getParameter<edm::InputTag>("stripCluster");
115  edm::InputTag pixelClusterInputTag_ = conf_.getParameter<edm::InputTag>("pixelCluster");
116  stripClustersToken_ = mayConsume<edmNew::DetSetVector<SiStripCluster> > (stripClusterInputTag_);
117  pixelClustersToken_ = mayConsume<edmNew::DetSetVector<SiPixelCluster> > (pixelClusterInputTag_);
118 
119  doFractionPlot_ = true;
120  if (alltrackProducer.label()==trackProducer.label()) doFractionPlot_ = false;
121 
122  Quality_ = conf_.getParameter<std::string>("Quality");
123  AlgoName_ = conf_.getParameter<std::string>("AlgoName");
124 
125  // get flag from the configuration
126  doPlotsVsBXlumi_ = conf_.getParameter<bool>("doPlotsVsBXlumi");
127  if ( doPlotsVsBXlumi_ )
128  theLumiDetails_ = new GetLumi( iConfig.getParameter<edm::ParameterSet>("BXlumiSetup"), c );
129  doPlotsVsGoodPVtx_ = conf_.getParameter<bool>("doPlotsVsGoodPVtx");
130  doPlotsVsLUMI_ = conf_.getParameter<bool>("doPlotsVsLUMI");
131  doPlotsVsBX_ = conf_.getParameter<bool>("doPlotsVsBX");
132 
133  if ( doPUmonitoring_ ) {
134 
135  std::vector<edm::InputTag> primaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("primaryVertexInputTags");
136  std::vector<edm::InputTag> selPrimaryVertexInputTags = conf_.getParameter<std::vector<edm::InputTag> >("selPrimaryVertexInputTags");
137  std::vector<std::string> pvLabels = conf_.getParameter<std::vector<std::string> > ("pvLabels");
138 
139  if (primaryVertexInputTags.size()==pvLabels.size() and primaryVertexInputTags.size()==selPrimaryVertexInputTags.size()) {
140  for (size_t i=0; i<primaryVertexInputTags.size(); i++) {
141  edm::InputTag iPVinputTag = primaryVertexInputTags[i];
142  edm::InputTag iSelPVinputTag = selPrimaryVertexInputTags[i];
143  std::string iPVlabel = pvLabels[i];
144 
145  theVertexMonitor.push_back(new VertexMonitor(conf_,iPVinputTag,iSelPVinputTag,iPVlabel,c) );
146  }
147  }
148  }
149 
150 }
151 
152 
153 TrackingMonitor::~TrackingMonitor()
154 {
155  if (theTrackAnalyzer) delete theTrackAnalyzer;
156  if (theTrackBuildingAnalyzer) delete theTrackBuildingAnalyzer;
157  if ( doPUmonitoring_ )
158  for (size_t i=0; i<theVertexMonitor.size(); i++)
159  if (theVertexMonitor[i]) delete theVertexMonitor[i];
160  if (genTriggerEventFlag_) delete genTriggerEventFlag_;
161 }
162 
163 
164 void TrackingMonitor::beginJob(void)
165 {
166 
167 
168 }
169 
170 void TrackingMonitor::bookHistograms(DQMStore::IBooker & ibooker,
171  edm::Run const & iRun,
172  edm::EventSetup const & iSetup)
173 {
174  // parameters from the configuration
175  std::string Quality = conf_.getParameter<std::string>("Quality");
176  std::string AlgoName = conf_.getParameter<std::string>("AlgoName");
177  std::string MEFolderName = conf_.getParameter<std::string>("FolderName");
178 
179  // test for the Quality veriable validity
180  if( Quality_ != "") {
181  if( Quality_ != "highPurity" && Quality_ != "tight" && Quality_ != "loose") {
182  edm::LogWarning("TrackingMonitor") << "Qualty Name is invalid, using no quality criterea by default";
183  Quality_ = "";
184  }
185  }
186 
187  // use the AlgoName and Quality Name
188  std::string CategoryName = Quality_ != "" ? AlgoName_ + "_" + Quality_ : AlgoName_;
189 
190  // get binning from the configuration
191  int TKNoBin = conf_.getParameter<int>( "TkSizeBin");
192  double TKNoMin = conf_.getParameter<double>("TkSizeMin");
193  double TKNoMax = conf_.getParameter<double>("TkSizeMax");
194 
195  int TCNoBin = conf_.getParameter<int>( "TCSizeBin");
196  double TCNoMin = conf_.getParameter<double>("TCSizeMin");
197  double TCNoMax = conf_.getParameter<double>("TCSizeMax");
198 
199  int TKNoSeedBin = conf_.getParameter<int>( "TkSeedSizeBin");
200  double TKNoSeedMin = conf_.getParameter<double>("TkSeedSizeMin");
201  double TKNoSeedMax = conf_.getParameter<double>("TkSeedSizeMax");
202 
203  int MeanHitBin = conf_.getParameter<int>( "MeanHitBin");
204  double MeanHitMin = conf_.getParameter<double>("MeanHitMin");
205  double MeanHitMax = conf_.getParameter<double>("MeanHitMax");
206 
207  int MeanLayBin = conf_.getParameter<int>( "MeanLayBin");
208  double MeanLayMin = conf_.getParameter<double>("MeanLayMin");
209  double MeanLayMax = conf_.getParameter<double>("MeanLayMax");
210 
211  int LSBin = conf_.getParameter<int>( "LSBin");
212  int LSMin = conf_.getParameter<double>("LSMin");
213  int LSMax = conf_.getParameter<double>("LSMax");
214 
215  std::string StateName = conf_.getParameter<std::string>("MeasurementState");
216  if (
217  StateName != "OuterSurface" &&
218  StateName != "InnerSurface" &&
219  StateName != "ImpactPoint" &&
220  StateName != "default" &&
221  StateName != "All"
222  ) {
223  // print warning
224  edm::LogWarning("TrackingMonitor") << "State Name is invalid, using 'ImpactPoint' by default";
225  }
226 
227  ibooker.setCurrentFolder(MEFolderName);
228 
229  // book the General Property histograms
230  // ---------------------------------------------------------------------------------//
231 
232  if (doGeneralPropertiesPlots_ || doAllPlots){
233 
234  ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
235 
236  histname = "NumberOfTracks_" + CategoryName;
237  // MODIFY by Mia in order to cope w/ high multiplicity
238  NumberOfTracks = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
239  NumberOfTracks->setAxisTitle("Number of Tracks per Event", 1);
240  NumberOfTracks->setAxisTitle("Number of Events", 2);
241 
242  histname = "NumberOfMeanRecHitsPerTrack_" + CategoryName;
243  NumberOfMeanRecHitsPerTrack = ibooker.book1D(histname, histname, MeanHitBin, MeanHitMin, MeanHitMax);
244  NumberOfMeanRecHitsPerTrack->setAxisTitle("Mean number of valid RecHits per Track", 1);
245  NumberOfMeanRecHitsPerTrack->setAxisTitle("Entries", 2);
246 
247  histname = "NumberOfMeanLayersPerTrack_" + CategoryName;
248  NumberOfMeanLayersPerTrack = ibooker.book1D(histname, histname, MeanLayBin, MeanLayMin, MeanLayMax);
249  NumberOfMeanLayersPerTrack->setAxisTitle("Mean number of Layers per Track", 1);
250  NumberOfMeanLayersPerTrack->setAxisTitle("Entries", 2);
251 
252  if (doFractionPlot_) {
253  histname = "FractionOfGoodTracks_" + CategoryName;
254  FractionOfGoodTracks = ibooker.book1D(histname, histname, 101, -0.005, 1.005);
255  FractionOfGoodTracks->setAxisTitle("Fraction of Tracks (w.r.t. generalTracks)", 1);
256  FractionOfGoodTracks->setAxisTitle("Entries", 2);
257  }
258  }
259 
260  if ( doLumiAnalysis ) {
261  // add by Mia in order to deal with LS transitions
262  ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
263 
264  histname = "NumberOfTracks_lumiFlag_" + CategoryName;
265  NumberOfTracks_lumiFlag = ibooker.book1D(histname, histname, 3*TKNoBin, TKNoMin, (TKNoMax+0.5)*3.-0.5);
266  NumberOfTracks_lumiFlag->setAxisTitle("Number of Tracks per Event", 1);
267  NumberOfTracks_lumiFlag->setAxisTitle("Number of Events", 2);
268 
269  }
270 
271  // book profile plots vs LS :
272  //---------------------------
273 
274 
275  if ( doProfilesVsLS_ || doAllPlots) {
276 
277  ibooker.setCurrentFolder(MEFolderName+"/GeneralProperties");
278 
279  histname = "NumberOfTracksVsLS_"+ CategoryName;
280  NumberOfTracksVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax, TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
281  NumberOfTracksVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
282  NumberOfTracksVsLS->setAxisTitle("#Lumi section",1);
283  NumberOfTracksVsLS->setAxisTitle("Number of Tracks",2);
284 
285  histname = "NumberOfRecHitsPerTrackVsLS_" + CategoryName;
286  NumberOfRecHitsPerTrackVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,0.,40.,"");
287  NumberOfRecHitsPerTrackVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
288  NumberOfRecHitsPerTrackVsLS->setAxisTitle("#Lumi section",1);
289  NumberOfRecHitsPerTrackVsLS->setAxisTitle("Mean number of Valid RecHits per track",2);
290 
291  histname = "NumberEventsVsLS_" + CategoryName;
292  NumberEventsOfVsLS = ibooker.book1D(histname,histname, LSBin,LSMin,LSMax);
293  NumberEventsOfVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
294  NumberEventsOfVsLS->setAxisTitle("#Lumi section",1);
295  NumberEventsOfVsLS->setAxisTitle("Number of events",2);
296 
297  double GoodPVtxMin = conf_.getParameter<double>("GoodPVtxMin");
298  double GoodPVtxMax = conf_.getParameter<double>("GoodPVtxMax");
299 
300  histname = "NumberOfGoodPVtxVsLS_" + CategoryName;
301  NumberOfGoodPVtxVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,GoodPVtxMin,GoodPVtxMax,"");
302  NumberOfGoodPVtxVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
303  NumberOfGoodPVtxVsLS->setAxisTitle("#Lumi section",1);
304  NumberOfGoodPVtxVsLS->setAxisTitle("Mean number of good PV",2);
305 
306  if (doFractionPlot_) {
307  histname = "GoodTracksFractionVsLS_"+ CategoryName;
308  GoodTracksFractionVsLS = ibooker.bookProfile(histname,histname, LSBin,LSMin,LSMax,0,1.1,"");
309  GoodTracksFractionVsLS->getTH1()->SetCanExtend(TH1::kAllAxes);
310  GoodTracksFractionVsLS->setAxisTitle("#Lumi section",1);
311  GoodTracksFractionVsLS->setAxisTitle("Fraction of Good Tracks",2);
312  }
313 
314  if ( doPlotsVsBX_ || doAllPlots ) {
315  ibooker.setCurrentFolder(MEFolderName+"/BXanalysis");
316  int BXBin = 3564; double BXMin = 0.5; double BXMax = 3564.5;
317 
318  histname = "NumberEventsVsBX_" + CategoryName;
319  NumberEventsOfVsBX = ibooker.book1D(histname,histname, BXBin,BXMin,BXMax);
320  NumberEventsOfVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
321  NumberEventsOfVsBX->setAxisTitle("BX",1);
322  NumberEventsOfVsBX->setAxisTitle("Number of events",2);
323 
324  histname = "NumberOfTracksVsBX_"+ CategoryName;
325  NumberOfTracksVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax, TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
326  NumberOfTracksVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
327  NumberOfTracksVsBX->setAxisTitle("BX",1);
328  NumberOfTracksVsBX->setAxisTitle("Number of Tracks",2);
329 
330  histname = "NumberOfRecHitsPerTrackVsBX_" + CategoryName;
331  NumberOfRecHitsPerTrackVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,0.,40.,"");
332  NumberOfRecHitsPerTrackVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
333  NumberOfRecHitsPerTrackVsBX->setAxisTitle("BX",1);
334  NumberOfRecHitsPerTrackVsBX->setAxisTitle("Mean number of Valid RecHits per track",2);
335 
336  histname = "NumberOfGoodPVtxVsBX_" + CategoryName;
337  NumberOfGoodPVtxVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,GoodPVtxMin,GoodPVtxMax,"");
338  NumberOfGoodPVtxVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
339  NumberOfGoodPVtxVsBX->setAxisTitle("BX",1);
340  NumberOfGoodPVtxVsBX->setAxisTitle("Mean number of good PV",2);
341 
342  if (doFractionPlot_) {
343  histname = "GoodTracksFractionVsBX_"+ CategoryName;
344  GoodTracksFractionVsBX = ibooker.bookProfile(histname,histname, BXBin,BXMin,BXMax,0,1.1,"");
345  GoodTracksFractionVsBX->getTH1()->SetCanExtend(TH1::kAllAxes);
346  GoodTracksFractionVsBX->setAxisTitle("BX",1);
347  GoodTracksFractionVsBX->setAxisTitle("Fraction of Good Tracks",2);
348  }
349  }
350 
351  }
352 
353  // book PU monitoring plots :
354  //---------------------------
355 
356  if ( doPUmonitoring_ ) {
357 
358  for (size_t i=0; i<theVertexMonitor.size(); i++)
359  theVertexMonitor[i]->initHisto(ibooker);
360  }
361 
362  if ( doPlotsVsGoodPVtx_ ) {
363  ibooker.setCurrentFolder(MEFolderName+"/PUmonitoring");
364  // get binning from the configuration
365  int GoodPVtxBin = conf_.getParameter<int>("GoodPVtxBin");
366  double GoodPVtxMin = conf_.getParameter<double>("GoodPVtxMin");
367  double GoodPVtxMax = conf_.getParameter<double>("GoodPVtxMax");
368 
369  histname = "NumberOfTracksVsGoodPVtx";
370  NumberOfTracksVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,TKNoMin, (TKNoMax+0.5)*3.-0.5,"");
371  NumberOfTracksVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
372  NumberOfTracksVsGoodPVtx->setAxisTitle("Number of PV",1);
373  NumberOfTracksVsGoodPVtx->setAxisTitle("Mean number of Tracks per Event",2);
374 
375  histname = "NumberOfTracksVsPUPVtx";
376  NumberOfTracksVsPUPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
377  NumberOfTracksVsPUPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
378  NumberOfTracksVsPUPVtx->setAxisTitle("Number of PU",1);
379  NumberOfTracksVsPUPVtx->setAxisTitle("Mean number of Tracks per PUvtx",2);
380 
381  histname = "NumberEventsVsGoodPVtx";
382  NumberEventsOfVsGoodPVtx = ibooker.book1D(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax);
383  NumberEventsOfVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
384  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
385  NumberEventsOfVsGoodPVtx->setAxisTitle("Number of events",2);
386 
387  if (doFractionPlot_) {
388  histname = "GoodTracksFractionVsGoodPVtx";
389  GoodTracksFractionVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 400.,"");
390  GoodTracksFractionVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
391  GoodTracksFractionVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
392  GoodTracksFractionVsGoodPVtx->setAxisTitle("Mean fraction of good tracks",2);
393  }
394 
395  histname = "NumberOfRecHitsPerTrackVsGoodPVtx";
396  NumberOfRecHitsPerTrackVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
397  NumberOfRecHitsPerTrackVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
398  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
399  NumberOfRecHitsPerTrackVsGoodPVtx->setAxisTitle("Mean number of valid rechits per Tracks",2);
400 
401  histname = "NumberOfPVtxVsGoodPVtx";
402  NumberOfPVtxVsGoodPVtx = ibooker.bookProfile(histname,histname,GoodPVtxBin,GoodPVtxMin,GoodPVtxMax,0., 100.,"");
403  NumberOfPVtxVsGoodPVtx->getTH1()->SetCanExtend(TH1::kAllAxes);
404  NumberOfPVtxVsGoodPVtx->setAxisTitle("Number of good PV (PU)",1);
405  NumberOfPVtxVsGoodPVtx->setAxisTitle("Mean number of vertices",2);
406  }
407 
408 
409  if ( doPlotsVsLUMI_ || doAllPlots ) {
410  ibooker.setCurrentFolder(MEFolderName+"/LUMIanalysis");
411  int LUMIBin = conf_.getParameter<int>("LUMIBin");
412  float LUMIMin = conf_.getParameter<double>("LUMIMin");
413  float LUMIMax = conf_.getParameter<double>("LUMIMax");
414 
415  histname = "NumberEventsVsLUMI";
416  NumberEventsOfVsLUMI = ibooker.book1D(histname,histname,LUMIBin,LUMIMin,LUMIMax);
417  NumberEventsOfVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
418  NumberEventsOfVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
419  NumberEventsOfVsLUMI->setAxisTitle("Number of events",2);
420 
421  histname = "NumberOfTracksVsLUMI";
422  NumberOfTracksVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,0., 400.,"");
423  NumberOfTracksVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
424  NumberOfTracksVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
425  NumberOfTracksVsLUMI->setAxisTitle("Mean number of vertices",2);
426 
427  if (doFractionPlot_) {
428  histname = "GoodTracksFractionVsLUMI";
429  GoodTracksFractionVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,0., 100.,"");
430  GoodTracksFractionVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
431  GoodTracksFractionVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
432  GoodTracksFractionVsLUMI->setAxisTitle("Mean number of vertices",2);
433  }
434 
435  histname = "NumberOfRecHitsPerTrackVsLUMI";
436  NumberOfRecHitsPerTrackVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,0., 20.,"");
437  NumberOfRecHitsPerTrackVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
438  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
439  NumberOfRecHitsPerTrackVsLUMI->setAxisTitle("Mean number of vertices",2);
440 
441  double GoodPVtxMin = conf_.getParameter<double>("GoodPVtxMin");
442  double GoodPVtxMax = conf_.getParameter<double>("GoodPVtxMax");
443 
444  histname = "NumberOfGoodPVtxVsLUMI";
445  NumberOfGoodPVtxVsLUMI = ibooker.bookProfile(histname,histname,LUMIBin,LUMIMin,LUMIMax,GoodPVtxMin,GoodPVtxMax,"");
446  NumberOfGoodPVtxVsLUMI->getTH1()->SetCanExtend(TH1::kAllAxes);
447  NumberOfGoodPVtxVsLUMI->setAxisTitle("scal lumi [10e30 Hz cm^{-2}]",1);
448  NumberOfGoodPVtxVsLUMI->setAxisTitle("Mean number of vertices",2);
449  }
450 
451 
452  if ( doPlotsVsBXlumi_ ) {
453  ibooker.setCurrentFolder(MEFolderName+"/PUmonitoring");
454  // get binning from the configuration
455  edm::ParameterSet BXlumiParameters = conf_.getParameter<edm::ParameterSet>("BXlumiSetup");
456  int BXlumiBin = BXlumiParameters.getParameter<int>("BXlumiBin");
457  double BXlumiMin = BXlumiParameters.getParameter<double>("BXlumiMin");
458  double BXlumiMax = BXlumiParameters.getParameter<double>("BXlumiMax");
459 
460  histname = "NumberOfTracksVsBXlumi_"+ CategoryName;
461  NumberOfTracksVsBXlumi = ibooker.bookProfile(histname,histname, BXlumiBin,BXlumiMin,BXlumiMax, TKNoMin, TKNoMax,"");
462  NumberOfTracksVsBXlumi->getTH1()->SetCanExtend(TH1::kAllAxes);
463  NumberOfTracksVsBXlumi->setAxisTitle("lumi BX [10^{30}Hzcm^{-2}]",1);
464  NumberOfTracksVsBXlumi->setAxisTitle("Mean number of Tracks",2);
465 
466  }
467 
468 
469  theTrackAnalyzer->initHisto(ibooker, iSetup);
470 
471  // book the Seed Property histograms
472  // ---------------------------------------------------------------------------------//
473 
474  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
475 
476  doAllSeedPlots = conf_.getParameter<bool>("doSeedParameterHistos");
477  doSeedNumberPlot = conf_.getParameter<bool>("doSeedNumberHisto");
478  doSeedLumiAnalysis_ = conf_.getParameter<bool>("doSeedLumiAnalysis");
479  doSeedVsClusterPlot = conf_.getParameter<bool>("doSeedVsClusterHisto");
480  // if (doAllPlots) doAllSeedPlots=true;
481 
482  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"));
483 
484  edm::InputTag seedProducer = conf_.getParameter<edm::InputTag>("SeedProducer");
485 
486  if (doAllSeedPlots || doSeedNumberPlot){
487  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
488  histname = "NumberOfSeeds_"+ seedProducer.label() + "_"+ CategoryName;
489  NumberOfSeeds = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
490  NumberOfSeeds->setAxisTitle("Number of Seeds per Event", 1);
491  NumberOfSeeds->setAxisTitle("Number of Events", 2);
492 
493  if ( doSeedLumiAnalysis_ ) {
494  ibooker.setCurrentFolder(MEFolderName+"/LSanalysis");
495  histname = "NumberOfSeeds_lumiFlag_"+ seedProducer.label() + "_"+ CategoryName;
496  NumberOfSeeds_lumiFlag = ibooker.book1D(histname, histname, TKNoSeedBin, TKNoSeedMin, TKNoSeedMax);
497  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Seeds per Event", 1);
498  NumberOfSeeds_lumiFlag->setAxisTitle("Number of Events", 2);
499  }
500 
501  }
502 
503  if (doAllSeedPlots || doSeedVsClusterPlot){
504  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
505 
506  ClusterLabels= conf_.getParameter<std::vector<std::string> >("ClusterLabels");
507 
508  std::vector<double> histoMin,histoMax;
509  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
510 
511  int NClusPxBin = conf_.getParameter<int>( "NClusPxBin");
512  double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
513  double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
514 
515  int NClusStrBin = conf_.getParameter<int>( "NClusStrBin");
516  double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
517  double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
518 
519  setMaxMinBin(histoMin,histoMax,histoBin,NClusStrMin,NClusStrMax,NClusStrBin,NClusPxMin,NClusPxMax,NClusPxBin);
520 
521  for (uint i=0; i<ClusterLabels.size(); i++){
522  histname = "SeedsVsClusters_" + seedProducer.label() + "_Vs_" + ClusterLabels[i] + "_" + CategoryName;
523  SeedsVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname, histoBin[i], histoMin[i], histoMax[i],
524  TKNoSeedBin, TKNoSeedMin, TKNoSeedMax)));
525  SeedsVsClusters[i]->setAxisTitle("Number of Clusters", 1);
526  SeedsVsClusters[i]->setAxisTitle("Number of Seeds", 2);
527  }
528  }
529 
530  doTkCandPlots=conf_.getParameter<bool>("doTrackCandHistos");
531  // if (doAllPlots) doTkCandPlots=true;
532 
533  if (doTkCandPlots){
534  ibooker.setCurrentFolder(MEFolderName+"/TrackBuilding");
535 
536  edm::InputTag tcProducer = conf_.getParameter<edm::InputTag>("TCProducer");
537 
538  histname = "NumberOfTrackCandidates_"+ tcProducer.label() + "_"+ CategoryName;
539  NumberOfTrackCandidates = ibooker.book1D(histname, histname, TCNoBin, TCNoMin, TCNoMax);
540  NumberOfTrackCandidates->setAxisTitle("Number of Track Candidates per Event", 1);
541  NumberOfTrackCandidates->setAxisTitle("Number of Event", 2);
542  }
543 
544  theTrackBuildingAnalyzer->initHisto(ibooker);
545 
546 
547  if (doLumiAnalysis) {
548  if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> setLumiFlag();
549  theTrackAnalyzer->setLumiFlag();
550  }
551 
552  if(doAllSeedPlots || doSeedNumberPlot){
553  if ( doSeedLumiAnalysis_ )
554  NumberOfSeeds_lumiFlag->setLumiFlag();
555  }
556 
557  if (doTrackerSpecific_ || doAllPlots) {
558 
559  ClusterLabels= conf_.getParameter<std::vector<std::string> >("ClusterLabels");
560 
561  std::vector<double> histoMin,histoMax;
562  std::vector<int> histoBin; //these vectors are for max min and nbins in histograms
563 
564  int NClusStrBin = conf_.getParameter<int>( "NClusStrBin");
565  double NClusStrMin = conf_.getParameter<double>("NClusStrMin");
566  double NClusStrMax = conf_.getParameter<double>("NClusStrMax");
567 
568  int NClusPxBin = conf_.getParameter<int>( "NClusPxBin");
569  double NClusPxMin = conf_.getParameter<double>("NClusPxMin");
570  double NClusPxMax = conf_.getParameter<double>("NClusPxMax");
571 
572  int NTrk2DBin = conf_.getParameter<int>( "NTrk2DBin");
573  double NTrk2DMin = conf_.getParameter<double>("NTrk2DMin");
574  double NTrk2DMax = conf_.getParameter<double>("NTrk2DMax");
575 
576  setMaxMinBin(histoMin,histoMax,histoBin,
577  NClusStrMin,NClusStrMax,NClusStrBin,
578  NClusPxMin, NClusPxMax, NClusPxBin);
579 
580  ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
581 
582  for (uint i=0; i<ClusterLabels.size(); i++){
583 
584  ibooker.setCurrentFolder(MEFolderName+"/HitProperties");
585  histname = "TracksVs" + ClusterLabels[i] + "Cluster_" + CategoryName;
586  NumberOfTrkVsClusters.push_back(dynamic_cast<MonitorElement*>(ibooker.book2D(histname, histname,
587  histoBin[i], histoMin[i], histoMax[i],
588  NTrk2DBin,NTrk2DMin,NTrk2DMax
589  )));
590  std::string title = "Number of " + ClusterLabels[i] + " Clusters";
591  if(ClusterLabels[i].compare("Tot")==0)
592  title = "# of Clusters in (Pixel+Strip) Detectors";
593  NumberOfTrkVsClusters[i]->setAxisTitle(title, 1);
594  NumberOfTrkVsClusters[i]->setAxisTitle("Number of Tracks", 2);
595  }
596  }
597 
598  // Initialize the GenericTriggerEventFlag
599  if ( genTriggerEventFlag_->on() ) genTriggerEventFlag_->initRun( iRun, iSetup );
600 
601 }
602 
603 /*
604 // -- BeginRun
605 //---------------------------------------------------------------------------------//
606 void TrackingMonitor::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
607 {
608 
609 }
610 */
611 
612 // - BeginLumi
613 // ---------------------------------------------------------------------------------//
614 void TrackingMonitor::beginLuminosityBlock(const edm::LuminosityBlock& lumi, const edm::EventSetup& eSetup) {
615 
616  if (doLumiAnalysis) {
617  if ( NumberOfTracks_lumiFlag ) NumberOfTracks_lumiFlag -> Reset();
618  theTrackAnalyzer->doReset();
619  }
620  if(doAllSeedPlots || doSeedNumberPlot) {
621  if ( doSeedLumiAnalysis_ )
622  NumberOfSeeds_lumiFlag->Reset();
623  }
624 }
625 
626 // -- Analyse
627 // ---------------------------------------------------------------------------------//
628 void TrackingMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
629 {
630 
631  // Filter out events if Trigger Filtering is requested
632  if (genTriggerEventFlag_->on()&& ! genTriggerEventFlag_->accept( iEvent, iSetup) ) return;
633 
634  float lumi = -1.;
635  edm::Handle<LumiScalersCollection> lumiScalers;
636  iEvent.getByToken(lumiscalersToken_, lumiScalers);
637  if ( lumiScalers.isValid() && lumiScalers->size() ) {
638  LumiScalersCollection::const_iterator scalit = lumiScalers->begin();
639  lumi = scalit->instantLumi();
640  } else
641  lumi = -1.;
642 
643  if (doPlotsVsLUMI_ || doAllPlots)
644  NumberEventsOfVsLUMI->Fill(lumi);
645 
646  // Analyse the tracks
647  // if the collection is empty, do not fill anything
648  // ---------------------------------------------------------------------------------//
649 
650  size_t bx = iEvent.bunchCrossing();
651  if ( doPlotsVsBX_ || doAllPlots )
652  NumberEventsOfVsBX->Fill(bx);
653 
654  // get the track collection
655  edm::Handle<reco::TrackCollection> trackHandle;
656  iEvent.getByToken(trackToken_, trackHandle);
657 
658  int numberOfTracks_den = 0;
659  edm::Handle<reco::TrackCollection> allTrackHandle;
660  iEvent.getByToken(allTrackToken_,allTrackHandle);
661  if (allTrackHandle.isValid()) {
662  for (reco::TrackCollection::const_iterator track = allTrackHandle->begin();
663  track!=allTrackHandle->end(); ++track) {
664  if ( denSelection_(*track) )
665  numberOfTracks_den++;
666  }
667  }
668 
669  edm::Handle< reco::VertexCollection > pvHandle;
670  iEvent.getByToken(pvSrcToken_, pvHandle );
671  reco::Vertex const * pv0 = nullptr;
672  if (pvHandle.isValid()) {
673  pv0 = &pvHandle->front();
674  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
675  if ( pv0->isFake() || pv0->tracksSize()==0
676  // definition of goodOfflinePrimaryVertex
677  || pv0->ndof() < pvNDOF_ || pv0->z() > 24.) pv0 = nullptr;
678  }
679 
680 
681  if (trackHandle.isValid()) {
682 
683  int numberOfTracks = trackHandle->size();
684  int numberOfTracks_num = 0;
685  int numberOfTracks_pv0 = 0;
686 
687  reco::TrackCollection trackCollection = *trackHandle;
688  // calculate the mean # rechits and layers
689  int totalRecHits = 0, totalLayers = 0;
690 
691  theTrackAnalyzer->setNumberOfGoodVertices(iEvent);
692  theTrackAnalyzer->setBX(iEvent);
693  theTrackAnalyzer->setLumi(iEvent,iSetup);
694  for (reco::TrackCollection::const_iterator track = trackCollection.begin();
695  track!=trackCollection.end(); ++track) {
696 
697  if ( doPlotsVsBX_ || doAllPlots )
698  NumberOfRecHitsPerTrackVsBX->Fill(bx,track->numberOfValidHits());
699  if ( numSelection_(*track) ) {
700  numberOfTracks_num++;
701  if (pv0 && std::abs(track->dz(pv0->position()))<0.15) ++numberOfTracks_pv0;
702  }
703 
704  if ( doProfilesVsLS_ || doAllPlots)
705  NumberOfRecHitsPerTrackVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),track->numberOfValidHits());
706 
707  if (doPlotsVsLUMI_ || doAllPlots)
708  NumberOfRecHitsPerTrackVsLUMI->Fill(lumi,track->numberOfValidHits());
709 
710  totalRecHits += track->numberOfValidHits();
711  totalLayers += track->hitPattern().trackerLayersWithMeasurement();
712 
713  // do analysis per track
714  theTrackAnalyzer->analyze(iEvent, iSetup, *track);
715  }
716 
717  double frac = -1.;
718  // if (numberOfAllTracks > 0) frac = static_cast<double>(numberOfTracks)/static_cast<double>(numberOfAllTracks);
719  if (numberOfTracks_den > 0) frac = static_cast<double>(numberOfTracks_num)/static_cast<double>(numberOfTracks_den);
720 
721  if (doGeneralPropertiesPlots_ || doAllPlots){
722  NumberOfTracks -> Fill(numberOfTracks);
723  if ( doPlotsVsBX_ || doAllPlots )
724  NumberOfTracksVsBX -> Fill(bx,numberOfTracks);
725  if (doPlotsVsLUMI_ || doAllPlots)
726  NumberOfTracksVsLUMI -> Fill(lumi,numberOfTracks);
727  if (doFractionPlot_) {
728  FractionOfGoodTracks -> Fill(frac);
729 
730  if (doFractionPlot_) {
731  if ( doPlotsVsBX_ || doAllPlots )
732  GoodTracksFractionVsBX -> Fill(bx, frac);
733  if (doPlotsVsLUMI_ || doAllPlots)
734  GoodTracksFractionVsLUMI -> Fill(lumi,frac);
735  }
736  }
737  if( numberOfTracks > 0 ) {
738  double meanRecHits = static_cast<double>(totalRecHits) / static_cast<double>(numberOfTracks);
739  double meanLayers = static_cast<double>(totalLayers) / static_cast<double>(numberOfTracks);
740  NumberOfMeanRecHitsPerTrack -> Fill(meanRecHits);
741  NumberOfMeanLayersPerTrack -> Fill(meanLayers);
742  }
743  }
744 
745  if ( doProfilesVsLS_ || doAllPlots) {
746  float nLS = static_cast<double>(iEvent.id().luminosityBlock());
747  NumberEventsOfVsLS ->Fill(nLS);
748  NumberOfTracksVsLS ->Fill(nLS,numberOfTracks);
749  if (doFractionPlot_)
750  GoodTracksFractionVsLS->Fill(nLS,frac);
751  }
752 
753  if ( doLumiAnalysis ) {
754  NumberOfTracks_lumiFlag -> Fill(numberOfTracks);
755  }
756 
757 
758  // Analyse the Track Building variables
759  // if the collection is empty, do not fill anything
760  // ---------------------------------------------------------------------------------//
761 
762 
763  // fill the TrackCandidate info
764  if (doTkCandPlots) {
765  // magnetic field
766  edm::ESHandle<MagneticField> theMF;
767  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
768 
769  // get the candidate collection
770  edm::Handle<TrackCandidateCollection> theTCHandle;
771  iEvent.getByToken( trackCandidateToken_, theTCHandle );
772  const TrackCandidateCollection& theTCCollection = *theTCHandle;
773 
774  if (theTCHandle.isValid()) {
775 
776  // get the beam spot
777  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
778  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
779  const reco::BeamSpot& bs = *recoBeamSpotHandle;
780 
781  NumberOfTrackCandidates->Fill(theTCCollection.size());
782  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
783  for( TrackCandidateCollection::const_iterator cand = theTCCollection.begin(); cand != theTCCollection.end(); ++cand) {
784 
785  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *cand, bs, theMF, theTTRHBuilder);
786  }
787  } else {
788  edm::LogWarning("TrackingMonitor") << "No Track Candidates in the event. Not filling associated histograms";
789  }
790  }
791 
792  //plots for trajectory seeds
793 
794  if (doAllSeedPlots || doSeedNumberPlot || doSeedVsClusterPlot || runTrackBuildingAnalyzerForSeed) {
795 
796  // get the seed collection
797  edm::Handle<edm::View<TrajectorySeed> > seedHandle;
798  iEvent.getByToken(seedToken_, seedHandle );
799  const edm::View<TrajectorySeed>& seedCollection = *seedHandle;
800 
801  // fill the seed info
802  if (seedHandle.isValid()) {
803 
804  if(doAllSeedPlots || doSeedNumberPlot) {
805  NumberOfSeeds->Fill(seedCollection.size());
806  if ( doSeedLumiAnalysis_ )
807  NumberOfSeeds_lumiFlag->Fill(seedCollection.size());
808  }
809 
810  if(doAllSeedPlots || doSeedVsClusterPlot){
811 
812  std::vector<int> NClus;
813  setNclus(iEvent,NClus);
814  for (uint i=0; i< ClusterLabels.size(); i++){
815  SeedsVsClusters[i]->Fill(NClus[i],seedCollection.size());
816  }
817  }
818 
819  if (doAllSeedPlots || runTrackBuildingAnalyzerForSeed){
820 
821  //here duplication of mag field and be informations is needed to allow seed and track cand histos to be independent
822  // magnetic field
823  edm::ESHandle<MagneticField> theMF;
824  iSetup.get<IdealMagneticFieldRecord>().get(theMF);
825 
826  // get the beam spot
827  edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
828  iEvent.getByToken(bsSrcToken_, recoBeamSpotHandle );
829  const reco::BeamSpot& bs = *recoBeamSpotHandle;
830 
831  iSetup.get<TransientRecHitRecord>().get(builderName,theTTRHBuilder);
832  for(size_t i=0; i < seedHandle->size(); ++i) {
833 
834  edm::RefToBase<TrajectorySeed> seed(seedHandle, i);
835  theTrackBuildingAnalyzer->analyze(iEvent, iSetup, *seed, bs, theMF, theTTRHBuilder);
836  }
837  }
838 
839  } else {
840  edm::LogWarning("TrackingMonitor") << "No Trajectory seeds in the event. Not filling associated histograms";
841  }
842  }
843 
844 
845  if (doTrackerSpecific_ || doAllPlots) {
846 
847  std::vector<int> NClus;
848  setNclus(iEvent,NClus);
849  for (uint i=0; i< ClusterLabels.size(); i++) {
850  NumberOfTrkVsClusters[i]->Fill(NClus[i],numberOfTracks);
851  }
852  }
853 
854  if ( doPUmonitoring_ ) {
855 
856  // do vertex monitoring
857  for (size_t i=0; i<theVertexMonitor.size(); i++)
858  theVertexMonitor[i]->analyze(iEvent, iSetup);
859  }
860  if ( doPlotsVsGoodPVtx_ ) {
861 
862  size_t totalNumGoodPV = 0;
863  if (pvHandle.isValid()) {
864 
865  for (reco::VertexCollection::const_iterator pv = pvHandle->begin();
866  pv != pvHandle->end(); ++pv) {
867 
868  //--- pv fake (the pv collection should have size==1 and the pv==beam spot)
869  if (pv->isFake() || pv->tracksSize()==0) continue;
870 
871  // definition of goodOfflinePrimaryVertex
872  if (pv->ndof() < pvNDOF_ || pv->z() > 24.) continue;
873  totalNumGoodPV++;
874  }
875 
876  NumberEventsOfVsGoodPVtx -> Fill( float(totalNumGoodPV) );
877  NumberOfTracksVsGoodPVtx -> Fill( float(totalNumGoodPV), numberOfTracks );
878  if (totalNumGoodPV>1) NumberOfTracksVsPUPVtx-> Fill( totalNumGoodPV-1, double(numberOfTracks-numberOfTracks_pv0)/double(totalNumGoodPV-1) );
879  NumberOfPVtxVsGoodPVtx -> Fill(float(totalNumGoodPV),pvHandle->size());
880 
881  for (reco::TrackCollection::const_iterator track = trackCollection.begin();
882  track!=trackCollection.end(); ++track) {
883  NumberOfRecHitsPerTrackVsGoodPVtx -> Fill(float(totalNumGoodPV), track->numberOfValidHits());
884  }
885 
886  if ( doProfilesVsLS_ || doAllPlots)
887  NumberOfGoodPVtxVsLS->Fill(static_cast<double>(iEvent.id().luminosityBlock()),totalNumGoodPV);
888  if ( doPlotsVsBX_ || doAllPlots )
889  NumberOfGoodPVtxVsBX->Fill(bx, float(totalNumGoodPV));
890 
891  if (doFractionPlot_)
892  GoodTracksFractionVsGoodPVtx->Fill(float(totalNumGoodPV),frac);
893 
894  if ( doPlotsVsLUMI_ || doAllPlots )
895  NumberOfGoodPVtxVsLUMI->Fill(lumi,float(totalNumGoodPV));
896  }
897 
898 
899  if ( doPlotsVsBXlumi_ ) {
900  double bxlumi = theLumiDetails_->getValue(iEvent);
901  NumberOfTracksVsBXlumi -> Fill( bxlumi, numberOfTracks );
902  }
903 
904  } // PU monitoring
905 
906  } // trackHandle is valid
907 
908 }
909 
910 
911 void TrackingMonitor::endRun(const edm::Run&, const edm::EventSetup&)
912 {
913 }
914 
915 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)
916 {
917  arrayMin.resize(ClusterLabels.size());
918  arrayMax.resize(ClusterLabels.size());
919  arrayBin.resize(ClusterLabels.size());
920 
921  for (uint i=0; i<ClusterLabels.size(); ++i) {
922 
923  if (ClusterLabels[i].compare("Pix")==0 ) {arrayMin[i]=pmin; arrayMax[i]=pmax; arrayBin[i]=pbin;}
924  else if(ClusterLabels[i].compare("Strip")==0) {arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
925  else if(ClusterLabels[i].compare("Tot")==0 ) {arrayMin[i]=smin; arrayMax[i]=smax+pmax; arrayBin[i]=sbin;}
926  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined, using strip parameters ";
927  arrayMin[i]=smin; arrayMax[i]=smax; arrayBin[i]=sbin;}
928 
929  }
930 
931 }
932 
933 void TrackingMonitor::setNclus(const edm::Event& iEvent,std::vector<int> &arrayNclus)
934 {
935 
936  int ncluster_pix=-1;
937  int ncluster_strip=-1;
938 
939  edm::Handle< edmNew::DetSetVector<SiStripCluster> > strip_clusters;
940  iEvent.getByToken(stripClustersToken_, strip_clusters );
941  edm::Handle< edmNew::DetSetVector<SiPixelCluster> > pixel_clusters;
942  iEvent.getByToken(pixelClustersToken_, pixel_clusters );
943 
944  if (strip_clusters.isValid() && pixel_clusters.isValid()) {
945  ncluster_pix = (*pixel_clusters).dataSize();
946  ncluster_strip = (*strip_clusters).dataSize();
947  }
948 
949  arrayNclus.resize(ClusterLabels.size());
950  for (uint i=0; i<ClusterLabels.size(); ++i){
951 
952  if (ClusterLabels[i].compare("Pix")==0 ) arrayNclus[i]=ncluster_pix ;
953  else if(ClusterLabels[i].compare("Strip")==0) arrayNclus[i]=ncluster_strip;
954  else if(ClusterLabels[i].compare("Tot")==0 ) arrayNclus[i]=ncluster_pix+ncluster_strip;
955  else {edm::LogWarning("TrackingMonitor") << "Cluster Label " << ClusterLabels[i] << " not defined using stri parametrs ";
956  arrayNclus[i]=ncluster_strip ;}
957  }
958 
959 }
960 DEFINE_FWK_MODULE(TrackingMonitor);
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
TrackingMonitor::seedToken_
edm::EDGetTokenT< edm::View< TrajectorySeed > > seedToken_
Definition: TrackingMonitor.h:87
i
int i
Definition: DBlmapReader.cc:9
TrackingMonitor::NumberOfTrkVsClusters
std::vector< MonitorElement * > NumberOfTrkVsClusters
Definition: TrackingMonitor.h:124
TrackingMonitor::FractionOfGoodTracks
MonitorElement * FractionOfGoodTracks
Definition: TrackingMonitor.h:111
TrackingMonitor::setMaxMinBin
virtual void setMaxMinBin(std::vector< double > &, std::vector< double > &, std::vector< int > &, double, double, int, double, double, int)
Definition: TrackingMonitor.cc:915
TrackingMonitor::NumberOfTracksVsBX
MonitorElement * NumberOfTracksVsBX
Definition: TrackingMonitor.h:138
TrackingMonitor::theTrackAnalyzer
TrackAnalyzer * theTrackAnalyzer
Definition: TrackingMonitor.h:100
TrackingMonitor::NumberOfRecHitsPerTrackVsBX
MonitorElement * NumberOfRecHitsPerTrackVsBX
Definition: TrackingMonitor.h:140
TrackingMonitor::NumberOfRecHitsPerTrackVsLUMI
MonitorElement * NumberOfRecHitsPerTrackVsLUMI
Definition: TrackingMonitor.h:157
TrackingMonitor::conf_
edm::ParameterSet conf_
Definition: TrackingMonitor.h:76
TrackingMonitor::setNclus
virtual void setNclus(const edm::Event &, std::vector< int > &)
Definition: TrackingMonitor.cc:933
TrackingMonitor::allTrackToken_
edm::EDGetTokenT< reco::TrackCollection > allTrackToken_
Definition: TrackingMonitor.h:84
DQMStore::IBooker::bookProfile
MonitorElement * bookProfile(Args &&...args)
Definition: DQMStore.h:157
TrackingMonitor::NumberEventsOfVsGoodPVtx
MonitorElement * NumberEventsOfVsGoodPVtx
Definition: TrackingMonitor.h:148
TrackingMonitor::theLumiDetails_
GetLumi * theLumiDetails_
Definition: TrackingMonitor.h:103
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:462
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
HLT_25ns10e33_v2_cff.AlgoName
tuple AlgoName
Definition: HLT_25ns10e33_v2_cff.py:2729
TrackCandidateCollection
std::vector< TrackCandidate > TrackCandidateCollection
Definition: TrackCandidateCollection.h:7
reco::TrackCollection
std::vector< Track > TrackCollection
collection of Tracks
Definition: TrackFwd.h:14
edm::EventBase::bunchCrossing
int bunchCrossing() const
Definition: EventBase.h:65
TrackingMonitor::pvSrc_
edm::InputTag pvSrc_
Definition: TrackingMonitor.h:80
edm::View::size
size_type size() const
NULL
#define NULL
Definition: scimark2.h:8
TrackingMonitor::GoodTracksFractionVsLUMI
MonitorElement * GoodTracksFractionVsLUMI
Definition: TrackingMonitor.h:156
TrackingMonitor::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:628
GenericTriggerEventFlag
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Definition: GenericTriggerEventFlag.h:41
TrackingMonitor::NumberOfPVtxVsGoodPVtx
MonitorElement * NumberOfPVtxVsGoodPVtx
Definition: TrackingMonitor.h:151
TrackingMonitor::NumberOfMeanRecHitsPerTrack
MonitorElement * NumberOfMeanRecHitsPerTrack
Definition: TrackingMonitor.h:107
TrackingMonitor::NumberOfTracksVsGoodPVtx
MonitorElement * NumberOfTracksVsGoodPVtx
Definition: TrackingMonitor.h:146
edm::EventID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:40
reco::Vertex::position
const Point & position() const
position
Definition: Vertex.h:99
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
TrackingMonitor::GoodTracksFractionVsLS
MonitorElement * GoodTracksFractionVsLS
Definition: TrackingMonitor.h:132
TrackAnalyzer::setLumi
void setLumi(const edm::Event &, const edm::EventSetup &iSetup)
Definition: TrackAnalyzer.cc:908
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:170
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:96
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:323
TrackingMonitor::bsSrc_
edm::InputTag bsSrc_
Definition: TrackingMonitor.h:79
TrackingMonitor::NumberOfSeeds
MonitorElement * NumberOfSeeds
Definition: TrackingMonitor.h:114
iEvent
int iEvent
Definition: GenABIO.cc:230
TrackingMonitor::NumberOfGoodPVtxVsLS
MonitorElement * NumberOfGoodPVtxVsLS
Definition: TrackingMonitor.h:134
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
TrackingMonitor::NumberOfGoodPVtxVsLUMI
MonitorElement * NumberOfGoodPVtxVsLUMI
Definition: TrackingMonitor.h:158
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:72
TrackingMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: TrackingMonitor.cc:170
GenericTriggerEventFlag::accept
bool accept(const edm::Event &event, const edm::EventSetup &setup)
To be called from analyze/filter() methods.
Definition: GenericTriggerEventFlag.cc:239
TrackAnalyzer::setBX
void setBX(const edm::Event &)
Definition: TrackAnalyzer.cc:903
TrackBuildingAnalyzer::initHisto
virtual void initHisto(DQMStore::IBooker &ibooker)
Definition: TrackBuildingAnalyzer.cc:44
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
TrackingMonitor::NumberOfTracksVsLS
MonitorElement * NumberOfTracksVsLS
Definition: TrackingMonitor.h:131
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
reco::Vertex::z
double z() const
y coordinate
Definition: Vertex.h:105
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1450
HLT_25ns10e33_v2_cff.trackProducer
tuple trackProducer
Definition: HLT_25ns10e33_v2_cff.py:11697
TrackingMonitor::NumberOfTracksVsPUPVtx
MonitorElement * NumberOfTracksVsPUPVtx
Definition: TrackingMonitor.h:147
TrackingMonitor::lumiscalersToken_
edm::EDGetTokenT< LumiScalersCollection > lumiscalersToken_
Definition: TrackingMonitor.h:89
TrackingMonitor::NumberEventsOfVsBX
MonitorElement * NumberEventsOfVsBX
Definition: TrackingMonitor.h:137
TrackingMonitor::runTrackBuildingAnalyzerForSeed
bool runTrackBuildingAnalyzerForSeed
Definition: TrackingMonitor.h:178
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
TrackingMonitor::SeedsVsClusters
std::vector< MonitorElement * > SeedsVsClusters
Definition: TrackingMonitor.h:116
HLT_25ns10e33_v2_cff.trackCollection
tuple trackCollection
Definition: HLT_25ns10e33_v2_cff.py:55766
TrackingMonitor::NumberOfRecHitsPerTrackVsLS
MonitorElement * NumberOfRecHitsPerTrackVsLS
Definition: TrackingMonitor.h:133
TrackingMonitor::GoodTracksFractionVsGoodPVtx
MonitorElement * GoodTracksFractionVsGoodPVtx
Definition: TrackingMonitor.h:149
TrackingMonitor::endRun
virtual void endRun(const edm::Run &, const edm::EventSetup &)
Definition: TrackingMonitor.cc:911
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:95
TrackingMonitor::NumberOfRecHitsPerTrackVsGoodPVtx
MonitorElement * NumberOfRecHitsPerTrackVsGoodPVtx
Definition: TrackingMonitor.h:150
TrackingMonitor::histname
std::string histname
Definition: TrackingMonitor.h:72
TrackingMonitor::theVertexMonitor
std::vector< VertexMonitor * > theVertexMonitor
Definition: TrackingMonitor.h:102
TrackingMonitor::NumberOfTracksVsBXlumi
MonitorElement * NumberOfTracksVsBXlumi
Definition: TrackingMonitor.h:143
TrackingMonitor::stripClusterInputTag_
edm::InputTag stripClusterInputTag_
Definition: TrackingMonitor.h:91
TrackingMonitor::doGeneralPropertiesPlots_
bool doGeneralPropertiesPlots_
Definition: TrackingMonitor.h:172
TrackingMonitor::theTrackBuildingAnalyzer
TrackBuildingAnalyzer * theTrackBuildingAnalyzer
Definition: TrackingMonitor.h:101
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:276
reco::Vertex::isFake
bool isFake() const
Definition: Vertex.h:64
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:957
TrackingMonitor::AlgoName_
std::string AlgoName_
Definition: TrackingMonitor.h:97
TrackingMonitor::trackToken_
edm::EDGetTokenT< reco::TrackCollection > trackToken_
Definition: TrackingMonitor.h:85
TrackingMonitor::trackCandidateToken_
edm::EDGetTokenT< TrackCandidateCollection > trackCandidateToken_
Definition: TrackingMonitor.h:86
TrackingMonitor::NumberOfMeanLayersPerTrack
MonitorElement * NumberOfMeanLayersPerTrack
Definition: TrackingMonitor.h:108
TrackingMonitor::denSelection_
StringCutObjectSelector< reco::Track, true > denSelection_
Definition: TrackingMonitor.h:190
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
TrackingMonitor::numSelection_
StringCutObjectSelector< reco::Track, true > numSelection_
Definition: TrackingMonitor.h:189
TrackingMonitor::genTriggerEventFlag_
GenericTriggerEventFlag * genTriggerEventFlag_
Definition: TrackingMonitor.h:187
TrackingMonitor::GoodTracksFractionVsBX
MonitorElement * GoodTracksFractionVsBX
Definition: TrackingMonitor.h:139
TrackingMonitor::pixelClusterInputTag_
edm::InputTag pixelClusterInputTag_
Definition: TrackingMonitor.h:92
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
TrackingMonitor::NumberOfSeeds_lumiFlag
MonitorElement * NumberOfSeeds_lumiFlag
Definition: TrackingMonitor.h:115
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:59
TrackingMonitor::TrackingMonitor
TrackingMonitor(const edm::ParameterSet &)
Definition: TrackingMonitor.cc:40
TrackingMonitor::theTTRHBuilder
edm::ESHandle< TransientTrackingRecHitBuilder > theTTRHBuilder
Definition: TrackingMonitor.h:164
TrackingMonitor::beginJob
virtual void beginJob(void)
Definition: TrackingMonitor.cc:164
TrackingMonitor::NumberOfTrackCandidates
MonitorElement * NumberOfTrackCandidates
Definition: TrackingMonitor.h:121
TrackAnalyzer::initHisto
virtual void initHisto(DQMStore::IBooker &ibooker, const edm::EventSetup &)
Definition: TrackAnalyzer.cc:163
TrackingMonitor::pixelClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > > pixelClustersToken_
Definition: TrackingMonitor.h:94
HcalObjRepresent::Reset
void Reset(std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:620
TrackingMonitor::stripClustersToken_
edm::EDGetTokenT< edmNew::DetSetVector< SiStripCluster > > stripClustersToken_
Definition: TrackingMonitor.h:93
GenericTriggerEventFlag::initRun
void initRun(const edm::Run &run, const edm::EventSetup &setup)
To be called from beginRun() methods.
Definition: GenericTriggerEventFlag.cc:134
TrackingMonitor::NumberOfGoodPVtxVsBX
MonitorElement * NumberOfGoodPVtxVsBX
Definition: TrackingMonitor.h:141
MonitorElement::setLumiFlag
void setLumiFlag(void)
this ME is meant to be stored for each luminosity section
Definition: MonitorElement.h:154
TrackingMonitor::NumberEventsOfVsLUMI
MonitorElement * NumberEventsOfVsLUMI
Definition: TrackingMonitor.h:154
TrackAnalyzer::setNumberOfGoodVertices
void setNumberOfGoodVertices(const edm::Event &)
Definition: TrackAnalyzer.cc:890
TrackingMonitor::NumberOfTracks_lumiFlag
MonitorElement * NumberOfTracks_lumiFlag
Definition: TrackingMonitor.h:161
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:947
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:453
TrackingMonitor::bsSrcToken_
edm::EDGetTokenT< reco::BeamSpot > bsSrcToken_
Definition: TrackingMonitor.h:81
TrackingMonitor::NumberOfTracks
MonitorElement * NumberOfTracks
Definition: TrackingMonitor.h:106
reco::Vertex::tracksSize
size_t tracksSize() const
number of tracks
Definition: Vertex.cc:34
TrackingMonitor::pvSrcToken_
edm::EDGetTokenT< reco::VertexCollection > pvSrcToken_
Definition: TrackingMonitor.h:82
edm::Run
Definition: Run.h:43
TrackingMonitor::NumberEventsOfVsLS
MonitorElement * NumberEventsOfVsLS
Definition: TrackingMonitor.h:130
TrackingMonitor::NumberOfTracksVsLUMI
MonitorElement * NumberOfTracksVsLUMI
Definition: TrackingMonitor.h:155
TrackingMonitor::beginLuminosityBlock
virtual void beginLuminosityBlock(const edm::LuminosityBlock &lumi, const edm::EventSetup &eSetup)
Definition: TrackingMonitor.cc:614
TrackingMonitor::ClusterLabels
std::vector< std::string > ClusterLabels
Definition: TrackingMonitor.h:117
TrackingMonitor::builderName
std::string builderName
Definition: TrackingMonitor.h:163
Generated for CMSSW Reference Manual by doxygen 1.8.5