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