CMS 3D CMS Logo
PrimaryVertexValidation.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: Alignment/OfflineValidation
4 // Class: PrimaryVertexValidation
5 //
13 //
14 // Original Author: Marco Musich
15 // Created: Tue Mar 02 10:39:34 CDT 2010
16 //
17 
18 // system include files
19 #include <memory>
20 #include <vector>
21 #include <regex>
22 #include <cassert>
23 #include <chrono>
24 #include <iomanip>
25 
26 // user include files
27 #include "Alignment/OfflineValidation/plugins/PrimaryVertexValidation.h"
28 
29 // ROOT includes
30 #include "TH1F.h"
31 #include "TH2F.h"
32 #include "TF1.h"
33 #include "TVector3.h"
34 #include "TFile.h"
35 #include "TMath.h"
36 #include "TROOT.h"
37 #include "TChain.h"
38 #include "TNtuple.h"
39 #include "TMatrixD.h"
40 #include "TVectorD.h"
41 
42 // CMSSW includes
43 #include "CondFormats/RunInfo/interface/RunInfo.h"
44 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
45 #include "DataFormats/GeometryCommonDetAlgo/interface/Measurement1D.h"
46 #include "DataFormats/TrackReco/interface/Track.h"
47 #include "DataFormats/TrackReco/interface/TrackFwd.h"
48 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
49 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"
50 #include "FWCore/MessageLogger/interface/MessageLogger.h"
51 #include "FWCore/ParameterSet/interface/ParameterSet.h"
52 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
53 #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
54 #include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
55 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
56 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
57 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
58 #include "MagneticField/Engine/interface/MagneticField.h"
59 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
60 #include "RecoVertex/PrimaryVertexProducer/interface/DAClusterizerInZ_vect.h"
61 #include "RecoVertex/PrimaryVertexProducer/interface/DAClusterizerInZ.h"
62 #include "RecoVertex/PrimaryVertexProducer/interface/GapClusterizerInZ.h"
63 #include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
64 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
65 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
66 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateClosestToPoint.h"
67 
68 const int PrimaryVertexValidation::nMaxtracks_;
69 
70 // Constructor
71 PrimaryVertexValidation::PrimaryVertexValidation(const edm::ParameterSet& iConfig)
72  : storeNtuple_(iConfig.getParameter<bool>("storeNtuple")),
73  lightNtupleSwitch_(iConfig.getParameter<bool>("isLightNtuple")),
74  useTracksFromRecoVtx_(iConfig.getParameter<bool>("useTracksFromRecoVtx")),
75  vertexZMax_(iConfig.getUntrackedParameter<double>("vertexZMax", 99.)),
76  intLumi_(iConfig.getUntrackedParameter<double>("intLumi", 0.)),
77  askFirstLayerHit_(iConfig.getParameter<bool>("askFirstLayerHit")),
78  doBPix_(iConfig.getUntrackedParameter<bool>("doBPix", true)),
79  doFPix_(iConfig.getUntrackedParameter<bool>("doFPix", true)),
80  ptOfProbe_(iConfig.getUntrackedParameter<double>("probePt", 0.)),
81  pOfProbe_(iConfig.getUntrackedParameter<double>("probeP", 0.)),
82  etaOfProbe_(iConfig.getUntrackedParameter<double>("probeEta", 2.4)),
83  nHitsOfProbe_(iConfig.getUntrackedParameter<double>("probeNHits", 0.)),
84  nBins_(iConfig.getUntrackedParameter<int>("numberOfBins", 24)),
85  minPt_(iConfig.getUntrackedParameter<double>("minPt", 1.)),
86  maxPt_(iConfig.getUntrackedParameter<double>("maxPt", 20.)),
87  debug_(iConfig.getParameter<bool>("Debug")),
88  runControl_(iConfig.getUntrackedParameter<bool>("runControl", false)),
89  forceBeamSpotContraint_(iConfig.getUntrackedParameter<bool>("forceBeamSpot", false)) {
90  // now do what ever initialization is needed
91  // initialize phase space boundaries
92 
93  usesResource(TFileService::kSharedResource);
94 
95  std::vector<unsigned int> defaultRuns;
96  defaultRuns.push_back(0);
97  runControlNumbers_ = iConfig.getUntrackedParameter<std::vector<unsigned int> >("runControlNumber", defaultRuns);
98 
99  edm::InputTag TrackCollectionTag_ = iConfig.getParameter<edm::InputTag>("TrackCollectionTag");
100  theTrackCollectionToken = consumes<reco::TrackCollection>(TrackCollectionTag_);
101 
102  edm::InputTag VertexCollectionTag_ = iConfig.getParameter<edm::InputTag>("VertexCollectionTag");
103  theVertexCollectionToken = consumes<reco::VertexCollection>(VertexCollectionTag_);
104 
105  edm::InputTag BeamspotTag_ = edm::InputTag("offlineBeamSpot");
106  theBeamspotToken = consumes<reco::BeamSpot>(BeamspotTag_);
107 
108  // select and configure the track filter
109  theTrackFilter_ = std::unique_ptr<TrackFilterForPVFinding>(
110  new TrackFilterForPVFinding(iConfig.getParameter<edm::ParameterSet>("TkFilterParameters")));
111  // select and configure the track clusterizer
112  std::string clusteringAlgorithm =
113  iConfig.getParameter<edm::ParameterSet>("TkClusParameters").getParameter<std::string>("algorithm");
114  if (clusteringAlgorithm == "gap") {
115  theTrackClusterizer_ = std::unique_ptr<GapClusterizerInZ>(
116  new GapClusterizerInZ(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
117  .getParameter<edm::ParameterSet>("TkGapClusParameters")));
118  } else if (clusteringAlgorithm == "DA") {
119  theTrackClusterizer_ = std::unique_ptr<DAClusterizerInZ>(
120  new DAClusterizerInZ(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
121  .getParameter<edm::ParameterSet>("TkDAClusParameters")));
122  // provide the vectorized version of the clusterizer, if supported by the build
123  } else if (clusteringAlgorithm == "DA_vect") {
124  theTrackClusterizer_ = std::unique_ptr<DAClusterizerInZ_vect>(
125  new DAClusterizerInZ_vect(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
126  .getParameter<edm::ParameterSet>("TkDAClusParameters")));
127  } else {
128  throw VertexException("PrimaryVertexProducerAlgorithm: unknown clustering algorithm: " + clusteringAlgorithm);
129  }
130 
131  theDetails_.histobins = 500;
132  theDetails_.setMap(PVValHelper::dxy, PVValHelper::phi, -2000., 2000.);
133  theDetails_.setMap(PVValHelper::dxy, PVValHelper::eta, -3000., 3000.);
134  theDetails_.setMap(PVValHelper::dxy, PVValHelper::pT, -1000., 1000.);
135  theDetails_.setMap(PVValHelper::dxy, PVValHelper::pTCentral, -1000., 1000.);
136  theDetails_.setMap(PVValHelper::dxy, PVValHelper::ladder, -1000., 1000.);
137  theDetails_.setMap(PVValHelper::dxy, PVValHelper::modZ, -1000., 1000.);
138 
139  for (int i = PVValHelper::phi; i < PVValHelper::END_OF_PLOTS; i++) {
140  for (int j = PVValHelper::dx; j < PVValHelper::END_OF_TYPES; j++) {
141  auto plot_index = static_cast<PVValHelper::plotVariable>(i);
142  auto res_index = static_cast<PVValHelper::residualType>(j);
143 
144  if (debug_) {
145  edm::LogInfo("PrimaryVertexValidation")
146  << "==> " << std::get<0>(PVValHelper::getTypeString(res_index)) << " " << std::setw(10)
147  << std::get<0>(PVValHelper::getVarString(plot_index)) << std::endl;
148  }
149  if (res_index != PVValHelper::d3D && res_index != PVValHelper::norm_d3D)
150  theDetails_.setMap(res_index,
151  plot_index,
152  theDetails_.getLow(PVValHelper::dxy, plot_index),
153  theDetails_.getHigh(PVValHelper::dxy, plot_index));
154  else
155  theDetails_.setMap(res_index, plot_index, 0., theDetails_.getHigh(PVValHelper::dxy, plot_index));
156  }
157  }
158 
159  edm::LogVerbatim("PrimaryVertexValidation") << "######################################";
160  for (const auto& it : theDetails_.range) {
161  edm::LogVerbatim("PrimaryVertexValidation")
162  << "|" << std::setw(10) << std::get<0>(PVValHelper::getTypeString(it.first.first)) << "|" << std::setw(10)
163  << std::get<0>(PVValHelper::getVarString(it.first.second)) << "| (" << std::setw(5) << it.second.first << ";"
164  << std::setw(5) << it.second.second << ") |" << std::endl;
165  }
166 
167  theDetails_.trendbins[PVValHelper::phi] = PVValHelper::generateBins(nBins_ + 1, -180., 360.);
168  theDetails_.trendbins[PVValHelper::eta] = PVValHelper::generateBins(nBins_ + 1, -etaOfProbe_, 2 * etaOfProbe_);
169 
170  if (debug_) {
171  edm::LogVerbatim("PrimaryVertexValidation") << "etaBins: ";
172  for (auto ieta : theDetails_.trendbins[PVValHelper::eta]) {
173  edm::LogVerbatim("PrimaryVertexValidation") << ieta << " ";
174  }
175  edm::LogVerbatim("PrimaryVertexValidation") << "\n";
176 
177  edm::LogVerbatim("PrimaryVertexValidation") << "phiBins: ";
178  for (auto iphi : theDetails_.trendbins[PVValHelper::phi]) {
179  edm::LogVerbatim("PrimaryVertexValidation") << iphi << " ";
180  }
181  edm::LogVerbatim("PrimaryVertexValidation") << "\n";
182  }
183 
184  // create the bins of the pT-binned distributions
185 
186  mypT_bins_ = PVValHelper::makeLogBins<float, nPtBins_>(minPt_, maxPt_);
187 
188  std::string toOutput = "";
189  for (auto ptbin : mypT_bins_) {
190  toOutput += " ";
191  toOutput += std::to_string(ptbin);
192  toOutput += ",";
193  }
194 
195  edm::LogVerbatim("PrimaryVertexValidation") << "######################################\n";
196  edm::LogVerbatim("PrimaryVertexValidation") << "The pT binning is: [" << toOutput << "] \n";
197 }
198 
199 // Destructor
200 PrimaryVertexValidation::~PrimaryVertexValidation() {
201  // do anything here that needs to be done at desctruction time
202  // (e.g. close files, deallocate resources etc.)
203 }
204 
205 //
206 // member functions
207 //
208 
209 // ------------ method called to for each event ------------
210 void PrimaryVertexValidation::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
211  using namespace std;
212  using namespace reco;
213  using namespace IPTools;
214 
215  if (!isBFieldConsistentWithMode(iSetup)) {
216  edm::LogWarning("PrimaryVertexValidation")
217  << "*********************************************************************************\n"
218  << "* The configuration (ptOfProbe > " << ptOfProbe_
219  << "GeV) is not correctly set for current value of magnetic field \n"
220  << "* Switching it to 0. !!! \n"
221  << "*********************************************************************************" << std::endl;
222  ptOfProbe_ = 0.;
223  }
224 
225  if (nBins_ != 24 && debug_) {
226  edm::LogInfo("PrimaryVertexValidation") << "Using: " << nBins_ << " bins plots";
227  }
228 
229  bool passesRunControl = false;
230 
231  if (runControl_) {
232  for (const auto& runControlNumber : runControlNumbers_) {
233  if (iEvent.eventAuxiliary().run() == runControlNumber) {
234  if (debug_) {
235  edm::LogInfo("PrimaryVertexValidation")
236  << " run number: " << iEvent.eventAuxiliary().run() << " keeping run:" << runControlNumber;
237  }
238  passesRunControl = true;
239  break;
240  }
241  }
242  if (!passesRunControl)
243  return;
244  }
245 
246  Nevt_++;
247 
248  //=======================================================
249  // Initialize Root-tuple variables
250  //=======================================================
251 
252  SetVarToZero();
253 
254  //=======================================================
255  // Retrieve the Magnetic Field information
256  //=======================================================
257 
258  edm::ESHandle<MagneticField> theMGField;
259  iSetup.get<IdealMagneticFieldRecord>().get(theMGField);
260 
261  //=======================================================
262  // Retrieve the Tracking Geometry information
263  //=======================================================
264 
265  edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry;
266  iSetup.get<GlobalTrackingGeometryRecord>().get(theTrackingGeometry);
267 
268  //=======================================================
269  // Retrieve geometry information
270  //=======================================================
271 
272  edm::LogInfo("read tracker geometry...");
273  edm::ESHandle<TrackerGeometry> pDD;
274  iSetup.get<TrackerDigiGeometryRecord>().get(pDD);
275  edm::LogInfo("tracker geometry read") << "There are: " << pDD->dets().size() << " detectors";
276 
277  // switch on the phase1
278  if ((pDD->isThere(GeomDetEnumerators::P1PXB)) || (pDD->isThere(GeomDetEnumerators::P1PXEC))) {
279  isPhase1_ = true;
280  nLadders_ = 12;
281 
282  if (h_dxy_ladderOverlap_.size() != nLadders_) {
283  PVValHelper::shrinkHistVectorToFit(h_dxy_ladderOverlap_, nLadders_);
284  PVValHelper::shrinkHistVectorToFit(h_dxy_ladderNoOverlap_, nLadders_);
285  PVValHelper::shrinkHistVectorToFit(h_dxy_ladder_, nLadders_);
286  PVValHelper::shrinkHistVectorToFit(h_dz_ladder_, nLadders_);
287  PVValHelper::shrinkHistVectorToFit(h_norm_dxy_ladder_, nLadders_);
288  PVValHelper::shrinkHistVectorToFit(h_norm_dz_ladder_, nLadders_);
289 
290  if (debug_) {
291  edm::LogInfo("PrimaryVertexValidation") << "checking size:" << h_dxy_ladder_.size() << std::endl;
292  }
293  }
294 
295  if (debug_) {
296  edm::LogInfo("PrimaryVertexValidation") << " pixel phase1 setup, nLadders: " << nLadders_;
297  }
298 
299  } else {
300  isPhase1_ = false;
301  nLadders_ = 20;
302  if (debug_) {
303  edm::LogInfo("PrimaryVertexValidation") << " pixel phase0 setup, nLadders: " << nLadders_;
304  }
305  }
306 
307  if (isPhase1_) {
308  etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase1);
309  } else {
310  etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase0);
311  }
312 
313  if (h_etaMax->GetEntries() == 0.) {
314  h_etaMax->SetBinContent(1., etaOfProbe_);
315  h_nbins->SetBinContent(1., nBins_);
316  h_nLadders->SetBinContent(1., nLadders_);
317  h_pTinfo->SetBinContent(1., mypT_bins_.size());
318  h_pTinfo->SetBinContent(2., minPt_);
319  h_pTinfo->SetBinContent(3., maxPt_);
320  }
321 
322  //=======================================================
323  // Retrieve the Transient Track Builder information
324  //=======================================================
325 
326  edm::ESHandle<TransientTrackBuilder> theB_;
327  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", theB_);
328  double fBfield_ = ((*theB_).field()->inTesla(GlobalPoint(0., 0., 0.))).z();
329 
330  //=======================================================
331  // Retrieve the Track information
332  //=======================================================
333 
334  edm::Handle<TrackCollection> trackCollectionHandle;
335  iEvent.getByToken(theTrackCollectionToken, trackCollectionHandle);
336  if (!trackCollectionHandle.isValid())
337  return;
338  auto const& tracks = *trackCollectionHandle;
339 
340  //=======================================================
341  // Retrieve tracker topology from geometry
342  //=======================================================
343 
344  edm::ESHandle<TrackerTopology> tTopoHandle;
345  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
346  const TrackerTopology* const tTopo = tTopoHandle.product();
347 
348  //=======================================================
349  // Retrieve offline vartex information (only for reco)
350  //=======================================================
351 
352  //edm::Handle<VertexCollection> vertices;
353  edm::Handle<std::vector<Vertex> > vertices;
354 
355  try {
356  iEvent.getByToken(theVertexCollectionToken, vertices);
357  } catch (cms::Exception& er) {
358  LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
359  }
360 
361  std::vector<Vertex> vsorted = *(vertices);
362  // sort the vertices by number of tracks in descending order
363  // use chi2 as tiebreaker
364  std::sort(vsorted.begin(), vsorted.end(), PrimaryVertexValidation::vtxSort);
365 
366  // skip events with no PV, this should not happen
367 
368  if (vsorted.empty())
369  return;
370 
371  // skip events failing vertex cut
372  if (std::abs(vsorted[0].z()) > vertexZMax_)
373  return;
374 
375  if (vsorted[0].isValid()) {
376  xOfflineVertex_ = (vsorted)[0].x();
377  yOfflineVertex_ = (vsorted)[0].y();
378  zOfflineVertex_ = (vsorted)[0].z();
379 
380  xErrOfflineVertex_ = (vsorted)[0].xError();
381  yErrOfflineVertex_ = (vsorted)[0].yError();
382  zErrOfflineVertex_ = (vsorted)[0].zError();
383  }
384 
385  h_xOfflineVertex->Fill(xOfflineVertex_);
386  h_yOfflineVertex->Fill(yOfflineVertex_);
387  h_zOfflineVertex->Fill(zOfflineVertex_);
388  h_xErrOfflineVertex->Fill(xErrOfflineVertex_);
389  h_yErrOfflineVertex->Fill(yErrOfflineVertex_);
390  h_zErrOfflineVertex->Fill(zErrOfflineVertex_);
391 
392  unsigned int vertexCollectionSize = vsorted.size();
393  int nvvertex = 0;
394 
395  for (unsigned int i = 0; i < vertexCollectionSize; i++) {
396  const Vertex& vertex = vsorted.at(i);
397  if (vertex.isValid())
398  nvvertex++;
399  }
400 
401  nOfflineVertices_ = nvvertex;
402  h_nOfflineVertices->Fill(nvvertex);
403 
404  if (!vsorted.empty() && useTracksFromRecoVtx_) {
405  double sumpt = 0;
406  size_t ntracks = 0;
407  double chi2ndf = 0.;
408  double chi2prob = 0.;
409 
410  if (!vsorted.at(0).isFake()) {
411  Vertex pv = vsorted.at(0);
412 
413  ntracks = pv.tracksSize();
414  chi2ndf = pv.normalizedChi2();
415  chi2prob = TMath::Prob(pv.chi2(), (int)pv.ndof());
416 
417  h_recoVtxNtracks_->Fill(ntracks);
418  h_recoVtxChi2ndf_->Fill(chi2ndf);
419  h_recoVtxChi2Prob_->Fill(chi2prob);
420 
421  for (Vertex::trackRef_iterator itrk = pv.tracks_begin(); itrk != pv.tracks_end(); ++itrk) {
422  double pt = (**itrk).pt();
423  sumpt += pt * pt;
424 
425  const math::XYZPoint myVertex(pv.position().x(), pv.position().y(), pv.position().z());
426 
427  double dxyRes = (**itrk).dxy(myVertex);
428  double dzRes = (**itrk).dz(myVertex);
429 
430  double dxy_err = (**itrk).dxyError();
431  double dz_err = (**itrk).dzError();
432 
433  float trackphi = ((**itrk).phi()) * (180 / M_PI);
434  float tracketa = (**itrk).eta();
435 
436  for (int i = 0; i < nBins_; i++) {
437  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
438  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
439 
440  float etaF = theDetails_.trendbins[PVValHelper::eta][i];
441  float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
442 
443  if (tracketa >= etaF && tracketa < etaL) {
444  PVValHelper::fillByIndex(a_dxyEtaBiasResiduals, i, dxyRes * cmToum);
445  PVValHelper::fillByIndex(a_dzEtaBiasResiduals, i, dzRes * cmToum);
446  PVValHelper::fillByIndex(n_dxyEtaBiasResiduals, i, (dxyRes) / dxy_err);
447  PVValHelper::fillByIndex(n_dzEtaBiasResiduals, i, (dzRes) / dz_err);
448  }
449 
450  if (trackphi >= phiF && trackphi < phiL) {
451  PVValHelper::fillByIndex(a_dxyPhiBiasResiduals, i, dxyRes * cmToum);
452  PVValHelper::fillByIndex(a_dzPhiBiasResiduals, i, dzRes * cmToum);
453  PVValHelper::fillByIndex(n_dxyPhiBiasResiduals, i, (dxyRes) / dxy_err);
454  PVValHelper::fillByIndex(n_dzPhiBiasResiduals, i, (dzRes) / dz_err);
455 
456  for (int j = 0; j < nBins_; j++) {
457  float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
458  float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
459 
460  if (tracketa >= etaJ && tracketa < etaK) {
461  a_dxyBiasResidualsMap[i][j]->Fill(dxyRes * cmToum);
462  a_dzBiasResidualsMap[i][j]->Fill(dzRes * cmToum);
463 
464  n_dxyBiasResidualsMap[i][j]->Fill((dxyRes) / dxy_err);
465  n_dzBiasResidualsMap[i][j]->Fill((dzRes) / dz_err);
466  }
467  }
468  }
469  }
470  }
471 
472  h_recoVtxSumPt_->Fill(sumpt);
473  }
474  }
475 
476  //=======================================================
477  // Retrieve Beamspot information
478  //=======================================================
479 
480  BeamSpot beamSpot;
481  edm::Handle<BeamSpot> beamSpotHandle;
482  iEvent.getByToken(theBeamspotToken, beamSpotHandle);
483 
484  if (beamSpotHandle.isValid()) {
485  beamSpot = *beamSpotHandle;
486  BSx0_ = beamSpot.x0();
487  BSy0_ = beamSpot.y0();
488  BSz0_ = beamSpot.z0();
489  Beamsigmaz_ = beamSpot.sigmaZ();
490  Beamdxdz_ = beamSpot.dxdz();
491  BeamWidthX_ = beamSpot.BeamWidthX();
492  BeamWidthY_ = beamSpot.BeamWidthY();
493 
494  wxy2_ = TMath::Power(BeamWidthX_, 2) + TMath::Power(BeamWidthY_, 2);
495 
496  } else {
497  edm::LogWarning("PrimaryVertexValidation") << "No BeamSpot found!";
498  }
499 
500  h_BSx0->Fill(BSx0_);
501  h_BSy0->Fill(BSy0_);
502  h_BSz0->Fill(BSz0_);
503  h_Beamsigmaz->Fill(Beamsigmaz_);
504  h_BeamWidthX->Fill(BeamWidthX_);
505  h_BeamWidthY->Fill(BeamWidthY_);
506 
507  if (debug_)
508  edm::LogInfo("PrimaryVertexValidation") << "Beamspot x:" << BSx0_ << " y:" << BSy0_ << " z:" << BSz0_;
509 
510  //=======================================================
511  // Starts here ananlysis
512  //=======================================================
513 
514  RunNumber_ = iEvent.eventAuxiliary().run();
515  h_runNumber->Fill(RunNumber_);
516 
517  if (!runNumbersTimesLog_.count(RunNumber_)) {
518  auto times = getRunTime(iSetup);
519 
520  if (debug_) {
521  const time_t start_time = times.first / 1000000;
522  edm::LogInfo("PrimaryVertexValidation")
523  << RunNumber_ << " has start time: " << times.first << " - " << times.second << std::endl;
524  edm::LogInfo("PrimaryVertexValidation")
525  << "human readable time: " << std::asctime(std::gmtime(&start_time)) << std::endl;
526  }
527 
528  runNumbersTimesLog_[RunNumber_] = times;
529  }
530 
531  if (h_runFromEvent->GetEntries() == 0) {
532  h_runFromEvent->SetBinContent(1, RunNumber_);
533  }
534 
535  LuminosityBlockNumber_ = iEvent.eventAuxiliary().luminosityBlock();
536  EventNumber_ = iEvent.eventAuxiliary().id().event();
537 
538  if (debug_)
539  edm::LogInfo("PrimaryVertexValidation") << " looping over " << trackCollectionHandle->size() << "tracks";
540 
541  h_nTracks->Fill(trackCollectionHandle->size());
542 
543  //======================================================
544  // Interface RECO tracks to vertex reconstruction
545  //======================================================
546 
547  std::vector<TransientTrack> t_tks;
548  for (const auto& track : tracks) {
549  TransientTrack tt = theB_->build(&(track));
550  tt.setBeamSpot(beamSpot);
551  t_tks.push_back(tt);
552  }
553 
554  if (debug_) {
555  edm::LogInfo("PrimaryVertexValidation") << "Found: " << t_tks.size() << " reconstructed tracks";
556  }
557 
558  //======================================================
559  // select the tracks
560  //======================================================
561 
562  std::vector<TransientTrack> seltks = theTrackFilter_->select(t_tks);
563 
564  //======================================================
565  // clusterize tracks in Z
566  //======================================================
567 
568  vector<vector<TransientTrack> > clusters = theTrackClusterizer_->clusterize(seltks);
569 
570  if (debug_) {
571  edm::LogInfo("PrimaryVertexValidation")
572  << " looping over: " << clusters.size() << " clusters from " << t_tks.size() << " selected tracks";
573  }
574 
575  nClus_ = clusters.size();
576  h_nClus->Fill(nClus_);
577 
578  //======================================================
579  // Starts loop on clusters
580  //======================================================
581  for (const auto& iclus : clusters) {
582  nTracksPerClus_ = 0;
583 
584  unsigned int i = 0;
585  for (const auto& theTTrack : iclus) {
586  i++;
587 
588  if (nTracks_ >= nMaxtracks_) {
589  edm::LogError("PrimaryVertexValidation")
590  << " Warning - Number of tracks: " << nTracks_ << " , greater than " << nMaxtracks_;
591  continue;
592  }
593 
594  const Track& theTrack = theTTrack.track();
595 
596  pt_[nTracks_] = theTrack.pt();
597  p_[nTracks_] = theTrack.p();
598  nhits_[nTracks_] = theTrack.numberOfValidHits();
599  eta_[nTracks_] = theTrack.eta();
600  theta_[nTracks_] = theTrack.theta();
601  phi_[nTracks_] = theTrack.phi();
602  chi2_[nTracks_] = theTrack.chi2();
603  chi2ndof_[nTracks_] = theTrack.normalizedChi2();
604  charge_[nTracks_] = theTrack.charge();
605  qoverp_[nTracks_] = theTrack.qoverp();
606  dz_[nTracks_] = theTrack.dz();
607  dxy_[nTracks_] = theTrack.dxy();
608 
609  TrackBase::TrackQuality _trackQuality = TrackBase::qualityByName("highPurity");
610  isHighPurity_[nTracks_] = theTrack.quality(_trackQuality);
611 
612  math::XYZPoint point(BSx0_, BSy0_, BSz0_);
613  dxyBs_[nTracks_] = theTrack.dxy(point);
614  dzBs_[nTracks_] = theTrack.dz(point);
615 
616  xPCA_[nTracks_] = theTrack.vertex().x();
617  yPCA_[nTracks_] = theTrack.vertex().y();
618  zPCA_[nTracks_] = theTrack.vertex().z();
619 
620  //=======================================================
621  // Retrieve rechit information
622  //=======================================================
623 
624  const reco::HitPattern& hits = theTrack.hitPattern();
625 
626  int nRecHit1D = 0;
627  int nRecHit2D = 0;
628  int nhitinTIB = hits.numberOfValidStripTIBHits();
629  int nhitinTOB = hits.numberOfValidStripTOBHits();
630  int nhitinTID = hits.numberOfValidStripTIDHits();
631  int nhitinTEC = hits.numberOfValidStripTECHits();
632  int nhitinBPIX = hits.numberOfValidPixelBarrelHits();
633  int nhitinFPIX = hits.numberOfValidPixelEndcapHits();
634  for (trackingRecHit_iterator iHit = theTTrack.recHitsBegin(); iHit != theTTrack.recHitsEnd(); ++iHit) {
635  if ((*iHit)->isValid()) {
636  if (this->isHit2D(**iHit)) {
637  ++nRecHit2D;
638  } else {
639  ++nRecHit1D;
640  }
641  }
642  }
643 
644  nhits1D_[nTracks_] = nRecHit1D;
645  nhits2D_[nTracks_] = nRecHit2D;
646  nhitsBPIX_[nTracks_] = nhitinBPIX;
647  nhitsFPIX_[nTracks_] = nhitinFPIX;
648  nhitsTIB_[nTracks_] = nhitinTIB;
649  nhitsTID_[nTracks_] = nhitinTID;
650  nhitsTOB_[nTracks_] = nhitinTOB;
651  nhitsTEC_[nTracks_] = nhitinTEC;
652 
653  //=======================================================
654  // Good tracks for vertexing selection
655  //=======================================================
656 
657  bool pass = true;
658  if (askFirstLayerHit_)
659  pass = this->hasFirstLayerPixelHits(theTTrack);
660  if (pass && (theTrack.pt() >= ptOfProbe_) && std::abs(theTrack.eta()) <= etaOfProbe_ &&
661  (theTrack.numberOfValidHits()) >= nHitsOfProbe_ && (theTrack.p()) >= pOfProbe_) {
662  isGoodTrack_[nTracks_] = 1;
663  }
664 
665  //=======================================================
666  // Fit unbiased vertex
667  //=======================================================
668 
669  vector<TransientTrack> theFinalTracks;
670  theFinalTracks.clear();
671 
672  for (const auto& tk : iclus) {
673  pass = this->hasFirstLayerPixelHits(tk);
674  if (pass) {
675  if (tk == theTTrack)
676  continue;
677  else {
678  theFinalTracks.push_back(tk);
679  }
680  }
681  }
682 
683  if (theFinalTracks.size() > 1) {
684  if (debug_)
685  edm::LogInfo("PrimaryVertexValidation") << "Transient Track Collection size: " << theFinalTracks.size();
686  try {
687  //AdaptiveVertexFitter* theFitter = new AdaptiveVertexFitter;
688  auto theFitter = std::unique_ptr<VertexFitter<5> >(new AdaptiveVertexFitter());
689  TransientVertex theFittedVertex;
690 
691  if (forceBeamSpotContraint_) {
692  theFittedVertex = theFitter->vertex(theFinalTracks, beamSpot); // if you want the beam constraint
693  } else {
694  theFittedVertex = theFitter->vertex(theFinalTracks);
695  }
696 
697  double totalTrackWeights = 0;
698  if (theFittedVertex.isValid()) {
699  if (theFittedVertex.hasTrackWeight()) {
700  for (const auto& theFinalTrack : theFinalTracks) {
701  sumOfWeightsUnbiasedVertex_[nTracks_] += theFittedVertex.trackWeight(theFinalTrack);
702  totalTrackWeights += theFittedVertex.trackWeight(theFinalTrack);
703  h_fitVtxTrackWeights_->Fill(theFittedVertex.trackWeight(theFinalTrack));
704  }
705  }
706 
707  h_fitVtxTrackAverageWeight_->Fill(totalTrackWeights / theFinalTracks.size());
708 
709  const math::XYZPoint theRecoVertex(xOfflineVertex_, yOfflineVertex_, zOfflineVertex_);
710  const math::XYZPoint myVertex(
711  theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
712 
713  const Vertex vertex = theFittedVertex;
714  fillTrackHistos(hDA, "all", &theTTrack, vertex, beamSpot, fBfield_);
715 
716  hasRecVertex_[nTracks_] = 1;
717  xUnbiasedVertex_[nTracks_] = theFittedVertex.position().x();
718  yUnbiasedVertex_[nTracks_] = theFittedVertex.position().y();
719  zUnbiasedVertex_[nTracks_] = theFittedVertex.position().z();
720 
721  chi2normUnbiasedVertex_[nTracks_] = theFittedVertex.normalisedChiSquared();
722  chi2UnbiasedVertex_[nTracks_] = theFittedVertex.totalChiSquared();
723  DOFUnbiasedVertex_[nTracks_] = theFittedVertex.degreesOfFreedom();
724  chi2ProbUnbiasedVertex_[nTracks_] =
725  TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom());
726  tracksUsedForVertexing_[nTracks_] = theFinalTracks.size();
727 
728  h_fitVtxNtracks_->Fill(theFinalTracks.size());
729  h_fitVtxChi2_->Fill(theFittedVertex.totalChiSquared());
730  h_fitVtxNdof_->Fill(theFittedVertex.degreesOfFreedom());
731  h_fitVtxChi2ndf_->Fill(theFittedVertex.normalisedChiSquared());
732  h_fitVtxChi2Prob_->Fill(
733  TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom()));
734 
735  // from my Vertex
736  double dxyFromMyVertex = theTrack.dxy(myVertex);
737  double dzFromMyVertex = theTrack.dz(myVertex);
738 
739  GlobalPoint vert(
740  theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
741 
742  //FreeTrajectoryState theTrackNearVertex = theTTrack.trajectoryStateClosestToPoint(vert).theState();
743  //double dz_err = sqrt(theFittedVertex.positionError().czz() + theTrackNearVertex.cartesianError().position().czz());
744  //double dz_err = hypot(theTrack.dzError(),theFittedVertex.positionError().czz());
745 
746  double dz_err = sqrt(std::pow(theTrack.dzError(), 2) + theFittedVertex.positionError().czz());
747 
748  // PV2D
749  std::pair<bool, Measurement1D> s_ip2dpv = signedTransverseImpactParameter(
750  theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
751 
752  double s_ip2dpv_corr = s_ip2dpv.second.value();
753  double s_ip2dpv_err = s_ip2dpv.second.error();
754 
755  // PV3D
756  std::pair<bool, Measurement1D> s_ip3dpv = signedImpactParameter3D(
757  theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
758 
759  double s_ip3dpv_corr = s_ip3dpv.second.value();
760  double s_ip3dpv_err = s_ip3dpv.second.error();
761 
762  // PV3D absolute
763  std::pair<bool, Measurement1D> ip3dpv = absoluteImpactParameter3D(theTTrack, theFittedVertex);
764  double ip3d_corr = ip3dpv.second.value();
765  double ip3d_err = ip3dpv.second.error();
766 
767  // with respect to any specified vertex, such as primary vertex
768  TrajectoryStateClosestToPoint traj = (theTTrack).trajectoryStateClosestToPoint(vert);
769 
770  GlobalPoint refPoint = traj.position();
771  GlobalPoint cPToVtx = traj.theState().position();
772 
773  float my_dx = refPoint.x() - myVertex.x();
774  float my_dy = refPoint.y() - myVertex.y();
775 
776  float my_dx2 = cPToVtx.x() - myVertex.x();
777  float my_dy2 = cPToVtx.y() - myVertex.y();
778 
779  float my_dxy = std::sqrt(my_dx * my_dx + my_dy * my_dy);
780 
781  double d0 = traj.perigeeParameters().transverseImpactParameter();
782  //double d0_error = traj.perigeeError().transverseImpactParameterError();
783  double z0 = traj.perigeeParameters().longitudinalImpactParameter();
784  double z0_error = traj.perigeeError().longitudinalImpactParameterError();
785 
786  if (debug_) {
787  edm::LogInfo("PrimaryVertexValidation")
788  << "my_dx:" << my_dx << " my_dy:" << my_dy << " my_dxy:" << my_dxy << " my_dx2:" << my_dx2
789  << " my_dy2:" << my_dy2 << " d0: " << d0 << " dxyFromVtx:" << dxyFromMyVertex << "\n"
790  << " ============================== "
791  << "\n"
792  << "diff1:" << std::abs(d0) - std::abs(my_dxy) << "\n"
793  << "diff2:" << std::abs(d0) - std::abs(dxyFromMyVertex) << "\n"
794  << "diff3:" << (my_dx - my_dx2) << " " << (my_dy - my_dy2) << "\n"
795  << std::endl;
796  }
797 
798  // define IPs
799 
800  dxyFromMyVertex_[nTracks_] = dxyFromMyVertex;
801  dxyErrorFromMyVertex_[nTracks_] = s_ip2dpv_err;
802  IPTsigFromMyVertex_[nTracks_] = dxyFromMyVertex / s_ip2dpv_err;
803 
804  dzFromMyVertex_[nTracks_] = dzFromMyVertex;
805  dzErrorFromMyVertex_[nTracks_] = dz_err;
806  IPLsigFromMyVertex_[nTracks_] = dzFromMyVertex / dz_err;
807 
808  d3DFromMyVertex_[nTracks_] = ip3d_corr;
809  d3DErrorFromMyVertex_[nTracks_] = ip3d_err;
810  IP3DsigFromMyVertex_[nTracks_] = (ip3d_corr / ip3d_err);
811 
812  // fill directly the histograms of residuals
813 
814  float trackphi = (theTrack.phi()) * (180. / M_PI);
815  float tracketa = theTrack.eta();
816  float trackpt = theTrack.pt();
817  float trackp = theTrack.p();
818  float tracknhits = theTrack.numberOfValidHits();
819 
820  // determine the module number and ladder
821 
822  int ladder_num = -1.;
823  int module_num = -1.;
824  int L1BPixHitCount = 0;
825 
826  for (auto const& hit : theTrack.recHits()) {
827  const DetId& detId = hit->geographicalId();
828  unsigned int subid = detId.subdetId();
829 
830  if (hit->isValid() && (subid == PixelSubdetector::PixelBarrel)) {
831  int layer = tTopo->pxbLayer(detId);
832  if (layer == 1) {
833  const SiPixelRecHit* prechit = dynamic_cast<const SiPixelRecHit*>(
834  hit); //to be used to get the associated cluster and the cluster probability
835  double clusterProbability = prechit->clusterProbability(0);
836  if (clusterProbability > 0) {
837  h_probeL1ClusterProb_->Fill(log10(clusterProbability));
838  }
839 
840  L1BPixHitCount += 1;
841  ladder_num = tTopo->pxbLadder(detId);
842  module_num = tTopo->pxbModule(detId);
843  }
844  }
845  }
846 
847  h_probeL1Ladder_->Fill(ladder_num);
848  h_probeL1Module_->Fill(module_num);
849  h2_probeLayer1Map_->Fill(module_num, ladder_num);
850  h_probeHasBPixL1Overlap_->Fill(L1BPixHitCount);
851 
852  // residuals vs ladder and module number for map
853  if (module_num > 0 && ladder_num > 0) { // only if we are on BPix Layer 1
854  a_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex * cmToum);
855  a_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex * cmToum);
856  n_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex / s_ip2dpv_err);
857  n_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex / dz_err);
858  }
859 
860  // filling the pT-binned distributions
861 
862  for (int ipTBin = 0; ipTBin < nPtBins_; ipTBin++) {
863  float pTF = mypT_bins_[ipTBin];
864  float pTL = mypT_bins_[ipTBin + 1];
865 
866  if (debug_)
867  edm::LogInfo("PrimaryVertexValidation") << "ipTBin:" << ipTBin << " " << mypT_bins_[ipTBin]
868  << " < pT < " << mypT_bins_[ipTBin + 1] << std::endl;
869 
870  if (std::abs(tracketa) < 1.5 && (trackpt >= pTF && trackpt < pTL)) {
871  if (debug_)
872  edm::LogInfo("PrimaryVertexValidation") << "passes this cut: " << mypT_bins_[ipTBin] << std::endl;
873  PVValHelper::fillByIndex(h_dxy_pT_, ipTBin, dxyFromMyVertex * cmToum);
874  PVValHelper::fillByIndex(h_dz_pT_, ipTBin, dzFromMyVertex * cmToum);
875  PVValHelper::fillByIndex(h_norm_dxy_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err);
876  PVValHelper::fillByIndex(h_norm_dz_pT_, ipTBin, dzFromMyVertex / dz_err);
877 
878  if (std::abs(tracketa) < 1.) {
879  if (debug_)
880  edm::LogInfo("PrimaryVertexValidation")
881  << "passes tight eta cut: " << mypT_bins_[ipTBin] << std::endl;
882  PVValHelper::fillByIndex(h_dxy_Central_pT_, ipTBin, dxyFromMyVertex * cmToum);
883  PVValHelper::fillByIndex(h_dz_Central_pT_, ipTBin, dzFromMyVertex * cmToum);
884  PVValHelper::fillByIndex(h_norm_dxy_Central_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err);
885  PVValHelper::fillByIndex(h_norm_dz_Central_pT_, ipTBin, dzFromMyVertex / dz_err);
886  }
887  }
888  }
889 
890  // checks on the probe track quality
891  if (trackpt >= ptOfProbe_ && std::abs(tracketa) <= etaOfProbe_ && tracknhits >= nHitsOfProbe_ &&
892  trackp >= pOfProbe_) {
893  std::pair<bool, bool> pixelOcc = pixelHitsCheck((theTTrack));
894 
895  if (debug_) {
896  if (pixelOcc.first == true)
897  edm::LogInfo("PrimaryVertexValidation") << "has BPIx hits" << std::endl;
898  if (pixelOcc.second == true)
899  edm::LogInfo("PrimaryVertexValidation") << "has FPix hits" << std::endl;
900  }
901 
902  if (!doBPix_ && (pixelOcc.first == true))
903  continue;
904  if (!doFPix_ && (pixelOcc.second == true))
905  continue;
906 
907  fillTrackHistos(hDA, "sel", &(theTTrack), vertex, beamSpot, fBfield_);
908 
909  // probe checks
910  h_probePt_->Fill(theTrack.pt());
911  h_probePtRebin_->Fill(theTrack.pt());
912  h_probeP_->Fill(theTrack.p());
913  h_probeEta_->Fill(theTrack.eta());
914  h_probePhi_->Fill(theTrack.phi());
915  h2_probeEtaPhi_->Fill(theTrack.eta(), theTrack.phi());
916  h2_probeEtaPt_->Fill(theTrack.eta(), theTrack.pt());
917 
918  h_probeChi2_->Fill(theTrack.chi2());
919  h_probeNormChi2_->Fill(theTrack.normalizedChi2());
920  h_probeCharge_->Fill(theTrack.charge());
921  h_probeQoverP_->Fill(theTrack.qoverp());
922  h_probeHits_->Fill(theTrack.numberOfValidHits());
923  h_probeHits1D_->Fill(nRecHit1D);
924  h_probeHits2D_->Fill(nRecHit2D);
925  h_probeHitsInTIB_->Fill(nhitinBPIX);
926  h_probeHitsInTOB_->Fill(nhitinFPIX);
927  h_probeHitsInTID_->Fill(nhitinTIB);
928  h_probeHitsInTEC_->Fill(nhitinTID);
929  h_probeHitsInBPIX_->Fill(nhitinTOB);
930  h_probeHitsInFPIX_->Fill(nhitinTEC);
931 
932  float dxyRecoV = theTrack.dz(theRecoVertex);
933  float dzRecoV = theTrack.dxy(theRecoVertex);
934  float dxysigmaRecoV =
935  TMath::Sqrt(theTrack.d0Error() * theTrack.d0Error() + xErrOfflineVertex_ * yErrOfflineVertex_);
936  float dzsigmaRecoV =
937  TMath::Sqrt(theTrack.dzError() * theTrack.dzError() + zErrOfflineVertex_ * zErrOfflineVertex_);
938 
939  double zTrack = (theTTrack.stateAtBeamLine().trackStateAtPCA()).position().z();
940  double zVertex = theFittedVertex.position().z();
941  double tantheta = tan((theTTrack.stateAtBeamLine().trackStateAtPCA()).momentum().theta());
942 
943  double dz2 = pow(theTrack.dzError(), 2) + wxy2_ / pow(tantheta, 2);
944  double restrkz = zTrack - zVertex;
945  double pulltrkz = (zTrack - zVertex) / TMath::Sqrt(dz2);
946 
947  h_probedxyRecoV_->Fill(dxyRecoV);
948  h_probedzRecoV_->Fill(dzRecoV);
949 
950  h_probedzRefitV_->Fill(dxyFromMyVertex);
951  h_probedxyRefitV_->Fill(dzFromMyVertex);
952 
953  h_probed0RefitV_->Fill(d0);
954  h_probez0RefitV_->Fill(z0);
955 
956  h_probesignIP2DRefitV_->Fill(s_ip2dpv_corr);
957  h_probed3DRefitV_->Fill(ip3d_corr);
958  h_probereszRefitV_->Fill(restrkz);
959 
960  h_probeRecoVSigZ_->Fill(dzRecoV / dzsigmaRecoV);
961  h_probeRecoVSigXY_->Fill(dxyRecoV / dxysigmaRecoV);
962  h_probeRefitVSigZ_->Fill(dzFromMyVertex / dz_err);
963  h_probeRefitVSigXY_->Fill(dxyFromMyVertex / s_ip2dpv_err);
964  h_probeRefitVSig3D_->Fill(ip3d_corr / ip3d_err);
965  h_probeRefitVLogSig3D_->Fill(log10(ip3d_corr / ip3d_err));
966  h_probeRefitVSigResZ_->Fill(pulltrkz);
967 
968  a_dxyVsPhi->Fill(trackphi, dxyFromMyVertex * cmToum);
969  a_dzVsPhi->Fill(trackphi, z0 * cmToum);
970  n_dxyVsPhi->Fill(trackphi, dxyFromMyVertex / s_ip2dpv_err);
971  n_dzVsPhi->Fill(trackphi, z0 / z0_error);
972 
973  a_dxyVsEta->Fill(tracketa, dxyFromMyVertex * cmToum);
974  a_dzVsEta->Fill(tracketa, z0 * cmToum);
975  n_dxyVsEta->Fill(tracketa, dxyFromMyVertex / s_ip2dpv_err);
976  n_dzVsEta->Fill(tracketa, z0 / z0_error);
977 
978  if (ladder_num > 0 && module_num > 0) {
979  LogDebug("PrimaryVertexValidation")
980  << " ladder_num" << ladder_num << " module_num" << module_num << std::endl;
981 
982  PVValHelper::fillByIndex(h_dxy_modZ_, module_num - 1, dxyFromMyVertex * cmToum);
983  PVValHelper::fillByIndex(h_dz_modZ_, module_num - 1, dzFromMyVertex * cmToum);
984  PVValHelper::fillByIndex(h_norm_dxy_modZ_, module_num - 1, dxyFromMyVertex / s_ip2dpv_err);
985  PVValHelper::fillByIndex(h_norm_dz_modZ_, module_num - 1, dzFromMyVertex / dz_err);
986 
987  PVValHelper::fillByIndex(h_dxy_ladder_, ladder_num - 1, dxyFromMyVertex * cmToum);
988 
989  LogDebug("PrimaryVertexValidation") << "h_dxy_ladder size:" << h_dxy_ladder_.size() << std::endl;
990 
991  if (L1BPixHitCount == 1) {
992  PVValHelper::fillByIndex(h_dxy_ladderNoOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
993  } else {
994  PVValHelper::fillByIndex(h_dxy_ladderOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
995  }
996 
997  PVValHelper::fillByIndex(h_dz_ladder_, ladder_num - 1, dzFromMyVertex * cmToum);
998  PVValHelper::fillByIndex(h_norm_dxy_ladder_, ladder_num - 1, dxyFromMyVertex / s_ip2dpv_err);
999  PVValHelper::fillByIndex(h_norm_dz_ladder_, ladder_num - 1, dzFromMyVertex / dz_err);
1000 
1001  h2_probePassingLayer1Map_->Fill(module_num, ladder_num);
1002  }
1003 
1004  // filling the binned distributions
1005  for (int i = 0; i < nBins_; i++) {
1006  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1007  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
1008 
1009  float etaF = theDetails_.trendbins[PVValHelper::eta][i];
1010  float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
1011 
1012  if (tracketa >= etaF && tracketa < etaL) {
1013  PVValHelper::fillByIndex(a_dxyEtaResiduals, i, dxyFromMyVertex * cmToum, "1");
1014  PVValHelper::fillByIndex(a_dxEtaResiduals, i, my_dx * cmToum, "2");
1015  PVValHelper::fillByIndex(a_dyEtaResiduals, i, my_dy * cmToum, "3");
1016  PVValHelper::fillByIndex(a_dzEtaResiduals, i, dzFromMyVertex * cmToum, "4");
1017  PVValHelper::fillByIndex(n_dxyEtaResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "5");
1018  PVValHelper::fillByIndex(n_dzEtaResiduals, i, dzFromMyVertex / dz_err, "6");
1019  PVValHelper::fillByIndex(a_IP2DEtaResiduals, i, s_ip2dpv_corr * cmToum, "7");
1020  PVValHelper::fillByIndex(n_IP2DEtaResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "8");
1021  PVValHelper::fillByIndex(a_reszEtaResiduals, i, restrkz * cmToum, "9");
1022  PVValHelper::fillByIndex(n_reszEtaResiduals, i, pulltrkz, "10");
1023  PVValHelper::fillByIndex(a_d3DEtaResiduals, i, ip3d_corr * cmToum, "11");
1024  PVValHelper::fillByIndex(n_d3DEtaResiduals, i, ip3d_corr / ip3d_err, "12");
1025  PVValHelper::fillByIndex(a_IP3DEtaResiduals, i, s_ip3dpv_corr * cmToum, "13");
1026  PVValHelper::fillByIndex(n_IP3DEtaResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "14");
1027  }
1028 
1029  if (trackphi >= phiF && trackphi < phiL) {
1030  PVValHelper::fillByIndex(a_dxyPhiResiduals, i, dxyFromMyVertex * cmToum, "15");
1031  PVValHelper::fillByIndex(a_dxPhiResiduals, i, my_dx * cmToum, "16");
1032  PVValHelper::fillByIndex(a_dyPhiResiduals, i, my_dy * cmToum, "17");
1033  PVValHelper::fillByIndex(a_dzPhiResiduals, i, dzFromMyVertex * cmToum, "18");
1034  PVValHelper::fillByIndex(n_dxyPhiResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "19");
1035  PVValHelper::fillByIndex(n_dzPhiResiduals, i, dzFromMyVertex / dz_err, "20");
1036  PVValHelper::fillByIndex(a_IP2DPhiResiduals, i, s_ip2dpv_corr * cmToum, "21");
1037  PVValHelper::fillByIndex(n_IP2DPhiResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "22");
1038  PVValHelper::fillByIndex(a_reszPhiResiduals, i, restrkz * cmToum, "23");
1039  PVValHelper::fillByIndex(n_reszPhiResiduals, i, pulltrkz, "24");
1040  PVValHelper::fillByIndex(a_d3DPhiResiduals, i, ip3d_corr * cmToum, "25");
1041  PVValHelper::fillByIndex(n_d3DPhiResiduals, i, ip3d_corr / ip3d_err, "26");
1042  PVValHelper::fillByIndex(a_IP3DPhiResiduals, i, s_ip3dpv_corr * cmToum, "27");
1043  PVValHelper::fillByIndex(n_IP3DPhiResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "28");
1044 
1045  for (int j = 0; j < nBins_; j++) {
1046  float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
1047  float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
1048 
1049  if (tracketa >= etaJ && tracketa < etaK) {
1050  a_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex * cmToum);
1051  a_dzResidualsMap[i][j]->Fill(dzFromMyVertex * cmToum);
1052  n_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex / s_ip2dpv_err);
1053  n_dzResidualsMap[i][j]->Fill(dzFromMyVertex / dz_err);
1054  a_d3DResidualsMap[i][j]->Fill(ip3d_corr * cmToum);
1055  n_d3DResidualsMap[i][j]->Fill(ip3d_corr / ip3d_err);
1056  }
1057  }
1058  }
1059  }
1060  }
1061 
1062  if (debug_) {
1063  edm::LogInfo("PrimaryVertexValidation")
1064  << " myVertex.x()= " << myVertex.x() << "\n"
1065  << " myVertex.y()= " << myVertex.y() << " \n"
1066  << " myVertex.z()= " << myVertex.z() << " \n"
1067  << " theTrack.dz(myVertex)= " << theTrack.dz(myVertex) << " \n"
1068  << " zPCA -myVertex.z() = " << (theTrack.vertex().z() - myVertex.z());
1069 
1070  } // ends if debug_
1071  } // ends if the fitted vertex is Valid
1072 
1073  //delete theFitter;
1074 
1075  } catch (cms::Exception& er) {
1076  LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
1077  }
1078 
1079  } //ends if theFinalTracks.size() > 2
1080 
1081  else {
1082  if (debug_)
1083  edm::LogInfo("PrimaryVertexValidation") << "Not enough tracks to make a vertex. Returns no vertex info";
1084  }
1085 
1086  ++nTracks_;
1087  ++nTracksPerClus_;
1088 
1089  if (debug_)
1090  edm::LogInfo("PrimaryVertexValidation") << "Track " << i << " : pT = " << theTrack.pt();
1091 
1092  } // for loop on tracks
1093  } // for loop on track clusters
1094 
1095  // Fill the TTree if needed
1096 
1097  if (storeNtuple_) {
1098  rootTree_->Fill();
1099  }
1100 }
1101 
1102 // ------------ method called to discriminate 1D from 2D hits ------------
1103 bool PrimaryVertexValidation::isHit2D(const TrackingRecHit& hit) const {
1104  if (hit.dimension() < 2) {
1105  return false; // some (muon...) stuff really has RecHit1D
1106  } else {
1107  const DetId detId(hit.geographicalId());
1108  if (detId.det() == DetId::Tracker) {
1109  if (detId.subdetId() == PixelSubdetector::PixelBarrel || detId.subdetId() == PixelSubdetector::PixelEndcap) {
1110  return true; // pixel is always 2D
1111  } else { // should be SiStrip now
1112  if (dynamic_cast<const SiStripRecHit2D*>(&hit))
1113  return false; // normal hit
1114  else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit))
1115  return true; // matched is 2D
1116  else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit))
1117  return false; // crazy hit...
1118  else {
1119  edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
1120  << "Tracker hit not in pixel and neither SiStripRecHit2D nor "
1121  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1122  return false;
1123  }
1124  }
1125  } else { // not tracker??
1126  edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
1127  << "Hit not in tracker with 'official' dimension >=2.";
1128  return true; // dimension() >= 2 so accept that...
1129  }
1130  }
1131  // never reached...
1132 }
1133 
1134 // ------------ method to check the presence of pixel hits ------------
1135 std::pair<bool, bool> PrimaryVertexValidation::pixelHitsCheck(const reco::TransientTrack& track) {
1136  bool hasBPixHits = false;
1137  bool hasFPixHits = false;
1138 
1139  const reco::HitPattern& p = track.hitPattern();
1140  if (p.numberOfValidPixelEndcapHits() != 0) {
1141  hasFPixHits = true;
1142  }
1143  if (p.numberOfValidPixelBarrelHits() != 0) {
1144  hasBPixHits = true;
1145  }
1146 
1147  return std::make_pair(hasBPixHits, hasFPixHits);
1148 }
1149 
1150 // ------------ method to check the presence of pixel hits ------------
1151 bool PrimaryVertexValidation::hasFirstLayerPixelHits(const reco::TransientTrack& track) {
1152  using namespace reco;
1153  const HitPattern& p = track.hitPattern();
1154  for (int i = 0; i < p.numberOfAllHits(HitPattern::TRACK_HITS); i++) {
1155  uint32_t pattern = p.getHitPattern(HitPattern::TRACK_HITS, i);
1156  if (p.pixelBarrelHitFilter(pattern) || p.pixelEndcapHitFilter(pattern)) {
1157  if (p.getLayer(pattern) == 1) {
1158  if (p.validHitFilter(pattern)) {
1159  return true;
1160  }
1161  }
1162  }
1163  }
1164  return false;
1165 }
1166 
1167 // ------------ method called once each job before begining the event loop ------------
1168 void PrimaryVertexValidation::beginJob() {
1169  edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
1170  << "Begin Job \n"
1171  << "######################################";
1172 
1173  // Define TTree for output
1174  Nevt_ = 0;
1175 
1176  // rootFile_ = new TFile(filename_.c_str(),"recreate");
1177  rootTree_ = fs->make<TTree>("tree", "PV Validation tree");
1178 
1179  // Track Paramters
1180 
1181  if (lightNtupleSwitch_) {
1182  rootTree_->Branch("EventNumber", &EventNumber_, "EventNumber/i");
1183  rootTree_->Branch("RunNumber", &RunNumber_, "RunNumber/i");
1184  rootTree_->Branch("LuminosityBlockNumber", &LuminosityBlockNumber_, "LuminosityBlockNumber/i");
1185  rootTree_->Branch("nOfflineVertices", &nOfflineVertices_, "nOfflineVertices/I");
1186  rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
1187  rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
1188  rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
1189  rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
1190  rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
1191  rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
1192  rootTree_->Branch("d3DFromMyVertex", &d3DFromMyVertex_, "d3DFromMyVertex[nTracks]/D");
1193  rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
1194  rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
1195  rootTree_->Branch("IP3DsigFromMyVertex", &IP3DsigFromMyVertex_, "IP3DsigFromMyVertex_[nTracks]/D");
1196  rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
1197  rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
1198  rootTree_->Branch("isHighPurity", &isHighPurity_, "isHighPurity_[nTracks]/I");
1199 
1200  } else {
1201  rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
1202  rootTree_->Branch("nTracksPerClus", &nTracksPerClus_, "nTracksPerClus/I");
1203  rootTree_->Branch("nClus", &nClus_, "nClus/I");
1204  rootTree_->Branch("xOfflineVertex", &xOfflineVertex_, "xOfflineVertex/D");
1205  rootTree_->Branch("yOfflineVertex", &yOfflineVertex_, "yOfflineVertex/D");
1206  rootTree_->Branch("zOfflineVertex", &zOfflineVertex_, "zOfflineVertex/D");
1207  rootTree_->Branch("BSx0", &BSx0_, "BSx0/D");
1208  rootTree_->Branch("BSy0", &BSy0_, "BSy0/D");
1209  rootTree_->Branch("BSz0", &BSz0_, "BSz0/D");
1210  rootTree_->Branch("Beamsigmaz", &Beamsigmaz_, "Beamsigmaz/D");
1211  rootTree_->Branch("Beamdxdz", &Beamdxdz_, "Beamdxdz/D");
1212  rootTree_->Branch("BeamWidthX", &BeamWidthX_, "BeamWidthX/D");
1213  rootTree_->Branch("BeamWidthY", &BeamWidthY_, "BeamWidthY/D");
1214  rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
1215  rootTree_->Branch("p", &p_, "p[nTracks]/D");
1216  rootTree_->Branch("nhits", &nhits_, "nhits[nTracks]/I");
1217  rootTree_->Branch("nhits1D", &nhits1D_, "nhits1D[nTracks]/I");
1218  rootTree_->Branch("nhits2D", &nhits2D_, "nhits2D[nTracks]/I");
1219  rootTree_->Branch("nhitsBPIX", &nhitsBPIX_, "nhitsBPIX[nTracks]/I");
1220  rootTree_->Branch("nhitsFPIX", &nhitsFPIX_, "nhitsFPIX[nTracks]/I");
1221  rootTree_->Branch("nhitsTIB", &nhitsTIB_, "nhitsTIB[nTracks]/I");
1222  rootTree_->Branch("nhitsTID", &nhitsTID_, "nhitsTID[nTracks]/I");
1223  rootTree_->Branch("nhitsTOB", &nhitsTOB_, "nhitsTOB[nTracks]/I");
1224  rootTree_->Branch("nhitsTEC", &nhitsTEC_, "nhitsTEC[nTracks]/I");
1225  rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
1226  rootTree_->Branch("theta", &theta_, "theta[nTracks]/D");
1227  rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
1228  rootTree_->Branch("chi2", &chi2_, "chi2[nTracks]/D");
1229  rootTree_->Branch("chi2ndof", &chi2ndof_, "chi2ndof[nTracks]/D");
1230  rootTree_->Branch("charge", &charge_, "charge[nTracks]/I");
1231  rootTree_->Branch("qoverp", &qoverp_, "qoverp[nTracks]/D");
1232  rootTree_->Branch("dz", &dz_, "dz[nTracks]/D");
1233  rootTree_->Branch("dxy", &dxy_, "dxy[nTracks]/D");
1234  rootTree_->Branch("dzBs", &dzBs_, "dzBs[nTracks]/D");
1235  rootTree_->Branch("dxyBs", &dxyBs_, "dxyBs[nTracks]/D");
1236  rootTree_->Branch("xPCA", &xPCA_, "xPCA[nTracks]/D");
1237  rootTree_->Branch("yPCA", &yPCA_, "yPCA[nTracks]/D");
1238  rootTree_->Branch("zPCA", &zPCA_, "zPCA[nTracks]/D");
1239  rootTree_->Branch("xUnbiasedVertex", &xUnbiasedVertex_, "xUnbiasedVertex[nTracks]/D");
1240  rootTree_->Branch("yUnbiasedVertex", &yUnbiasedVertex_, "yUnbiasedVertex[nTracks]/D");
1241  rootTree_->Branch("zUnbiasedVertex", &zUnbiasedVertex_, "zUnbiasedVertex[nTracks]/D");
1242  rootTree_->Branch("chi2normUnbiasedVertex", &chi2normUnbiasedVertex_, "chi2normUnbiasedVertex[nTracks]/F");
1243  rootTree_->Branch("chi2UnbiasedVertex", &chi2UnbiasedVertex_, "chi2UnbiasedVertex[nTracks]/F");
1244  rootTree_->Branch("DOFUnbiasedVertex", &DOFUnbiasedVertex_, " DOFUnbiasedVertex[nTracks]/F");
1245  rootTree_->Branch("chi2ProbUnbiasedVertex", &chi2ProbUnbiasedVertex_, "chi2ProbUnbiasedVertex[nTracks]/F");
1246  rootTree_->Branch(
1247  "sumOfWeightsUnbiasedVertex", &sumOfWeightsUnbiasedVertex_, "sumOfWeightsUnbiasedVertex[nTracks]/F");
1248  rootTree_->Branch("tracksUsedForVertexing", &tracksUsedForVertexing_, "tracksUsedForVertexing[nTracks]/I");
1249  rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
1250  rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
1251  rootTree_->Branch("dxyErrorFromMyVertex", &dxyErrorFromMyVertex_, "dxyErrorFromMyVertex_[nTracks]/D");
1252  rootTree_->Branch("dzErrorFromMyVertex", &dzErrorFromMyVertex_, "dzErrorFromMyVertex_[nTracks]/D");
1253  rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
1254  rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
1255  rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
1256  rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
1257  }
1258 
1259  // event histograms
1260  TFileDirectory EventFeatures = fs->mkdir("EventFeatures");
1261 
1262  TH1F::SetDefaultSumw2(kTRUE);
1263 
1264  h_lumiFromConfig =
1265  EventFeatures.make<TH1F>("h_lumiFromConfig", "luminosity from config;;luminosity of present run", 1, -0.5, 0.5);
1266  h_lumiFromConfig->SetBinContent(1, intLumi_);
1267 
1268  h_runFromConfig = EventFeatures.make<TH1I>("h_runFromConfig",
1269  "run number from config;;run number (from configuration)",
1270  runControlNumbers_.size(),
1271  0.,
1272  runControlNumbers_.size());
1273  for (const auto r : runControlNumbers_) {
1274  h_runFromConfig->SetBinContent(r + 1, r);
1275  }
1276 
1277  h_runFromEvent =
1278  EventFeatures.make<TH1I>("h_runFromEvent", "run number from config;;run number (from event)", 1, -0.5, 0.5);
1279  h_nTracks =
1280  EventFeatures.make<TH1F>("h_nTracks", "number of tracks per event;n_{tracks}/event;n_{events}", 300, -0.5, 299.5);
1281  h_nClus =
1282  EventFeatures.make<TH1F>("h_nClus", "number of track clusters;n_{clusters}/event;n_{events}", 50, -0.5, 49.5);
1283  h_nOfflineVertices = EventFeatures.make<TH1F>(
1284  "h_nOfflineVertices", "number of offline reconstructed vertices;n_{vertices}/event;n_{events}", 50, -0.5, 49.5);
1285  h_runNumber = EventFeatures.make<TH1F>("h_runNumber", "run number;run number;n_{events}", 100000, 250000., 350000.);
1286  h_xOfflineVertex = EventFeatures.make<TH1F>(
1287  "h_xOfflineVertex", "x-coordinate of offline vertex;x_{vertex};n_{events}", 100, -0.1, 0.1);
1288  h_yOfflineVertex = EventFeatures.make<TH1F>(
1289  "h_yOfflineVertex", "y-coordinate of offline vertex;y_{vertex};n_{events}", 100, -0.1, 0.1);
1290  h_zOfflineVertex = EventFeatures.make<TH1F>(
1291  "h_zOfflineVertex", "z-coordinate of offline vertex;z_{vertex};n_{events}", 100, -30., 30.);
1292  h_xErrOfflineVertex = EventFeatures.make<TH1F>(
1293  "h_xErrOfflineVertex", "x-coordinate error of offline vertex;err_{x}^{vtx};n_{events}", 100, 0., 0.01);
1294  h_yErrOfflineVertex = EventFeatures.make<TH1F>(
1295  "h_yErrOfflineVertex", "y-coordinate error of offline vertex;err_{y}^{vtx};n_{events}", 100, 0., 0.01);
1296  h_zErrOfflineVertex = EventFeatures.make<TH1F>(
1297  "h_zErrOfflineVertex", "z-coordinate error of offline vertex;err_{z}^{vtx};n_{events}", 100, 0., 10.);
1298  h_BSx0 = EventFeatures.make<TH1F>("h_BSx0", "x-coordinate of reco beamspot;x^{BS}_{0};n_{events}", 100, -0.1, 0.1);
1299  h_BSy0 = EventFeatures.make<TH1F>("h_BSy0", "y-coordinate of reco beamspot;y^{BS}_{0};n_{events}", 100, -0.1, 0.1);
1300  h_BSz0 = EventFeatures.make<TH1F>("h_BSz0", "z-coordinate of reco beamspot;z^{BS}_{0};n_{events}", 100, -1., 1.);
1301  h_Beamsigmaz =
1302  EventFeatures.make<TH1F>("h_Beamsigmaz", "z-coordinate beam width;#sigma_{Z}^{beam};n_{events}", 100, 0., 1.);
1303  h_BeamWidthX =
1304  EventFeatures.make<TH1F>("h_BeamWidthX", "x-coordinate beam width;#sigma_{X}^{beam};n_{events}", 100, 0., 0.01);
1305  h_BeamWidthY =
1306  EventFeatures.make<TH1F>("h_BeamWidthY", "y-coordinate beam width;#sigma_{Y}^{beam};n_{events}", 100, 0., 0.01);
1307 
1308  h_etaMax = EventFeatures.make<TH1F>("etaMax", "etaMax", 1, -0.5, 0.5);
1309  h_pTinfo = EventFeatures.make<TH1F>("pTinfo", "pTinfo", 3, -1.5, 1.5);
1310  h_pTinfo->GetXaxis()->SetBinLabel(1, "n. bins");
1311  h_pTinfo->GetXaxis()->SetBinLabel(2, "pT min");
1312  h_pTinfo->GetXaxis()->SetBinLabel(3, "pT max");
1313 
1314  h_nbins = EventFeatures.make<TH1F>("nbins", "nbins", 1, -0.5, 0.5);
1315  h_nLadders = EventFeatures.make<TH1F>("nladders", "n. ladders", 1, -0.5, 0.5);
1316 
1317  // probe track histograms
1318  TFileDirectory ProbeFeatures = fs->mkdir("ProbeTrackFeatures");
1319 
1320  h_probePt_ = ProbeFeatures.make<TH1F>("h_probePt", "p_{T} of probe track;track p_{T} (GeV); tracks", 100, 0., 50.);
1321  h_probePtRebin_ = ProbeFeatures.make<TH1F>(
1322  "h_probePtRebin", "p_{T} of probe track;track p_{T} (GeV); tracks", mypT_bins_.size() - 1, mypT_bins_.data());
1323  h_probeP_ = ProbeFeatures.make<TH1F>("h_probeP", "momentum of probe track;track p (GeV); tracks", 100, 0., 100.);
1324  h_probeEta_ = ProbeFeatures.make<TH1F>("h_probeEta", "#eta of the probe track;track #eta;tracks", 54, -2.8, 2.8);
1325  h_probePhi_ = ProbeFeatures.make<TH1F>("h_probePhi", "#phi of probe track;track #phi (rad);tracks", 100, -3.15, 3.15);
1326 
1327  h2_probeEtaPhi_ =
1328  ProbeFeatures.make<TH2F>("h2_probeEtaPhi",
1329  "probe track #phi vs #eta;#eta of probe track;track #phi of probe track (rad); tracks",
1330  54,
1331  -2.8,
1332  2.8,
1333  100,
1334  -3.15,
1335  3.15);
1336  h2_probeEtaPt_ = ProbeFeatures.make<TH2F>("h2_probeEtaPt",
1337  "probe track p_{T} vs #eta;#eta of probe track;track p_{T} (GeV); tracks",
1338  54,
1339  -2.8,
1340  2.8,
1341  100,
1342  0.,
1343  50.);
1344 
1345  h_probeChi2_ =
1346  ProbeFeatures.make<TH1F>("h_probeChi2", "#chi^{2} of probe track;track #chi^{2}; tracks", 100, 0., 100.);
1347  h_probeNormChi2_ = ProbeFeatures.make<TH1F>(
1348  "h_probeNormChi2", " normalized #chi^{2} of probe track;track #chi^{2}/ndof; tracks", 100, 0., 10.);
1349  h_probeCharge_ =
1350  ProbeFeatures.make<TH1F>("h_probeCharge", "charge of probe track;track charge Q;tracks", 3, -1.5, 1.5);
1351  h_probeQoverP_ =
1352  ProbeFeatures.make<TH1F>("h_probeQoverP", "q/p of probe track; track Q/p (GeV^{-1});tracks", 200, -1., 1.);
1353  h_probedzRecoV_ = ProbeFeatures.make<TH1F>(
1354  "h_probedzRecoV", "d_{z}(V_{offline}) of probe track;track d_{z}(V_{off}) (cm);tracks", 200, -1., 1.);
1355  h_probedxyRecoV_ = ProbeFeatures.make<TH1F>(
1356  "h_probedxyRecoV", "d_{xy}(V_{offline}) of probe track;track d_{xy}(V_{off}) (cm);tracks", 200, -1., 1.);
1357  h_probedzRefitV_ = ProbeFeatures.make<TH1F>(
1358  "h_probedzRefitV", "d_{z}(V_{refit}) of probe track;track d_{z}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
1359  h_probesignIP2DRefitV_ = ProbeFeatures.make<TH1F>(
1360  "h_probesignIPRefitV", "ip_{2D}(V_{refit}) of probe track;track ip_{2D}(V_{fit}) (cm);tracks", 200, -1., 1.);
1361  h_probedxyRefitV_ = ProbeFeatures.make<TH1F>(
1362  "h_probedxyRefitV", "d_{xy}(V_{refit}) of probe track;track d_{xy}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
1363 
1364  h_probez0RefitV_ = ProbeFeatures.make<TH1F>(
1365  "h_probez0RefitV", "z_{0}(V_{refit}) of probe track;track z_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
1366  h_probed0RefitV_ = ProbeFeatures.make<TH1F>(
1367  "h_probed0RefitV", "d_{0}(V_{refit}) of probe track;track d_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
1368 
1369  h_probed3DRefitV_ = ProbeFeatures.make<TH1F>(
1370  "h_probed3DRefitV", "d_{3D}(V_{refit}) of probe track;track d_{3D}(V_{fit}) (cm);tracks", 200, 0., 1.);
1371  h_probereszRefitV_ = ProbeFeatures.make<TH1F>(
1372  "h_probeReszRefitV", "z_{track} -z_{V_{refit}};track res_{z}(V_{refit}) (cm);tracks", 200, -1., 1.);
1373 
1374  h_probeRecoVSigZ_ = ProbeFeatures.make<TH1F>(
1375  "h_probeRecoVSigZ", "Longitudinal DCA Significance (reco);d_{z}(V_{off})/#sigma_{dz};tracks", 100, -8, 8);
1376  h_probeRecoVSigXY_ = ProbeFeatures.make<TH1F>(
1377  "h_probeRecoVSigXY", "Transverse DCA Significance (reco);d_{xy}(V_{off})/#sigma_{dxy};tracks", 100, -8, 8);
1378  h_probeRefitVSigZ_ = ProbeFeatures.make<TH1F>(
1379  "h_probeRefitVSigZ", "Longitudinal DCA Significance (refit);d_{z}(V_{fit})/#sigma_{dz};tracks", 100, -8, 8);
1380  h_probeRefitVSigXY_ = ProbeFeatures.make<TH1F>(
1381  "h_probeRefitVSigXY", "Transverse DCA Significance (refit);d_{xy}(V_{fit})/#sigma_{dxy};tracks", 100, -8, 8);
1382  h_probeRefitVSig3D_ = ProbeFeatures.make<TH1F>(
1383  "h_probeRefitVSig3D", "3D DCA Significance (refit);d_{3D}/#sigma_{3D};tracks", 100, 0., 20.);
1384  h_probeRefitVLogSig3D_ =
1385  ProbeFeatures.make<TH1F>("h_probeRefitVLogSig3D",
1386  "log_{10}(3D DCA-Significance) (refit);log_{10}(d_{3D}/#sigma_{3D});tracks",
1387  100,
1388  -5.,
1389  4.);
1390  h_probeRefitVSigResZ_ = ProbeFeatures.make<TH1F>(
1391  "h_probeRefitVSigResZ",
1392  "Longitudinal residual significance (refit);(z_{track} -z_{V_{fit}})/#sigma_{res_{z}};tracks",
1393  100,
1394  -8,
1395  8);
1396 
1397  h_probeHits_ = ProbeFeatures.make<TH1F>("h_probeNRechits", "N_{hits} ;N_{hits} ;tracks", 40, -0.5, 39.5);
1398  h_probeHits1D_ = ProbeFeatures.make<TH1F>("h_probeNRechits1D", "N_{hits} 1D ;N_{hits} 1D ;tracks", 40, -0.5, 39.5);
1399  h_probeHits2D_ = ProbeFeatures.make<TH1F>("h_probeNRechits2D", "N_{hits} 2D ;N_{hits} 2D ;tracks", 40, -0.5, 39.5);
1400  h_probeHitsInTIB_ =
1401  ProbeFeatures.make<TH1F>("h_probeNRechitsTIB", "N_{hits} TIB ;N_{hits} TIB;tracks", 40, -0.5, 39.5);
1402  h_probeHitsInTOB_ =
1403  ProbeFeatures.make<TH1F>("h_probeNRechitsTOB", "N_{hits} TOB ;N_{hits} TOB;tracks", 40, -0.5, 39.5);
1404  h_probeHitsInTID_ =
1405  ProbeFeatures.make<TH1F>("h_probeNRechitsTID", "N_{hits} TID ;N_{hits} TID;tracks", 40, -0.5, 39.5);
1406  h_probeHitsInTEC_ =
1407  ProbeFeatures.make<TH1F>("h_probeNRechitsTEC", "N_{hits} TEC ;N_{hits} TEC;tracks", 40, -0.5, 39.5);
1408  h_probeHitsInBPIX_ =
1409  ProbeFeatures.make<TH1F>("h_probeNRechitsBPIX", "N_{hits} BPIX;N_{hits} BPIX;tracks", 40, -0.5, 39.5);
1410  h_probeHitsInFPIX_ =
1411  ProbeFeatures.make<TH1F>("h_probeNRechitsFPIX", "N_{hits} FPIX;N_{hits} FPIX;tracks", 40, -0.5, 39.5);
1412 
1413  h_probeL1Ladder_ =
1414  ProbeFeatures.make<TH1F>("h_probeL1Ladder", "Ladder number (L1 hit); ladder number", 22, -1.5, 20.5);
1415  h_probeL1Module_ =
1416  ProbeFeatures.make<TH1F>("h_probeL1Module", "Module number (L1 hit); module number", 10, -1.5, 8.5);
1417 
1418  h2_probeLayer1Map_ = ProbeFeatures.make<TH2F>(
1419  "h2_probeLayer1Map", "Position in Layer 1 of first hit;module number;ladder number", 8, 0.5, 8.5, 12, 0.5, 12.5);
1420  h2_probePassingLayer1Map_ = ProbeFeatures.make<TH2F>("h2_probePassingLayer1Map",
1421  "Position in Layer 1 of first hit;module number;ladder number",
1422  8,
1423  0.5,
1424  8.5,
1425  12,
1426  0.5,
1427  12.5);
1428  h_probeHasBPixL1Overlap_ =
1429  ProbeFeatures.make<TH1I>("h_probeHasBPixL1Overlap", "n. hits in L1;n. L1-BPix hits;tracks", 5, -0.5, 4.5);
1430  h_probeL1ClusterProb_ = ProbeFeatures.make<TH1F>(
1431  "h_probeL1ClusterProb",
1432  "log_{10}(Cluster Probability) for Layer1 hits;log_{10}(cluster probability); n. Layer1 hits",
1433  100,
1434  -10.,
1435  0.);
1436 
1437  // refit vertex features
1438  TFileDirectory RefitVertexFeatures = fs->mkdir("RefitVertexFeatures");
1439  h_fitVtxNtracks_ = RefitVertexFeatures.make<TH1F>(
1440  "h_fitVtxNtracks", "N_{trks} used in vertex fit;N^{fit}_{tracks};vertices", 100, -0.5, 99.5);
1441  h_fitVtxNdof_ = RefitVertexFeatures.make<TH1F>(
1442  "h_fitVtxNdof", "N_{DOF} of vertex fit;N_{DOF} of refit vertex;vertices", 100, -0.5, 99.5);
1443  h_fitVtxChi2_ = RefitVertexFeatures.make<TH1F>(
1444  "h_fitVtxChi2", "#chi^{2} of vertex fit;vertex #chi^{2};vertices", 100, -0.5, 99.5);
1445  h_fitVtxChi2ndf_ = RefitVertexFeatures.make<TH1F>(
1446  "h_fitVtxChi2ndf", "#chi^{2}/ndf of vertex fit;vertex #chi^{2}/ndf;vertices", 100, -0.5, 9.5);
1447  h_fitVtxChi2Prob_ = RefitVertexFeatures.make<TH1F>(
1448  "h_fitVtxChi2Prob", "Prob(#chi^{2},ndf) of vertex fit;Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
1449  h_fitVtxTrackWeights_ = RefitVertexFeatures.make<TH1F>(
1450  "h_fitVtxTrackWeights", "track weights associated to track;track weights;tracks", 40, 0., 1.);
1451  h_fitVtxTrackAverageWeight_ = RefitVertexFeatures.make<TH1F>(
1452  "h_fitVtxTrackAverageWeight_", "average track weight per vertex;#LT track weight #GT;vertices", 40, 0., 1.);
1453 
1454  if (useTracksFromRecoVtx_) {
1455  TFileDirectory RecoVertexFeatures = fs->mkdir("RecoVertexFeatures");
1456  h_recoVtxNtracks_ =
1457  RecoVertexFeatures.make<TH1F>("h_recoVtxNtracks", "N^{vtx}_{trks};N^{vtx}_{trks};vertices", 100, -0.5, 99.5);
1458  h_recoVtxChi2ndf_ =
1459  RecoVertexFeatures.make<TH1F>("h_recoVtxChi2ndf", "#chi^{2}/ndf vtx;#chi^{2}/ndf vtx;vertices", 10, -0.5, 9.5);
1460  h_recoVtxChi2Prob_ = RecoVertexFeatures.make<TH1F>(
1461  "h_recoVtxChi2Prob", "Prob(#chi^{2},ndf);Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
1462  h_recoVtxSumPt_ =
1463  RecoVertexFeatures.make<TH1F>("h_recoVtxSumPt", "Sum(p^{trks}_{T});Sum(p^{trks}_{T});vertices", 100, 0., 200.);
1464  }
1465 
1466  TFileDirectory DA = fs->mkdir("DA");
1467  //DA.cd();
1468  hDA = bookVertexHistograms(DA);
1469  //for(std::map<std::string,TH1*>::const_iterator hist=hDA.begin(); hist!=hDA.end(); hist++){
1470  //hist->second->SetDirectory(DA);
1471  // DA.make<TH1F>(hist->second);
1472  // }
1473 
1474  // initialize the residuals histograms
1475 
1476  const float dxymax_phi = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
1477  const float dzmax_phi = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
1478  const float dxymax_eta = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
1479  const float dzmax_eta = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
1480  //const float d3Dmax_phi = theDetails_.getHigh(PVValHelper::d3D,PVValHelper::phi);
1481  const float d3Dmax_eta = theDetails_.getHigh(PVValHelper::d3D, PVValHelper::eta);
1482 
1484  //
1485  // Unbiased track-to-vertex residuals
1486  // The vertex is refit without the probe track
1487  //
1489 
1490  // _ _ _ _ ___ _ _ _
1491  // /_\ | |__ ___ ___| |_ _| |_ ___ | _ \___ __(_)__| |_ _ __ _| |___
1492  // / _ \| '_ (_-</ _ \ | || | _/ -_) | / -_|_-< / _` | || / _` | (_-<
1493  // /_/ \_\_.__/__/\___/_|\_,_|\__\___| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1494  //
1495 
1496  TFileDirectory AbsTransPhiRes = fs->mkdir("Abs_Transv_Phi_Residuals");
1497  a_dxyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
1498  a_dxPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dx, PVValHelper::phi);
1499  a_dyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dy, PVValHelper::phi);
1500  a_IP2DPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::IP2D, PVValHelper::phi);
1501 
1502  TFileDirectory AbsTransEtaRes = fs->mkdir("Abs_Transv_Eta_Residuals");
1503  a_dxyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
1504  a_dxEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dx, PVValHelper::eta);
1505  a_dyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dy, PVValHelper::eta);
1506  a_IP2DEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::IP2D, PVValHelper::eta);
1507 
1508  TFileDirectory AbsLongPhiRes = fs->mkdir("Abs_Long_Phi_Residuals");
1509  a_dzPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::dz, PVValHelper::phi);
1510  a_reszPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::resz, PVValHelper::phi);
1511 
1512  TFileDirectory AbsLongEtaRes = fs->mkdir("Abs_Long_Eta_Residuals");
1513  a_dzEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::dz, PVValHelper::eta);
1514  a_reszEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::resz, PVValHelper::eta);
1515 
1516  TFileDirectory Abs3DPhiRes = fs->mkdir("Abs_3D_Phi_Residuals");
1517  a_d3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::d3D, PVValHelper::phi);
1518  a_IP3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::IP3D, PVValHelper::phi);
1519 
1520  TFileDirectory Abs3DEtaRes = fs->mkdir("Abs_3D_Eta_Residuals");
1521  a_d3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::d3D, PVValHelper::eta);
1522  a_IP3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::IP3D, PVValHelper::eta);
1523 
1524  TFileDirectory NormTransPhiRes = fs->mkdir("Norm_Transv_Phi_Residuals");
1525  n_dxyPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_dxy, PVValHelper::phi, true);
1526  n_IP2DPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::phi, true);
1527 
1528  TFileDirectory NormTransEtaRes = fs->mkdir("Norm_Transv_Eta_Residuals");
1529  n_dxyEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_dxy, PVValHelper::eta, true);
1530  n_IP2DEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::eta, true);
1531 
1532  TFileDirectory NormLongPhiRes = fs->mkdir("Norm_Long_Phi_Residuals");
1533  n_dzPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_dz, PVValHelper::phi, true);
1534  n_reszPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_resz, PVValHelper::phi, true);
1535 
1536  TFileDirectory NormLongEtaRes = fs->mkdir("Norm_Long_Eta_Residuals");
1537  n_dzEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_dz, PVValHelper::eta, true);
1538  n_reszEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_resz, PVValHelper::eta, true);
1539 
1540  TFileDirectory Norm3DPhiRes = fs->mkdir("Norm_3D_Phi_Residuals");
1541  n_d3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_d3D, PVValHelper::phi, true);
1542  n_IP3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::phi, true);
1543 
1544  TFileDirectory Norm3DEtaRes = fs->mkdir("Norm_3D_Eta_Residuals");
1545  n_d3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_d3D, PVValHelper::eta, true);
1546  n_IP3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::eta, true);
1547 
1548  TFileDirectory AbsDoubleDiffRes = fs->mkdir("Abs_DoubleDiffResiduals");
1549  TFileDirectory NormDoubleDiffRes = fs->mkdir("Norm_DoubleDiffResiduals");
1550 
1551  TFileDirectory AbsL1Map = fs->mkdir("Abs_L1Residuals");
1552  TFileDirectory NormL1Map = fs->mkdir("Norm_L1Residuals");
1553 
1554  // book residuals vs pT histograms
1555 
1556  TFileDirectory AbsTranspTRes = fs->mkdir("Abs_Transv_pT_Residuals");
1557  h_dxy_pT_ = bookResidualsHistogram(AbsTranspTRes, nPtBins_, PVValHelper::dxy, PVValHelper::pT);
1558 
1559  TFileDirectory AbsLongpTRes = fs->mkdir("Abs_Long_pT_Residuals");
1560  h_dz_pT_ = bookResidualsHistogram(AbsLongpTRes, nPtBins_, PVValHelper::dz, PVValHelper::pT);
1561 
1562  TFileDirectory NormTranspTRes = fs->mkdir("Norm_Transv_pT_Residuals");
1563  h_norm_dxy_pT_ = bookResidualsHistogram(NormTranspTRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pT, true);
1564 
1565  TFileDirectory NormLongpTRes = fs->mkdir("Norm_Long_pT_Residuals");
1566  h_norm_dz_pT_ = bookResidualsHistogram(NormLongpTRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pT, true);
1567 
1568  // book residuals vs pT histograms in central region (|eta|<1.0)
1569 
1570  TFileDirectory AbsTranspTCentralRes = fs->mkdir("Abs_Transv_pTCentral_Residuals");
1571  h_dxy_Central_pT_ = bookResidualsHistogram(AbsTranspTCentralRes, nPtBins_, PVValHelper::dxy, PVValHelper::pTCentral);
1572 
1573  TFileDirectory AbsLongpTCentralRes = fs->mkdir("Abs_Long_pTCentral_Residuals");
1574  h_dz_Central_pT_ = bookResidualsHistogram(AbsLongpTCentralRes, nPtBins_, PVValHelper::dz, PVValHelper::pTCentral);
1575 
1576  TFileDirectory NormTranspTCentralRes = fs->mkdir("Norm_Transv_pTCentral_Residuals");
1577  h_norm_dxy_Central_pT_ =
1578  bookResidualsHistogram(NormTranspTCentralRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pTCentral, true);
1579 
1580  TFileDirectory NormLongpTCentralRes = fs->mkdir("Norm_Long_pTCentral_Residuals");
1581  h_norm_dz_Central_pT_ =
1582  bookResidualsHistogram(NormLongpTCentralRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pTCentral, true);
1583 
1584  // book residuals vs module number
1585 
1586  TFileDirectory AbsTransModZRes = fs->mkdir("Abs_Transv_modZ_Residuals");
1587  h_dxy_modZ_ = bookResidualsHistogram(AbsTransModZRes, 8, PVValHelper::dxy, PVValHelper::modZ);
1588 
1589  TFileDirectory AbsLongModZRes = fs->mkdir("Abs_Long_modZ_Residuals");
1590  h_dz_modZ_ = bookResidualsHistogram(AbsLongModZRes, 8, PVValHelper::dz, PVValHelper::modZ);
1591 
1592  // _ _ _ _ _ ___ _ _ _
1593  // | \| |___ _ _ _ __ __ _| (_)______ __| | | _ \___ __(_)__| |_ _ __ _| |___
1594  // | .` / _ \ '_| ' \/ _` | | |_ / -_) _` | | / -_|_-< / _` | || / _` | (_-<
1595  // |_|\_\___/_| |_|_|_\__,_|_|_/__\___\__,_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1596  //
1597 
1598  TFileDirectory NormTransModZRes = fs->mkdir("Norm_Transv_modZ_Residuals");
1599  h_norm_dxy_modZ_ = bookResidualsHistogram(NormTransModZRes, 8, PVValHelper::norm_dxy, PVValHelper::modZ, true);
1600 
1601  TFileDirectory NormLongModZRes = fs->mkdir("Norm_Long_modZ_Residuals");
1602  h_norm_dz_modZ_ = bookResidualsHistogram(NormLongModZRes, 8, PVValHelper::norm_dz, PVValHelper::modZ, true);
1603 
1604  TFileDirectory AbsTransLadderRes = fs->mkdir("Abs_Transv_ladder_Residuals");
1605  h_dxy_ladder_ = bookResidualsHistogram(AbsTransLadderRes, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1606 
1607  TFileDirectory AbsTransLadderResOverlap = fs->mkdir("Abs_Transv_ladderOverlap_Residuals");
1608  h_dxy_ladderOverlap_ =
1609  bookResidualsHistogram(AbsTransLadderResOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1610 
1611  TFileDirectory AbsTransLadderResNoOverlap = fs->mkdir("Abs_Transv_ladderNoOverlap_Residuals");
1612  h_dxy_ladderNoOverlap_ =
1613  bookResidualsHistogram(AbsTransLadderResNoOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1614 
1615  TFileDirectory AbsLongLadderRes = fs->mkdir("Abs_Long_ladder_Residuals");
1616  h_dz_ladder_ = bookResidualsHistogram(AbsLongLadderRes, nLadders_, PVValHelper::dz, PVValHelper::ladder);
1617 
1618  TFileDirectory NormTransLadderRes = fs->mkdir("Norm_Transv_ladder_Residuals");
1619  h_norm_dxy_ladder_ =
1620  bookResidualsHistogram(NormTransLadderRes, nLadders_, PVValHelper::norm_dxy, PVValHelper::ladder, true);
1621 
1622  TFileDirectory NormLongLadderRes = fs->mkdir("Norm_Long_ladder_Residuals");
1623  h_norm_dz_ladder_ =
1624  bookResidualsHistogram(NormLongLadderRes, nLadders_, PVValHelper::norm_dz, PVValHelper::ladder, true);
1625 
1626  // book residuals as function of nLadders and nModules
1627 
1628  for (unsigned int iLadder = 0; iLadder < nLadders_; iLadder++) {
1629  for (unsigned int iModule = 0; iModule < 8; iModule++) {
1630  a_dxyL1ResidualsMap[iLadder][iModule] =
1631  AbsL1Map.make<TH1F>(Form("histo_dxy_ladder%i_module%i", iLadder, iModule),
1632  Form("d_{xy} ladder=%i module=%i;d_{xy} [#mum];tracks", iLadder, iModule),
1633  theDetails_.histobins,
1634  -dzmax_eta,
1635  dzmax_eta);
1636 
1637  a_dzL1ResidualsMap[iLadder][iModule] =
1638  AbsL1Map.make<TH1F>(Form("histo_dz_ladder%i_module%i", iLadder, iModule),
1639  Form("d_{z} ladder=%i module=%i;d_{z} [#mum];tracks", iLadder, iModule),
1640  theDetails_.histobins,
1641  -dzmax_eta,
1642  dzmax_eta);
1643 
1644  n_dxyL1ResidualsMap[iLadder][iModule] =
1645  NormL1Map.make<TH1F>(Form("histo_norm_dxy_ladder%i_module%i", iLadder, iModule),
1646  Form("d_{xy} ladder=%i module=%i;d_{xy}/#sigma_{d_{xy}};tracks", iLadder, iModule),
1647  theDetails_.histobins,
1648  -dzmax_eta / 100,
1649  dzmax_eta / 100);
1650 
1651  n_dzL1ResidualsMap[iLadder][iModule] =
1652  NormL1Map.make<TH1F>(Form("histo_norm_dz_ladder%i_module%i", iLadder, iModule),
1653  Form("d_{z} ladder=%i module=%i;d_{z}/#sigma_{d_{z}};tracks", iLadder, iModule),
1654  theDetails_.histobins,
1655  -dzmax_eta / 100,
1656  dzmax_eta / 100);
1657  }
1658  }
1659 
1660  // book residuals as function of phi and eta
1661 
1662  for (int i = 0; i < nBins_; ++i) {
1663  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1664  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
1665 
1666  // ___ _ _ ___ _ __ __ ___ _ _ _
1667  // | \ ___ _ _| |__| |___| \(_)/ _|/ _| | _ \___ __(_)__| |_ _ __ _| |___
1668  // | |) / _ \ || | '_ \ / -_) |) | | _| _| | / -_|_-< / _` | || / _` | (_-<
1669  // |___/\___/\_,_|_.__/_\___|___/|_|_| |_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1670 
1671  for (int j = 0; j < nBins_; ++j) {
1672  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
1673  float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
1674 
1675  a_dxyResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1676  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
1677  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy};tracks", etaF, etaL, phiF, phiL),
1678  theDetails_.histobins,
1679  -dzmax_eta,
1680  dzmax_eta);
1681 
1682  a_dzResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1683  Form("histo_dz_eta_plot%i_phi_plot%i", i, j),
1684  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z};tracks", etaF, etaL, phiF, phiL),
1685  theDetails_.histobins,
1686  -dzmax_eta,
1687  dzmax_eta);
1688 
1689  a_d3DResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1690  Form("histo_d3D_eta_plot%i_phi_plot%i", i, j),
1691  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D};tracks", etaF, etaL, phiF, phiL),
1692  theDetails_.histobins,
1693  0.,
1694  d3Dmax_eta);
1695 
1696  n_dxyResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1697  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
1698  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
1699  etaF,
1700  etaL,
1701  phiF,
1702  phiL),
1703  theDetails_.histobins,
1704  -dzmax_eta / 100,
1705  dzmax_eta / 100);
1706 
1707  n_dzResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1708  Form("histo_norm_dz_eta_plot%i_phi_plot%i", i, j),
1709  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
1710  etaF,
1711  etaL,
1712  phiF,
1713  phiL),
1714  theDetails_.histobins,
1715  -dzmax_eta / 100,
1716  dzmax_eta / 100);
1717 
1718  n_d3DResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1719  Form("histo_norm_d3D_eta_plot%i_phi_plot%i", i, j),
1720  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D}/#sigma_{d_{3D}};tracks",
1721  etaF,
1722  etaL,
1723  phiF,
1724  phiL),
1725  theDetails_.histobins,
1726  0.,
1727  d3Dmax_eta);
1728  }
1729  }
1730 
1731  // declaration of the directories
1732 
1733  TFileDirectory BiasVsParameter = fs->mkdir("BiasVsParameter");
1734 
1735  a_dxyVsPhi = BiasVsParameter.make<TH2F>("h2_dxy_vs_phi",
1736  "d_{xy} vs track #phi;track #phi [rad];track d_{xy}(PV) [#mum]",
1737  nBins_,
1738  -M_PI,
1739  M_PI,
1740  theDetails_.histobins,
1741  -dxymax_phi,
1742  dxymax_phi);
1743 
1744  a_dzVsPhi = BiasVsParameter.make<TH2F>("h2_dz_vs_phi",
1745  "d_{z} vs track #phi;track #phi [rad];track d_{z}(PV) [#mum]",
1746  nBins_,
1747  -M_PI,
1748  M_PI,
1749  theDetails_.histobins,
1750  -dzmax_phi,
1751  dzmax_phi);
1752 
1753  n_dxyVsPhi = BiasVsParameter.make<TH2F>(
1754  "h2_n_dxy_vs_phi",
1755  "d_{xy}/#sigma_{d_{xy}} vs track #phi;track #phi [rad];track d_{xy}(PV)/#sigma_{d_{xy}}",
1756  nBins_,
1757  -M_PI,
1758  M_PI,
1759  theDetails_.histobins,
1760  -dxymax_phi / 100.,
1761  dxymax_phi / 100.);
1762 
1763  n_dzVsPhi =
1764  BiasVsParameter.make<TH2F>("h2_n_dz_vs_phi",
1765  "d_{z}/#sigma_{d_{z}} vs track #phi;track #phi [rad];track d_{z}(PV)/#sigma_{d_{z}}",
1766  nBins_,
1767  -M_PI,
1768  M_PI,
1769  theDetails_.histobins,
1770  -dzmax_phi / 100.,
1771  dzmax_phi / 100.);
1772 
1773  a_dxyVsEta = BiasVsParameter.make<TH2F>("h2_dxy_vs_eta",
1774  "d_{xy} vs track #eta;track #eta;track d_{xy}(PV) [#mum]",
1775  nBins_,
1776  -etaOfProbe_,
1777  etaOfProbe_,
1778  theDetails_.histobins,
1779  -dxymax_eta,
1780  dzmax_eta);
1781 
1782  a_dzVsEta = BiasVsParameter.make<TH2F>("h2_dz_vs_eta",
1783  "d_{z} vs track #eta;track #eta;track d_{z}(PV) [#mum]",
1784  nBins_,
1785  -etaOfProbe_,
1786  etaOfProbe_,
1787  theDetails_.histobins,
1788  -dzmax_eta,
1789  dzmax_eta);
1790 
1791  n_dxyVsEta =
1792  BiasVsParameter.make<TH2F>("h2_n_dxy_vs_eta",
1793  "d_{xy}/#sigma_{d_{xy}} vs track #eta;track #eta;track d_{xy}(PV)/#sigma_{d_{xy}}",
1794  nBins_,
1795  -etaOfProbe_,
1796  etaOfProbe_,
1797  theDetails_.histobins,
1798  -dxymax_eta / 100.,
1799  dxymax_eta / 100.);
1800 
1801  n_dzVsEta = BiasVsParameter.make<TH2F>("h2_n_dz_vs_eta",
1802  "d_{z}/#sigma_{d_{z}} vs track #eta;track #eta;track d_{z}(PV)/#sigma_{d_{z}}",
1803  nBins_,
1804  -etaOfProbe_,
1805  etaOfProbe_,
1806  theDetails_.histobins,
1807  -dzmax_eta / 100.,
1808  dzmax_eta / 100.);
1809 
1810  MeanTrendsDir = fs->mkdir("MeanTrends");
1811  WidthTrendsDir = fs->mkdir("WidthTrends");
1812  MedianTrendsDir = fs->mkdir("MedianTrends");
1813  MADTrendsDir = fs->mkdir("MADTrends");
1814 
1815  Mean2DMapsDir = fs->mkdir("MeanMaps");
1816  Width2DMapsDir = fs->mkdir("WidthMaps");
1817 
1818  double highedge = nBins_ - 0.5;
1819  double lowedge = -0.5;
1820 
1821  // means and widths from the fit
1822 
1823  a_dxyPhiMeanTrend =
1824  MeanTrendsDir.make<TH1F>("means_dxy_phi",
1825  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
1826  nBins_,
1827  lowedge,
1828  highedge);
1829 
1830  a_dxyPhiWidthTrend =
1831  WidthTrendsDir.make<TH1F>("widths_dxy_phi",
1832  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
1833  nBins_,
1834  lowedge,
1835  highedge);
1836 
1837  a_dzPhiMeanTrend =
1838  MeanTrendsDir.make<TH1F>("means_dz_phi",
1839  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
1840  nBins_,
1841  lowedge,
1842  highedge);
1843 
1844  a_dzPhiWidthTrend =
1845  WidthTrendsDir.make<TH1F>("widths_dz_phi",
1846  "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
1847  nBins_,
1848  lowedge,
1849  highedge);
1850 
1851  a_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1852  "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
1853 
1854  a_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_eta",
1855  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
1856  nBins_,
1857  lowedge,
1858  highedge);
1859 
1860  a_dzEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1861  "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
1862 
1863  a_dzEtaWidthTrend = WidthTrendsDir.make<TH1F>(
1864  "widths_dz_eta", "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]", nBins_, lowedge, highedge);
1865 
1866  n_dxyPhiMeanTrend = MeanTrendsDir.make<TH1F>(
1867  "norm_means_dxy_phi",
1868  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1869  nBins_,
1870  lowedge,
1871  highedge);
1872 
1873  n_dxyPhiWidthTrend = WidthTrendsDir.make<TH1F>(
1874  "norm_widths_dxy_phi",
1875  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
1876  nBins_,
1877  lowedge,
1878  highedge);
1879 
1880  n_dzPhiMeanTrend = MeanTrendsDir.make<TH1F>(
1881  "norm_means_dz_phi",
1882  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
1883  nBins_,
1884  lowedge,
1885  highedge);
1886 
1887  n_dzPhiWidthTrend = WidthTrendsDir.make<TH1F>(
1888  "norm_widths_dz_phi",
1889  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
1890  nBins_,
1891  lowedge,
1892  highedge);
1893 
1894  n_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1895  "norm_means_dxy_eta",
1896  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
1897  nBins_,
1898  lowedge,
1899  highedge);
1900 
1901  n_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>(
1902  "norm_widths_dxy_eta",
1903  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
1904  nBins_,
1905  lowedge,
1906  highedge);
1907 
1908  n_dzEtaMeanTrend =
1909  MeanTrendsDir.make<TH1F>("norm_means_dz_eta",
1910  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
1911  nBins_,
1912  lowedge,
1913  highedge);
1914 
1915  n_dzEtaWidthTrend =
1916  WidthTrendsDir.make<TH1F>("norm_widths_dz_eta",
1917  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
1918  nBins_,
1919  lowedge,
1920  highedge);
1921 
1922  // means and widhts vs pT and pTCentral
1923 
1924  a_dxypTMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_pT",
1925  "#LT d_{xy} #GT vs pT;p_{T} [GeV];#LT d_{xy} #GT [#mum]",
1926  mypT_bins_.size() - 1,
1927  mypT_bins_.data());
1928 
1929  a_dxypTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_pT",
1930  "#sigma_{d_{xy}} vs pT;p_{T} [GeV];#sigma_{d_{xy}} [#mum]",
1931  mypT_bins_.size() - 1,
1932  mypT_bins_.data());
1933 
1934  a_dzpTMeanTrend = MeanTrendsDir.make<TH1F>(
1935  "means_dz_pT", "#LT d_{z} #GT vs pT;p_{T} [GeV];#LT d_{z} #GT [#mum]", mypT_bins_.size() - 1, mypT_bins_.data());
1936 
1937  a_dzpTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_pT",
1938  "#sigma_{d_{z}} vs pT;p_{T} [GeV];#sigma_{d_{z}} [#mum]",
1939  mypT_bins_.size() - 1,
1940  mypT_bins_.data());
1941 
1942  n_dxypTMeanTrend =
1943  MeanTrendsDir.make<TH1F>("norm_means_dxy_pT",
1944  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs pT;p_{T} [GeV];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1945  mypT_bins_.size() - 1,
1946  mypT_bins_.data());
1947 
1948  n_dxypTWidthTrend =
1949  WidthTrendsDir.make<TH1F>("norm_widths_dxy_pT",
1950  "width(d_{xy}/#sigma_{d_{xy}}) vs pT;p_{T} [GeV]; width(d_{xy}/#sigma_{d_{xy}})",
1951  mypT_bins_.size() - 1,
1952  mypT_bins_.data());
1953 
1954  n_dzpTMeanTrend =
1955  MeanTrendsDir.make<TH1F>("norm_means_dz_pT",
1956  "#LT d_{z}/#sigma_{d_{z}} #GT vs pT;p_{T} [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
1957  mypT_bins_.size() - 1,
1958  mypT_bins_.data());
1959 
1960  n_dzpTWidthTrend =
1961  WidthTrendsDir.make<TH1F>("norm_widths_dz_pT",
1962  "width(d_{z}/#sigma_{d_{z}}) vs pT;p_{T} [GeV];width(d_{z}/#sigma_{d_{z}})",
1963  mypT_bins_.size() - 1,
1964  mypT_bins_.data());
1965 
1966  a_dxypTCentralMeanTrend =
1967  MeanTrendsDir.make<TH1F>("means_dxy_pTCentral",
1968  "#LT d_{xy} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy} #GT [#mum]",
1969  mypT_bins_.size() - 1,
1970  mypT_bins_.data());
1971 
1972  a_dxypTCentralWidthTrend =
1973  WidthTrendsDir.make<TH1F>("widths_dxy_pTCentral",
1974  "#sigma_{d_{xy}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{xy}} [#mum]",
1975  mypT_bins_.size() - 1,
1976  mypT_bins_.data());
1977 
1978  a_dzpTCentralMeanTrend =
1979  MeanTrendsDir.make<TH1F>("means_dz_pTCentral",
1980  "#LT d_{z} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z} #GT [#mum]",
1981  mypT_bins_.size() - 1,
1982  mypT_bins_.data());
1983 
1984  a_dzpTCentralWidthTrend =
1985  WidthTrendsDir.make<TH1F>("widths_dz_pTCentral",
1986  "#sigma_{d_{z}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{z}} [#mum]",
1987  mypT_bins_.size() - 1,
1988  mypT_bins_.data());
1989 
1990  n_dxypTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
1991  "norm_means_dxy_pTCentral",
1992  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy}/#sigma_{d_{z}} #GT",
1993  mypT_bins_.size() - 1,
1994  mypT_bins_.data());
1995 
1996  n_dxypTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
1997  "norm_widths_dxy_pTCentral",
1998  "width(d_{xy}/#sigma_{d_{xy}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{xy}/#sigma_{d_{z}})",
1999  mypT_bins_.size() - 1,
2000  mypT_bins_.data());
2001 
2002  n_dzpTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
2003  "norm_means_dz_pTCentral",
2004  "#LT d_{z}/#sigma_{d_{z}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
2005  mypT_bins_.size() - 1,
2006  mypT_bins_.data());
2007 
2008  n_dzpTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
2009  "norm_widths_dz_pTCentral",
2010  "width(d_{z}/#sigma_{d_{z}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{z}/#sigma_{d_{z}})",
2011  mypT_bins_.size() - 1,
2012  mypT_bins_.data());
2013 
2014  // 2D maps
2015 
2016  a_dxyMeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_map",
2017  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
2018  nBins_,
2019  lowedge,
2020  highedge,
2021  nBins_,
2022  lowedge,
2023  highedge);
2024 
2025  a_dzMeanMap = Mean2DMapsDir.make<TH2F>("means_dz_map",
2026  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
2027  nBins_,
2028  lowedge,
2029  highedge,
2030  nBins_,
2031  lowedge,
2032  highedge);
2033 
2034  n_dxyMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dxy_map",
2035  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2036  nBins_,
2037  lowedge,
2038  highedge,
2039  nBins_,
2040  lowedge,
2041  highedge);
2042 
2043  n_dzMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_map",
2044  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2045  nBins_,
2046  lowedge,
2047  highedge,
2048  nBins_,
2049  lowedge,
2050  highedge);
2051 
2052  a_dxyWidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_map",
2053  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
2054  nBins_,
2055  lowedge,
2056  highedge,
2057  nBins_,
2058  lowedge,
2059  highedge);
2060 
2061  a_dzWidthMap = Width2DMapsDir.make<TH2F>("widths_dz_map",
2062  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
2063  nBins_,
2064  lowedge,
2065  highedge,
2066  nBins_,
2067  lowedge,
2068  highedge);
2069 
2070  n_dxyWidthMap =
2071  Width2DMapsDir.make<TH2F>("norm_widths_dxy_map",
2072  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
2073  nBins_,
2074  lowedge,
2075  highedge,
2076  nBins_,
2077  lowedge,
2078  highedge);
2079 
2080  n_dzWidthMap = Width2DMapsDir.make<TH2F>("norm_widths_dz_map",
2081  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
2082  nBins_,
2083  lowedge,
2084  highedge,
2085  nBins_,
2086  lowedge,
2087  highedge);
2088 
2089  // medians and MADs
2090 
2091  a_dxyPhiMedianTrend =
2092  MedianTrendsDir.make<TH1F>("medians_dxy_phi",
2093  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
2094  nBins_,
2095  lowedge,
2096  highedge);
2097 
2098  a_dxyPhiMADTrend = MADTrendsDir.make<TH1F>(
2099  "MADs_dxy_phi",
2100  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
2101  nBins_,
2102  lowedge,
2103  highedge);
2104 
2105  a_dzPhiMedianTrend =
2106  MedianTrendsDir.make<TH1F>("medians_dz_phi",
2107  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
2108  nBins_,
2109  lowedge,
2110  highedge);
2111 
2112  a_dzPhiMADTrend = MADTrendsDir.make<TH1F>(
2113  "MADs_dz_phi",
2114  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
2115  nBins_,
2116  lowedge,
2117  highedge);
2118 
2119  a_dxyEtaMedianTrend =
2120  MedianTrendsDir.make<TH1F>("medians_dxy_eta",
2121  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
2122  nBins_,
2123  lowedge,
2124  highedge);
2125 
2126  a_dxyEtaMADTrend =
2127  MADTrendsDir.make<TH1F>("MADs_dxy_eta",
2128  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
2129  nBins_,
2130  lowedge,
2131  highedge);
2132 
2133  a_dzEtaMedianTrend =
2134  MedianTrendsDir.make<TH1F>("medians_dz_eta",
2135  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
2136  nBins_,
2137  lowedge,
2138  highedge);
2139 
2140  a_dzEtaMADTrend =
2141  MADTrendsDir.make<TH1F>("MADs_dz_eta",
2142  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
2143  nBins_,
2144  lowedge,
2145  highedge);
2146 
2147  n_dxyPhiMedianTrend = MedianTrendsDir.make<TH1F>(
2148  "norm_medians_dxy_phi",
2149  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
2150  nBins_,
2151  lowedge,
2152  highedge);
2153 
2154  n_dxyPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
2155  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
2156  "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
2157  nBins_,
2158  lowedge,
2159  highedge);
2160 
2161  n_dzPhiMedianTrend = MedianTrendsDir.make<TH1F>(
2162  "norm_medians_dz_phi",
2163  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2164  nBins_,
2165  lowedge,
2166  highedge);
2167 
2168  n_dzPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dz_phi",
2169  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi "
2170  "(sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
2171  nBins_,
2172  lowedge,
2173  highedge);
2174 
2175  n_dxyEtaMedianTrend = MedianTrendsDir.make<TH1F>(
2176  "norm_medians_dxy_eta",
2177  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
2178  nBins_,
2179  lowedge,
2180  highedge);
2181 
2182  n_dxyEtaMADTrend = MADTrendsDir.make<TH1F>(
2183  "norm_MADs_dxy_eta",
2184  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
2185  nBins_,
2186  lowedge,
2187  highedge);
2188 
2189  n_dzEtaMedianTrend = MedianTrendsDir.make<TH1F>(
2190  "norm_medians_dz_eta",
2191  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2192  nBins_,
2193  lowedge,
2194  highedge);
2195 
2196  n_dzEtaMADTrend = MADTrendsDir.make<TH1F>(
2197  "norm_MADs_dz_eta",
2198  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
2199  nBins_,
2200  lowedge,
2201  highedge);
2202 
2204  //
2205  // plots of biased residuals
2206  // The vertex includes the probe track
2207  //
2209 
2210  if (useTracksFromRecoVtx_) {
2211  TFileDirectory AbsTransPhiBiasRes = fs->mkdir("Abs_Transv_Phi_BiasResiduals");
2212  a_dxyPhiBiasResiduals = bookResidualsHistogram(AbsTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
2213 
2214  TFileDirectory AbsTransEtaBiasRes = fs->mkdir("Abs_Transv_Eta_BiasResiduals");
2215  a_dxyEtaBiasResiduals = bookResidualsHistogram(AbsTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
2216 
2217  TFileDirectory AbsLongPhiBiasRes = fs->mkdir("Abs_Long_Phi_BiasResiduals");
2218  a_dzPhiBiasResiduals = bookResidualsHistogram(AbsLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
2219 
2220  TFileDirectory AbsLongEtaBiasRes = fs->mkdir("Abs_Long_Eta_BiasResiduals");
2221  a_dzEtaBiasResiduals = bookResidualsHistogram(AbsLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
2222 
2223  TFileDirectory NormTransPhiBiasRes = fs->mkdir("Norm_Transv_Phi_BiasResiduals");
2224  n_dxyPhiBiasResiduals = bookResidualsHistogram(NormTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
2225 
2226  TFileDirectory NormTransEtaBiasRes = fs->mkdir("Norm_Transv_Eta_BiasResiduals");
2227  n_dxyEtaBiasResiduals = bookResidualsHistogram(NormTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
2228 
2229  TFileDirectory NormLongPhiBiasRes = fs->mkdir("Norm_Long_Phi_BiasResiduals");
2230  n_dzPhiBiasResiduals = bookResidualsHistogram(NormLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
2231 
2232  TFileDirectory NormLongEtaBiasRes = fs->mkdir("Norm_Long_Eta_BiasResiduals");
2233  n_dzEtaBiasResiduals = bookResidualsHistogram(NormLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
2234 
2235  TFileDirectory AbsDoubleDiffBiasRes = fs->mkdir("Abs_DoubleDiffBiasResiduals");
2236  TFileDirectory NormDoubleDiffBiasRes = fs->mkdir("Norm_DoubleDiffBiasResiduals");
2237 
2238  for (int i = 0; i < nBins_; ++i) {
2239  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
2240  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
2241 
2242  for (int j = 0; j < nBins_; ++j) {
2243  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
2244  float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
2245 
2246  a_dxyBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
2247  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
2248  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy} [#mum];tracks", etaF, etaL, phiF, phiL),
2249  theDetails_.histobins,
2250  -dzmax_eta,
2251  dzmax_eta);
2252 
2253  a_dzBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
2254  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
2255  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z} [#mum];tracks", etaF, etaL, phiF, phiL),
2256  theDetails_.histobins,
2257  -dzmax_eta,
2258  dzmax_eta);
2259 
2260  n_dxyBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
2261  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
2262  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
2263  etaF,
2264  etaL,
2265  phiF,
2266  phiL),
2267  theDetails_.histobins,
2268  -dzmax_eta / 100,
2269  dzmax_eta / 100);
2270 
2271  n_dzBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
2272  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
2273  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
2274  etaF,
2275  etaL,
2276  phiF,
2277  phiL),
2278  theDetails_.histobins,
2279  -dzmax_eta / 100,
2280  dzmax_eta / 100);
2281  }
2282  }
2283 
2284  // declaration of the directories
2285 
2286  TFileDirectory MeanBiasTrendsDir = fs->mkdir("MeanBiasTrends");
2287  TFileDirectory WidthBiasTrendsDir = fs->mkdir("WidthBiasTrends");
2288  TFileDirectory MedianBiasTrendsDir = fs->mkdir("MedianBiasTrends");
2289  TFileDirectory MADBiasTrendsDir = fs->mkdir("MADBiasTrends");
2290 
2291  TFileDirectory Mean2DBiasMapsDir = fs->mkdir("MeanBiasMaps");
2292  TFileDirectory Width2DBiasMapsDir = fs->mkdir("WidthBiasMaps");
2293 
2294  // means and widths from the fit
2295 
2296  a_dxyPhiMeanBiasTrend =
2297  MeanBiasTrendsDir.make<TH1F>("means_dxy_phi",
2298  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
2299  nBins_,
2300  lowedge,
2301  highedge);
2302 
2303  a_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2304  "widths_dxy_phi",
2305  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
2306  nBins_,
2307  lowedge,
2308  highedge);
2309 
2310  a_dzPhiMeanBiasTrend =
2311  MeanBiasTrendsDir.make<TH1F>("means_dz_phi",
2312  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
2313  nBins_,
2314  lowedge,
2315  highedge);
2316 
2317  a_dzPhiWidthBiasTrend =
2318  WidthBiasTrendsDir.make<TH1F>("widths_dz_phi",
2319  "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
2320  nBins_,
2321  lowedge,
2322  highedge);
2323 
2324  a_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2325  "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
2326 
2327  a_dxyEtaWidthBiasTrend =
2328  WidthBiasTrendsDir.make<TH1F>("widths_dxy_eta",
2329  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
2330  nBins_,
2331  lowedge,
2332  highedge);
2333 
2334  a_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2335  "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
2336 
2337  a_dzEtaWidthBiasTrend =
2338  WidthBiasTrendsDir.make<TH1F>("widths_dz_eta",
2339  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]",
2340  nBins_,
2341  lowedge,
2342  highedge);
2343 
2344  n_dxyPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2345  "norm_means_dxy_phi",
2346  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
2347  nBins_,
2348  lowedge,
2349  highedge);
2350 
2351  n_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2352  "norm_widths_dxy_phi",
2353  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
2354  nBins_,
2355  lowedge,
2356  highedge);
2357 
2358  n_dzPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2359  "norm_means_dz_phi",
2360  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
2361  nBins_,
2362  lowedge,
2363  highedge);
2364 
2365  n_dzPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2366  "norm_widths_dz_phi",
2367  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
2368  nBins_,
2369  lowedge,
2370  highedge);
2371 
2372  n_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2373  "norm_means_dxy_eta",
2374  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
2375  nBins_,
2376  lowedge,
2377  highedge);
2378 
2379  n_dxyEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2380  "norm_widths_dxy_eta",
2381  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
2382  nBins_,
2383  lowedge,
2384  highedge);
2385 
2386  n_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2387  "norm_means_dz_eta",
2388  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
2389  nBins_,
2390  lowedge,
2391  highedge);
2392 
2393  n_dzEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2394  "norm_widths_dz_eta",
2395  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
2396  nBins_,
2397  lowedge,
2398  highedge);
2399 
2400  // 2D maps
2401 
2402  a_dxyMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dxy_map",
2403  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
2404  nBins_,
2405  lowedge,
2406  highedge,
2407  nBins_,
2408  lowedge,
2409  highedge);
2410 
2411  a_dzMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dz_map",
2412  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
2413  nBins_,
2414  lowedge,
2415  highedge,
2416  nBins_,
2417  lowedge,
2418  highedge);
2419 
2420  n_dxyMeanBiasMap =
2421  Mean2DBiasMapsDir.make<TH2F>("norm_means_dxy_map",
2422  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2423  nBins_,
2424  lowedge,
2425  highedge,
2426  nBins_,
2427  lowedge,
2428  highedge);
2429 
2430  n_dzMeanBiasMap =
2431  Mean2DBiasMapsDir.make<TH2F>("norm_means_dz_map",
2432  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2433  nBins_,
2434  lowedge,
2435  highedge,
2436  nBins_,
2437  lowedge,
2438  highedge);
2439 
2440  a_dxyWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dxy_map",
2441  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
2442  nBins_,
2443  lowedge,
2444  highedge,
2445  nBins_,
2446  lowedge,
2447  highedge);
2448 
2449  a_dzWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dz_map",
2450  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
2451  nBins_,
2452  lowedge,
2453  highedge,
2454  nBins_,
2455  lowedge,
2456  highedge);
2457 
2458  n_dxyWidthBiasMap =
2459  Width2DBiasMapsDir.make<TH2F>("norm_widths_dxy_map",
2460  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
2461  nBins_,
2462  lowedge,
2463  highedge,
2464  nBins_,
2465  lowedge,
2466  highedge);
2467 
2468  n_dzWidthBiasMap =
2469  Width2DBiasMapsDir.make<TH2F>("norm_widths_dz_map",
2470  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
2471  nBins_,
2472  lowedge,
2473  highedge,
2474  nBins_,
2475  lowedge,
2476  highedge);
2477 
2478  // medians and MADs
2479 
2480  a_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2481  "medians_dxy_phi",
2482  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
2483  nBins_,
2484  lowedge,
2485  highedge);
2486 
2487  a_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2488  "MADs_dxy_phi",
2489  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
2490  nBins_,
2491  lowedge,
2492  highedge);
2493 
2494  a_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2495  "medians_dz_phi",
2496  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
2497  nBins_,
2498  lowedge,
2499  highedge);
2500 
2501  a_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2502  "MADs_dz_phi",
2503  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
2504  nBins_,
2505  lowedge,
2506  highedge);
2507 
2508  a_dxyEtaMedianBiasTrend =
2509  MedianBiasTrendsDir.make<TH1F>("medians_dxy_eta",
2510  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
2511  nBins_,
2512  lowedge,
2513  highedge);
2514 
2515  a_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2516  "MADs_dxy_eta",
2517  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
2518  nBins_,
2519  lowedge,
2520  highedge);
2521 
2522  a_dzEtaMedianBiasTrend =
2523  MedianBiasTrendsDir.make<TH1F>("medians_dz_eta",
2524  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
2525  nBins_,
2526  lowedge,
2527  highedge);
2528 
2529  a_dzEtaMADBiasTrend =
2530  MADBiasTrendsDir.make<TH1F>("MADs_dz_eta",
2531  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
2532  nBins_,
2533  lowedge,
2534  highedge);
2535 
2536  n_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2537  "norm_medians_dxy_phi",
2538  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
2539  nBins_,
2540  lowedge,
2541  highedge);
2542 
2543  n_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
2544  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
2545  "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
2546  nBins_,
2547  lowedge,
2548  highedge);
2549 
2550  n_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2551  "norm_medians_dz_phi",
2552  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2553  nBins_,
2554  lowedge,
2555  highedge);
2556 
2557  n_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dz_phi",
2558  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi "
2559  "sector;#varphi (sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
2560  nBins_,
2561  lowedge,
2562  highedge);
2563 
2564  n_dxyEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2565  "norm_medians_dxy_eta",
2566  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
2567  nBins_,
2568  lowedge,
2569  highedge);
2570 
2571  n_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2572  "norm_MADs_dxy_eta",
2573  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
2574  nBins_,
2575  lowedge,
2576  highedge);
2577 
2578  n_dzEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2579  "norm_medians_dz_eta",
2580  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2581  nBins_,
2582  lowedge,
2583  highedge);
2584 
2585  n_dzEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2586  "norm_MADs_dz_eta",
2587  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
2588  nBins_,
2589  lowedge,
2590  highedge);
2591  }
2592 }
2593 // ------------ method called once each job just after ending the event loop ------------
2594 void PrimaryVertexValidation::endJob() {
2595  TFileDirectory RunFeatures = fs->mkdir("RunFeatures");
2596  h_runStartTimes = RunFeatures.make<TH1I>(
2597  "runStartTimes", "run start times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
2598  h_runEndTimes =
2599  RunFeatures.make<TH1I>("runEndTimes", "run end times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
2600 
2601  unsigned int count = 1;
2602  for (const auto& run : runNumbersTimesLog_) {
2603  // strip down the microseconds
2604  h_runStartTimes->SetBinContent(count, run.second.first / 10e6);
2605  h_runStartTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
2606 
2607  h_runEndTimes->SetBinContent(count, run.second.second / 10e6);
2608  h_runEndTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
2609 
2610  count++;
2611  }
2612 
2613  edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
2614  << "# PrimaryVertexValidation::endJob()\n"
2615  << "# Number of analyzed events: " << Nevt_ << "\n"
2616  << "######################################";
2617 
2618  // means and widhts vs ladder and module number
2619 
2620  a_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
2621  "means_dxy_modZ", "#LT d_{xy} #GT vs modZ;module number (Z);#LT d_{xy} #GT [#mum]", nModZ_, 0., nModZ_);
2622 
2623  a_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
2624  "widths_dxy_modZ", "#sigma_{d_{xy}} vs modZ;module number (Z);#sigma_{d_{xy}} [#mum]", nModZ_, 0., nModZ_);
2625 
2626  a_dzmodZMeanTrend = MeanTrendsDir.make<TH1F>(
2627  "means_dz_modZ", "#LT d_{z} #GT vs modZ;module number (Z);#LT d_{z} #GT [#mum]", nModZ_, 0., nModZ_);
2628 
2629  a_dzmodZWidthTrend = WidthTrendsDir.make<TH1F>(
2630  "widths_dz_modZ", "#sigma_{d_{z}} vs modZ;module number (Z);#sigma_{d_{z}} [#mum]", nModZ_, 0., nModZ_);
2631 
2632  a_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_ladder",
2633  "#LT d_{xy} #GT vs ladder;ladder number (#phi);#LT d_{xy} #GT [#mum]",
2634  nLadders_,
2635  0.,
2636  nLadders_);
2637 
2638  a_dxyladderWidthTrend =
2639  WidthTrendsDir.make<TH1F>("widths_dxy_ladder",
2640  "#sigma_{d_{xy}} vs ladder;ladder number (#phi);#sigma_{d_{xy}} [#mum]",
2641  nLadders_,
2642  0.,
2643  nLadders_);
2644 
2645  a_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
2646  "means_dz_ladder", "#LT d_{z} #GT vs ladder;ladder number (#phi);#LT d_{z} #GT [#mum]", nLadders_, 0., nLadders_);
2647 
2648  a_dzladderWidthTrend =
2649  WidthTrendsDir.make<TH1F>("widths_dz_ladder",
2650  "#sigma_{d_{z}} vs ladder;ladder number (#phi);#sigma_{d_{z}} [#mum]",
2651  nLadders_,
2652  0.,
2653  nLadders_);
2654 
2655  n_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
2656  "norm_means_dxy_modZ",
2657  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs modZ;module number (Z);#LT d_{xy}/#sigma_{d_{xy}} #GT",
2658  nModZ_,
2659  0.,
2660  nModZ_);
2661 
2662  n_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
2663  "norm_widths_dxy_modZ",
2664  "width(d_{xy}/#sigma_{d_{xy}}) vs modZ;module number (Z); width(d_{xy}/#sigma_{d_{xy}})",
2665  nModZ_,
2666  0.,
2667  nModZ_);
2668 
2669  n_dzmodZMeanTrend =
2670  MeanTrendsDir.make<TH1F>("norm_means_dz_modZ",
2671  "#LT d_{z}/#sigma_{d_{z}} #GT vs modZ;module number (Z);#LT d_{z}/#sigma_{d_{z}} #GT",
2672  nModZ_,
2673  0.,
2674  nModZ_);
2675 
2676  n_dzmodZWidthTrend =
2677  WidthTrendsDir.make<TH1F>("norm_widths_dz_modZ",
2678  "width(d_{z}/#sigma_{d_{z}}) vs pT;module number (Z);width(d_{z}/#sigma_{d_{z}})",
2679  nModZ_,
2680  0.,
2681  nModZ_);
2682 
2683  n_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>(
2684  "norm_means_dxy_ladder",
2685  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs ladder;ladder number (#phi);#LT d_{xy}/#sigma_{d_{z}} #GT",
2686  nLadders_,
2687  0.,
2688  nLadders_);
2689 
2690  n_dxyladderWidthTrend = WidthTrendsDir.make<TH1F>(
2691  "norm_widths_dxy_ladder",
2692  "width(d_{xy}/#sigma_{d_{xy}}) vs ladder;ladder number (#phi);width(d_{xy}/#sigma_{d_{z}})",
2693  nLadders_,
2694  0.,
2695  nLadders_);
2696 
2697  n_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
2698  "norm_means_dz_ladder",
2699  "#LT d_{z}/#sigma_{d_{z}} #GT vs ladder;ladder number (#phi);#LT d_{z}/#sigma_{d_{z}} #GT",
2700  nLadders_,
2701  0.,
2702  nLadders_);
2703 
2704  n_dzladderWidthTrend = WidthTrendsDir.make<TH1F>(
2705  "norm_widths_dz_ladder",
2706  "width(d_{z}/#sigma_{d_{z}}) vs ladder;ladder number (#phi);width(d_{z}/#sigma_{d_{z}})",
2707  nLadders_,
2708  0.,
2709  nLadders_);
2710 
2711  // 2D maps of residuals in bins of L1 modules
2712 
2713  a_dxyL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_l1map",
2714  "#LT d_{xy} #GT map;module number [z];ladder number [#varphi]",
2715  8,
2716  0.,
2717  8.,
2718  nLadders_,
2719  0.,
2720  nLadders_);
2721 
2722  a_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dz_l1map",
2723  "#LT d_{z} #GT map;module number [z];ladder number [#varphi]",
2724  8,
2725  0.,
2726  8.,
2727  nLadders_,
2728  0.,
2729  nLadders_);
2730 
2731  n_dxyL1MeanMap =
2732  Mean2DMapsDir.make<TH2F>("norm_means_dxy_l1map",
2733  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;module number [z];ladder number [#varphi]",
2734  8,
2735  0.,
2736  8.,
2737  nLadders_,
2738  0.,
2739  nLadders_);
2740 
2741  n_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_l1map",
2742  "#LT d_{z}/#sigma_{d_{z}} #GT map;module number [z];ladder number [#varphi]",
2743  8,
2744  0.,
2745  8.,
2746  nLadders_,
2747  0.,
2748  nLadders_);
2749 
2750  a_dxyL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_l1map",
2751  "#sigma_{d_{xy}} map;module number [z];ladder number [#varphi]",
2752  8,
2753  0.,
2754  8.,
2755  nLadders_,
2756  0.,
2757  nLadders_);
2758 
2759  a_dzL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dz_l1map",
2760  "#sigma_{d_{z}} map;module number [z];ladder number [#varphi]",
2761  8,
2762  0.,
2763  8.,
2764  nLadders_,
2765  0.,
2766  nLadders_);
2767 
2768  n_dxyL1WidthMap =
2769  Width2DMapsDir.make<TH2F>("norm_widths_dxy_l1map",
2770  "width(d_{xy}/#sigma_{d_{xy}}) map;module number [z];ladder number [#varphi]",
2771  8,
2772  0.,
2773  8.,
2774  nLadders_,
2775  0.,
2776  nLadders_);
2777 
2778  n_dzL1WidthMap =
2779  Width2DMapsDir.make<TH2F>("norm_widths_dz_l1map",
2780  "width(d_{z}/#sigma_{d_{z}}) map;module number [z];ladder number [#varphi]",
2781  8,
2782  0.,
2783  8.,
2784  nLadders_,
2785  0.,
2786  nLadders_);
2787 
2788  if (useTracksFromRecoVtx_) {
2789  fillTrendPlotByIndex(a_dxyPhiMeanBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2790  fillTrendPlotByIndex(a_dxyPhiWidthBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2791  fillTrendPlotByIndex(a_dzPhiMeanBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2792  fillTrendPlotByIndex(a_dzPhiWidthBiasTrend, a_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2793 
2794  fillTrendPlotByIndex(a_dxyEtaMeanBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2795  fillTrendPlotByIndex(a_dxyEtaWidthBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2796  fillTrendPlotByIndex(a_dzEtaMeanBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2797  fillTrendPlotByIndex(a_dzEtaWidthBiasTrend, a_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2798 
2799  fillTrendPlotByIndex(n_dxyPhiMeanBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2800  fillTrendPlotByIndex(n_dxyPhiWidthBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2801  fillTrendPlotByIndex(n_dzPhiMeanBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2802  fillTrendPlotByIndex(n_dzPhiWidthBiasTrend, n_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2803 
2804  fillTrendPlotByIndex(n_dxyEtaMeanBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2805  fillTrendPlotByIndex(n_dxyEtaWidthBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2806  fillTrendPlotByIndex(n_dzEtaMeanBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2807  fillTrendPlotByIndex(n_dzEtaWidthBiasTrend, n_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2808 
2809  // medians and MADs
2810 
2811  fillTrendPlotByIndex(a_dxyPhiMedianBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2812  fillTrendPlotByIndex(a_dxyPhiMADBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2813  fillTrendPlotByIndex(a_dzPhiMedianBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2814  fillTrendPlotByIndex(a_dzPhiMADBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2815 
2816  fillTrendPlotByIndex(a_dxyEtaMedianBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2817  fillTrendPlotByIndex(a_dxyEtaMADBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2818  fillTrendPlotByIndex(a_dzEtaMedianBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2819  fillTrendPlotByIndex(a_dzEtaMADBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2820 
2821  fillTrendPlotByIndex(n_dxyPhiMedianBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2822  fillTrendPlotByIndex(n_dxyPhiMADBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2823  fillTrendPlotByIndex(n_dzPhiMedianBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2824  fillTrendPlotByIndex(n_dzPhiMADBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2825 
2826  fillTrendPlotByIndex(n_dxyEtaMedianBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2827  fillTrendPlotByIndex(n_dxyEtaMADBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2828  fillTrendPlotByIndex(n_dzEtaMedianBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2829  fillTrendPlotByIndex(n_dzEtaMADBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2830 
2831  // 2d Maps
2832 
2833  fillMap(a_dxyMeanBiasMap, a_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2834  fillMap(a_dxyWidthBiasMap, a_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2835  fillMap(a_dzMeanBiasMap, a_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2836  fillMap(a_dzWidthBiasMap, a_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2837 
2838  fillMap(n_dxyMeanBiasMap, n_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2839  fillMap(n_dxyWidthBiasMap, n_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2840  fillMap(n_dzMeanBiasMap, n_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2841  fillMap(n_dzWidthBiasMap, n_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2842  }
2843 
2844  // do profiles
2845 
2846  fillTrendPlotByIndex(a_dxyPhiMeanTrend, a_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2847  fillTrendPlotByIndex(a_dxyPhiWidthTrend, a_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2848  fillTrendPlotByIndex(a_dzPhiMeanTrend, a_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2849  fillTrendPlotByIndex(a_dzPhiWidthTrend, a_dzPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2850 
2851  fillTrendPlotByIndex(a_dxyEtaMeanTrend, a_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2852  fillTrendPlotByIndex(a_dxyEtaWidthTrend, a_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2853  fillTrendPlotByIndex(a_dzEtaMeanTrend, a_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2854  fillTrendPlotByIndex(a_dzEtaWidthTrend, a_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2855 
2856  fillTrendPlotByIndex(n_dxyPhiMeanTrend, n_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2857  fillTrendPlotByIndex(n_dxyPhiWidthTrend, n_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2858  fillTrendPlotByIndex(n_dzPhiMeanTrend, n_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2859  fillTrendPlotByIndex(n_dzPhiWidthTrend, n_dzPhiResiduals, PVValHelper::WIDTH);
2860 
2861  fillTrendPlotByIndex(n_dxyEtaMeanTrend, n_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2862  fillTrendPlotByIndex(n_dxyEtaWidthTrend, n_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2863  fillTrendPlotByIndex(n_dzEtaMeanTrend, n_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2864  fillTrendPlotByIndex(n_dzEtaWidthTrend, n_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2865 
2866  // vs transverse momentum
2867 
2868  fillTrendPlotByIndex(a_dxypTMeanTrend, h_dxy_pT_, PVValHelper::MEAN);
2869  fillTrendPlotByIndex(a_dxypTWidthTrend, h_dxy_pT_, PVValHelper::WIDTH);
2870  fillTrendPlotByIndex(a_dzpTMeanTrend, h_dz_pT_, PVValHelper::MEAN);
2871  fillTrendPlotByIndex(a_dzpTWidthTrend, h_dz_pT_, PVValHelper::WIDTH);
2872 
2873  fillTrendPlotByIndex(a_dxypTCentralMeanTrend, h_dxy_Central_pT_, PVValHelper::MEAN);
2874  fillTrendPlotByIndex(a_dxypTCentralWidthTrend, h_dxy_Central_pT_, PVValHelper::WIDTH);
2875  fillTrendPlotByIndex(a_dzpTCentralMeanTrend, h_dz_Central_pT_, PVValHelper::MEAN);
2876  fillTrendPlotByIndex(a_dzpTCentralWidthTrend, h_dz_Central_pT_, PVValHelper::WIDTH);
2877 
2878  fillTrendPlotByIndex(n_dxypTMeanTrend, h_norm_dxy_pT_, PVValHelper::MEAN);
2879  fillTrendPlotByIndex(n_dxypTWidthTrend, h_norm_dxy_pT_, PVValHelper::WIDTH);
2880  fillTrendPlotByIndex(n_dzpTMeanTrend, h_norm_dz_pT_, PVValHelper::MEAN);
2881  fillTrendPlotByIndex(n_dzpTWidthTrend, h_norm_dz_pT_, PVValHelper::WIDTH);
2882 
2883  fillTrendPlotByIndex(n_dxypTCentralMeanTrend, h_norm_dxy_Central_pT_, PVValHelper::MEAN);
2884  fillTrendPlotByIndex(n_dxypTCentralWidthTrend, h_norm_dxy_Central_pT_, PVValHelper::WIDTH);
2885  fillTrendPlotByIndex(n_dzpTCentralMeanTrend, h_norm_dz_Central_pT_, PVValHelper::MEAN);
2886  fillTrendPlotByIndex(n_dzpTCentralWidthTrend, h_norm_dz_Central_pT_, PVValHelper::WIDTH);
2887 
2888  // vs ladder and module number
2889 
2890  fillTrendPlotByIndex(a_dxymodZMeanTrend, h_dxy_modZ_, PVValHelper::MEAN);
2891  fillTrendPlotByIndex(a_dxymodZWidthTrend, h_dxy_modZ_, PVValHelper::WIDTH);
2892  fillTrendPlotByIndex(a_dzmodZMeanTrend, h_dz_modZ_, PVValHelper::MEAN);
2893  fillTrendPlotByIndex(a_dzmodZWidthTrend, h_dz_modZ_, PVValHelper::WIDTH);
2894 
2895  fillTrendPlotByIndex(a_dxyladderMeanTrend, h_dxy_ladder_, PVValHelper::MEAN);
2896  fillTrendPlotByIndex(a_dxyladderWidthTrend, h_dxy_ladder_, PVValHelper::WIDTH);
2897  fillTrendPlotByIndex(a_dzladderMeanTrend, h_dz_ladder_, PVValHelper::MEAN);
2898  fillTrendPlotByIndex(a_dzladderWidthTrend, h_dz_ladder_, PVValHelper::WIDTH);
2899 
2900  fillTrendPlotByIndex(n_dxymodZMeanTrend, h_norm_dxy_modZ_, PVValHelper::MEAN);
2901  fillTrendPlotByIndex(n_dxymodZWidthTrend, h_norm_dxy_modZ_, PVValHelper::WIDTH);
2902  fillTrendPlotByIndex(n_dzmodZMeanTrend, h_norm_dz_modZ_, PVValHelper::MEAN);
2903  fillTrendPlotByIndex(n_dzmodZWidthTrend, h_norm_dz_modZ_, PVValHelper::WIDTH);
2904 
2905  fillTrendPlotByIndex(n_dxyladderMeanTrend, h_norm_dxy_ladder_, PVValHelper::MEAN);
2906  fillTrendPlotByIndex(n_dxyladderWidthTrend, h_norm_dxy_ladder_, PVValHelper::WIDTH);
2907  fillTrendPlotByIndex(n_dzladderMeanTrend, h_norm_dz_ladder_, PVValHelper::MEAN);
2908  fillTrendPlotByIndex(n_dzladderWidthTrend, h_norm_dz_ladder_, PVValHelper::WIDTH);
2909 
2910  // medians and MADs
2911 
2912  fillTrendPlotByIndex(a_dxyPhiMedianTrend, a_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2913  fillTrendPlotByIndex(a_dxyPhiMADTrend, a_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2914 
2915  fillTrendPlotByIndex(a_dzPhiMedianTrend, a_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2916  fillTrendPlotByIndex(a_dzPhiMADTrend, a_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2917 
2918  fillTrendPlotByIndex(a_dxyEtaMedianTrend, a_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2919  fillTrendPlotByIndex(a_dxyEtaMADTrend, a_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2920  fillTrendPlotByIndex(a_dzEtaMedianTrend, a_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2921  fillTrendPlotByIndex(a_dzEtaMADTrend, a_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2922 
2923  fillTrendPlotByIndex(n_dxyPhiMedianTrend, n_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2924  fillTrendPlotByIndex(n_dxyPhiMADTrend, n_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2925  fillTrendPlotByIndex(n_dzPhiMedianTrend, n_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2926  fillTrendPlotByIndex(n_dzPhiMADTrend, n_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2927 
2928  fillTrendPlotByIndex(n_dxyEtaMedianTrend, n_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2929  fillTrendPlotByIndex(n_dxyEtaMADTrend, n_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2930  fillTrendPlotByIndex(n_dzEtaMedianTrend, n_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2931  fillTrendPlotByIndex(n_dzEtaMADTrend, n_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2932 
2933  // 2D Maps
2934 
2935  fillMap(a_dxyMeanMap, a_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2936  fillMap(a_dxyWidthMap, a_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2937  fillMap(a_dzMeanMap, a_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2938  fillMap(a_dzWidthMap, a_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2939 
2940  fillMap(n_dxyMeanMap, n_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2941  fillMap(n_dxyWidthMap, n_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2942  fillMap(n_dzMeanMap, n_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2943  fillMap(n_dzWidthMap, n_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2944 
2945  // 2D Maps of residuals in bins of L1 modules
2946 
2947  fillMap(a_dxyL1MeanMap, a_dxyL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2948  fillMap(a_dxyL1WidthMap, a_dxyL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2949  fillMap(a_dzL1MeanMap, a_dzL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2950  fillMap(a_dzL1WidthMap, a_dzL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2951 
2952  fillMap(n_dxyL1MeanMap, n_dxyL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2953  fillMap(n_dxyL1WidthMap, n_dxyL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2954  fillMap(n_dzL1MeanMap, n_dzL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2955  fillMap(n_dzL1WidthMap, n_dzL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2956 }
2957 
2958 //*************************************************************
2959 std::pair<long long, long long> PrimaryVertexValidation::getRunTime(const edm::EventSetup& iSetup) const
2960 //*************************************************************
2961 {
2962  edm::ESHandle<RunInfo> runInfo;
2963  iSetup.get<RunInfoRcd>().get(runInfo);
2964  if (debug_) {
2965  edm::LogInfo("PrimaryVertexValidation")
2966  << runInfo.product()->m_start_time_str << " " << runInfo.product()->m_stop_time_str << std::endl;
2967  }
2968  return std::make_pair(runInfo.product()->m_start_time_ll, runInfo.product()->m_stop_time_ll);
2969 }
2970 
2971 //*************************************************************
2972 bool PrimaryVertexValidation::isBFieldConsistentWithMode(const edm::EventSetup& iSetup) const
2973 //*************************************************************
2974 {
2975  edm::ESHandle<RunInfo> runInfo;
2976  iSetup.get<RunInfoRcd>().get(runInfo);
2977 
2978  double average_current = runInfo.product()->m_avg_current;
2979  bool isOn = (average_current > 2000.);
2980  bool is0T = (ptOfProbe_ == 0.);
2981 
2982  return ((isOn && !is0T) || (!isOn && is0T));
2983 }
2984 
2985 //*************************************************************
2986 void PrimaryVertexValidation::SetVarToZero()
2987 //*************************************************************
2988 {
2989  nTracks_ = 0;
2990  nClus_ = 0;
2991  nOfflineVertices_ = 0;
2992  RunNumber_ = 0;
2993  LuminosityBlockNumber_ = 0;
2994  xOfflineVertex_ = -999.;
2995  yOfflineVertex_ = -999.;
2996  zOfflineVertex_ = -999.;
2997  xErrOfflineVertex_ = 0.;
2998  yErrOfflineVertex_ = 0.;
2999  zErrOfflineVertex_ = 0.;
3000  BSx0_ = -999.;
3001  BSy0_ = -999.;
3002  BSz0_ = -999.;
3003  Beamsigmaz_ = -999.;
3004  Beamdxdz_ = -999.;
3005  BeamWidthX_ = -999.;
3006  BeamWidthY_ = -999.;
3007  wxy2_ = -999.;
3008 
3009  for (int i = 0; i < nMaxtracks_; ++i) {
3010  pt_[i] = 0;
3011  p_[i] = 0;
3012  nhits_[i] = 0;
3013  nhits1D_[i] = 0;
3014  nhits2D_[i] = 0;
3015  nhitsBPIX_[i] = 0;
3016  nhitsFPIX_[i] = 0;
3017  nhitsTIB_[i] = 0;
3018  nhitsTID_[i] = 0;
3019  nhitsTOB_[i] = 0;
3020  nhitsTEC_[i] = 0;
3021  isHighPurity_[i] = 0;
3022  eta_[i] = 0;
3023  theta_[i] = 0;
3024  phi_[i] = 0;
3025  chi2_[i] = 0;
3026  chi2ndof_[i] = 0;
3027  charge_[i] = 0;
3028  qoverp_[i] = 0;
3029  dz_[i] = 0;
3030  dxy_[i] = 0;
3031  dzBs_[i] = 0;
3032  dxyBs_[i] = 0;
3033  xPCA_[i] = 0;
3034  yPCA_[i] = 0;
3035  zPCA_[i] = 0;
3036  xUnbiasedVertex_[i] = 0;
3037  yUnbiasedVertex_[i] = 0;
3038  zUnbiasedVertex_[i] = 0;
3039  chi2normUnbiasedVertex_[i] = 0;
3040  chi2UnbiasedVertex_[i] = 0;
3041  chi2ProbUnbiasedVertex_[i] = 0;
3042  DOFUnbiasedVertex_[i] = 0;
3043  sumOfWeightsUnbiasedVertex_[i] = 0;
3044  tracksUsedForVertexing_[i] = 0;
3045  dxyFromMyVertex_[i] = 0;
3046  dzFromMyVertex_[i] = 0;
3047  d3DFromMyVertex_[i] = 0;
3048  dxyErrorFromMyVertex_[i] = 0;
3049  dzErrorFromMyVertex_[i] = 0;
3050  d3DErrorFromMyVertex_[i] = 0;
3051  IPTsigFromMyVertex_[i] = 0;
3052  IPLsigFromMyVertex_[i] = 0;
3053  IP3DsigFromMyVertex_[i] = 0;
3054  hasRecVertex_[i] = 0;
3055  isGoodTrack_[i] = 0;
3056  }
3057 }
3058 
3059 //*************************************************************
3060 void PrimaryVertexValidation::fillTrendPlot(TH1F* trendPlot,
3061  TH1F* residualsPlot[100],
3062  PVValHelper::estimator fitPar_,
3063  const std::string& var_)
3064 //*************************************************************
3065 {
3066  for (int i = 0; i < nBins_; ++i) {
3067  char phibincenter[129];
3068  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3069  sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
3070 
3071  char etabincenter[129];
3072  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3073  sprintf(etabincenter, "%.1f", (etaBins[i] + etaBins[i + 1]) / 2.);
3074 
3075  switch (fitPar_) {
3076  case PVValHelper::MEAN: {
3077  float mean_ = PVValHelper::fitResiduals(residualsPlot[i]).first.value();
3078  float meanErr_ = PVValHelper::fitResiduals(residualsPlot[i]).first.error();
3079  trendPlot->SetBinContent(i + 1, mean_);
3080  trendPlot->SetBinError(i + 1, meanErr_);
3081  break;
3082  }
3083  case PVValHelper::WIDTH: {
3084  float width_ = PVValHelper::fitResiduals(residualsPlot[i]).second.value();
3085  float widthErr_ = PVValHelper::fitResiduals(residualsPlot[i]).second.error();
3086  trendPlot->SetBinContent(i + 1, width_);
3087  trendPlot->SetBinError(i + 1, widthErr_);
3088  break;
3089  }
3090  case PVValHelper::MEDIAN: {
3091  float median_ = PVValHelper::getMedian(residualsPlot[i]).value();
3092  float medianErr_ = PVValHelper::getMedian(residualsPlot[i]).error();
3093  trendPlot->SetBinContent(i + 1, median_);
3094  trendPlot->SetBinError(i + 1, medianErr_);
3095  break;
3096  }
3097  case PVValHelper::MAD: {
3098  float mad_ = PVValHelper::getMAD(residualsPlot[i]).value();
3099  float madErr_ = PVValHelper::getMAD(residualsPlot[i]).error();
3100  trendPlot->SetBinContent(i + 1, mad_);
3101  trendPlot->SetBinError(i + 1, madErr_);
3102  break;
3103  }
3104  default:
3105  edm::LogWarning("PrimaryVertexValidation")
3106  << "fillTrendPlot() " << fitPar_ << " unknown estimator!" << std::endl;
3107  break;
3108  }
3109 
3110  if (var_.find("eta") != std::string::npos) {
3111  trendPlot->GetXaxis()->SetBinLabel(i + 1, etabincenter);
3112  } else if (var_.find("phi") != std::string::npos) {
3113  trendPlot->GetXaxis()->SetBinLabel(i + 1, phibincenter);
3114  } else {
3115  edm::LogWarning("PrimaryVertexValidation")
3116  << "fillTrendPlot() " << var_ << " unknown track parameter!" << std::endl;
3117  }
3118  }
3119 }
3120 
3121 //*************************************************************
3122 void PrimaryVertexValidation::fillTrendPlotByIndex(TH1F* trendPlot,
3123  std::vector<TH1F*>& h,
3124  PVValHelper::estimator fitPar_,
3125  PVValHelper::plotVariable plotVar)
3126 //*************************************************************
3127 {
3128  for (auto iterator = h.begin(); iterator != h.end(); iterator++) {
3129  unsigned int bin = std::distance(h.begin(), iterator) + 1;
3130  std::pair<Measurement1D, Measurement1D> myFit = PVValHelper::fitResiduals((*iterator));
3131 
3132  switch (fitPar_) {
3133  case PVValHelper::MEAN: {
3134  float mean_ = myFit.first.value();
3135  float meanErr_ = myFit.first.error();
3136  trendPlot->SetBinContent(bin, mean_);
3137  trendPlot->SetBinError(bin, meanErr_);
3138  break;
3139  }
3140  case PVValHelper::WIDTH: {
3141  float width_ = myFit.second.value();
3142  float widthErr_ = myFit.second.error();
3143  trendPlot->SetBinContent(bin, width_);
3144  trendPlot->SetBinError(bin, widthErr_);
3145  break;
3146  }
3147  case PVValHelper::MEDIAN: {
3148  float median_ = PVValHelper::getMedian(*iterator).value();
3149  float medianErr_ = PVValHelper::getMedian(*iterator).error();
3150  trendPlot->SetBinContent(bin, median_);
3151  trendPlot->SetBinError(bin, medianErr_);
3152  break;
3153  }
3154  case PVValHelper::MAD: {
3155  float mad_ = PVValHelper::getMAD(*iterator).value();
3156  float madErr_ = PVValHelper::getMAD(*iterator).error();
3157  trendPlot->SetBinContent(bin, mad_);
3158  trendPlot->SetBinError(bin, madErr_);
3159  break;
3160  }
3161  default:
3162  edm::LogWarning("PrimaryVertexValidation")
3163  << "fillTrendPlotByIndex() " << fitPar_ << " unknown estimator!" << std::endl;
3164  break;
3165  }
3166 
3167  char bincenter[129];
3168  if (plotVar == PVValHelper::eta) {
3169  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3170  sprintf(bincenter, "%.1f", (etaBins[bin - 1] + etaBins[bin]) / 2.);
3171  trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
3172  } else if (plotVar == PVValHelper::phi) {
3173  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3174  sprintf(bincenter, "%.f", (phiBins[bin - 1] + phiBins[bin]) / 2.);
3175  trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
3176  } else {
3178  //edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlotByIndex() "<< plotVar <<" unknown track parameter!"<<std::endl;
3179  }
3180  }
3181 }
3182 
3183 //*************************************************************
3184 void PrimaryVertexValidation::fillMap(TH2F* trendMap,
3185  TH1F* residualsMapPlot[100][100],
3186  PVValHelper::estimator fitPar_,
3187  const int nXBins_,
3188  const int nYBins_)
3189 //*************************************************************
3190 {
3191  for (int i = 0; i < nYBins_; ++i) {
3192  char phibincenter[129];
3193  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3194  sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
3195 
3196  if (nXBins_ == nYBins_) {
3197  trendMap->GetYaxis()->SetBinLabel(i + 1, phibincenter);
3198  }
3199 
3200  for (int j = 0; j < nXBins_; ++j) {
3201  char etabincenter[129];
3202  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3203  sprintf(etabincenter, "%.1f", (etaBins[j] + etaBins[j + 1]) / 2.);
3204 
3205  if (i == 0) {
3206  if (nXBins_ == nYBins_) {
3207  trendMap->GetXaxis()->SetBinLabel(j + 1, etabincenter);
3208  }
3209  }
3210 
3211  switch (fitPar_) {
3212  case PVValHelper::MEAN: {
3213  float mean_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.value();
3214  float meanErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.error();
3215  trendMap->SetBinContent(j + 1, i + 1, mean_);
3216  trendMap->SetBinError(j + 1, i + 1, meanErr_);
3217  break;
3218  }
3219  case PVValHelper::WIDTH: {
3220  float width_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.value();
3221  float widthErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.error();
3222  trendMap->SetBinContent(j + 1, i + 1, width_);
3223  trendMap->SetBinError(j + 1, i + 1, widthErr_);
3224  break;
3225  }
3226  case PVValHelper::MEDIAN: {
3227  float median_ = PVValHelper::getMedian(residualsMapPlot[i][j]).value();
3228  float medianErr_ = PVValHelper::getMedian(residualsMapPlot[i][j]).error();
3229  trendMap->SetBinContent(j + 1, i + 1, median_);
3230  trendMap->SetBinError(j + 1, i + 1, medianErr_);
3231  break;
3232  }
3233  case PVValHelper::MAD: {
3234  float mad_ = PVValHelper::getMAD(residualsMapPlot[i][j]).value();
3235  float madErr_ = PVValHelper::getMAD(residualsMapPlot[i][j]).error();
3236  trendMap->SetBinContent(j + 1, i + 1, mad_);
3237  trendMap->SetBinError(j + 1, i + 1, madErr_);
3238  break;
3239  }
3240  default:
3241  edm::LogWarning("PrimaryVertexValidation:") << " fillMap() " << fitPar_ << " unknown estimator!" << std::endl;
3242  }
3243  } // closes loop on eta bins
3244  } // cloeses loop on phi bins
3245 }
3246 
3247 //*************************************************************
3248 bool PrimaryVertexValidation::vtxSort(const reco::Vertex& a, const reco::Vertex& b)
3249 //*************************************************************
3250 {
3251  if (a.tracksSize() != b.tracksSize())
3252  return a.tracksSize() > b.tracksSize() ? true : false;
3253  else
3254  return a.chi2() < b.chi2() ? true : false;
3255 }
3256 
3257 //*************************************************************
3258 bool PrimaryVertexValidation::passesTrackCuts(const reco::Track& track,
3259  const reco::Vertex& vertex,
3260  const std::string& qualityString_,
3261  double dxyErrMax_,
3262  double dzErrMax_,
3263  double ptErrMax_)
3264 //*************************************************************
3265 {
3266  math::XYZPoint vtxPoint(0.0, 0.0, 0.0);
3267  double vzErr = 0.0, vxErr = 0.0, vyErr = 0.0;
3268  vtxPoint = vertex.position();
3269  vzErr = vertex.zError();
3270  vxErr = vertex.xError();
3271  vyErr = vertex.yError();
3272 
3273  double dxy = 0.0, dz = 0.0, dxysigma = 0.0, dzsigma = 0.0;
3274  dxy = track.dxy(vtxPoint);
3275  dz = track.dz(vtxPoint);
3276  dxysigma = sqrt(track.d0Error() * track.d0Error() + vxErr * vyErr);
3277  dzsigma = sqrt(track.dzError() * track.dzError() + vzErr * vzErr);
3278 
3279  if (track.quality(reco::TrackBase::qualityByName(qualityString_)) != 1)
3280  return false;
3281  if (std::abs(dxy / dxysigma) > dxyErrMax_)
3282  return false;
3283  if (std::abs(dz / dzsigma) > dzErrMax_)
3284  return false;
3285  if (track.ptError() / track.pt() > ptErrMax_)
3286  return false;
3287 
3288  return true;
3289 }
3290 
3291 //*************************************************************
3292 std::map<std::string, TH1*> PrimaryVertexValidation::bookVertexHistograms(const TFileDirectory& dir)
3293 //*************************************************************
3294 {
3295  TH1F::SetDefaultSumw2(kTRUE);
3296 
3297  std::map<std::string, TH1*> h;
3298 
3299  // histograms of track quality (Data and MC)
3300  std::string types[] = {"all", "sel"};
3301  for (const auto& type : types) {
3302  h["pseudorapidity_" + type] =
3303  dir.make<TH1F>(("rapidity_" + type).c_str(), "track pseudorapidity; track #eta; tracks", 100, -3., 3.);
3304  h["z0_" + type] = dir.make<TH1F>(("z0_" + type).c_str(), "track z_{0};track z_{0} (cm);tracks", 80, -40., 40.);
3305  h["phi_" + type] = dir.make<TH1F>(("phi_" + type).c_str(), "track #phi; track #phi;tracks", 80, -M_PI, M_PI);
3306  h["eta_" + type] = dir.make<TH1F>(("eta_" + type).c_str(), "track #eta; track #eta;tracks", 80, -4., 4.);
3307  h["pt_" + type] = dir.make<TH1F>(("pt_" + type).c_str(), "track p_{T}; track p_{T} [GeV];tracks", 100, 0., 20.);
3308  h["p_" + type] = dir.make<TH1F>(("p_" + type).c_str(), "track p; track p [GeV];tracks", 100, 0., 20.);
3309  h["found_" + type] =
3310  dir.make<TH1F>(("found_" + type).c_str(), "n. found hits;n^{found}_{hits};tracks", 30, 0., 30.);
3311  h["lost_" + type] = dir.make<TH1F>(("lost_" + type).c_str(), "n. lost hits;n^{lost}_{hits};tracks", 20, 0., 20.);
3312  h["nchi2_" + type] =
3313  dir.make<TH1F>(("nchi2_" + type).c_str(), "normalized track #chi^{2};track #chi^{2}/ndf;tracks", 100, 0., 20.);
3314  h["rstart_" + type] = dir.make<TH1F>(
3315  ("rstart_" + type).c_str(), "track start radius; track innermost radius r (cm);tracks", 100, 0., 20.);
3316  h["expectedInner_" + type] = dir.make<TH1F>(
3317  ("expectedInner_" + type).c_str(), "n. expected inner hits;n^{expected}_{inner};tracks", 10, 0., 10.);
3318  h["expectedOuter_" + type] = dir.make<TH1F>(
3319  ("expectedOuter_" + type).c_str(), "n. expected outer hits;n^{expected}_{outer};tracks ", 10, 0., 10.);
3320  h["logtresxy_" + type] =
3321  dir.make<TH1F>(("logtresxy_" + type).c_str(),
3322  "log10(track r-#phi resolution/#mum);log10(track r-#phi resolution/#mum);tracks",
3323  100,
3324  0.,
3325  5.);
3326  h["logtresz_" + type] = dir.make<TH1F>(("logtresz_" + type).c_str(),
3327  "log10(track z resolution/#mum);log10(track z resolution/#mum);tracks",
3328  100,
3329  0.,
3330  5.);
3331  h["tpullxy_" + type] =
3332  dir.make<TH1F>(("tpullxy_" + type).c_str(), "track r-#phi pull;pull_{r-#phi};tracks", 100, -10., 10.);
3333  h["tpullz_" + type] =
3334  dir.make<TH1F>(("tpullz_" + type).c_str(), "track r-z pull;pull_{r-z};tracks", 100, -50., 50.);
3335  h["tlogDCAxy_" + type] = dir.make<TH1F>(
3336  ("tlogDCAxy_" + type).c_str(), "track log_{10}(DCA_{r-#phi});track log_{10}(DCA_{r-#phi});tracks", 200, -5., 3.);
3337  h["tlogDCAz_" + type] = dir.make<TH1F>(
3338  ("tlogDCAz_" + type).c_str(), "track log_{10}(DCA_{r-z});track log_{10}(DCA_{r-z});tracks", 200, -5., 5.);
3339  h["lvseta_" + type] = dir.make<TH2F>(
3340  ("lvseta_" + type).c_str(), "cluster length vs #eta;track #eta;cluster length", 60, -3., 3., 20, 0., 20);
3341  h["lvstanlambda_" + type] = dir.make<TH2F>(("lvstanlambda_" + type).c_str(),
3342  "cluster length vs tan #lambda; tan#lambda;cluster length",
3343  60,
3344  -6.,
3345  6.,
3346  20,
3347  0.,
3348  20);
3349  h["restrkz_" + type] =
3350  dir.make<TH1F>(("restrkz_" + type).c_str(), "z-residuals (track vs vertex);res_{z} (cm);tracks", 200, -5., 5.);
3351  h["restrkzvsphi_" + type] = dir.make<TH2F>(("restrkzvsphi_" + type).c_str(),
3352  "z-residuals (track - vertex) vs track #phi;track #phi;res_{z} (cm)",
3353  12,
3354  -M_PI,
3355  M_PI,
3356  100,
3357  -0.5,
3358  0.5);
3359  h["restrkzvseta_" + type] = dir.make<TH2F>(("restrkzvseta_" + type).c_str(),
3360  "z-residuals (track - vertex) vs track #eta;track #eta;res_{z} (cm)",
3361  12,
3362  -3.,
3363  3.,
3364  200,
3365  -0.5,
3366  0.5);
3367  h["pulltrkzvsphi_" + type] =
3368  dir.make<TH2F>(("pulltrkzvsphi_" + type).c_str(),
3369  "normalized z-residuals (track - vertex) vs track #phi;track #phi;res_{z}/#sigma_{res_{z}}",
3370  12,
3371  -M_PI,
3372  M_PI,
3373  100,
3374  -5.,
3375  5.);
3376  h["pulltrkzvseta_" + type] =
3377  dir.make<TH2F>(("pulltrkzvseta_" + type).c_str(),
3378  "normalized z-residuals (track - vertex) vs track #eta;track #eta;res_{z}/#sigma_{res_{z}}",
3379  12,
3380  -3.,
3381  3.,
3382  100,
3383  -5.,
3384  5.);
3385  h["pulltrkz_" + type] = dir.make<TH1F>(("pulltrkz_" + type).c_str(),
3386  "normalized z-residuals (track vs vertex);res_{z}/#sigma_{res_{z}};tracks",
3387  100,
3388  -5.,
3389  5.);
3390  h["sigmatrkz0_" + type] = dir.make<TH1F>(
3391  ("sigmatrkz0_" + type).c_str(), "z-resolution (excluding beam);#sigma^{trk}_{z_{0}} (cm);tracks", 100, 0., 5.);
3392  h["sigmatrkz_" + type] = dir.make<TH1F>(
3393  ("sigmatrkz_" + type).c_str(), "z-resolution (including beam);#sigma^{trk}_{z} (cm);tracks", 100, 0., 5.);
3394  h["nbarrelhits_" + type] = dir.make<TH1F>(
3395  ("nbarrelhits_" + type).c_str(), "number of pixel barrel hits;n. hits Barrel Pixel;tracks", 10, 0., 10.);
3396  h["nbarrelLayers_" + type] = dir.make<TH1F>(
3397  ("nbarrelLayers_" + type).c_str(), "number of pixel barrel layers;n. layers Barrel Pixel;tracks", 10, 0., 10.);
3398  h["nPxLayers_" + type] = dir.make<TH1F>(
3399  ("nPxLayers_" + type).c_str(), "number of pixel layers (barrel+endcap);n. Pixel layers;tracks", 10, 0., 10.);
3400  h["nSiLayers_" + type] =
3401  dir.make<TH1F>(("nSiLayers_" + type).c_str(), "number of Tracker layers;n. Tracker layers;tracks", 20, 0., 20.);
3402  h["trackAlgo_" + type] =
3403  dir.make<TH1F>(("trackAlgo_" + type).c_str(), "track algorithm;track algo;tracks", 30, 0., 30.);
3404  h["trackQuality_" + type] =
3405  dir.make<TH1F>(("trackQuality_" + type).c_str(), "track quality;track quality;tracks", 7, -1., 6.);
3406  }
3407 
3408  return h;
3409 }
3410 
3411 //*************************************************************
3412 // Generic booker function
3413 //*************************************************************
3414 std::vector<TH1F*> PrimaryVertexValidation::bookResidualsHistogram(const TFileDirectory& dir,
3415  unsigned int theNOfBins,
3416  PVValHelper::residualType resType,
3417  PVValHelper::plotVariable varType,
3418  bool isNormalized) {
3419  TH1F::SetDefaultSumw2(kTRUE);
3420 
3421  auto hash = std::make_pair(resType, varType);
3422 
3423  double down = theDetails_.range[hash].first;
3424  double up = theDetails_.range[hash].second;
3425 
3426  if (isNormalized) {
3427  up = up / 100.;
3428  down = down / 100.;
3429  }
3430 
3431  std::vector<TH1F*> h;
3432  h.reserve(theNOfBins);
3433 
3434  if (theNOfBins == 0) {
3435  edm::LogError("PrimaryVertexValidation")
3436  << "bookResidualsHistogram() The number of bins cannot be identically 0" << std::endl;
3437  assert(false);
3438  }
3439 
3440  std::string s_resType = std::get<0>(PVValHelper::getTypeString(resType));
3441  std::string s_varType = std::get<0>(PVValHelper::getVarString(varType));
3442 
3443  std::string t_resType = std::get<1>(PVValHelper::getTypeString(resType));
3444  std::string t_varType = std::get<1>(PVValHelper::getVarString(varType));
3445  std::string units = std::get<2>(PVValHelper::getTypeString(resType));
3446 
3447  for (unsigned int i = 0; i < theNOfBins; i++) {
3448  TString title = (varType == PVValHelper::phi || varType == PVValHelper::eta)
3449  ? Form("%s vs %s - bin %i (%f < %s < %f);%s %s;tracks",
3450  t_resType.c_str(),
3451  t_varType.c_str(),
3452  i,
3453  theDetails_.trendbins[varType][i],
3454  t_varType.c_str(),
3455  theDetails_.trendbins[varType][i + 1],
3456  t_resType.c_str(),
3457  units.c_str())
3458  : Form("%s vs %s - bin %i;%s %s;tracks",
3459  t_resType.c_str(),
3460  t_varType.c_str(),
3461  i,
3462  t_resType.c_str(),
3463  units.c_str());
3464 
3465  TH1F* htemp = dir.make<TH1F>(
3466  Form("histo_%s_%s_plot%i", s_resType.c_str(), s_varType.c_str(), i),
3467  //Form("%s vs %s - bin %i;%s %s;tracks",t_resType.c_str(),t_varType.c_str(),i,t_resType.c_str(),units.c_str()),
3468  title.Data(),
3469  theDetails_.histobins,
3470  down,
3471  up);
3472  h.push_back(htemp);
3473  }
3474 
3475  return h;
3476 }
3477 
3478 //*************************************************************
3479 void PrimaryVertexValidation::fillTrackHistos(std::map<std::string, TH1*>& h,
3480  const std::string& ttype,
3481  const reco::TransientTrack* tt,
3482  const reco::Vertex& v,
3483  const reco::BeamSpot& beamSpot,
3484  double fBfield_)
3485 //*************************************************************
3486 {
3487  using namespace reco;
3488 
3489  PVValHelper::fill(h, "pseudorapidity_" + ttype, tt->track().eta());
3490  PVValHelper::fill(h, "z0_" + ttype, tt->track().vz());
3491  PVValHelper::fill(h, "phi_" + ttype, tt->track().phi());
3492  PVValHelper::fill(h, "eta_" + ttype, tt->track().eta());
3493  PVValHelper::fill(h, "pt_" + ttype, tt->track().pt());
3494  PVValHelper::fill(h, "p_" + ttype, tt->track().p());
3495  PVValHelper::fill(h, "found_" + ttype, tt->track().found());
3496  PVValHelper::fill(h, "lost_" + ttype, tt->track().lost());
3497  PVValHelper::fill(h, "nchi2_" + ttype, tt->track().normalizedChi2());
3498  PVValHelper::fill(h, "rstart_" + ttype, (tt->track().innerPosition()).Rho());
3499 
3500  double d0Error = tt->track().d0Error();
3501  double d0 = tt->track().dxy(beamSpot.position());
3502  double dz = tt->track().dz(beamSpot.position());
3503  if (d0Error > 0) {
3504  PVValHelper::fill(h, "logtresxy_" + ttype, log(d0Error / 0.0001) / log(10.));
3505  PVValHelper::fill(h, "tpullxy_" + ttype, d0 / d0Error);
3506  PVValHelper::fill(h, "tlogDCAxy_" + ttype, log(std::abs(d0 / d0Error)));
3507  }
3508  //double z0=tt->track().vz();
3509  double dzError = tt->track().dzError();
3510  if (dzError > 0) {
3511  PVValHelper::fill(h, "logtresz_" + ttype, log(dzError / 0.0001) / log(10.));
3512  PVValHelper::fill(h, "tpullz_" + ttype, dz / dzError);
3513  PVValHelper::fill(h, "tlogDCAz_" + ttype, log(std::abs(dz / dzError)));
3514  }
3515 
3516  //
3517  double wxy2_ = pow(beamSpot.BeamWidthX(), 2) + pow(beamSpot.BeamWidthY(), 2);
3518 
3519  PVValHelper::fill(
3520  h, "sigmatrkz_" + ttype, sqrt(pow(tt->track().dzError(), 2) + wxy2_ / pow(tan(tt->track().theta()), 2)));
3521  PVValHelper::fill(h, "sigmatrkz0_" + ttype, tt->track().dzError());
3522 
3523  // track vs vertex
3524  if (v.isValid()) { // && (v.ndof()<10.)) {
3525  // emulate clusterizer input
3526  //const TransientTrack & tt = theB_->build(&t); wrong !!!!
3527  //reco::TransientTrack tt = theB_->build(&t);
3528  //ttt->track().setBeamSpot(beamSpot); // need the setBeamSpot !
3529  double z = (tt->stateAtBeamLine().trackStateAtPCA()).position().z();
3530  double tantheta = tan((tt->stateAtBeamLine().trackStateAtPCA()).momentum().theta());
3531  double dz2 = pow(tt->track().dzError(), 2) + wxy2_ / pow(tantheta, 2);
3532 
3533  PVValHelper::fill(h, "restrkz_" + ttype, z - v.position().z());
3534  PVValHelper::fill(h, "restrkzvsphi_" + ttype, tt->track().phi(), z - v.position().z());
3535  PVValHelper::fill(h, "restrkzvseta_" + ttype, tt->track().eta(), z - v.position().z());
3536  PVValHelper::fill(h, "pulltrkzvsphi_" + ttype, tt->track().phi(), (z - v.position().z()) / sqrt(dz2));
3537  PVValHelper::fill(h, "pulltrkzvseta_" + ttype, tt->track().eta(), (z - v.position().z()) / sqrt(dz2));
3538 
3539  PVValHelper::fill(h, "pulltrkz_" + ttype, (z - v.position().z()) / sqrt(dz2));
3540 
3541  double x1 = tt->track().vx() - beamSpot.x0();
3542  double y1 = tt->track().vy() - beamSpot.y0();
3543 
3544  double kappa = -0.002998 * fBfield_ * tt->track().qoverp() / cos(tt->track().theta());
3545  double D0 = x1 * sin(tt->track().phi()) - y1 * cos(tt->track().phi()) - 0.5 * kappa * (x1 * x1 + y1 * y1);
3546  double q = sqrt(1. - 2. * kappa * D0);
3547  double s0 = (x1 * cos(tt->track().phi()) + y1 * sin(tt->track().phi())) / q;
3548  // double s1;
3549  if (std::abs(kappa * s0) > 0.001) {
3550  //s1=asin(kappa*s0)/kappa;
3551  } else {
3552  //double ks02=(kappa*s0)*(kappa*s0);
3553  //s1=s0*(1.+ks02/6.+3./40.*ks02*ks02+5./112.*pow(ks02,3));
3554  }
3555  // sp.ddcap=-2.*D0/(1.+q);
3556  //double zdcap=tt->track().vz()-s1/tan(tt->track().theta());
3557  }
3558  //
3559 
3560  // collect some info on hits and clusters
3561  PVValHelper::fill(h, "nbarrelLayers_" + ttype, tt->track().hitPattern().pixelBarrelLayersWithMeasurement());
3562  PVValHelper::fill(h, "nPxLayers_" + ttype, tt->track().hitPattern().pixelLayersWithMeasurement());
3563  PVValHelper::fill(h, "nSiLayers_" + ttype, tt->track().hitPattern().trackerLayersWithMeasurement());
3564  PVValHelper::fill(
3565  h, "expectedInner_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS));
3566  PVValHelper::fill(
3567  h, "expectedOuter_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_OUTER_HITS));
3568  PVValHelper::fill(h, "trackAlgo_" + ttype, tt->track().algo());
3569  PVValHelper::fill(h, "trackQuality_" + ttype, tt->track().qualityMask());
3570 
3571  //
3572  int longesthit = 0, nbarrel = 0;
3573  for (auto const& hit : tt->track().recHits()) {
3574  if (hit->isValid() && hit->geographicalId().det() == DetId::Tracker) {
3575  bool barrel = DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
3576  //bool endcap = DetId::DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
3577  if (barrel) {
3578  const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>(&(*hit));
3579  edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const& clust = (*pixhit).cluster();
3580  if (clust.isNonnull()) {
3581  nbarrel++;
3582  if (clust->sizeY() - longesthit > 0)
3583  longesthit = clust->sizeY();
3584  if (clust->sizeY() > 20.) {
3585  PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), 19.9);
3586  PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), 19.9);
3587  } else {
3588  PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), float(clust->sizeY()));
3589  PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), float(clust->sizeY()));
3590  }
3591  }
3592  }
3593  }
3594  }
3595  PVValHelper::fill(h, "nbarrelhits_" + ttype, float(nbarrel));
3596  //-------------------------------------------------------------------
3597 }
3598 
3599 //define this as a plug-in
3600 DEFINE_FWK_MODULE(PrimaryVertexValidation);
AdaptiveVertexFitter
Definition: AdaptiveVertexFitter.h:29
PrimaryVertexValidation::a_dxyEtaWidthBiasTrend
TH1F * a_dxyEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:531
PrimaryVertexValidation::chi2UnbiasedVertex_
float chi2UnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:259
PVValHelper::getVarString
plotLabels getVarString(plotVariable var)
Definition: PVValidationHelpers.cc:130
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
PrimaryVertexValidation::h_norm_dz_modZ_
std::vector< TH1F * > h_norm_dz_modZ_
Definition: PrimaryVertexValidation.h:690
PrimaryVertexValidation::MADTrendsDir
TFileDirectory MADTrendsDir
Definition: PrimaryVertexValidation.h:285
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:38
PrimaryVertexValidation::n_dzPhiResiduals
std::vector< TH1F * > n_dzPhiResiduals
Definition: PrimaryVertexValidation.h:333
PrimaryVertexValidation::n_dxyEtaMedianTrend
TH1F * n_dxyEtaMedianTrend
Definition: PrimaryVertexValidation.h:448
PVValHelper::resz
Definition: PVValidationHelpers.h:52
PerigeeTrajectoryParameters::longitudinalImpactParameter
double longitudinalImpactParameter() const
Definition: PerigeeTrajectoryParameters.h:74
PrimaryVertexValidation::a_dxyL1MeanMap
TH2F * a_dxyL1MeanMap
Definition: PrimaryVertexValidation.h:483
PrimaryVertexValidation::PrimaryVertexValidation
PrimaryVertexValidation(const edm::ParameterSet &)
Definition: PrimaryVertexValidation.cc:71
PrimaryVertexValidation::a_dzpTWidthTrend
TH1F * a_dzpTWidthTrend
Definition: PrimaryVertexValidation.h:392
DDAxes::y
PrimaryVertexValidation::h_probeChi2_
TH1F * h_probeChi2_
Definition: PrimaryVertexValidation.h:612
PrimaryVertexValidation::chi2_
double chi2_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:244
PrimaryVertexValidation::n_dxyPhiBiasResiduals
std::vector< TH1F * > n_dxyPhiBiasResiduals
Definition: PrimaryVertexValidation.h:509
PrimaryVertexValidation::h_runNumber
TH1F * h_runNumber
Definition: PrimaryVertexValidation.h:585
PrimaryVertexValidation::a_dzEtaMADBiasTrend
TH1F * a_dzEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:555
PrimaryVertexValidation::h_probeL1ClusterProb_
TH1F * h_probeL1ClusterProb_
Definition: PrimaryVertexValidation.h:652
PrimaryVertexValidation::n_dzPhiBiasResiduals
std::vector< TH1F * > n_dzPhiBiasResiduals
Definition: PrimaryVertexValidation.h:512
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
PrimaryVertexValidation::n_d3DEtaResiduals
std::vector< TH1F * > n_d3DEtaResiduals
Definition: PrimaryVertexValidation.h:346
PrimaryVertexValidation::h_probeHits_
TH1F * h_probeHits_
Definition: PrimaryVertexValidation.h:638
MonitorHOAlCaRecoStream_cfi.highedge
highedge
Definition: MonitorHOAlCaRecoStream_cfi.py:12
PrimaryVertexValidation::IP3DsigFromMyVertex_
double IP3DsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:275
electrons_cff.bool
bool
Definition: electrons_cff.py:372
mps_fire.i
i
Definition: mps_fire.py:355
PrimaryVertexValidation::n_dxyWidthMap
TH2F * n_dxyWidthMap
Definition: PrimaryVertexValidation.h:478
PrimaryVertexValidation::h2_probeLayer1Map_
TH2F * h2_probeLayer1Map_
Definition: PrimaryVertexValidation.h:653
PrimaryVertexValidation::h_norm_dz_Central_pT_
std::vector< TH1F * > h_norm_dz_Central_pT_
Definition: PrimaryVertexValidation.h:683
PrimaryVertexValidation::n_dxyPhiMedianTrend
TH1F * n_dxyPhiMedianTrend
Definition: PrimaryVertexValidation.h:443
PrimaryVertexValidation::h_norm_dxy_modZ_
std::vector< TH1F * > h_norm_dxy_modZ_
Definition: PrimaryVertexValidation.h:689
PVValHelper::max_eta_phase1
const double max_eta_phase1
Definition: PVValidationHelpers.h:24
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
PrimaryVertexValidation::h_nClus
TH1F * h_nClus
Definition: PrimaryVertexValidation.h:583
PrimaryVertexValidation::n_dzEtaMeanTrend
TH1F * n_dzEtaMeanTrend
Definition: PrimaryVertexValidation.h:384
PrimaryVertexValidation::h_nbins
TH1F * h_nbins
Definition: PrimaryVertexValidation.h:292
Reference_intrackfit_cff.barrel
list barrel
Definition: Reference_intrackfit_cff.py:37
PrimaryVertexValidation::a_dxyEtaMADBiasTrend
TH1F * a_dxyEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:553
PrimaryVertexValidation::WidthTrendsDir
TFileDirectory WidthTrendsDir
Definition: PrimaryVertexValidation.h:283
PrimaryVertexValidation::BSz0_
double BSz0_
Definition: PrimaryVertexValidation.h:221
MessageLogger.h
PrimaryVertexValidation::n_dzEtaMedianTrend
TH1F * n_dzEtaMedianTrend
Definition: PrimaryVertexValidation.h:450
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
PrimaryVertexValidation::h_probePhi_
TH1F * h_probePhi_
Definition: PrimaryVertexValidation.h:611
PrimaryVertexValidation::a_dzBiasResidualsMap
TH1F * a_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:518
funct::false
false
Definition: Factorize.h:34
PixelSubdetector::PixelEndcap
Definition: PixelSubdetector.h:11
PrimaryVertexValidation::n_dzWidthMap
TH2F * n_dzWidthMap
Definition: PrimaryVertexValidation.h:479
TrackerGeometry.h
DAClusterizerInZ_vect.h
PrimaryVertexValidation::n_dxyEtaMADBiasTrend
TH1F * n_dxyEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:563
PrimaryVertexValidation::h_probePt_
TH1F * h_probePt_
Definition: PrimaryVertexValidation.h:608
PrimaryVertexValidation::n_dzladderMeanTrend
TH1F * n_dzladderMeanTrend
Definition: PrimaryVertexValidation.h:428
PrimaryVertexValidation::nhits1D_
int nhits1D_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:232
PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11
PrimaryVertexValidation::h_probedzRecoV_
TH1F * h_probedzRecoV_
Definition: PrimaryVertexValidation.h:617
PrimaryVertexValidation::n_dzResidualsMap
TH1F * n_dzResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:355
PrimaryVertexValidation::a_dxyEtaMedianTrend
TH1F * a_dxyEtaMedianTrend
Definition: PrimaryVertexValidation.h:438
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
PVValHelper::norm_IP2D
Definition: PVValidationHelpers.h:60
PrimaryVertexValidation::a_d3DEtaResiduals
std::vector< TH1F * > a_d3DEtaResiduals
Definition: PrimaryVertexValidation.h:326
PrimaryVertexValidation::nBins_
int nBins_
Definition: PrimaryVertexValidation.h:165
PrimaryVertexValidation::a_dxyResidualsMap
TH1F * a_dxyResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:350
groupFilesInBlocks.tt
int tt
Definition: groupFilesInBlocks.py:144
PrimaryVertexValidation::a_dxyladderMeanTrend
TH1F * a_dxyladderMeanTrend
Definition: PrimaryVertexValidation.h:416
PrimaryVertexValidation::h_fitVtxNtracks_
TH1F * h_fitVtxNtracks_
Definition: PrimaryVertexValidation.h:660
PrimaryVertexValidation::a_dzResidualsMap
TH1F * a_dzResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:351
VertexException
Common base class.
Definition: VertexException.h:12
PrimaryVertexValidation::xErrOfflineVertex_
double xErrOfflineVertex_
Definition: PrimaryVertexValidation.h:215
PrimaryVertexValidation::h_probedxyRecoV_
TH1F * h_probedxyRecoV_
Definition: PrimaryVertexValidation.h:618
PrimaryVertexValidation::h_probeEta_
TH1F * h_probeEta_
Definition: PrimaryVertexValidation.h:610
funct::D0
Divides< arg, void > D0
Definition: Factorize.h:135
PrimaryVertexValidation::a_dzEtaMeanBiasTrend
TH1F * a_dzEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:532
PrimaryVertexValidation::n_dxyL1MeanMap
TH2F * n_dxyL1MeanMap
Definition: PrimaryVertexValidation.h:486
PrimaryVertexValidation::runControlNumbers_
std::vector< unsigned int > runControlNumbers_
Definition: PrimaryVertexValidation.h:171
PrimaryVertexValidation::a_dxyPhiWidthBiasTrend
TH1F * a_dxyPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:526
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PVValHelper::WIDTH
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::a_dzpTMeanTrend
TH1F * a_dzpTMeanTrend
Definition: PrimaryVertexValidation.h:391
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:605
PrimaryVertexValidation::h_norm_dxy_Central_pT_
std::vector< TH1F * > h_norm_dxy_Central_pT_
Definition: PrimaryVertexValidation.h:682
PrimaryVertexValidation::n_dzmodZWidthTrend
TH1F * n_dzmodZWidthTrend
Definition: PrimaryVertexValidation.h:424
min
T min(T a, T b)
Definition: MathUtil.h:58
cond::hash
Definition: Time.h:19
TrajectoryStateClosestToPoint.h
PrimaryVertexValidation::a_dzEtaBiasResiduals
std::vector< TH1F * > a_dzEtaBiasResiduals
Definition: PrimaryVertexValidation.h:505
PrimaryVertexValidation::endJob
void endJob() override
Definition: PrimaryVertexValidation.cc:2594
PrimaryVertexValidation
Definition: PrimaryVertexValidation.h:67
PrimaryVertexValidation::h_probeRefitVSig3D_
TH1F * h_probeRefitVSig3D_
Definition: PrimaryVertexValidation.h:634
PrimaryVertexValidation::a_IP3DPhiResiduals
std::vector< TH1F * > a_IP3DPhiResiduals
Definition: PrimaryVertexValidation.h:319
TFileDirectory::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileDirectory.h:53
PrimaryVertexValidation::a_dzWidthMap
TH2F * a_dzWidthMap
Definition: PrimaryVertexValidation.h:476
PrimaryVertexValidation::a_dzL1MeanMap
TH2F * a_dzL1MeanMap
Definition: PrimaryVertexValidation.h:484
Measurement1D::value
double value() const
Definition: Measurement1D.h:25
PrimaryVertexValidation::n_dxyladderWidthTrend
TH1F * n_dxyladderWidthTrend
Definition: PrimaryVertexValidation.h:427
PrimaryVertexValidation::a_dxyL1WidthMap
TH2F * a_dxyL1WidthMap
Definition: PrimaryVertexValidation.h:489
PrimaryVertexValidation::h_nTracks
TH1F * h_nTracks
Definition: PrimaryVertexValidation.h:582
TrackerTopology
Definition: TrackerTopology.h:16
IPTools::absoluteImpactParameter3D
std::pair< bool, Measurement1D > absoluteImpactParameter3D(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:38
PrimaryVertexValidation::h_BSy0
TH1F * h_BSy0
Definition: PrimaryVertexValidation.h:596
PrimaryVertexValidation::a_dzPhiMeanTrend
TH1F * a_dzPhiMeanTrend
Definition: PrimaryVertexValidation.h:369
PrimaryVertexValidation::h_probez0RefitV_
TH1F * h_probez0RefitV_
Definition: PrimaryVertexValidation.h:624
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
h
FWCore Framework interface EventSetupRecordImplementation h
Helper function to determine trigger accepts.
Definition: L1TUtmAlgorithmRcd.h:4
PrimaryVertexValidation::nMaxtracks_
static const int nMaxtracks_
Definition: PrimaryVertexValidation.h:189
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
PrimaryVertexValidation::h_runFromEvent
TH1I * h_runFromEvent
Definition: PrimaryVertexValidation.h:588
PrimaryVertexValidation::RunNumber_
unsigned int RunNumber_
Definition: PrimaryVertexValidation.h:208
PrimaryVertexValidation::h_probereszRefitV_
TH1F * h_probereszRefitV_
Definition: PrimaryVertexValidation.h:628
PVValHelper::fill
void fill(std::map< std::string, TH1 * > &h, const std::string &s, double x)
Definition: PVValidationHelpers.cc:20
edm::LogInfo
Definition: MessageLogger.h:254
PrimaryVertexValidation::h_probesignIP2DRefitV_
TH1F * h_probesignIP2DRefitV_
Definition: PrimaryVertexValidation.h:626
PrimaryVertexValidation::isHit2D
bool isHit2D(const TrackingRecHit &hit) const
Definition: PrimaryVertexValidation.cc:1103
PrimaryVertexValidation::a_dxypTWidthTrend
TH1F * a_dxypTWidthTrend
Definition: PrimaryVertexValidation.h:390
PVValHelper::getTypeString
plotLabels getTypeString(residualType type)
Definition: PVValidationHelpers.cc:63
PrimaryVertexValidation::nTracks_
int nTracks_
Definition: PrimaryVertexValidation.h:204
HLT_2018_cff.etaBins
etaBins
Definition: HLT_2018_cff.py:13873
PrimaryVertexValidation::Nevt_
int Nevt_
Definition: PrimaryVertexValidation.h:132
PrimaryVertexValidation::DOFUnbiasedVertex_
float DOFUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:261
PrimaryVertexValidation::n_dxyPhiMADBiasTrend
TH1F * n_dxyPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:558
data-class-funcs.q
q
Definition: data-class-funcs.py:169
Measurement1D.h
PrimaryVertexValidation::n_dxyEtaResiduals
std::vector< TH1F * > n_dxyEtaResiduals
Definition: PrimaryVertexValidation.h:331
PrimaryVertexValidation::h_probeRefitVSigResZ_
TH1F * h_probeRefitVSigResZ_
Definition: PrimaryVertexValidation.h:636
PVValHelper::fillByIndex
void fillByIndex(std::vector< TH1F * > &h, unsigned int index, double x, std::string tag="")
Definition: PVValidationHelpers.cc:42
PrimaryVertexValidation::d3DFromMyVertex_
double d3DFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:267
PrimaryVertexValidation::qoverp_
double qoverp_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:247
PrimaryVertexValidation::h_probeL1Module_
TH1F * h_probeL1Module_
Definition: PrimaryVertexValidation.h:649
PrimaryVertexValidation::debug_
bool debug_
Definition: PrimaryVertexValidation.h:173
cms::cuda::assert
assert(be >=bs)
HLT_2018_cff.distance
distance
Definition: HLT_2018_cff.py:6417
PrimaryVertexValidation::a_reszPhiResiduals
std::vector< TH1F * > a_reszPhiResiduals
Definition: PrimaryVertexValidation.h:322
PrimaryVertexValidation::BSy0_
double BSy0_
Definition: PrimaryVertexValidation.h:220
reco::TrackBase::TrackQuality
TrackQuality
track quality
Definition: TrackBase.h:150
PrimaryVertexValidation::hDA
std::map< std::string, TH1 * > hDA
Definition: PrimaryVertexValidation.h:671
PrimaryVertexValidation::n_dxyMeanBiasMap
TH2F * n_dxyMeanBiasMap
Definition: PrimaryVertexValidation.h:572
PrimaryVertexValidation::h_probeHitsInTID_
TH1F * h_probeHitsInTID_
Definition: PrimaryVertexValidation.h:643
GlobalTrackingGeometryRecord
Definition: GlobalTrackingGeometryRecord.h:17
PrimaryVertexValidation::a_dxyWidthMap
TH2F * a_dxyWidthMap
Definition: PrimaryVertexValidation.h:475
PrimaryVertexValidation::h_pTinfo
TH1F * h_pTinfo
Definition: PrimaryVertexValidation.h:294
PrimaryVertexValidation::h_probedzRefitV_
TH1F * h_probedzRefitV_
Definition: PrimaryVertexValidation.h:620
PrimaryVertexValidation::dxyBs_
double dxyBs_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:250
PVValHelper::histodetails::histobins
int histobins
Definition: PVValidationHelpers.h:78
PrimaryVertexValidation::n_reszPhiResiduals
std::vector< TH1F * > n_reszPhiResiduals
Definition: PrimaryVertexValidation.h:342
reco::TrackBase::px
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:611
PrimaryVertexValidation::nOfflineVertices_
int nOfflineVertices_
Definition: PrimaryVertexValidation.h:207
PrimaryVertexValidation::a_dxyPhiMedianTrend
TH1F * a_dxyPhiMedianTrend
Definition: PrimaryVertexValidation.h:433
PrimaryVertexValidation::BeamWidthY_
double BeamWidthY_
Definition: PrimaryVertexValidation.h:225
PrimaryVertexValidation::pOfProbe_
double pOfProbe_
Definition: PrimaryVertexValidation.h:159
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
PrimaryVertexValidation::a_dzPhiWidthBiasTrend
TH1F * a_dzPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:528
PrimaryVertexValidation::h_probePtRebin_
TH1F * h_probePtRebin_
Definition: PrimaryVertexValidation.h:609
PrimaryVertexValidation::dxyFromMyVertex_
double dxyFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:265
PrimaryVertexValidation::a_dzladderWidthTrend
TH1F * a_dzladderWidthTrend
Definition: PrimaryVertexValidation.h:419
PrimaryVertexValidation::n_d3DPhiResiduals
std::vector< TH1F * > n_d3DPhiResiduals
Definition: PrimaryVertexValidation.h:345
PrimaryVertexValidation::a_dzEtaWidthBiasTrend
TH1F * a_dzEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:533
DDAxes::x
TFileDirectory
Definition: TFileDirectory.h:24
SiPixelCluster
Pixel cluster – collection of neighboring pixels above threshold.
Definition: SiPixelCluster.h:27
PrimaryVertexValidation::n_dzL1WidthMap
TH2F * n_dzL1WidthMap
Definition: PrimaryVertexValidation.h:493
PrimaryVertexValidation::h_probeRefitVSigXY_
TH1F * h_probeRefitVSigXY_
Definition: PrimaryVertexValidation.h:633
PrimaryVertexValidation::n_dxyBiasResidualsMap
TH1F * n_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:520
PrimaryVertexValidation::MeanTrendsDir
TFileDirectory MeanTrendsDir
Definition: PrimaryVertexValidation.h:282
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
PrimaryVertexValidation::h_fitVtxNdof_
TH1F * h_fitVtxNdof_
Definition: PrimaryVertexValidation.h:658
FreeTrajectoryState::position
GlobalPoint position() const
Definition: FreeTrajectoryState.h:67
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
cms::Exception::what
char const * what() const noexcept override
Definition: Exception.cc:103
TransientTrack.h
PVValHelper::plotVariable
plotVariable
Definition: PVValidationHelpers.h:67
findQualityFiles.v
v
Definition: findQualityFiles.py:179
IPTools::signedTransverseImpactParameter
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:57
PrimaryVertexValidation::h_etaMax
TH1F * h_etaMax
Definition: PrimaryVertexValidation.h:291
PrimaryVertexValidation::h_probeRefitVSigZ_
TH1F * h_probeRefitVSigZ_
Definition: PrimaryVertexValidation.h:632
PrimaryVertexValidation::h_dz_modZ_
std::vector< TH1F * > h_dz_modZ_
Definition: PrimaryVertexValidation.h:688
PrimaryVertexValidation::h_dxy_modZ_
std::vector< TH1F * > h_dxy_modZ_
Definition: PrimaryVertexValidation.h:687
PrimaryVertexValidation::isGoodTrack_
int isGoodTrack_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:278
PrimaryVertexValidation::pixelHitsCheck
std::pair< bool, bool > pixelHitsCheck(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1135
edm::Handle
Definition: AssociativeIterator.h:50
PrimaryVertexValidation::LuminosityBlockNumber_
unsigned int LuminosityBlockNumber_
Definition: PrimaryVertexValidation.h:210
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:751
PrimaryVertexValidation::a_dzpTCentralWidthTrend
TH1F * a_dzpTCentralWidthTrend
Definition: PrimaryVertexValidation.h:397
PrimaryVertexValidation::n_dxyEtaBiasResiduals
std::vector< TH1F * > n_dxyEtaBiasResiduals
Definition: PrimaryVertexValidation.h:510
PrimaryVertexValidation::h_norm_dxy_ladder_
std::vector< TH1F * > h_norm_dxy_ladder_
Definition: PrimaryVertexValidation.h:697
PrimaryVertexValidation::nhits_
int nhits_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:231
PrimaryVertexValidation::Beamsigmaz_
double Beamsigmaz_
Definition: PrimaryVertexValidation.h:222
PrimaryVertexValidation::nhitsTIB_
int nhitsTIB_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:236
PrimaryVertexValidation::fillTrendPlot
void fillTrendPlot(TH1F *trendPlot, TH1F *residualsPlot[100], PVValHelper::estimator fitPar_, const std::string &var_)
Definition: PrimaryVertexValidation.cc:3060
PrimaryVertexValidation::a_dxyVsEta
TH2F * a_dxyVsEta
Definition: PrimaryVertexValidation.h:461
PrimaryVertexValidation::n_dzPhiWidthBiasTrend
TH1F * n_dzPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:538
SiPixelRecHit
Our base class.
Definition: SiPixelRecHit.h:23
PrimaryVertexValidation::h_dxy_pT_
std::vector< TH1F * > h_dxy_pT_
Definition: PrimaryVertexValidation.h:675
PrimaryVertexValidation::IPTsigFromMyVertex_
double IPTsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:273
edm::Ref
Definition: AssociativeIterator.h:58
HLT_FULL_cff.zVertex
zVertex
Definition: HLT_FULL_cff.py:109725
PrimaryVertexValidation::a_dzPhiWidthTrend
TH1F * a_dzPhiWidthTrend
Definition: PrimaryVertexValidation.h:370
PrimaryVertexValidation::a_IP3DEtaResiduals
std::vector< TH1F * > a_IP3DEtaResiduals
Definition: PrimaryVertexValidation.h:320
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
units
TString units(TString variable, Char_t axis)
PrimaryVertexValidation::zPCA_
double zPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:254
PrimaryVertexValidation::SetVarToZero
void SetVarToZero()
Definition: PrimaryVertexValidation.cc:2986
PrimaryVertexValidation::a_dzEtaMeanTrend
TH1F * a_dzEtaMeanTrend
Definition: PrimaryVertexValidation.h:374
PVValHelper::END_OF_TYPES
Definition: PVValidationHelpers.h:64
PrimaryVertexValidation::chi2ProbUnbiasedVertex_
float chi2ProbUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:260
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
PrimaryVertexValidation::h_fitVtxTrackWeights_
TH1F * h_fitVtxTrackWeights_
Definition: PrimaryVertexValidation.h:663
PrimaryVertexValidation::h_norm_dxy_pT_
std::vector< TH1F * > h_norm_dxy_pT_
Definition: PrimaryVertexValidation.h:677
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:608
PrimaryVertexValidation::a_d3DPhiResiduals
std::vector< TH1F * > a_d3DPhiResiduals
Definition: PrimaryVertexValidation.h:325
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
PrimaryVertexValidation::n_reszEtaResiduals
std::vector< TH1F * > n_reszEtaResiduals
Definition: PrimaryVertexValidation.h:343
DetId
Definition: DetId.h:17
PrimaryVertexValidation::h_fitVtxChi2ndf_
TH1F * h_fitVtxChi2ndf_
Definition: PrimaryVertexValidation.h:661
PrimaryVertexValidation::wxy2_
double wxy2_
Definition: PrimaryVertexValidation.h:226
PVValHelper::norm_resz
Definition: PVValidationHelpers.h:61
TrackerTopology.h
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33
PVValHelper::histodetails::trendbins
std::map< plotVariable, std::vector< float > > trendbins
Definition: PVValidationHelpers.h:80
reco::HitPattern
Definition: HitPattern.h:147
down
Definition: BitonicSort.h:7
PVValHelper::norm_d3D
Definition: PVValidationHelpers.h:63
testProducerWithPsetDescEmpty_cfi.y1
y1
Definition: testProducerWithPsetDescEmpty_cfi.py:29
PrimaryVertexValidation::h_lumiFromConfig
TH1F * h_lumiFromConfig
Definition: PrimaryVertexValidation.h:586
PrimaryVertexValidation::h_fitVtxChi2Prob_
TH1F * h_fitVtxChi2Prob_
Definition: PrimaryVertexValidation.h:662
PrimaryVertexValidation::a_dzL1ResidualsMap
TH1F * a_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:361
PrimaryVertexValidation::a_dzVsEta
TH2F * a_dzVsEta
Definition: PrimaryVertexValidation.h:462
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
PrimaryVertexValidation::h_probeQoverP_
TH1F * h_probeQoverP_
Definition: PrimaryVertexValidation.h:615
h
PrimaryVertexValidation::a_dzmodZMeanTrend
TH1F * a_dzmodZMeanTrend
Definition: PrimaryVertexValidation.h:413
TrackerTopologyRcd.h
Track.h
PVValHelper::estimator
estimator
Definition: PVValidationHelpers.h:44
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
TrackFwd.h
PrimaryVertexValidation::ptOfProbe_
double ptOfProbe_
Definition: PrimaryVertexValidation.h:158
PrimaryVertexValidation::a_dxyPhiMADBiasTrend
TH1F * a_dxyPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:548
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
PrimaryVertexValidation::a_dxyPhiWidthTrend
TH1F * a_dxyPhiWidthTrend
Definition: PrimaryVertexValidation.h:368
BeamSpot.h
PrimaryVertexValidation::zErrOfflineVertex_
double zErrOfflineVertex_
Definition: PrimaryVertexValidation.h:217
PrimaryVertexValidation::zOfflineVertex_
double zOfflineVertex_
Definition: PrimaryVertexValidation.h:213
PerigeeConversions::trajectoryStateClosestToPoint
TrajectoryStateClosestToPoint trajectoryStateClosestToPoint(const AlgebraicVector3 &momentum, const GlobalPoint &referencePoint, const TrackCharge &charge, const AlgebraicSymMatrix66 &theCovarianceMatrix, const MagneticField *field)
Definition: PerigeeConversions.cc:97
reco::TrackBase::py
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:614
PrimaryVertexValidation::h_xErrOfflineVertex
TH1F * h_xErrOfflineVertex
Definition: PrimaryVertexValidation.h:592
PrimaryVertexValidation::h_dxy_ladder_
std::vector< TH1F * > h_dxy_ladder_
Definition: PrimaryVertexValidation.h:695
PerigeeTrajectoryError::longitudinalImpactParameterError
double longitudinalImpactParameterError() const
Definition: PerigeeTrajectoryError.h:68
PrimaryVertexValidation::fillTrackHistos
void fillTrackHistos(std::map< std::string, TH1 * > &h, const std::string &ttype, const reco::TransientTrack *tt, const reco::Vertex &v, const reco::BeamSpot &beamSpot, double fBfield)
Definition: PrimaryVertexValidation.cc:3479
PVValHelper::max_eta_phase0
const double max_eta_phase0
Definition: PVValidationHelpers.h:23
PrimaryVertexValidation::chi2normUnbiasedVertex_
float chi2normUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:258
GeomDetEnumerators::P1PXEC
Definition: GeomDetEnumerators.h:26
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
PrimaryVertexValidation::a_dxyEtaMeanTrend
TH1F * a_dxyEtaMeanTrend
Definition: PrimaryVertexValidation.h:372
PrimaryVertexValidation::h_BSz0
TH1F * h_BSz0
Definition: PrimaryVertexValidation.h:597
TrajectoryStateClosestToPoint::position
GlobalPoint position() const
Definition: TrajectoryStateClosestToPoint.h:90
PVValHelper::eta
Definition: PVValidationHelpers.h:69
PrimaryVertexValidation::yUnbiasedVertex_
double yUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:256
PrimaryVertexValidation::pt_
double pt_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:229
PVValHelper::pT
Definition: PVValidationHelpers.h:70
DAClusterizerInZ.h
PVValHelper::pTCentral
Definition: PVValidationHelpers.h:71
PrimaryVertexValidation::fillTrendPlotByIndex
void fillTrendPlotByIndex(TH1F *trendPlot, std::vector< TH1F * > &h, PVValHelper::estimator fitPar_, PVValHelper::plotVariable plotVar=PVValHelper::END_OF_PLOTS)
Definition: PrimaryVertexValidation.cc:3122
PrimaryVertexValidation::theTrackClusterizer_
std::unique_ptr< TrackClusterizerInZ > theTrackClusterizer_
Definition: PrimaryVertexValidation.h:135
TrackerDigiGeometryRecord
Definition: TrackerDigiGeometryRecord.h:15
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PrimaryVertexValidation::theVertexCollectionToken
edm::EDGetTokenT< reco::VertexCollection > theVertexCollectionToken
Definition: PrimaryVertexValidation.h:180
PrimaryVertexValidation::h_BSx0
TH1F * h_BSx0
Definition: PrimaryVertexValidation.h:595
PrimaryVertexValidation::n_dzEtaWidthBiasTrend
TH1F * n_dzEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:543
PrimaryVertexValidation::n_dxyL1WidthMap
TH2F * n_dxyL1WidthMap
Definition: PrimaryVertexValidation.h:492
PrimaryVertexValidation::n_dzEtaMADBiasTrend
TH1F * n_dzEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:565
PrimaryVertexValidation::a_dzPhiBiasResiduals
std::vector< TH1F * > a_dzPhiBiasResiduals
Definition: PrimaryVertexValidation.h:504
reco::BeamSpot
Definition: BeamSpot.h:21
DDAxes::z
TransientTrackRecord
Definition: TransientTrackRecord.h:11
PrimaryVertexValidation::a_IP2DPhiResiduals
std::vector< TH1F * > a_IP2DPhiResiduals
Definition: PrimaryVertexValidation.h:316
PrimaryVertexValidation::a_dxyMeanMap
TH2F * a_dxyMeanMap
Definition: PrimaryVertexValidation.h:469
reco::Track
Definition: Track.h:27
IdealMagneticFieldRecord.h
edm::ESHandle< MagneticField >
PrimaryVertexValidation::a_dzVsPhi
TH2F * a_dzVsPhi
Definition: PrimaryVertexValidation.h:456
PrimaryVertexValidation::h2_probePassingLayer1Map_
TH2F * h2_probePassingLayer1Map_
Definition: PrimaryVertexValidation.h:654
PVValHelper::histodetails::getHigh
float getHigh(residualType type, plotVariable plot)
Definition: PVValidationHelpers.h:105
PrimaryVertexValidation::a_dzEtaResiduals
std::vector< TH1F * > a_dzEtaResiduals
Definition: PrimaryVertexValidation.h:314
PrimaryVertexValidation::h_zOfflineVertex
TH1F * h_zOfflineVertex
Definition: PrimaryVertexValidation.h:591
PVValHelper::modZ
Definition: PVValidationHelpers.h:73
PrimaryVertexValidation::a_dzPhiMeanBiasTrend
TH1F * a_dzPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:527
reco::Track::recHits
auto recHits() const
Access to reconstructed hits on the track.
Definition: Track.h:85
PVValHelper::norm_dxy
Definition: PVValidationHelpers.h:56
PrimaryVertexValidation::vertexZMax_
double vertexZMax_
Definition: PrimaryVertexValidation.h:149
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:581
PrimaryVertexValidation::n_dxymodZWidthTrend
TH1F * n_dxymodZWidthTrend
Definition: PrimaryVertexValidation.h:422
PrimaryVertexValidation::EventNumber_
unsigned int EventNumber_
Definition: PrimaryVertexValidation.h:209
TrajectoryStateClosestToPoint::perigeeError
const PerigeeTrajectoryError & perigeeError() const
Definition: TrajectoryStateClosestToPoint.h:84
PrimaryVertexValidation::bookVertexHistograms
std::map< std::string, TH1 * > bookVertexHistograms(const TFileDirectory &dir)
Definition: PrimaryVertexValidation.cc:3292
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:602
PrimaryVertexValidation::theTrackFilter_
std::unique_ptr< TrackFilterForPVFindingBase > theTrackFilter_
Definition: PrimaryVertexValidation.h:134
HLTMuonOfflineAnalyzer_cfi.z0
z0
Definition: HLTMuonOfflineAnalyzer_cfi.py:98
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
PrimaryVertexValidation::a_dxEtaResiduals
std::vector< TH1F * > a_dxEtaResiduals
Definition: PrimaryVertexValidation.h:308
PrimaryVertexValidation::n_dzPhiMeanBiasTrend
TH1F * n_dzPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:537
Point3DBase< float, GlobalTag >
PrimaryVertexValidation::nhitsTID_
int nhitsTID_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:237
TrajectoryStateClosestToPoint::perigeeParameters
const PerigeeTrajectoryParameters & perigeeParameters() const
Definition: TrajectoryStateClosestToPoint.h:73
PrimaryVertexValidation::beginJob
void beginJob() override
Definition: PrimaryVertexValidation.cc:1168
b
double b
Definition: hdecay.h:118
TrackerGeometry::isThere
bool isThere(GeomDetEnumerators::SubDetector subdet) const
Definition: TrackerGeometry.cc:219
PrimaryVertexValidation::h_probeHits2D_
TH1F * h_probeHits2D_
Definition: PrimaryVertexValidation.h:640
PrimaryVertexValidation::dzErrorFromMyVertex_
double dzErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:270
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:620
dumpRecoGeometry_cfg.varType
varType
Definition: dumpRecoGeometry_cfg.py:8
PrimaryVertexValidation::h_yErrOfflineVertex
TH1F * h_yErrOfflineVertex
Definition: PrimaryVertexValidation.h:593
PrimaryVertexValidation::nhitsFPIX_
int nhitsFPIX_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:235
PrimaryVertexValidation::nHitsOfProbe_
double nHitsOfProbe_
Definition: PrimaryVertexValidation.h:161
PrimaryVertexValidation::isHighPurity_
int isHighPurity_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:240
PVValHelper::END_OF_PLOTS
Definition: PVValidationHelpers.h:74
PrimaryVertexValidation::dz_
double dz_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:248
PrimaryVertexValidation::doFPix_
bool doFPix_
Definition: PrimaryVertexValidation.h:157
edm::OwnVector::const_iterator
Definition: OwnVector.h:41
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
Measurement1D::error
double error() const
Definition: Measurement1D.h:27
GlobalTrackingGeometryRecord.h
PrimaryVertexValidation::useTracksFromRecoVtx_
bool useTracksFromRecoVtx_
Definition: PrimaryVertexValidation.h:143
RunInfoRcd
Definition: RunSummaryRcd.h:26
PrimaryVertexValidation::n_dxyPhiMADTrend
TH1F * n_dxyPhiMADTrend
Definition: PrimaryVertexValidation.h:444
PrimaryVertexValidation::n_dzPhiMADBiasTrend
TH1F * n_dzPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:560
RunInfo::m_stop_time_ll
long long m_stop_time_ll
Definition: RunInfo.h:23
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PrimaryVertexValidation::n_dzPhiMedianBiasTrend
TH1F * n_dzPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:559
PrimaryVertexValidation::isBFieldConsistentWithMode
bool isBFieldConsistentWithMode(const edm::EventSetup &iSetup) const
Definition: PrimaryVertexValidation.cc:2972
PrimaryVertexValidation::n_dzMeanBiasMap
TH2F * n_dzMeanBiasMap
Definition: PrimaryVertexValidation.h:573
edm::LogWarning
Definition: MessageLogger.h:141
PrimaryVertexValidation::n_dzpTWidthTrend
TH1F * n_dzpTWidthTrend
Definition: PrimaryVertexValidation.h:402
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
PrimaryVertexValidation::a_dzPhiMADTrend
TH1F * a_dzPhiMADTrend
Definition: PrimaryVertexValidation.h:436
PrimaryVertexValidation::nTracksPerClus_
int nTracksPerClus_
Definition: PrimaryVertexValidation.h:205
PrimaryVertexValidation::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: PrimaryVertexValidation.cc:210
PrimaryVertexValidation::n_dxyVsPhi
TH2F * n_dxyVsPhi
Definition: PrimaryVertexValidation.h:458
PrimaryVertexValidation::h_dz_pT_
std::vector< TH1F * > h_dz_pT_
Definition: PrimaryVertexValidation.h:676
PrimaryVertexValidation::h_probeRecoVSigXY_
TH1F * h_probeRecoVSigXY_
Definition: PrimaryVertexValidation.h:631
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
PrimaryVertexValidation::a_dzEtaMedianTrend
TH1F * a_dzEtaMedianTrend
Definition: PrimaryVertexValidation.h:440
PrimaryVertexValidation::h_probed3DRefitV_
TH1F * h_probed3DRefitV_
Definition: PrimaryVertexValidation.h:627
funct::true
true
Definition: Factorize.h:173
GeomDetEnumerators::P1PXB
Definition: GeomDetEnumerators.h:25
PrimaryVertexValidation::a_dxymodZWidthTrend
TH1F * a_dxymodZWidthTrend
Definition: PrimaryVertexValidation.h:412
PrimaryVertexValidation::theta_
double theta_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:242
PrimaryVertexValidation::fs
edm::Service< TFileService > fs
Definition: PrimaryVertexValidation.h:280
PrimaryVertexValidation::h_dz_Central_pT_
std::vector< TH1F * > h_dz_Central_pT_
Definition: PrimaryVertexValidation.h:681
TrackerDigiGeometryRecord.h
SiPixelRecHitCollection.h
PrimaryVertexValidation::a_dxypTCentralWidthTrend
TH1F * a_dxypTCentralWidthTrend
Definition: PrimaryVertexValidation.h:395
PrimaryVertexValidation::h_fitVtxChi2_
TH1F * h_fitVtxChi2_
Definition: PrimaryVertexValidation.h:659
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
PrimaryVertexValidation::a_dxyPhiMADTrend
TH1F * a_dxyPhiMADTrend
Definition: PrimaryVertexValidation.h:434
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
PrimaryVertexValidation::nhitsTOB_
int nhitsTOB_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:238
PrimaryVertexValidation::h_runFromConfig
TH1I * h_runFromConfig
Definition: PrimaryVertexValidation.h:587
PrimaryVertexValidation::h_probeP_
TH1F * h_probeP_
Definition: PrimaryVertexValidation.h:607
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
PVValHelper::getMedian
Measurement1D getMedian(TH1F *histo)
Definition: PVValidationHelpers.cc:178
edm::ParameterSet
Definition: ParameterSet.h:36
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
PrimaryVertexValidation::a_IP2DEtaResiduals
std::vector< TH1F * > a_IP2DEtaResiduals
Definition: PrimaryVertexValidation.h:317
PrimaryVertexValidation::nPtBins_
static const int nPtBins_
Definition: PrimaryVertexValidation.h:191
PrimaryVertexValidation::a_dxyMeanBiasMap
TH2F * a_dxyMeanBiasMap
Definition: PrimaryVertexValidation.h:569
PrimaryVertexValidation::dzBs_
double dzBs_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:251
PrimaryVertexValidation::yPCA_
double yPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:253
edm::LogError
Definition: MessageLogger.h:183
PrimaryVertexValidation::fillMap
void fillMap(TH2F *trendMap, TH1F *residualsMapPlot[100][100], PVValHelper::estimator fitPar_, const int nXBins_, const int nYBins_)
Definition: PrimaryVertexValidation.cc:3184
a
double a
Definition: hdecay.h:119
DetId::Tracker
Definition: DetId.h:25
PrimaryVertexValidation::n_dzEtaResiduals
std::vector< TH1F * > n_dzEtaResiduals
Definition: PrimaryVertexValidation.h:334
PrimaryVertexValidation::a_dxyEtaWidthTrend
TH1F * a_dxyEtaWidthTrend
Definition: PrimaryVertexValidation.h:373
PVValHelper::IP3D
Definition: PVValidationHelpers.h:53
PrimaryVertexValidation::a_dxypTMeanTrend
TH1F * a_dxypTMeanTrend
Definition: PrimaryVertexValidation.h:389
PrimaryVertexValidation::n_dxyWidthBiasMap
TH2F * n_dxyWidthBiasMap
Definition: PrimaryVertexValidation.h:578
PrimaryVertexValidation::tracksUsedForVertexing_
int tracksUsedForVertexing_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:263
PrimaryVertexValidation::Beamdxdz_
double Beamdxdz_
Definition: PrimaryVertexValidation.h:223
PrimaryVertexValidation::h_fitVtxTrackAverageWeight_
TH1F * h_fitVtxTrackAverageWeight_
Definition: PrimaryVertexValidation.h:664
PVValHelper::phi
Definition: PVValidationHelpers.h:68
PrimaryVertexValidation::Width2DMapsDir
TFileDirectory Width2DMapsDir
Definition: PrimaryVertexValidation.h:288
PrimaryVertexValidation::nhitsTEC_
int nhitsTEC_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:239
PrimaryVertexValidation::n_IP3DEtaResiduals
std::vector< TH1F * > n_IP3DEtaResiduals
Definition: PrimaryVertexValidation.h:340
PrimaryVertexValidation::eta_
double eta_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:241
PrimaryVertexValidation::n_dxyMeanMap
TH2F * n_dxyMeanMap
Definition: PrimaryVertexValidation.h:472
PrimaryVertexValidation::a_dxyEtaBiasResiduals
std::vector< TH1F * > a_dxyEtaBiasResiduals
Definition: PrimaryVertexValidation.h:502
PrimaryVertexValidation::zUnbiasedVertex_
double zUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:257
KineDebug3::count
void count()
Definition: KinematicConstrainedVertexUpdatorT.h:21
PrimaryVertexValidation::n_dxyVsEta
TH2F * n_dxyVsEta
Definition: PrimaryVertexValidation.h:464
PrimaryVertexValidation::n_dxypTCentralWidthTrend
TH1F * n_dxypTCentralWidthTrend
Definition: PrimaryVertexValidation.h:405
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
PrimaryVertexValidation::a_dzPhiMedianTrend
TH1F * a_dzPhiMedianTrend
Definition: PrimaryVertexValidation.h:435
PrimaryVertexValidation::a_dzPhiResiduals
std::vector< TH1F * > a_dzPhiResiduals
Definition: PrimaryVertexValidation.h:313
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:623
PrimaryVertexValidation::h_norm_dz_pT_
std::vector< TH1F * > h_norm_dz_pT_
Definition: PrimaryVertexValidation.h:678
PrimaryVertexValidation::nLadders_
unsigned int nLadders_
Definition: PrimaryVertexValidation.h:193
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
PrimaryVertexValidation::h2_probeEtaPt_
TH2F * h2_probeEtaPt_
Definition: PrimaryVertexValidation.h:605
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:731
PrimaryVertexValidation::n_dxypTMeanTrend
TH1F * n_dxypTMeanTrend
Definition: PrimaryVertexValidation.h:399
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
PrimaryVertexValidation::h_BeamWidthY
TH1F * h_BeamWidthY
Definition: PrimaryVertexValidation.h:600
IPTools
Definition: IPTools.h:16
PrimaryVertexValidation::h_probeHasBPixL1Overlap_
TH1I * h_probeHasBPixL1Overlap_
Definition: PrimaryVertexValidation.h:650
PrimaryVertexValidation::n_dzL1ResidualsMap
TH1F * n_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:363
PrimaryVertexValidation::xOfflineVertex_
double xOfflineVertex_
Definition: PrimaryVertexValidation.h:211
PVValHelper::MAD
Definition: PVValidationHelpers.h:44
createfilelist.int
int
Definition: createfilelist.py:10
PrimaryVertexValidation::BSx0_
double BSx0_
Definition: PrimaryVertexValidation.h:219
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
PrimaryVertexValidation::a_dzladderMeanTrend
TH1F * a_dzladderMeanTrend
Definition: PrimaryVertexValidation.h:418
PrimaryVertexValidation::forceBeamSpotContraint_
bool forceBeamSpotContraint_
Definition: PrimaryVertexValidation.h:177
PrimaryVertexValidation::h_dxy_ladderNoOverlap_
std::vector< TH1F * > h_dxy_ladderNoOverlap_
Definition: PrimaryVertexValidation.h:693
PrimaryVertexValidation::n_dzL1MeanMap
TH2F * n_dzL1MeanMap
Definition: PrimaryVertexValidation.h:487
PrimaryVertexValidation::h_probeRefitVLogSig3D_
TH1F * h_probeRefitVLogSig3D_
Definition: PrimaryVertexValidation.h:635
PVValHelper::norm_IP3D
Definition: PVValidationHelpers.h:62
PrimaryVertexValidation::n_dzEtaBiasResiduals
std::vector< TH1F * > n_dzEtaBiasResiduals
Definition: PrimaryVertexValidation.h:513
DAClusterizerInZ
Definition: DAClusterizerInZ.h:18
PrimaryVertexValidation::n_dzPhiMADTrend
TH1F * n_dzPhiMADTrend
Definition: PrimaryVertexValidation.h:446
PrimaryVertexValidation::a_dzMeanBiasMap
TH2F * a_dzMeanBiasMap
Definition: PrimaryVertexValidation.h:570
PrimaryVertexValidation::h_xOfflineVertex
TH1F * h_xOfflineVertex
Definition: PrimaryVertexValidation.h:589
PVValHelper::residualType
residualType
Definition: PVValidationHelpers.h:46
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
edm::LogVerbatim
Definition: MessageLogger.h:297
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
PrimaryVertexValidation::storeNtuple_
bool storeNtuple_
Definition: PrimaryVertexValidation.h:141
PrimaryVertexValidation::n_dxyPhiResiduals
std::vector< TH1F * > n_dxyPhiResiduals
Definition: PrimaryVertexValidation.h:330
PrimaryVertexValidation::dzFromMyVertex_
double dzFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:266
PrimaryVertexValidation::chi2ndof_
double chi2ndof_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:245
PrimaryVertexValidation::n_dxyL1ResidualsMap
TH1F * n_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:362
PrimaryVertexValidation::n_dzPhiWidthTrend
TH1F * n_dzPhiWidthTrend
Definition: PrimaryVertexValidation.h:380
PVValHelper::dy
Definition: PVValidationHelpers.h:49
MagneticField.h
MonitorHOAlCaRecoStream_cfi.lowedge
lowedge
Definition: MonitorHOAlCaRecoStream_cfi.py:11
TransientVertex
Definition: TransientVertex.h:18
edm::EventSetup
Definition: EventSetup.h:57
TrackerGeometry::dets
const DetContainer & dets() const override
Returm a vector of all GeomDet (including all GeomDetUnits)
Definition: TrackerGeometry.h:62
PrimaryVertexValidation::h_probeHitsInBPIX_
TH1F * h_probeHitsInBPIX_
Definition: PrimaryVertexValidation.h:645
PVValHelper::histodetails::getLow
float getLow(residualType type, plotVariable plot)
Definition: PVValidationHelpers.h:96
TrajectoryStateClosestToPoint
Definition: TrajectoryStateClosestToPoint.h:18
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:572
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:578
PVValHelper::generateBins
std::vector< float > generateBins(int n, float start, float range)
Definition: PVValidationHelpers.cc:161
TransientTrackRecord.h
PrimaryVertexValidation::n_dxypTWidthTrend
TH1F * n_dxypTWidthTrend
Definition: PrimaryVertexValidation.h:400
PrimaryVertexValidation::h_probeHitsInTIB_
TH1F * h_probeHitsInTIB_
Definition: PrimaryVertexValidation.h:641
PrimaryVertexValidation::nhits2D_
int nhits2D_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:233
PrimaryVertexValidation::a_dxyEtaMedianBiasTrend
TH1F * a_dxyEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:552
get
#define get
PrimaryVertexValidation::n_dzVsEta
TH2F * n_dzVsEta
Definition: PrimaryVertexValidation.h:465
PVValHelper::MEAN
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::n_dxyPhiWidthTrend
TH1F * n_dxyPhiWidthTrend
Definition: PrimaryVertexValidation.h:378
PrimaryVertexValidation::intLumi_
double intLumi_
Definition: PrimaryVertexValidation.h:152
PrimaryVertexValidation::h_runEndTimes
TH1I * h_runEndTimes
Definition: PrimaryVertexValidation.h:298
PrimaryVertexValidation::etaOfProbe_
double etaOfProbe_
Definition: PrimaryVertexValidation.h:160
PrimaryVertexValidation::n_dzVsPhi
TH2F * n_dzVsPhi
Definition: PrimaryVertexValidation.h:459
PrimaryVertexValidation::a_dzpTCentralMeanTrend
TH1F * a_dzpTCentralMeanTrend
Definition: PrimaryVertexValidation.h:396
PVValHelper::d3D
Definition: PVValidationHelpers.h:54
reco::TrackBase::vertex
const Point & vertex() const
reference point on the track. This method is DEPRECATED, please use referencePoint() instead
Definition: TrackBase.h:647
PrimaryVertexValidation::h_recoVtxChi2ndf_
TH1F * h_recoVtxChi2ndf_
Definition: PrimaryVertexValidation.h:667
PrimaryVertexValidation::n_d3DResidualsMap
TH1F * n_d3DResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:356
PrimaryVertexValidation::a_dxypTCentralMeanTrend
TH1F * a_dxypTCentralMeanTrend
Definition: PrimaryVertexValidation.h:394
PrimaryVertexValidation::MedianTrendsDir
TFileDirectory MedianTrendsDir
Definition: PrimaryVertexValidation.h:284
TrackingRecHit
Definition: TrackingRecHit.h:21
alignCSCRings.r
r
Definition: alignCSCRings.py:93
PrimaryVertexValidation::a_dxyPhiResiduals
std::vector< TH1F * > a_dxyPhiResiduals
Definition: PrimaryVertexValidation.h:304
newFWLiteAna.bin
bin
Definition: newFWLiteAna.py:161
overlapproblemtsosanalyzer_cfi.title
title
Definition: overlapproblemtsosanalyzer_cfi.py:7
PrimaryVertexValidation::a_dxyL1ResidualsMap
TH1F * a_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:360
PrimaryVertexValidation::phi_
double phi_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:243
PrimaryVertexValidation::n_dzPhiMeanTrend
TH1F * n_dzPhiMeanTrend
Definition: PrimaryVertexValidation.h:379
PrimaryVertexValidation::a_dxyPhiBiasResiduals
std::vector< TH1F * > a_dxyPhiBiasResiduals
Definition: PrimaryVertexValidation.h:501
PrimaryVertexValidation::h_nLadders
TH1F * h_nLadders
Definition: PrimaryVertexValidation.h:293
types
types
Definition: AlignPCLThresholds_PayloadInspector.cc:30
reco::TrackBase::qualityByName
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:126
PrimaryVertexValidation::dxyErrorFromMyVertex_
double dxyErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:269
PrimaryVertexValidation::a_dxyEtaMeanBiasTrend
TH1F * a_dxyEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:530
RunInfo::m_start_time_str
std::string m_start_time_str
Definition: RunInfo.h:22
PrimaryVertexValidation::a_d3DResidualsMap
TH1F * a_d3DResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:352
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
PrimaryVertexValidation::n_dxypTCentralMeanTrend
TH1F * n_dxypTCentralMeanTrend
Definition: PrimaryVertexValidation.h:404
PrimaryVertexValidation::a_dyEtaResiduals
std::vector< TH1F * > a_dyEtaResiduals
Definition: PrimaryVertexValidation.h:311
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:489
PrimaryVertexValidation::runNumbersTimesLog_
std::map< unsigned int, std::pair< long long, long long > > runNumbersTimesLog_
Definition: PrimaryVertexValidation.h:296
PrimaryVertexValidation::a_dzEtaMedianBiasTrend
TH1F * a_dzEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:554
RunInfo.h
PrimaryVertexValidation::h_norm_dz_ladder_
std::vector< TH1F * > h_norm_dz_ladder_
Definition: PrimaryVertexValidation.h:698
GeomDet.h
PrimaryVertexValidation::h_recoVtxNtracks_
TH1F * h_recoVtxNtracks_
Definition: PrimaryVertexValidation.h:666
TransientVertex.h
PrimaryVertexValidation::h_probeL1Ladder_
TH1F * h_probeL1Ladder_
Definition: PrimaryVertexValidation.h:648
DAClusterizerInZ_vect
Definition: DAClusterizerInZ_vect.h:20
PrimaryVertexValidation::IPLsigFromMyVertex_
double IPLsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:274
PrimaryVertexValidation::sumOfWeightsUnbiasedVertex_
float sumOfWeightsUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:262
type
type
Definition: HCALResponse.h:21
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
PrimaryVertexValidation::d3DErrorFromMyVertex_
double d3DErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:271
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:725
PrimaryVertexValidation::hasFirstLayerPixelHits
bool hasFirstLayerPixelHits(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1151
PrimaryVertexValidation::n_dxymodZMeanTrend
TH1F * n_dxymodZMeanTrend
Definition: PrimaryVertexValidation.h:421
PrimaryVertexValidation::h_dxy_ladderOverlap_
std::vector< TH1F * > h_dxy_ladderOverlap_
Definition: PrimaryVertexValidation.h:692
reco::TransientTrack
Definition: TransientTrack.h:19
PrimaryVertexValidation::a_dzEtaWidthTrend
TH1F * a_dzEtaWidthTrend
Definition: PrimaryVertexValidation.h:375
PVValHelper::dxy
Definition: PVValidationHelpers.h:47
PrimaryVertexValidation::bookResidualsHistogram
std::vector< TH1F * > bookResidualsHistogram(const TFileDirectory &dir, unsigned int theNOfBins, PVValHelper::residualType resType, PVValHelper::plotVariable varType, bool isNormalized=false)
Definition: PrimaryVertexValidation.cc:3414
TrackerTopology::pxbModule
unsigned int pxbModule(const DetId &id) const
Definition: TrackerTopology.h:160
PrimaryVertexValidation::p_
double p_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:230
PrimaryVertexValidation::yErrOfflineVertex_
double yErrOfflineVertex_
Definition: PrimaryVertexValidation.h:216
PrimaryVertexValidation::h2_probeEtaPhi_
TH2F * h2_probeEtaPhi_
Definition: PrimaryVertexValidation.h:604
PrimaryVertexValidation::n_IP2DPhiResiduals
std::vector< TH1F * > n_IP2DPhiResiduals
Definition: PrimaryVertexValidation.h:336
PrimaryVertexValidation::theDetails_
PVValHelper::histodetails theDetails_
Definition: PrimaryVertexValidation.h:146
PVValHelper::dz
Definition: PVValidationHelpers.h:50
PrimaryVertexValidation::h_nOfflineVertices
TH1F * h_nOfflineVertices
Definition: PrimaryVertexValidation.h:584
PrimaryVertexValidation::h_dxy_Central_pT_
std::vector< TH1F * > h_dxy_Central_pT_
Definition: PrimaryVertexValidation.h:680
PrimaryVertexValidation::xUnbiasedVertex_
double xUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:255
PrimaryVertexValidation::n_dzEtaWidthTrend
TH1F * n_dzEtaWidthTrend
Definition: PrimaryVertexValidation.h:385
PrimaryVertexValidation::mypT_bins_
std::array< float, nPtBins_+1 > mypT_bins_
Definition: PrimaryVertexValidation.h:201
PVValHelper::MEDIAN
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::h_zErrOfflineVertex
TH1F * h_zErrOfflineVertex
Definition: PrimaryVertexValidation.h:594
PrimaryVertexValidation::a_dzMeanMap
TH2F * a_dzMeanMap
Definition: PrimaryVertexValidation.h:470
PrimaryVertexValidation::h_probeHits1D_
TH1F * h_probeHits1D_
Definition: PrimaryVertexValidation.h:639
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
PVValHelper::getMAD
Measurement1D getMAD(TH1F *histo)
Definition: PVValidationHelpers.cc:194
PrimaryVertexValidation::getRunTime
std::pair< long long, long long > getRunTime(const edm::EventSetup &iSetup) const
Definition: PrimaryVertexValidation.cc:2959
PrimaryVertexValidation::passesTrackCuts
bool passesTrackCuts(const reco::Track &track, const reco::Vertex &vertex, const std::string &qualityString_, double dxyErrMax_, double dzErrMax_, double ptErrMax_)
Definition: PrimaryVertexValidation.cc:3258
PVValHelper::ladder
Definition: PVValidationHelpers.h:72
PrimaryVertexValidation::n_dxyEtaMeanTrend
TH1F * n_dxyEtaMeanTrend
Definition: PrimaryVertexValidation.h:382
PrimaryVertexValidation::n_dzPhiMedianTrend
TH1F * n_dzPhiMedianTrend
Definition: PrimaryVertexValidation.h:445
PrimaryVertexValidation::a_dzL1WidthMap
TH2F * a_dzL1WidthMap
Definition: PrimaryVertexValidation.h:490
PrimaryVertexValidation::n_dxyPhiMeanBiasTrend
TH1F * n_dxyPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:535
PrimaryVertexValidation::askFirstLayerHit_
bool askFirstLayerHit_
Definition: PrimaryVertexValidation.h:155
PrimaryVertexValidation::n_dxyPhiWidthBiasTrend
TH1F * n_dxyPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:536
PrimaryVertexValidation::charge_
int charge_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:246
PrimaryVertexValidation::nhitsBPIX_
int nhitsBPIX_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:234
PrimaryVertexValidation::n_dzEtaMeanBiasTrend
TH1F * n_dzEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:542
PrimaryVertexValidation::n_dzladderWidthTrend
TH1F * n_dzladderWidthTrend
Definition: PrimaryVertexValidation.h:429
PrimaryVertexValidation::isPhase1_
bool isPhase1_
Definition: PrimaryVertexValidation.h:162
PrimaryVertexValidation::runControl_
bool runControl_
Definition: PrimaryVertexValidation.h:174
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
GapClusterizerInZ
Definition: GapClusterizerInZ.h:14
PrimaryVertexValidation::a_dxymodZMeanTrend
TH1F * a_dxymodZMeanTrend
Definition: PrimaryVertexValidation.h:411
TrackFilterForPVFinding
Definition: TrackFilterForPVFinding.h:14
PrimaryVertexValidation::a_dxyPhiMeanTrend
TH1F * a_dxyPhiMeanTrend
Definition: PrimaryVertexValidation.h:367
PrimaryVertexValidation::doBPix_
bool doBPix_
Definition: PrimaryVertexValidation.h:156
PrimaryVertexValidation::h_dz_ladder_
std::vector< TH1F * > h_dz_ladder_
Definition: PrimaryVertexValidation.h:696
PrimaryVertexValidation::n_dzEtaMADTrend
TH1F * n_dzEtaMADTrend
Definition: PrimaryVertexValidation.h:451
PrimaryVertexValidation::n_dzmodZMeanTrend
TH1F * n_dzmodZMeanTrend
Definition: PrimaryVertexValidation.h:423
PrimaryVertexValidation::n_dzEtaMedianBiasTrend
TH1F * n_dzEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:564
PrimaryVertexValidation::h_probed0RefitV_
TH1F * h_probed0RefitV_
Definition: PrimaryVertexValidation.h:623
PrimaryVertexValidation::a_dxyWidthBiasMap
TH2F * a_dxyWidthBiasMap
Definition: PrimaryVertexValidation.h:575
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
HLT_2018_cff.track
track
Definition: HLT_2018_cff.py:10352
PrimaryVertexValidation::Mean2DMapsDir
TFileDirectory Mean2DMapsDir
Definition: PrimaryVertexValidation.h:287
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:30
PrimaryVertexValidation::a_dzWidthBiasMap
TH2F * a_dzWidthBiasMap
Definition: PrimaryVertexValidation.h:576
PVValHelper::histodetails::setMap
void setMap(residualType type, plotVariable plot, float low, float high)
Definition: PVValidationHelpers.h:82
PrimaryVertexValidation::h_probeHitsInFPIX_
TH1F * h_probeHitsInFPIX_
Definition: PrimaryVertexValidation.h:646
reco::TrackBase::pz
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:617
PrimaryVertexValidation::BeamWidthX_
double BeamWidthX_
Definition: PrimaryVertexValidation.h:224
PrimaryVertexValidation::a_dxyPhiMedianBiasTrend
TH1F * a_dxyPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:547
cms::Exception
Definition: Exception.h:70
PrimaryVertexValidation::a_dxyVsPhi
TH2F * a_dxyVsPhi
Definition: PrimaryVertexValidation.h:455
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
PrimaryVertexValidation::a_dxyladderWidthTrend
TH1F * a_dxyladderWidthTrend
Definition: PrimaryVertexValidation.h:417
PrimaryVertexValidation::nModZ_
unsigned int nModZ_
Definition: PrimaryVertexValidation.h:194
PrimaryVertexValidation::nClus_
int nClus_
Definition: PrimaryVertexValidation.h:206
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
kappa
static const G4double kappa
Definition: UrbanMscModel93.cc:35
PrimaryVertexValidation::xPCA_
double xPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:252
PrimaryVertexValidation::h_probeCharge_
TH1F * h_probeCharge_
Definition: PrimaryVertexValidation.h:614
PrimaryVertexValidation::n_dzMeanMap
TH2F * n_dzMeanMap
Definition: PrimaryVertexValidation.h:473
TrackerTopologyRcd
Definition: TrackerTopologyRcd.h:10
PVValHelper::histodetails::range
std::map< std::pair< residualType, plotVariable >, std::pair< float, float > > range
Definition: PVValidationHelpers.h:79
ParameterSet.h
PrimaryVertexValidation::dxy_
double dxy_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:249
GapClusterizerInZ.h
PrimaryVertexValidation::n_dzpTMeanTrend
TH1F * n_dzpTMeanTrend
Definition: PrimaryVertexValidation.h:401
PrimaryVertexValidation::a_dxPhiResiduals
std::vector< TH1F * > a_dxPhiResiduals
Definition: PrimaryVertexValidation.h:307
PerigeeTrajectoryParameters::transverseImpactParameter
double transverseImpactParameter() const
Definition: PerigeeTrajectoryParameters.h:68
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
PrimaryVertexValidation::n_dzpTCentralWidthTrend
TH1F * n_dzpTCentralWidthTrend
Definition: PrimaryVertexValidation.h:407
TrajectoryStateClosestToPoint::theState
const FreeTrajectoryState & theState() const
Definition: TrajectoryStateClosestToPoint.h:96
PrimaryVertexValidation::n_dxyEtaMADTrend
TH1F * n_dxyEtaMADTrend
Definition: PrimaryVertexValidation.h:449
PrimaryVertexValidation::lightNtupleSwitch_
bool lightNtupleSwitch_
Definition: PrimaryVertexValidation.h:142
PrimaryVertexValidation::h_recoVtxSumPt_
TH1F * h_recoVtxSumPt_
Definition: PrimaryVertexValidation.h:669
PrimaryVertexValidation::maxPt_
const double maxPt_
Definition: PrimaryVertexValidation.h:169
PrimaryVertexValidation::n_dxyResidualsMap
TH1F * n_dxyResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:354
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
RunInfo::m_avg_current
float m_avg_current
Definition: RunInfo.h:28
PrimaryVertexValidation::n_dzpTCentralMeanTrend
TH1F * n_dzpTCentralMeanTrend
Definition: PrimaryVertexValidation.h:406
GlobalTrackingGeometry.h
PrimaryVertexValidation::minPt_
const double minPt_
Definition: PrimaryVertexValidation.h:168
edm::Event
Definition: Event.h:73
PrimaryVertexValidation::n_dxyPhiMedianBiasTrend
TH1F * n_dxyPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:557
PrimaryVertexValidation::n_dxyEtaMeanBiasTrend
TH1F * n_dxyEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:540
PrimaryVertexValidation::h_probeHitsInTOB_
TH1F * h_probeHitsInTOB_
Definition: PrimaryVertexValidation.h:642
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:84
PrimaryVertexValidation::theTrackCollectionToken
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken
Definition: PrimaryVertexValidation.h:179
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:587
PrimaryVertexValidation::a_dxyEtaMADTrend
TH1F * a_dxyEtaMADTrend
Definition: PrimaryVertexValidation.h:439
PrimaryVertexValidation::theBeamspotToken
edm::EDGetTokenT< reco::BeamSpot > theBeamspotToken
Definition: PrimaryVertexValidation.h:181
PrimaryVertexValidation.h
PrimaryVertexValidation::a_dzPhiMADBiasTrend
TH1F * a_dzPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:550
PrimaryVertexValidation::h_yOfflineVertex
TH1F * h_yOfflineVertex
Definition: PrimaryVertexValidation.h:590
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:593
PrimaryVertexValidation::~PrimaryVertexValidation
~PrimaryVertexValidation() override
Definition: PrimaryVertexValidation.cc:200
PrimaryVertexValidation::n_IP2DEtaResiduals
std::vector< TH1F * > n_IP2DEtaResiduals
Definition: PrimaryVertexValidation.h:337
PrimaryVertexValidation::cmToum
static const int cmToum
Definition: PrimaryVertexValidation.h:190
PrimaryVertexValidation::a_dzEtaMADTrend
TH1F * a_dzEtaMADTrend
Definition: PrimaryVertexValidation.h:441
SiPixelRecHit::clusterProbability
float clusterProbability(unsigned int flags=0) const
Definition: SiPixelRecHit.cc:9
reco::TrackBase::quality
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:537
edm::InputTag
Definition: InputTag.h:15
PVValHelper::dx
Definition: PVValidationHelpers.h:48
PrimaryVertexValidation::vtxSort
static bool vtxSort(const reco::Vertex &a, const reco::Vertex &b)
Definition: PrimaryVertexValidation.cc:3248
PrimaryVertexValidation::h_probeHitsInTEC_
TH1F * h_probeHitsInTEC_
Definition: PrimaryVertexValidation.h:644
PrimaryVertexValidation::n_dxyEtaWidthTrend
TH1F * n_dxyEtaWidthTrend
Definition: PrimaryVertexValidation.h:383
PrimaryVertexValidation::n_dzBiasResidualsMap
TH1F * n_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:521
PrimaryVertexValidation::a_dyPhiResiduals
std::vector< TH1F * > a_dyPhiResiduals
Definition: PrimaryVertexValidation.h:310
PrimaryVertexValidation::n_dxyEtaMedianBiasTrend
TH1F * n_dxyEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:562
PrimaryVertexValidation::n_dxyPhiMeanTrend
TH1F * n_dxyPhiMeanTrend
Definition: PrimaryVertexValidation.h:377
up
Definition: BitonicSort.h:7
PrimaryVertexValidation::a_dxyPhiMeanBiasTrend
TH1F * a_dxyPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:525
PrimaryVertexValidation::h_BeamWidthX
TH1F * h_BeamWidthX
Definition: PrimaryVertexValidation.h:599
PrimaryVertexValidation::h_probedxyRefitV_
TH1F * h_probedxyRefitV_
Definition: PrimaryVertexValidation.h:621
PrimaryVertexValidation::yOfflineVertex_
double yOfflineVertex_
Definition: PrimaryVertexValidation.h:212
reco::Vertex
Definition: Vertex.h:35
PrimaryVertexValidation::h_probeRecoVSigZ_
TH1F * h_probeRecoVSigZ_
Definition: PrimaryVertexValidation.h:630
hit
Definition: SiStripHitEffFromCalibTree.cc:88
RunInfo::m_stop_time_str
std::string m_stop_time_str
Definition: RunInfo.h:24
PrimaryVertexValidation::n_dxyEtaWidthBiasTrend
TH1F * n_dxyEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:541
PrimaryVertexValidation::rootTree_
TTree * rootTree_
Definition: PrimaryVertexValidation.h:183
TFileService::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileService.h:64
PrimaryVertexValidation::h_recoVtxChi2Prob_
TH1F * h_recoVtxChi2Prob_
Definition: PrimaryVertexValidation.h:668
PrimaryVertexValidation::h_probeNormChi2_
TH1F * h_probeNormChi2_
Definition: PrimaryVertexValidation.h:613
PrimaryVertexValidation::a_reszEtaResiduals
std::vector< TH1F * > a_reszEtaResiduals
Definition: PrimaryVertexValidation.h:323
reco::TrackBase::qoverp
double qoverp() const
q / p
Definition: TrackBase.h:584
PVValHelper::IP2D
Definition: PVValidationHelpers.h:51
PrimaryVertexValidation::n_dzWidthBiasMap
TH2F * n_dzWidthBiasMap
Definition: PrimaryVertexValidation.h:579
PrimaryVertexValidation::n_IP3DPhiResiduals
std::vector< TH1F * > n_IP3DPhiResiduals
Definition: PrimaryVertexValidation.h:339
PrimaryVertexValidation::a_dxyEtaResiduals
std::vector< TH1F * > a_dxyEtaResiduals
Definition: PrimaryVertexValidation.h:305
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
RunInfo::m_start_time_ll
long long m_start_time_ll
Definition: RunInfo.h:21
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
PVValHelper::shrinkHistVectorToFit
void shrinkHistVectorToFit(std::vector< TH1F * > &h, unsigned int desired_size)
Definition: PVValidationHelpers.cc:56
PrimaryVertexValidation::a_dzmodZWidthTrend
TH1F * a_dzmodZWidthTrend
Definition: PrimaryVertexValidation.h:414
PrimaryVertexValidation::a_dzPhiMedianBiasTrend
TH1F * a_dzPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:549
PrimaryVertexValidation::h_Beamsigmaz
TH1F * h_Beamsigmaz
Definition: PrimaryVertexValidation.h:598
PVValHelper::norm_dz
Definition: PVValidationHelpers.h:59
PrimaryVertexValidation::h_runStartTimes
TH1I * h_runStartTimes
Definition: PrimaryVertexValidation.h:297
PrimaryVertexValidation::hasRecVertex_
int hasRecVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:277
PrimaryVertexValidation::a_dxyBiasResidualsMap
TH1F * a_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:517
PVValHelper::fitResiduals
std::pair< Measurement1D, Measurement1D > fitResiduals(TH1 *hist)
Definition: PVValidationHelpers.cc:223
PrimaryVertexValidation::n_dxyladderMeanTrend
TH1F * n_dxyladderMeanTrend
Definition: PrimaryVertexValidation.h:426
Generated for CMSSW Reference Manual by doxygen 1.8.16