CMS 3D CMS Logo
PrimaryVertexMonitor.cc
Go to the documentation of this file.
1 #include "DQMOffline/RecoB/plugins/PrimaryVertexMonitor.h"
2 #include "FWCore/ServiceRegistry/interface/Service.h"
3 #include "FWCore/Framework/interface/MakerMacros.h"
4 #include "FWCore/Utilities/interface/isFinite.h"
5 
6 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"
7 
8 #include "FWCore/MessageLogger/interface/MessageLogger.h"
9 
10 #include "TMath.h"
11 
12 using namespace reco;
13 using namespace edm;
14 
15 PrimaryVertexMonitor::PrimaryVertexMonitor(const edm::ParameterSet& pSet)
16  : conf_(pSet),
17  TopFolderName_(pSet.getParameter<std::string>("TopFolderName")),
18  AlignmentLabel_(pSet.getParameter<std::string>("AlignmentLabel")),
19  ndof_(pSet.getParameter<int>("ndof")),
20  useHPfoAlignmentPlots_(pSet.getParameter<bool>("useHPforAlignmentPlots")),
21  errorPrinted_(false),
22  nbvtx(nullptr),
23  bsX(nullptr),
24  bsY(nullptr),
25  bsZ(nullptr),
26  bsSigmaZ(nullptr),
27  bsDxdz(nullptr),
28  bsDydz(nullptr),
29  bsBeamWidthX(nullptr),
30  bsBeamWidthY(nullptr),
31  bsType(nullptr),
32  sumpt(nullptr),
33  ntracks(nullptr),
34  weight(nullptr),
35  chi2ndf(nullptr),
36  chi2prob(nullptr),
37  dxy(nullptr),
38  dxy2(nullptr),
39  dz(nullptr),
40  dxyErr(nullptr),
41  dzErr(nullptr),
42  dxyVsPhi_pt1(nullptr),
43  dzVsPhi_pt1(nullptr),
44  dxyVsEta_pt1(nullptr),
45  dzVsEta_pt1(nullptr),
46  dxyVsEtaVsPhi_pt1(nullptr),
47  dzVsEtaVsPhi_pt1(nullptr),
48  dxyVsPhi_pt10(nullptr),
49  dzVsPhi_pt10(nullptr),
50  dxyVsEta_pt10(nullptr),
51  dzVsEta_pt10(nullptr),
52  dxyVsEtaVsPhi_pt10(nullptr),
53  dzVsEtaVsPhi_pt10(nullptr) {
54  // dqmStore_ = edm::Service<DQMStore>().operator->();
55 
56  vertexInputTag_ = pSet.getParameter<InputTag>("vertexLabel");
57  beamSpotInputTag_ = pSet.getParameter<InputTag>("beamSpotLabel");
58  vertexToken_ = consumes<reco::VertexCollection>(vertexInputTag_);
59  scoreToken_ = consumes<VertexScore>(vertexInputTag_);
60  beamspotToken_ = consumes<reco::BeamSpot>(beamSpotInputTag_);
61 }
62 
63 // -- BeginRun
64 //---------------------------------------------------------------------------------//
65 void PrimaryVertexMonitor::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const&, edm::EventSetup const&) {
66  std::string dqmLabel = "";
67 
68  //
69  // Book all histograms.
70  //
71 
72  // get the store
73  dqmLabel = TopFolderName_ + "/" + vertexInputTag_.label();
74  iBooker.setCurrentFolder(dqmLabel);
75 
76  // xPos = iBooker.book1D ("xPos","x Coordinate" ,100, -0.1, 0.1);
77 
78  nbvtx = iBooker.book1D("vtxNbr", "Reconstructed Vertices in Event", 80, -0.5, 79.5);
79  nbgvtx = iBooker.book1D("goodvtxNbr", "Reconstructed Good Vertices in Event", 80, -0.5, 79.5);
80 
81  // to be configured each year...
82  auto vposx = conf_.getParameter<double>("Xpos");
83  auto vposy = conf_.getParameter<double>("Ypos");
84 
85  nbtksinvtx[0] = iBooker.book1D("otherVtxTrksNbr", "Reconstructed Tracks in Vertex (other Vtx)", 40, -0.5, 99.5);
86  ntracksVsZ[0] = iBooker.bookProfile(
87  "otherVtxTrksVsZ", "Reconstructed Tracks in Vertex (other Vtx) vs Z", 80, -20., 20., 50, 0, 100, "");
88  ntracksVsZ[0]->setAxisTitle("z-bs", 1);
89  ntracksVsZ[0]->setAxisTitle("#tracks", 2);
90 
91  score[0] = iBooker.book1D("otherVtxScore", "sqrt(score) (other Vtx)", 100, 0., 400.);
92  trksWeight[0] = iBooker.book1D("otherVtxTrksWeight", "Total weight of Tracks in Vertex (other Vtx)", 40, 0, 100.);
93  vtxchi2[0] = iBooker.book1D("otherVtxChi2", "#chi^{2} (other Vtx)", 100, 0., 200.);
94  vtxndf[0] = iBooker.book1D("otherVtxNdf", "ndof (other Vtx)", 100, 0., 200.);
95  vtxprob[0] = iBooker.book1D("otherVtxProb", "#chi^{2} probability (other Vtx)", 100, 0., 1.);
96  nans[0] = iBooker.book1D("otherVtxNans", "Illegal values for x,y,z,xx,xy,xz,yy,yz,zz (other Vtx)", 9, 0.5, 9.5);
97 
98  nbtksinvtx[1] = iBooker.book1D("tagVtxTrksNbr", "Reconstructed Tracks in Vertex (tagged Vtx)", 100, -0.5, 99.5);
99  ntracksVsZ[1] = iBooker.bookProfile(
100  "tagVtxTrksVsZ", "Reconstructed Tracks in Vertex (tagged Vtx) vs Z", 80, -20., 20., 50, 0, 100, "");
101  ntracksVsZ[1]->setAxisTitle("z-bs", 1);
102  ntracksVsZ[1]->setAxisTitle("#tracks", 2);
103 
104  score[1] = iBooker.book1D("tagVtxScore", "sqrt(score) (tagged Vtx)", 100, 0., 400.);
105  trksWeight[1] = iBooker.book1D("tagVtxTrksWeight", "Total weight of Tracks in Vertex (tagged Vtx)", 100, 0, 100.);
106  vtxchi2[1] = iBooker.book1D("tagVtxChi2", "#chi^{2} (tagged Vtx)", 100, 0., 200.);
107  vtxndf[1] = iBooker.book1D("tagVtxNdf", "ndof (tagged Vtx)", 100, 0., 200.);
108  vtxprob[1] = iBooker.book1D("tagVtxProb", "#chi^{2} probability (tagged Vtx)", 100, 0., 1.);
109  nans[1] = iBooker.book1D("tagVtxNans", "Illegal values for x,y,z,xx,xy,xz,yy,yz,zz (tagged Vtx)", 9, 0.5, 9.5);
110 
111  xrec[0] = iBooker.book1D("otherPosX", "Position x Coordinate (other Vtx)", 100, vposx - 0.1, vposx + 0.1);
112  yrec[0] = iBooker.book1D("otherPosY", "Position y Coordinate (other Vtx)", 100, vposy - 0.1, vposy + 0.1);
113  zrec[0] = iBooker.book1D("otherPosZ", "Position z Coordinate (other Vtx)", 100, -20., 20.);
114  xDiff[0] = iBooker.book1D("otherDiffX", "X distance from BeamSpot (other Vtx)", 100, -500, 500);
115  yDiff[0] = iBooker.book1D("otherDiffY", "Y distance from BeamSpot (other Vtx)", 100, -500, 500);
116  xerr[0] = iBooker.book1D("otherErrX", "Uncertainty x Coordinate (other Vtx)", 100, 0., 100);
117  yerr[0] = iBooker.book1D("otherErrY", "Uncertainty y Coordinate (other Vtx)", 100, 0., 100);
118  zerr[0] = iBooker.book1D("otherErrZ", "Uncertainty z Coordinate (other Vtx)", 100, 0., 100);
119  xerrVsTrks[0] = iBooker.book2D(
120  "otherErrVsWeightX", "Uncertainty x Coordinate vs. track weight (other Vtx)", 100, 0, 100., 100, 0., 100);
121  yerrVsTrks[0] = iBooker.book2D(
122  "otherErrVsWeightY", "Uncertainty y Coordinate vs. track weight (other Vtx)", 100, 0, 100., 100, 0., 100);
123  zerrVsTrks[0] = iBooker.book2D(
124  "otherErrVsWeightZ", "Uncertainty z Coordinate vs. track weight (other Vtx)", 100, 0, 100., 100, 0., 100);
125 
126  xrec[1] = iBooker.book1D("tagPosX", "Position x Coordinate (tagged Vtx)", 100, vposx - 0.1, vposx + 0.1);
127  yrec[1] = iBooker.book1D("tagPosY", "Position y Coordinate (tagged Vtx)", 100, vposy - 0.1, vposy + 0.1);
128  zrec[1] = iBooker.book1D("tagPosZ", "Position z Coordinate (tagged Vtx)", 100, -20., 20.);
129  xDiff[1] = iBooker.book1D("tagDiffX", "X distance from BeamSpot (tagged Vtx)", 100, -500, 500);
130  yDiff[1] = iBooker.book1D("tagDiffY", "Y distance from BeamSpot (tagged Vtx)", 100, -500, 500);
131  xerr[1] = iBooker.book1D("tagErrX", "Uncertainty x Coordinate (tagged Vtx)", 100, 0., 100);
132  yerr[1] = iBooker.book1D("tagErrY", "Uncertainty y Coordinate (tagged Vtx)", 100, 0., 100);
133  zerr[1] = iBooker.book1D("tagErrZ", "Uncertainty z Coordinate (tagged Vtx)", 100, 0., 100);
134  xerrVsTrks[1] = iBooker.book2D(
135  "tagErrVsWeightX", "Uncertainty x Coordinate vs. track weight (tagged Vtx)", 100, 0, 100., 100, 0., 100);
136  yerrVsTrks[1] = iBooker.book2D(
137  "tagErrVsWeightY", "Uncertainty y Coordinate vs. track weight (tagged Vtx)", 100, 0, 100., 100, 0., 100);
138  zerrVsTrks[1] = iBooker.book2D(
139  "tagErrVsWeightZ", "Uncertainty z Coordinate vs. track weight (tagged Vtx)", 100, 0, 100., 100, 0., 100);
140 
141  type[0] = iBooker.book1D("otherType", "Vertex type (other Vtx)", 3, -0.5, 2.5);
142  type[1] = iBooker.book1D("tagType", "Vertex type (tagged Vtx)", 3, -0.5, 2.5);
143  for (int i = 0; i < 2; ++i) {
144  type[i]->setBinLabel(1, "Valid, real");
145  type[i]->setBinLabel(2, "Valid, fake");
146  type[i]->setBinLabel(3, "Invalid");
147  }
148 
149  // get the store
150  dqmLabel = TopFolderName_ + "/" + beamSpotInputTag_.label();
151  iBooker.setCurrentFolder(dqmLabel);
152 
153  bsX = iBooker.book1D("bsX", "BeamSpot x0", 100, -0.1, 0.1);
154  bsY = iBooker.book1D("bsY", "BeamSpot y0", 100, -0.1, 0.1);
155  bsZ = iBooker.book1D("bsZ", "BeamSpot z0", 100, -2., 2.);
156  bsSigmaZ = iBooker.book1D("bsSigmaZ", "BeamSpot sigmaZ", 100, 0., 10.);
157  bsDxdz = iBooker.book1D("bsDxdz", "BeamSpot dxdz", 100, -0.0003, 0.0003);
158  bsDydz = iBooker.book1D("bsDydz", "BeamSpot dydz", 100, -0.0003, 0.0003);
159  bsBeamWidthX = iBooker.book1D("bsBeamWidthX", "BeamSpot BeamWidthX", 100, 0., 100.);
160  bsBeamWidthY = iBooker.book1D("bsBeamWidthY", "BeamSpot BeamWidthY", 100, 0., 100.);
161  bsType = iBooker.book1D("bsType", "BeamSpot type", 4, -1.5, 2.5);
162  bsType->setBinLabel(1, "Unknown");
163  bsType->setBinLabel(2, "Fake");
164  bsType->setBinLabel(3, "LHC");
165  bsType->setBinLabel(4, "Tracker");
166 
167  // get the store
168  dqmLabel = TopFolderName_ + "/" + AlignmentLabel_;
169  iBooker.setCurrentFolder(dqmLabel);
170 
171  int TKNoBin = conf_.getParameter<int>("TkSizeBin");
172  double TKNoMin = conf_.getParameter<double>("TkSizeMin");
173  double TKNoMax = conf_.getParameter<double>("TkSizeMax");
174 
175  int DxyBin = conf_.getParameter<int>("DxyBin");
176  double DxyMin = conf_.getParameter<double>("DxyMin");
177  double DxyMax = conf_.getParameter<double>("DxyMax");
178 
179  int DzBin = conf_.getParameter<int>("DzBin");
180  double DzMin = conf_.getParameter<double>("DzMin");
181  double DzMax = conf_.getParameter<double>("DzMax");
182 
183  int PhiBin = conf_.getParameter<int>("PhiBin");
184  int PhiBin2D = conf_.getParameter<int>("PhiBin2D");
185  double PhiMin = conf_.getParameter<double>("PhiMin");
186  double PhiMax = conf_.getParameter<double>("PhiMax");
187 
188  int EtaBin = conf_.getParameter<int>("EtaBin");
189  int EtaBin2D = conf_.getParameter<int>("EtaBin2D");
190  double EtaMin = conf_.getParameter<double>("EtaMin");
191  double EtaMax = conf_.getParameter<double>("EtaMax");
192 
193  ntracks = iBooker.book1D("ntracks", "number of PV tracks (p_{T} > 1 GeV)", TKNoBin, TKNoMin, TKNoMax);
194  ntracks->setAxisTitle("Number of PV Tracks (p_{T} > 1 GeV) per Event", 1);
195  ntracks->setAxisTitle("Number of Event", 2);
196 
197  weight = iBooker.book1D("weight", "weight of PV tracks (p_{T} > 1 GeV)", 100, 0., 1.);
198  weight->setAxisTitle("weight of PV Tracks (p_{T} > 1 GeV) per Event", 1);
199  weight->setAxisTitle("Number of Event", 2);
200 
201  sumpt = iBooker.book1D("sumpt", "#Sum p_{T} of PV tracks (p_{T} > 1 GeV)", 100, -0.5, 249.5);
202  chi2ndf = iBooker.book1D("chi2ndf", "PV tracks (p_{T} > 1 GeV) #chi^{2}/ndof", 100, 0., 20.);
203  chi2prob = iBooker.book1D("chi2prob", "PV tracks (p_{T} > 1 GeV) #chi^{2} probability", 100, 0., 1.);
204 
205  dxy = iBooker.book1D("dxy", "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum)", DxyBin, DxyMin, DxyMax);
206  dxy2 = iBooker.book1D("dxyzoom", "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum)", DxyBin, DxyMin / 5., DxyMax / 5.);
207  dxyErr = iBooker.book1D("dxyErr", "PV tracks (p_{T} > 1 GeV) d_{xy} error (#mum)", 100, 0., 2000.);
208  dz = iBooker.book1D("dz", "PV tracks (p_{T} > 1 GeV) d_{z} (#mum)", DzBin, DzMin, DzMax);
209  dzErr = iBooker.book1D("dzErr", "PV tracks (p_{T} > 1 GeV) d_{z} error(#mum)", 100, 0., 10000.);
210 
211  dxyVsPhi_pt1 = iBooker.bookProfile("dxyVsPhi_pt1",
212  "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum) VS track #phi",
213  PhiBin,
214  PhiMin,
215  PhiMax,
216  DxyBin,
217  DxyMin,
218  DxyMax,
219  "");
220  dxyVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi", 1);
221  dxyVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{xy} (#mum)", 2);
222 
223  dzVsPhi_pt1 = iBooker.bookProfile("dzVsPhi_pt1",
224  "PV tracks (p_{T} > 1 GeV) d_{z} (#mum) VS track #phi",
225  PhiBin,
226  PhiMin,
227  PhiMax,
228  DzBin,
229  DzMin,
230  DzMax,
231  "");
232  dzVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi", 1);
233  dzVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{z} (#mum)", 2);
234 
235  dxyVsEta_pt1 = iBooker.bookProfile("dxyVsEta_pt1",
236  "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum) VS track #eta",
237  EtaBin,
238  EtaMin,
239  EtaMax,
240  DxyBin,
241  DxyMin,
242  DxyMax,
243  "");
244  dxyVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta", 1);
245  dxyVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{xy} (#mum)", 2);
246 
247  dzVsEta_pt1 = iBooker.bookProfile("dzVsEta_pt1",
248  "PV tracks (p_{T} > 1 GeV) d_{z} (#mum) VS track #eta",
249  EtaBin,
250  EtaMin,
251  EtaMax,
252  DzBin,
253  DzMin,
254  DzMax,
255  "");
256  dzVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta", 1);
257  dzVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{z} (#mum)", 2);
258 
259  dxyVsEtaVsPhi_pt1 = iBooker.bookProfile2D("dxyVsEtaVsPhi_pt1",
260  "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum) VS track #eta VS track #phi",
261  EtaBin2D,
262  EtaMin,
263  EtaMax,
264  PhiBin2D,
265  PhiMin,
266  PhiMax,
267  DxyBin,
268  DxyMin,
269  DxyMax,
270  "");
271  dxyVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta", 1);
272  dxyVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi", 2);
273  dxyVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{xy} (#mum)", 3);
274 
275  dzVsEtaVsPhi_pt1 = iBooker.bookProfile2D("dzVsEtaVsPhi_pt1",
276  "PV tracks (p_{T} > 1 GeV) d_{z} (#mum) VS track #eta VS track #phi",
277  EtaBin2D,
278  EtaMin,
279  EtaMax,
280  PhiBin2D,
281  PhiMin,
282  PhiMax,
283  DzBin,
284  DzMin,
285  DzMax,
286  "");
287  dzVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta", 1);
288  dzVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi", 2);
289  dzVsEtaVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{z} (#mum)", 3);
290 
291  dxyVsPhi_pt10 = iBooker.bookProfile("dxyVsPhi_pt10",
292  "PV tracks (p_{T} > 10 GeV) d_{xy} (#mum) VS track #phi",
293  PhiBin,
294  PhiMin,
295  PhiMax,
296  DxyBin,
297  DxyMin,
298  DxyMax,
299  "");
300  dxyVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi", 1);
301  dxyVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{xy} (#mum)", 2);
302 
303  dzVsPhi_pt10 = iBooker.bookProfile("dzVsPhi_pt10",
304  "PV tracks (p_{T} > 10 GeV) d_{z} (#mum) VS track #phi",
305  PhiBin,
306  PhiMin,
307  PhiMax,
308  DzBin,
309  DzMin,
310  DzMax,
311  "");
312  dzVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi", 1);
313  dzVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{z} (#mum)", 2);
314 
315  dxyVsEta_pt10 = iBooker.bookProfile("dxyVsEta_pt10",
316  "PV tracks (p_{T} > 10 GeV) d_{xy} (#mum) VS track #eta",
317  EtaBin,
318  EtaMin,
319  EtaMax,
320  DxyBin,
321  DxyMin,
322  DxyMax,
323  "");
324  dxyVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta", 1);
325  dxyVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{xy} (#mum)", 2);
326 
327  dzVsEta_pt10 = iBooker.bookProfile("dzVsEta_pt10",
328  "PV tracks (p_{T} > 10 GeV) d_{z} (#mum) VS track #eta",
329  EtaBin,
330  EtaMin,
331  EtaMax,
332  DzBin,
333  DzMin,
334  DzMax,
335  "");
336  dzVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta", 1);
337  dzVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{z} (#mum)", 2);
338 
339  dxyVsEtaVsPhi_pt10 = iBooker.bookProfile2D("dxyVsEtaVsPhi_pt10",
340  "PV tracks (p_{T} > 10 GeV) d_{xy} (#mum) VS track #eta VS track #phi",
341  EtaBin2D,
342  EtaMin,
343  EtaMax,
344  PhiBin2D,
345  PhiMin,
346  PhiMax,
347  DxyBin,
348  DxyMin,
349  DxyMax,
350  "");
351  dxyVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta", 1);
352  dxyVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi", 2);
353  dxyVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{xy} (#mum)", 3);
354 
355  dzVsEtaVsPhi_pt10 = iBooker.bookProfile2D("dzVsEtaVsPhi_pt10",
356  "PV tracks (p_{T} > 10 GeV) d_{z} (#mum) VS track #eta VS track #phi",
357  EtaBin2D,
358  EtaMin,
359  EtaMax,
360  PhiBin2D,
361  PhiMin,
362  PhiMax,
363  DzBin,
364  DzMin,
365  DzMax,
366  "");
367  dzVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta", 1);
368  dzVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi", 2);
369  dzVsEtaVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{z} (#mum)", 3);
370 }
371 
372 PrimaryVertexMonitor::~PrimaryVertexMonitor() {}
373 
374 void PrimaryVertexMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
375  Handle<reco::VertexCollection> recVtxs;
376  iEvent.getByToken(vertexToken_, recVtxs);
377 
378  Handle<VertexScore> scores;
379  iEvent.getByToken(scoreToken_, scores);
380 
381  edm::Handle<reco::BeamSpot> beamSpotHandle;
382  iEvent.getByToken(beamspotToken_, beamSpotHandle);
383 
384  //
385  // check for absent products and simply "return" in that case
386  //
387  if (recVtxs.isValid() == false || beamSpotHandle.isValid() == false) {
388  edm::LogWarning("PrimaryVertexMonitor")
389  << " Some products not available in the event: VertexCollection " << vertexInputTag_ << " " << recVtxs.isValid()
390  << " BeamSpot " << beamSpotInputTag_ << " " << beamSpotHandle.isValid() << ". Skipping plots for this event";
391  return;
392  }
393 
394  // check upfront that refs to track are (likely) to be valid
395  {
396  bool ok = true;
397  for (const auto& v : *recVtxs) {
398  if (v.tracksSize() > 0) {
399  const auto& ref = v.trackRefAt(0);
400  if (ref.isNull() || !ref.isAvailable()) {
401  if (!errorPrinted_)
402  edm::LogWarning("PrimaryVertexMonitor")
403  << "Skipping vertex collection: " << vertexInputTag_
404  << " since likely the track collection the vertex has refs pointing to is missing (at least the first "
405  "TrackBaseRef is null or not available)";
406  else
407  errorPrinted_ = true;
408  ok = false;
409  }
410  }
411  }
412  if (!ok)
413  return;
414  }
415 
416  BeamSpot beamSpot = *beamSpotHandle;
417 
418  nbvtx->Fill(recVtxs->size() * 1.);
419  int ng = 0;
420  for (auto const& vx : (*recVtxs))
421  if (vx.isValid() && !vx.isFake() && vx.ndof() >= ndof_)
422  ++ng;
423  nbgvtx->Fill(ng * 1.);
424 
425  if (scores.isValid() && !(*scores).empty()) {
426  auto pvScore = (*scores).get(0);
427  score[1]->Fill(std::sqrt(pvScore));
428  for (unsigned int i = 1; i < (*scores).size(); ++i)
429  score[0]->Fill(std::sqrt((*scores).get(i)));
430  }
431 
432  // fill PV tracks MEs (as now, for alignment)
433  if (!recVtxs->empty()) {
434  vertexPlots(recVtxs->front(), beamSpot, 1);
435  pvTracksPlots(recVtxs->front());
436 
437  for (reco::VertexCollection::const_iterator v = recVtxs->begin() + 1; v != recVtxs->end(); ++v)
438  vertexPlots(*v, beamSpot, 0);
439  }
440 
441  // Beamline plots:
442  bsX->Fill(beamSpot.x0());
443  bsY->Fill(beamSpot.y0());
444  bsZ->Fill(beamSpot.z0());
445  bsSigmaZ->Fill(beamSpot.sigmaZ());
446  bsDxdz->Fill(beamSpot.dxdz());
447  bsDydz->Fill(beamSpot.dydz());
448  bsBeamWidthX->Fill(beamSpot.BeamWidthX() * 10000);
449  bsBeamWidthY->Fill(beamSpot.BeamWidthY() * 10000);
450  // bsType->Fill(beamSpot.type());
451 }
452 
453 void PrimaryVertexMonitor::pvTracksPlots(const Vertex& v) {
454  if (!v.isValid())
455  return;
456  if (v.isFake())
457  return;
458 
459  if (v.tracksSize() == 0) {
460  ntracks->Fill(0);
461  return;
462  }
463 
464  const math::XYZPoint myVertex(v.position().x(), v.position().y(), v.position().z());
465 
466  size_t nTracks = 0;
467  float sumPT = 0.;
468  const int cmToUm = 10000;
469 
470  for (reco::Vertex::trackRef_iterator t = v.tracks_begin(); t != v.tracks_end(); t++) {
471  bool isHighPurity = (**t).quality(reco::TrackBase::highPurity);
472  if (!isHighPurity && useHPfoAlignmentPlots_)
473  continue;
474 
475  float pt = (**t).pt();
476  if (pt < 1.)
477  continue;
478 
479  nTracks++;
480 
481  float eta = (**t).eta();
482  float phi = (**t).phi();
483 
484  float w = v.trackWeight(*t);
485  float chi2NDF = (**t).normalizedChi2();
486  float chi2Prob = TMath::Prob((**t).chi2(), (int)(**t).ndof());
487  float Dxy = (**t).dxy(myVertex) * cmToUm; // is it needed ?
488  float Dz = (**t).dz(myVertex) * cmToUm; // is it needed ?
489  float DxyErr = (**t).dxyError() * cmToUm;
490  float DzErr = (**t).dzError() * cmToUm;
491 
492  sumPT += pt * pt;
493 
494  // fill MEs
495  weight->Fill(w);
496  chi2ndf->Fill(chi2NDF);
497  chi2prob->Fill(chi2Prob);
498  dxy->Fill(Dxy);
499  dxy2->Fill(Dxy);
500  dz->Fill(Dz);
501  dxyErr->Fill(DxyErr);
502  dzErr->Fill(DzErr);
503 
504  dxyVsPhi_pt1->Fill(phi, Dxy);
505  dzVsPhi_pt1->Fill(phi, Dz);
506  dxyVsEta_pt1->Fill(eta, Dxy);
507  dzVsEta_pt1->Fill(eta, Dz);
508  dxyVsEtaVsPhi_pt1->Fill(eta, phi, Dxy);
509  dzVsEtaVsPhi_pt1->Fill(eta, phi, Dz);
510 
511  if (pt < 10.)
512  continue;
513  dxyVsPhi_pt10->Fill(phi, Dxy);
514  dzVsPhi_pt10->Fill(phi, Dz);
515  dxyVsEta_pt10->Fill(eta, Dxy);
516  dzVsEta_pt10->Fill(eta, Dz);
517  dxyVsEtaVsPhi_pt10->Fill(eta, phi, Dxy);
518  dzVsEtaVsPhi_pt10->Fill(eta, phi, Dz);
519  }
520  ntracks->Fill(float(nTracks));
521  sumpt->Fill(sumPT);
522 }
523 
524 void PrimaryVertexMonitor::vertexPlots(const Vertex& v, const BeamSpot& beamSpot, int i) {
525  if (i < 0 || i > 1)
526  return;
527  if (!v.isValid())
528  type[i]->Fill(2.);
529  else if (v.isFake())
530  type[i]->Fill(1.);
531  else
532  type[i]->Fill(0.);
533 
534  if (v.isValid() && !v.isFake()) {
535  float weight = 0;
536  for (reco::Vertex::trackRef_iterator t = v.tracks_begin(); t != v.tracks_end(); t++)
537  weight += v.trackWeight(*t);
538  trksWeight[i]->Fill(weight);
539  nbtksinvtx[i]->Fill(v.tracksSize());
540  ntracksVsZ[i]->Fill(v.position().z() - beamSpot.z0(), v.tracksSize());
541 
542  vtxchi2[i]->Fill(v.chi2());
543  vtxndf[i]->Fill(v.ndof());
544  vtxprob[i]->Fill(ChiSquaredProbability(v.chi2(), v.ndof()));
545 
546  xrec[i]->Fill(v.position().x());
547  yrec[i]->Fill(v.position().y());
548  zrec[i]->Fill(v.position().z());
549 
550  float xb = beamSpot.x0() + beamSpot.dxdz() * (v.position().z() - beamSpot.z0());
551  float yb = beamSpot.y0() + beamSpot.dydz() * (v.position().z() - beamSpot.z0());
552  xDiff[i]->Fill((v.position().x() - xb) * 10000);
553  yDiff[i]->Fill((v.position().y() - yb) * 10000);
554 
555  xerr[i]->Fill(v.xError() * 10000);
556  yerr[i]->Fill(v.yError() * 10000);
557  zerr[i]->Fill(v.zError() * 10000);
558  xerrVsTrks[i]->Fill(weight, v.xError() * 10000);
559  yerrVsTrks[i]->Fill(weight, v.yError() * 10000);
560  zerrVsTrks[i]->Fill(weight, v.zError() * 10000);
561 
562  nans[i]->Fill(1., edm::isNotFinite(v.position().x()) * 1.);
563  nans[i]->Fill(2., edm::isNotFinite(v.position().y()) * 1.);
564  nans[i]->Fill(3., edm::isNotFinite(v.position().z()) * 1.);
565 
566  int index = 3;
567  for (int k = 0; k != 3; k++) {
568  for (int j = k; j != 3; j++) {
569  index++;
570  nans[i]->Fill(index * 1., edm::isNotFinite(v.covariance(k, j)) * 1.);
571  // in addition, diagonal element must be positive
572  if (j == k && v.covariance(k, j) < 0) {
573  nans[i]->Fill(index * 1., 1.);
574  }
575  }
576  }
577  }
578 }
579 
580 //define this as a plug-in
581 DEFINE_FWK_MODULE(PrimaryVertexMonitor);
beam_dqm_sourceclient-live_cfg.DxyMin
DxyMin
Definition: beam_dqm_sourceclient-live_cfg.py:189
PrimaryVertexMonitor::zrec
MonitorElement * zrec[2]
Definition: PrimaryVertexMonitor.h:59
electrons_cff.dzErr
dzErr
Definition: electrons_cff.py:354
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:38
PrimaryVertexMonitor::sumpt
MonitorElement * sumpt
Definition: PrimaryVertexMonitor.h:66
electrons_cff.bool
bool
Definition: electrons_cff.py:366
mps_fire.i
i
Definition: mps_fire.py:428
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
MessageLogger.h
funct::false
false
Definition: Factorize.h:29
PrimaryVertexMonitor
Definition: PrimaryVertexMonitor.h:26
PrimaryVertexMonitor::dxyVsPhi_pt1
MonitorElement * dxyVsPhi_pt1
Definition: PrimaryVertexMonitor.h:68
PrimaryVertexMonitor.h
PrimaryVertexMonitor::conf_
edm::ParameterSet conf_
Definition: PrimaryVertexMonitor.h:46
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
edm::Run
Definition: Run.h:45
PrimaryVertexMonitor::vertexInputTag_
edm::InputTag vertexInputTag_
Definition: PrimaryVertexMonitor.h:44
ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13
PrimaryVertexMonitor::ndof_
int ndof_
Definition: PrimaryVertexMonitor.h:52
edm
HLT enums.
Definition: AlignableModifier.h:19
PrimaryVertexMonitor::dxyVsEta_pt10
MonitorElement * dxyVsEta_pt10
Definition: PrimaryVertexMonitor.h:72
dqm::implementation::IBooker::bookProfile2D
MonitorElement * bookProfile2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, double lowZ, double highZ, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:399
PrimaryVertexMonitor::score
MonitorElement * score[2]
Definition: PrimaryVertexMonitor.h:57
PrimaryVertexMonitor::bsY
MonitorElement * bsY
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::dqmLabel
std::string dqmLabel
Definition: PrimaryVertexMonitor.h:48
PrimaryVertexMonitor::xDiff
MonitorElement * xDiff[2]
Definition: PrimaryVertexMonitor.h:59
dqm::implementation::NavigatorBase::setCurrentFolder
virtual void setCurrentFolder(std::string const &fullpath)
Definition: DQMStore.cc:32
PrimaryVertexMonitor::dxy2
MonitorElement * dxy2
Definition: PrimaryVertexMonitor.h:67
PrimaryVertexMonitor::bsX
MonitorElement * bsX
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::zerr
MonitorElement * zerr[2]
Definition: PrimaryVertexMonitor.h:59
ChiSquaredProbability.h
PrimaryVertexMonitor::trksWeight
MonitorElement * trksWeight[2]
Definition: PrimaryVertexMonitor.h:57
PrimaryVertexMonitor::ntracksVsZ
MonitorElement * ntracksVsZ[2]
Definition: PrimaryVertexMonitor.h:61
PrimaryVertexMonitor::nbtksinvtx
MonitorElement * nbtksinvtx[2]
Definition: PrimaryVertexMonitor.h:57
PrimaryVertexMonitor::nans
MonitorElement * nans[2]
Definition: PrimaryVertexMonitor.h:62
PrimaryVertexMonitor::vtxprob
MonitorElement * vtxprob[2]
Definition: PrimaryVertexMonitor.h:62
MonitorTrackInnerTrackMuons_cff.EtaBin
EtaBin
Definition: MonitorTrackInnerTrackMuons_cff.py:64
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:46
vertices_cff.ntracks
ntracks
Definition: vertices_cff.py:34
PrimaryVertexMonitor::dxyVsEtaVsPhi_pt1
MonitorElement * dxyVsEtaVsPhi_pt1
Definition: PrimaryVertexMonitor.h:70
findQualityFiles.v
v
Definition: findQualityFiles.py:179
PrimaryVertexMonitor::vertexPlots
void vertexPlots(const reco::Vertex &v, const reco::BeamSpot &beamSpot, int i)
Definition: PrimaryVertexMonitor.cc:524
PrimaryVertexMonitor::bsDydz
MonitorElement * bsDydz
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::PrimaryVertexMonitor
PrimaryVertexMonitor(const edm::ParameterSet &pSet)
Definition: PrimaryVertexMonitor.cc:15
BeamSpotPI::nTracks
Definition: BeamSpotPayloadInspectorHelper.h:42
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
edm::Handle< reco::VertexCollection >
electrons_cff.dxyErr
dxyErr
Definition: electrons_cff.py:356
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
PrimaryVertexMonitor::bsSigmaZ
MonitorElement * bsSigmaZ
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::bsDxdz
MonitorElement * bsDxdz
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::yerr
MonitorElement * yerr[2]
Definition: PrimaryVertexMonitor.h:59
PrimaryVertexMonitor::yerrVsTrks
MonitorElement * yerrVsTrks[2]
Definition: PrimaryVertexMonitor.h:60
PrimaryVertexMonitor::errorPrinted_
bool errorPrinted_
Definition: PrimaryVertexMonitor.h:54
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
MakerMacros.h
MonitorTrackSTAMuons_cfi.PhiMax
PhiMax
Definition: MonitorTrackSTAMuons_cfi.py:230
PrimaryVertexMonitor::pvTracksPlots
void pvTracksPlots(const reco::Vertex &v)
Definition: PrimaryVertexMonitor.cc:453
PrimaryVertexMonitor::TopFolderName_
std::string TopFolderName_
Definition: PrimaryVertexMonitor.h:50
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
PrimaryVertexMonitor::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: PrimaryVertexMonitor.cc:374
PrimaryVertexMonitor::nbvtx
MonitorElement * nbvtx
Definition: PrimaryVertexMonitor.h:57
Service.h
PVValHelper::eta
Definition: PVValidationHelpers.h:70
w
const double w
Definition: UKUtility.cc:23
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
dqm::impl::MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:290
reco::BeamSpot
Definition: BeamSpot.h:21
dqm::implementation::IBooker::bookProfile
MonitorElement * bookProfile(TString const &name, TString const &title, int nchX, double lowX, double highX, int, double lowY, double highY, char const *option="s", FUNC onbooking=NOOP())
Definition: DQMStore.h:322
PrimaryVertexMonitor::AlignmentLabel_
std::string AlignmentLabel_
Definition: PrimaryVertexMonitor.h:51
beam_dqm_sourceclient-live_cfg.DxyMax
DxyMax
Definition: beam_dqm_sourceclient-live_cfg.py:190
PrimaryVertexMonitor::dxyVsEta_pt1
MonitorElement * dxyVsEta_pt1
Definition: PrimaryVertexMonitor.h:69
PrimaryVertexMonitor::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: PrimaryVertexMonitor.cc:65
dqmdumpme.k
k
Definition: dqmdumpme.py:60
PrimaryVertexMonitor_cff.EtaBin2D
EtaBin2D
Definition: PrimaryVertexMonitor_cff.py:28
PrimaryVertexMonitor::xerr
MonitorElement * xerr[2]
Definition: PrimaryVertexMonitor.h:59
PrimaryVertexMonitor::dzVsEtaVsPhi_pt10
MonitorElement * dzVsEtaVsPhi_pt10
Definition: PrimaryVertexMonitor.h:73
PrimaryVertexMonitor::yrec
MonitorElement * yrec[2]
Definition: PrimaryVertexMonitor.h:59
PrimaryVertexMonitor::useHPfoAlignmentPlots_
bool useHPfoAlignmentPlots_
Definition: PrimaryVertexMonitor.h:53
PrimaryVertexMonitor::dxyVsPhi_pt10
MonitorElement * dxyVsPhi_pt10
Definition: PrimaryVertexMonitor.h:71
PrimaryVertexMonitor::dzVsPhi_pt1
MonitorElement * dzVsPhi_pt1
Definition: PrimaryVertexMonitor.h:68
cmToUm
constexpr float cmToUm
Definition: DMRChecker.cc:126
edm::ParameterSet
Definition: ParameterSet.h:47
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
PrimaryVertexMonitor::nbgvtx
MonitorElement * nbgvtx
Definition: PrimaryVertexMonitor.h:57
PrimaryVertexMonitor::yDiff
MonitorElement * yDiff[2]
Definition: PrimaryVertexMonitor.h:59
PrimaryVertexMonitor::beamSpotInputTag_
edm::InputTag beamSpotInputTag_
Definition: PrimaryVertexMonitor.h:44
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
PrimaryVertexMonitor_cff.DzBin
DzBin
Definition: PrimaryVertexMonitor_cff.py:20
PrimaryVertexMonitor::vtxndf
MonitorElement * vtxndf[2]
Definition: PrimaryVertexMonitor.h:62
PrimaryVertexMonitor::bsBeamWidthY
MonitorElement * bsBeamWidthY
Definition: PrimaryVertexMonitor.h:64
createfilelist.int
int
Definition: createfilelist.py:10
iEvent
int iEvent
Definition: GenABIO.cc:224
PrimaryVertexMonitor::dzErr
MonitorElement * dzErr
Definition: PrimaryVertexMonitor.h:67
dqm::impl::MonitorElement::setBinLabel
virtual void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:771
PrimaryVertexMonitor::dzVsEtaVsPhi_pt1
MonitorElement * dzVsEtaVsPhi_pt1
Definition: PrimaryVertexMonitor.h:70
PrimaryVertexMonitor::bsType
MonitorElement * bsType
Definition: PrimaryVertexMonitor.h:64
MonitorTrackSTAMuons_cfi.PhiMin
PhiMin
Definition: MonitorTrackSTAMuons_cfi.py:231
beam_dqm_sourceclient-live_cfg.DxyBin
DxyBin
Definition: beam_dqm_sourceclient-live_cfg.py:191
edm::EventSetup
Definition: EventSetup.h:58
PrimaryVertexMonitor::dxy
MonitorElement * dxy
Definition: PrimaryVertexMonitor.h:67
PrimaryVertexMonitor::dxyVsEtaVsPhi_pt10
MonitorElement * dxyVsEtaVsPhi_pt10
Definition: PrimaryVertexMonitor.h:73
PrimaryVertexMonitor::vertexToken_
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
Definition: PrimaryVertexMonitor.h:39
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PrimaryVertexMonitor_cff.DzMin
DzMin
Definition: PrimaryVertexMonitor_cff.py:22
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:1053
PrimaryVertexMonitor_cff.DzMax
DzMax
Definition: PrimaryVertexMonitor_cff.py:21
PrimaryVertexMonitor_cff.PhiBin2D
PhiBin2D
Definition: PrimaryVertexMonitor_cff.py:24
DDAxes::phi
PrimaryVertexMonitor::zerrVsTrks
MonitorElement * zerrVsTrks[2]
Definition: PrimaryVertexMonitor.h:60
std
Definition: JetResolutionObject.h:76
PrimaryVertexMonitor::dzVsEta_pt1
MonitorElement * dzVsEta_pt1
Definition: PrimaryVertexMonitor.h:69
PrimaryVertexMonitor::scoreToken_
edm::EDGetTokenT< VertexScore > scoreToken_
Definition: PrimaryVertexMonitor.h:42
PrimaryVertexMonitor::dzVsEta_pt10
MonitorElement * dzVsEta_pt10
Definition: PrimaryVertexMonitor.h:72
PVValHelper::dxy
Definition: PVValidationHelpers.h:48
isFinite.h
MonitorTrackInnerTrackMuons_cff.EtaMin
EtaMin
Definition: MonitorTrackInnerTrackMuons_cff.py:64
MonitorTrackInnerTrackMuons_cff.EtaMax
EtaMax
Definition: MonitorTrackInnerTrackMuons_cff.py:64
PVValHelper::dz
Definition: PVValidationHelpers.h:51
dqm::implementation::IBooker::book2D
MonitorElement * book2D(TString const &name, TString const &title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, FUNC onbooking=NOOP())
Definition: DQMStore.h:177
PrimaryVertexMonitor::vtxchi2
MonitorElement * vtxchi2[2]
Definition: PrimaryVertexMonitor.h:62
PrimaryVertexMonitor::~PrimaryVertexMonitor
~PrimaryVertexMonitor() override
Definition: PrimaryVertexMonitor.cc:372
PrimaryVertexMonitor::beamspotToken_
edm::EDGetTokenT< reco::BeamSpot > beamspotToken_
Definition: PrimaryVertexMonitor.h:40
PrimaryVertexMonitor::xrec
MonitorElement * xrec[2]
Definition: PrimaryVertexMonitor.h:59
PrimaryVertexMonitor::bsZ
MonitorElement * bsZ
Definition: PrimaryVertexMonitor.h:64
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
MonitorTrackSTAMuons_cfi.PhiBin
PhiBin
Definition: MonitorTrackSTAMuons_cfi.py:229
dqm::implementation::IBooker
Definition: DQMStore.h:43
AlignmentPI::index
index
Definition: AlignmentPayloadInspectorHelper.h:46
PrimaryVertexMonitor::bsBeamWidthX
MonitorElement * bsBeamWidthX
Definition: PrimaryVertexMonitor.h:64
PrimaryVertexMonitor::dz
MonitorElement * dz
Definition: PrimaryVertexMonitor.h:67
PrimaryVertexMonitor::ntracks
MonitorElement * ntracks
Definition: PrimaryVertexMonitor.h:66
PrimaryVertexMonitor::xerrVsTrks
MonitorElement * xerrVsTrks[2]
Definition: PrimaryVertexMonitor.h:60
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
PrimaryVertexMonitor::dxyErr
MonitorElement * dxyErr
Definition: PrimaryVertexMonitor.h:67
edm::Event
Definition: Event.h:73
submitPVValidationJobs.t
string t
Definition: submitPVValidationJobs.py:644
PrimaryVertexMonitor::dzVsPhi_pt10
MonitorElement * dzVsPhi_pt10
Definition: PrimaryVertexMonitor.h:71
PrimaryVertexMonitor::chi2prob
MonitorElement * chi2prob
Definition: PrimaryVertexMonitor.h:66
dqm::impl::MonitorElement::setAxisTitle
virtual void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:800
edm::InputTag
Definition: InputTag.h:15
PrimaryVertexMonitor::chi2ndf
MonitorElement * chi2ndf
Definition: PrimaryVertexMonitor.h:66
weight
Definition: weight.py:1
reco::Vertex
Definition: Vertex.h:35
dqm::implementation::IBooker::book1D
MonitorElement * book1D(TString const &name, TString const &title, int const nchX, double const lowX, double const highX, FUNC onbooking=NOOP())
Definition: DQMStore.h:98
reco::TrackBase::highPurity
Definition: TrackBase.h:154
Generated for CMSSW Reference Manual by doxygen 1.8.16