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