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 
619  for (trackingRecHit_iterator iHit = theTTrack.recHitsBegin(); iHit != theTTrack.recHitsEnd(); ++iHit) {
620  if((*iHit)->isValid()) {
621 
622  if (this->isHit2D(**iHit)) {++nRecHit2D;}
623  else {++nRecHit1D; }
624  }
625  }
626 
627  nhits1D_[nTracks_] = nRecHit1D;
628  nhits2D_[nTracks_] = nRecHit2D;
629  nhitsBPIX_[nTracks_] = nhitinBPIX;
630  nhitsFPIX_[nTracks_] = nhitinFPIX;
631  nhitsTIB_[nTracks_] = nhitinTIB;
632  nhitsTID_[nTracks_] = nhitinTID;
633  nhitsTOB_[nTracks_] = nhitinTOB;
634  nhitsTEC_[nTracks_] = nhitinTEC;
635 
636  //=======================================================
637  // Good tracks for vertexing selection
638  //=======================================================
639 
640  bool pass = true;
641  if(askFirstLayerHit_) pass = this->hasFirstLayerPixelHits(theTTrack);
642  if (pass
643  && (theTrack.pt() >=ptOfProbe_)
644  && std::abs(theTrack.eta()) <= etaOfProbe_
645  && (theTrack.numberOfValidHits())>=nHitsOfProbe_
646  && (theTrack.p()) >= pOfProbe_ ){
647  isGoodTrack_[nTracks_]=1;
648  }
649 
650  //=======================================================
651  // Fit unbiased vertex
652  //=======================================================
653 
654  vector<TransientTrack> theFinalTracks;
655  theFinalTracks.clear();
656 
657  for (const auto & tk : iclus) {
658 
659  pass = this->hasFirstLayerPixelHits(tk);
660  if (pass){
661  if( tk == theTTrack ) continue;
662  else {
663  theFinalTracks.push_back(tk);
664  }
665  }
666  }
667 
668  if(theFinalTracks.size() > 1){
669 
670  if(debug_)
671  edm::LogInfo("PrimaryVertexValidation")<<"Transient Track Collection size: "<<theFinalTracks.size();
672  try{
673 
674  //AdaptiveVertexFitter* theFitter = new AdaptiveVertexFitter;
675  auto theFitter = std::unique_ptr<VertexFitter<5> >( new AdaptiveVertexFitter());
676  TransientVertex theFittedVertex;
677 
678  if(forceBeamSpotContraint_){
679  theFittedVertex = theFitter->vertex(theFinalTracks,beamSpot); // if you want the beam constraint
680  } else {
681  theFittedVertex = theFitter->vertex(theFinalTracks);
682  }
683 
684 
685 
686  double totalTrackWeights=0;
687  if(theFittedVertex.isValid ()){
688 
689 
690  if(theFittedVertex.hasTrackWeight()){
691  for(const auto & theFinalTrack : theFinalTracks){
692  sumOfWeightsUnbiasedVertex_[nTracks_] += theFittedVertex.trackWeight(theFinalTrack);
693  totalTrackWeights+= theFittedVertex.trackWeight(theFinalTrack);
694  h_fitVtxTrackWeights_->Fill(theFittedVertex.trackWeight(theFinalTrack));
695  }
696  }
697 
698  h_fitVtxTrackAverageWeight_->Fill(totalTrackWeights/theFinalTracks.size());
699 
700  const math::XYZPoint theRecoVertex(xOfflineVertex_,yOfflineVertex_,zOfflineVertex_);
701  const math::XYZPoint myVertex(theFittedVertex.position().x(),theFittedVertex.position().y(),theFittedVertex.position().z());
702 
703  const Vertex vertex = theFittedVertex;
704  fillTrackHistos(hDA,"all",&theTTrack,vertex,beamSpot,fBfield_);
705 
706  hasRecVertex_[nTracks_] = 1;
707  xUnbiasedVertex_[nTracks_] = theFittedVertex.position().x();
708  yUnbiasedVertex_[nTracks_] = theFittedVertex.position().y();
709  zUnbiasedVertex_[nTracks_] = theFittedVertex.position().z();
710 
711  chi2normUnbiasedVertex_[nTracks_] = theFittedVertex.normalisedChiSquared();
712  chi2UnbiasedVertex_[nTracks_] = theFittedVertex.totalChiSquared();
713  DOFUnbiasedVertex_[nTracks_] = theFittedVertex.degreesOfFreedom();
714  chi2ProbUnbiasedVertex_[nTracks_] = TMath::Prob(theFittedVertex.totalChiSquared(),(int)theFittedVertex.degreesOfFreedom());
715  tracksUsedForVertexing_[nTracks_] = theFinalTracks.size();
716 
717  h_fitVtxNtracks_->Fill(theFinalTracks.size());
718  h_fitVtxChi2_->Fill(theFittedVertex.totalChiSquared());
719  h_fitVtxNdof_->Fill(theFittedVertex.degreesOfFreedom());
720  h_fitVtxChi2ndf_->Fill(theFittedVertex.normalisedChiSquared());
721  h_fitVtxChi2Prob_->Fill(TMath::Prob(theFittedVertex.totalChiSquared(),(int)theFittedVertex.degreesOfFreedom()));
722 
723  // from my Vertex
724  double dxyFromMyVertex = theTrack.dxy(myVertex);
725  double dzFromMyVertex = theTrack.dz(myVertex);
726 
727  GlobalPoint vert(theFittedVertex.position().x(),theFittedVertex.position().y(),theFittedVertex.position().z());
728 
729  //FreeTrajectoryState theTrackNearVertex = theTTrack.trajectoryStateClosestToPoint(vert).theState();
730  //double dz_err = sqrt(theFittedVertex.positionError().czz() + theTrackNearVertex.cartesianError().position().czz());
731  //double dz_err = hypot(theTrack.dzError(),theFittedVertex.positionError().czz());
732 
733  double dz_err = sqrt(std::pow(theTrack.dzError(), 2) + theFittedVertex.positionError().czz());
734 
735 
736  // PV2D
737  std::pair<bool,Measurement1D> s_ip2dpv = signedTransverseImpactParameter(theTTrack,
738  GlobalVector(theTrack.px(),
739  theTrack.py(),
740  theTrack.pz()),
741  theFittedVertex);
742 
743  double s_ip2dpv_corr = s_ip2dpv.second.value();
744  double s_ip2dpv_err = s_ip2dpv.second.error();
745 
746  // PV3D
747  std::pair<bool, Measurement1D> s_ip3dpv = signedImpactParameter3D(theTTrack,
748  GlobalVector(theTrack.px(),
749  theTrack.py(),
750  theTrack.pz()),
751  theFittedVertex);
752 
753  double s_ip3dpv_corr = s_ip3dpv.second.value();
754  double s_ip3dpv_err = s_ip3dpv.second.error();
755 
756  // PV3D absolute
757  std::pair<bool,Measurement1D> ip3dpv = absoluteImpactParameter3D(theTTrack,theFittedVertex);
758  double ip3d_corr = ip3dpv.second.value();
759  double ip3d_err = ip3dpv.second.error();
760 
761  // with respect to any specified vertex, such as primary vertex
762  TrajectoryStateClosestToPoint traj = (theTTrack).trajectoryStateClosestToPoint(vert);
763 
764  GlobalPoint refPoint = traj.position();
765  GlobalPoint cPToVtx = traj.theState().position();
766 
767  float my_dx = refPoint.x() - myVertex.x();
768  float my_dy = refPoint.y() - myVertex.y();
769 
770  float my_dx2 = cPToVtx.x() - myVertex.x();
771  float my_dy2 = cPToVtx.y() - myVertex.y();
772 
773  float my_dxy = std::sqrt(my_dx*my_dx + my_dy*my_dy);
774 
775  double d0 = traj.perigeeParameters().transverseImpactParameter();
776  //double d0_error = traj.perigeeError().transverseImpactParameterError();
777  double z0 = traj.perigeeParameters().longitudinalImpactParameter();
778  double z0_error = traj.perigeeError().longitudinalImpactParameterError();
779 
780  if(debug_){
781  edm::LogInfo("PrimaryVertexValidation")<< "my_dx:" << my_dx
782  << " my_dy:" << my_dy
783  << " my_dxy:" << my_dxy
784  << " my_dx2:" << my_dx2
785  << " my_dy2:" << my_dy2
786  << " d0: " << d0
787  << " dxyFromVtx:" << dxyFromMyVertex << "\n"
788  << " ============================== "<< "\n"
789  << "diff1:" << std::abs(d0) - std::abs(my_dxy) << "\n"
790  << "diff2:" << std::abs(d0) - std::abs(dxyFromMyVertex) << "\n"
791  << "diff3:" << (my_dx - my_dx2) << " " << (my_dy - my_dy2) << "\n"
792  << std::endl;
793  }
794 
795  // define IPs
796 
797  dxyFromMyVertex_[nTracks_] = dxyFromMyVertex;
798  dxyErrorFromMyVertex_[nTracks_] = s_ip2dpv_err;
799  IPTsigFromMyVertex_[nTracks_] = dxyFromMyVertex/s_ip2dpv_err;
800 
801  dzFromMyVertex_[nTracks_] = dzFromMyVertex;
802  dzErrorFromMyVertex_[nTracks_] = dz_err;
803  IPLsigFromMyVertex_[nTracks_] = dzFromMyVertex/dz_err;
804 
805  d3DFromMyVertex_[nTracks_] = ip3d_corr;
806  d3DErrorFromMyVertex_[nTracks_] = ip3d_err;
807  IP3DsigFromMyVertex_[nTracks_] = (ip3d_corr/ip3d_err);
808 
809  // fill directly the histograms of residuals
810 
811  float trackphi = (theTrack.phi())*(180./M_PI);
812  float tracketa = theTrack.eta();
813  float trackpt = theTrack.pt();
814  float trackp = theTrack.p();
815  float tracknhits = theTrack.numberOfValidHits();
816 
817  // determine the module number and ladder
818 
819  int ladder_num = -1.;
820  int module_num = -1.;
821  int L1BPixHitCount = 0;
822 
823  for (trackingRecHit_iterator iHit = theTrack.recHitsBegin(); iHit != theTrack.recHitsEnd(); ++iHit) {
824  const DetId& detId = (*iHit)->geographicalId();
825  unsigned int subid = detId.subdetId();
826 
827  if((*iHit)->isValid() && ( subid == PixelSubdetector::PixelBarrel ) ) {
828  int layer = tTopo->pxbLayer(detId);
829  if(layer==1){
830  L1BPixHitCount+=1;
831  ladder_num = tTopo->pxbLadder(detId);
832  module_num = tTopo->pxbModule(detId);
833  }
834  }
835  }
836 
837  h_probeL1Ladder_->Fill(ladder_num);
838  h_probeL1Module_->Fill(module_num);
839  h_probeHasBPixL1Overlap_->Fill(L1BPixHitCount);
840 
841  // filling the pT-binned distributions
842 
843  for(int ipTBin=0; ipTBin<nPtBins_; ipTBin++){
844 
845  float pTF = mypT_bins_[ipTBin];
846  float pTL = mypT_bins_[ipTBin+1];
847 
848  if(debug_)
849  edm::LogInfo("PrimaryVertexValidation")<<"ipTBin:"<<ipTBin<< " "<<mypT_bins_[ipTBin]<< " < pT < "<<mypT_bins_[ipTBin+1]<<std::endl;
850 
851  if( std::abs(tracketa)<1.5 && (trackpt >= pTF && trackpt < pTL) ){
852 
853  if(debug_)
854  edm::LogInfo("PrimaryVertexValidation")<<"passes this cut: "<<mypT_bins_[ipTBin]<<std::endl;
855  PVValHelper::fillByIndex(h_dxy_pT_,ipTBin,dxyFromMyVertex*cmToum);
856  PVValHelper::fillByIndex(h_dz_pT_,ipTBin,dzFromMyVertex*cmToum);
857  PVValHelper::fillByIndex(h_norm_dxy_pT_,ipTBin,dxyFromMyVertex/s_ip2dpv_err);
858  PVValHelper::fillByIndex(h_norm_dz_pT_,ipTBin,dzFromMyVertex/dz_err);
859 
860  if(std::abs(tracketa)<1.){
861 
862  if(debug_)
863  edm::LogInfo("PrimaryVertexValidation")<<"passes tight eta cut: "<<mypT_bins_[ipTBin]<<std::endl;
864  PVValHelper::fillByIndex(h_dxy_Central_pT_,ipTBin,dxyFromMyVertex*cmToum);
865  PVValHelper::fillByIndex(h_dz_Central_pT_,ipTBin,dzFromMyVertex*cmToum);
866  PVValHelper::fillByIndex(h_norm_dxy_Central_pT_,ipTBin,dxyFromMyVertex/s_ip2dpv_err);
867  PVValHelper::fillByIndex(h_norm_dz_Central_pT_,ipTBin,dzFromMyVertex/dz_err);
868  }
869  }
870  }
871 
872  // checks on the probe track quality
873  if(trackpt >= ptOfProbe_
874  && std::abs(tracketa)<= etaOfProbe_
875  && tracknhits>=nHitsOfProbe_
876  && trackp >= pOfProbe_){
877 
878  std::pair<bool,bool> pixelOcc = pixelHitsCheck((theTTrack));
879 
880  if(debug_){
881  if(pixelOcc.first == true)
882  edm::LogInfo("PrimaryVertexValidation")<<"has BPIx hits"<<std::endl;
883  if(pixelOcc.second == true)
884  edm::LogInfo("PrimaryVertexValidation")<<"has FPix hits"<<std::endl;
885  }
886 
887  if(!doBPix_ && (pixelOcc.first == true)) continue;
888  if(!doFPix_ && (pixelOcc.second == true)) continue;
889 
890  fillTrackHistos(hDA,"sel",&(theTTrack),vertex,beamSpot,fBfield_);
891 
892  // probe checks
893  h_probePt_->Fill(theTrack.pt());
894  h_probePtRebin_->Fill(theTrack.pt());
895  h_probeP_->Fill(theTrack.p());
896  h_probeEta_->Fill(theTrack.eta());
897  h_probePhi_->Fill(theTrack.phi());
898  h2_probeEtaPhi_->Fill(theTrack.eta(),theTrack.phi());
899  h2_probeEtaPt_->Fill(theTrack.eta(),theTrack.pt());
900 
901  h_probeChi2_->Fill(theTrack.chi2());
902  h_probeNormChi2_->Fill(theTrack.normalizedChi2());
903  h_probeCharge_->Fill(theTrack.charge());
904  h_probeQoverP_->Fill(theTrack.qoverp());
905  h_probeHits_->Fill(theTrack.numberOfValidHits());
906  h_probeHits1D_->Fill(nRecHit1D);
907  h_probeHits2D_->Fill(nRecHit2D);
908  h_probeHitsInTIB_->Fill(nhitinBPIX);
909  h_probeHitsInTOB_->Fill(nhitinFPIX);
910  h_probeHitsInTID_->Fill(nhitinTIB);
911  h_probeHitsInTEC_->Fill(nhitinTID);
912  h_probeHitsInBPIX_->Fill(nhitinTOB);
913  h_probeHitsInFPIX_->Fill(nhitinTEC);
914 
915  float dxyRecoV = theTrack.dz(theRecoVertex);
916  float dzRecoV = theTrack.dxy(theRecoVertex);
917  float dxysigmaRecoV = TMath::Sqrt(theTrack.d0Error()*theTrack.d0Error()+xErrOfflineVertex_*yErrOfflineVertex_);
918  float dzsigmaRecoV = TMath::Sqrt(theTrack.dzError()*theTrack.dzError()+zErrOfflineVertex_*zErrOfflineVertex_);
919 
920  double zTrack=(theTTrack.stateAtBeamLine().trackStateAtPCA()).position().z();
921  double zVertex=theFittedVertex.position().z();
922  double tantheta=tan((theTTrack.stateAtBeamLine().trackStateAtPCA()).momentum().theta());
923 
924  double dz2= pow(theTrack.dzError(),2)+wxy2_/pow(tantheta,2);
925  double restrkz = zTrack-zVertex;
926  double pulltrkz = (zTrack-zVertex)/TMath::Sqrt(dz2);
927 
928  h_probedxyRecoV_->Fill(dxyRecoV);
929  h_probedzRecoV_->Fill(dzRecoV);
930 
931  h_probedzRefitV_->Fill(dxyFromMyVertex);
932  h_probedxyRefitV_->Fill(dzFromMyVertex);
933 
934  h_probed0RefitV_->Fill(d0);
935  h_probez0RefitV_->Fill(z0);
936 
937  h_probesignIP2DRefitV_->Fill(s_ip2dpv_corr);
938  h_probed3DRefitV_->Fill(ip3d_corr);
939  h_probereszRefitV_->Fill(restrkz);
940 
941  h_probeRecoVSigZ_->Fill(dzRecoV/dzsigmaRecoV);
942  h_probeRecoVSigXY_->Fill(dxyRecoV/dxysigmaRecoV);
943  h_probeRefitVSigZ_->Fill(dzFromMyVertex/dz_err);
944  h_probeRefitVSigXY_->Fill(dxyFromMyVertex/s_ip2dpv_err);
945  h_probeRefitVSig3D_->Fill(ip3d_corr/ip3d_err);
946  h_probeRefitVLogSig3D_->Fill(log10(ip3d_corr/ip3d_err));
947  h_probeRefitVSigResZ_->Fill(pulltrkz);
948 
949  a_dxyVsPhi->Fill(trackphi,dxyFromMyVertex*cmToum);
950  a_dzVsPhi->Fill(trackphi,z0*cmToum);
951  n_dxyVsPhi->Fill(trackphi,dxyFromMyVertex/s_ip2dpv_err);
952  n_dzVsPhi->Fill(trackphi,z0/z0_error);
953 
954  a_dxyVsEta->Fill(tracketa,dxyFromMyVertex*cmToum);
955  a_dzVsEta->Fill(tracketa,z0*cmToum);
956  n_dxyVsEta->Fill(tracketa,dxyFromMyVertex/s_ip2dpv_err);
957  n_dzVsEta->Fill(tracketa,z0/z0_error);
958 
959  if( ladder_num > 0 && module_num > 0 ) {
960 
961  LogDebug("PrimaryVertexValidation")<<" ladder_num"<<ladder_num <<" module_num"<<module_num <<std::endl;
962 
963  PVValHelper::fillByIndex(h_dxy_modZ_,module_num-1,dxyFromMyVertex*cmToum);
964  PVValHelper::fillByIndex(h_dz_modZ_,module_num-1,dzFromMyVertex*cmToum);
965  PVValHelper::fillByIndex(h_norm_dxy_modZ_,module_num-1,dxyFromMyVertex/s_ip2dpv_err);
966  PVValHelper::fillByIndex(h_norm_dz_modZ_,module_num-1,dzFromMyVertex/dz_err);
967 
968  PVValHelper::fillByIndex(h_dxy_ladder_,ladder_num-1,dxyFromMyVertex*cmToum);
969 
970  LogDebug("PrimaryVertexValidation")<<"h_dxy_ladder size:" <<h_dxy_ladder_.size() << std::endl;
971 
972  if(L1BPixHitCount==1){
973  PVValHelper::fillByIndex(h_dxy_ladderNoOverlap_,ladder_num-1,dxyFromMyVertex*cmToum);
974  } else {
975  PVValHelper::fillByIndex(h_dxy_ladderOverlap_,ladder_num-1,dxyFromMyVertex*cmToum);
976  }
977 
978  PVValHelper::fillByIndex(h_dz_ladder_,ladder_num-1,dzFromMyVertex*cmToum);
979  PVValHelper::fillByIndex(h_norm_dxy_ladder_,ladder_num-1,dxyFromMyVertex/s_ip2dpv_err);
980  PVValHelper::fillByIndex(h_norm_dz_ladder_,ladder_num-1,dzFromMyVertex/dz_err);
981 
982  }
983 
984  // filling the binned distributions
985  for(int i=0; i<nBins_; i++){
986 
987  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
988  float phiL = theDetails_.trendbins[PVValHelper::phi][i+1];
989 
990  float etaF = theDetails_.trendbins[PVValHelper::eta][i];
991  float etaL = theDetails_.trendbins[PVValHelper::eta][i+1];
992 
993  if(tracketa >= etaF && tracketa < etaL ){
994 
995  PVValHelper::fillByIndex(a_dxyEtaResiduals,i,dxyFromMyVertex*cmToum,"1");
996  PVValHelper::fillByIndex(a_dxEtaResiduals,i,my_dx*cmToum,"2");
997  PVValHelper::fillByIndex(a_dyEtaResiduals,i,my_dy*cmToum,"3");
998  PVValHelper::fillByIndex(a_dzEtaResiduals,i,dzFromMyVertex*cmToum,"4");
999  PVValHelper::fillByIndex(n_dxyEtaResiduals,i,dxyFromMyVertex/s_ip2dpv_err,"5");
1000  PVValHelper::fillByIndex(n_dzEtaResiduals,i,dzFromMyVertex/dz_err,"6");
1001  PVValHelper::fillByIndex(a_IP2DEtaResiduals,i,s_ip2dpv_corr*cmToum,"7");
1002  PVValHelper::fillByIndex(n_IP2DEtaResiduals,i,s_ip2dpv_corr/s_ip2dpv_err,"8");
1003  PVValHelper::fillByIndex(a_reszEtaResiduals,i,restrkz*cmToum,"9");
1004  PVValHelper::fillByIndex(n_reszEtaResiduals,i,pulltrkz,"10");
1005  PVValHelper::fillByIndex(a_d3DEtaResiduals,i,ip3d_corr*cmToum,"11");
1006  PVValHelper::fillByIndex(n_d3DEtaResiduals,i,ip3d_corr/ip3d_err,"12");
1007  PVValHelper::fillByIndex(a_IP3DEtaResiduals,i,s_ip3dpv_corr*cmToum,"13");
1008  PVValHelper::fillByIndex(n_IP3DEtaResiduals,i,s_ip3dpv_corr/s_ip3dpv_err,"14");
1009 
1010  }
1011 
1012  if(trackphi >= phiF && trackphi < phiL ){
1013 
1014  PVValHelper::fillByIndex(a_dxyPhiResiduals,i,dxyFromMyVertex*cmToum,"15");
1015  PVValHelper::fillByIndex(a_dxPhiResiduals,i,my_dx*cmToum,"16");
1016  PVValHelper::fillByIndex(a_dyPhiResiduals,i,my_dy*cmToum,"17");
1017  PVValHelper::fillByIndex(a_dzPhiResiduals,i,dzFromMyVertex*cmToum,"18");
1018  PVValHelper::fillByIndex(n_dxyPhiResiduals,i,dxyFromMyVertex/s_ip2dpv_err,"19");
1019  PVValHelper::fillByIndex(n_dzPhiResiduals,i,dzFromMyVertex/dz_err,"20");
1020  PVValHelper::fillByIndex(a_IP2DPhiResiduals,i,s_ip2dpv_corr*cmToum,"21");
1021  PVValHelper::fillByIndex(n_IP2DPhiResiduals,i,s_ip2dpv_corr/s_ip2dpv_err,"22");
1022  PVValHelper::fillByIndex(a_reszPhiResiduals,i,restrkz*cmToum,"23");
1023  PVValHelper::fillByIndex(n_reszPhiResiduals,i,pulltrkz,"24");
1024  PVValHelper::fillByIndex(a_d3DPhiResiduals,i,ip3d_corr*cmToum,"25");
1025  PVValHelper::fillByIndex(n_d3DPhiResiduals,i,ip3d_corr/ip3d_err,"26");
1026  PVValHelper::fillByIndex(a_IP3DPhiResiduals,i,s_ip3dpv_corr*cmToum,"27");
1027  PVValHelper::fillByIndex(n_IP3DPhiResiduals,i,s_ip3dpv_corr/s_ip3dpv_err,"28");
1028 
1029  for(int j=0; j<nBins_; j++){
1030 
1031  float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
1032  float etaK = theDetails_.trendbins[PVValHelper::eta][j+1];
1033 
1034  if(tracketa >= etaJ && tracketa < etaK ){
1035  a_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex*cmToum);
1036  a_dzResidualsMap[i][j]->Fill(dzFromMyVertex*cmToum);
1037  n_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex/s_ip2dpv_err);
1038  n_dzResidualsMap[i][j]->Fill(dzFromMyVertex/dz_err);
1039  a_d3DResidualsMap[i][j]->Fill(ip3d_corr*cmToum);
1040  n_d3DResidualsMap[i][j]->Fill(ip3d_corr/ip3d_err);
1041 
1042  }
1043  }
1044  }
1045  }
1046  }
1047 
1048  if(debug_){
1049  edm::LogInfo("PrimaryVertexValidation")<<" myVertex.x()= "<<myVertex.x()<<"\n"
1050  <<" myVertex.y()= "<<myVertex.y()<<" \n"
1051  <<" myVertex.z()= "<<myVertex.z()<<" \n"
1052  <<" theTrack.dz(myVertex)= "<<theTrack.dz(myVertex)<<" \n"
1053  <<" zPCA -myVertex.z() = "<<(theTrack.vertex().z() -myVertex.z());
1054 
1055  }// ends if debug_
1056  } // ends if the fitted vertex is Valid
1057 
1058  //delete theFitter;
1059 
1060  } catch ( cms::Exception& er ) {
1061  LogTrace("PrimaryVertexValidation")<<"caught std::exception "<<er.what()<<std::endl;
1062  }
1063 
1064  } //ends if theFinalTracks.size() > 2
1065 
1066  else {
1067  if(debug_)
1068  edm::LogInfo("PrimaryVertexValidation")<<"Not enough tracks to make a vertex. Returns no vertex info";
1069  }
1070 
1071  ++nTracks_;
1072  ++nTracksPerClus_;
1073 
1074  if(debug_)
1075  edm::LogInfo("PrimaryVertexValidation")<<"Track "<<i<<" : pT = "<<theTrack.pt();
1076 
1077  }// for loop on tracks
1078  } // for loop on track clusters
1079 
1080  // Fill the TTree if needed
1081 
1082  if(storeNtuple_){
1083  rootTree_->Fill();
1084  }
1085 
1086 
1087 }
1088 
1089 // ------------ method called to discriminate 1D from 2D hits ------------
1090 bool PrimaryVertexValidation::isHit2D(const TrackingRecHit &hit) const
1091 {
1092  if (hit.dimension() < 2) {
1093  return false; // some (muon...) stuff really has RecHit1D
1094  } else {
1095  const DetId detId(hit.geographicalId());
1096  if (detId.det() == DetId::Tracker) {
1097  if (detId.subdetId() == PixelSubdetector::PixelBarrel || detId.subdetId() == PixelSubdetector::PixelEndcap) {
1098  return true; // pixel is always 2D
1099  } else { // should be SiStrip now
1100  if (dynamic_cast<const SiStripRecHit2D*>(&hit)) return false; // normal hit
1101  else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit)) return true; // matched is 2D
1102  else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit)) return false; // crazy hit...
1103  else {
1104  edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
1105  << "Tracker hit not in pixel and neither SiStripRecHit2D nor "
1106  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1107  return false;
1108  }
1109  }
1110  } else { // not tracker??
1111  edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
1112  << "Hit not in tracker with 'official' dimension >=2.";
1113  return true; // dimension() >= 2 so accept that...
1114  }
1115  }
1116  // never reached...
1117 }
1118 
1119 
1120 // ------------ method to check the presence of pixel hits ------------
1121 std::pair<bool,bool> PrimaryVertexValidation::pixelHitsCheck(const reco::TransientTrack& track){
1122 
1123  bool hasBPixHits = false;
1124  bool hasFPixHits = false;
1125 
1126  const reco::HitPattern& p = track.hitPattern();
1127  if(p.numberOfValidPixelEndcapHits()!=0){
1128  hasFPixHits = true;
1129  }
1130  if(p.numberOfValidPixelBarrelHits()!=0){
1131  hasBPixHits = true;
1132  }
1133 
1134  return std::make_pair(hasBPixHits,hasFPixHits);
1135 }
1136 
1137 
1138 // ------------ method to check the presence of pixel hits ------------
1139 bool PrimaryVertexValidation::hasFirstLayerPixelHits(const reco::TransientTrack& track)
1140 {
1141  using namespace reco;
1142  const HitPattern& p = track.hitPattern();
1143  for (int i=0; i<p.numberOfAllHits(HitPattern::TRACK_HITS); i++) {
1144  uint32_t pattern = p.getHitPattern(HitPattern::TRACK_HITS, i);
1145  if (p.pixelBarrelHitFilter(pattern) || p.pixelEndcapHitFilter(pattern) ) {
1146  if (p.getLayer(pattern) == 1) {
1147  if (p.validHitFilter(pattern)) {
1148  return true;
1149  }
1150  }
1151  }
1152  }
1153  return false;
1154 }
1155 
1156 // ------------ method called once each job before begining the event loop ------------
1157 void PrimaryVertexValidation::beginJob()
1158 {
1159  edm::LogInfo("PrimaryVertexValidation")
1160  <<"######################################\n"
1161  <<"Begin Job \n"
1162  <<"######################################";
1163 
1164  // Define TTree for output
1165  Nevt_ = 0;
1166 
1167  // rootFile_ = new TFile(filename_.c_str(),"recreate");
1168  rootTree_ = fs->make<TTree>("tree","PV Validation tree");
1169 
1170  // Track Paramters
1171 
1172  if(lightNtupleSwitch_){
1173 
1174  rootTree_->Branch("EventNumber",&EventNumber_,"EventNumber/i");
1175  rootTree_->Branch("RunNumber",&RunNumber_,"RunNumber/i");
1176  rootTree_->Branch("LuminosityBlockNumber",&LuminosityBlockNumber_,"LuminosityBlockNumber/i");
1177  rootTree_->Branch("nOfflineVertices",&nOfflineVertices_,"nOfflineVertices/I");
1178  rootTree_->Branch("nTracks",&nTracks_,"nTracks/I");
1179  rootTree_->Branch("phi",&phi_,"phi[nTracks]/D");
1180  rootTree_->Branch("eta",&eta_,"eta[nTracks]/D");
1181  rootTree_->Branch("pt",&pt_,"pt[nTracks]/D");
1182  rootTree_->Branch("dxyFromMyVertex",&dxyFromMyVertex_,"dxyFromMyVertex[nTracks]/D");
1183  rootTree_->Branch("dzFromMyVertex",&dzFromMyVertex_,"dzFromMyVertex[nTracks]/D");
1184  rootTree_->Branch("d3DFromMyVertex",&d3DFromMyVertex_,"d3DFromMyVertex[nTracks]/D");
1185  rootTree_->Branch("IPTsigFromMyVertex",&IPTsigFromMyVertex_,"IPTsigFromMyVertex_[nTracks]/D");
1186  rootTree_->Branch("IPLsigFromMyVertex",&IPLsigFromMyVertex_,"IPLsigFromMyVertex_[nTracks]/D");
1187  rootTree_->Branch("IP3DsigFromMyVertex",&IP3DsigFromMyVertex_,"IP3DsigFromMyVertex_[nTracks]/D");
1188  rootTree_->Branch("hasRecVertex",&hasRecVertex_,"hasRecVertex[nTracks]/I");
1189  rootTree_->Branch("isGoodTrack",&isGoodTrack_,"isGoodTrack[nTracks]/I");
1190  rootTree_->Branch("isHighPurity",&isHighPurity_,"isHighPurity_[nTracks]/I");
1191 
1192  } else {
1193 
1194  rootTree_->Branch("nTracks",&nTracks_,"nTracks/I");
1195  rootTree_->Branch("nTracksPerClus",&nTracksPerClus_,"nTracksPerClus/I");
1196  rootTree_->Branch("nClus",&nClus_,"nClus/I");
1197  rootTree_->Branch("xOfflineVertex",&xOfflineVertex_,"xOfflineVertex/D");
1198  rootTree_->Branch("yOfflineVertex",&yOfflineVertex_,"yOfflineVertex/D");
1199  rootTree_->Branch("zOfflineVertex",&zOfflineVertex_,"zOfflineVertex/D");
1200  rootTree_->Branch("BSx0",&BSx0_,"BSx0/D");
1201  rootTree_->Branch("BSy0",&BSy0_,"BSy0/D");
1202  rootTree_->Branch("BSz0",&BSz0_,"BSz0/D");
1203  rootTree_->Branch("Beamsigmaz",&Beamsigmaz_,"Beamsigmaz/D");
1204  rootTree_->Branch("Beamdxdz",&Beamdxdz_,"Beamdxdz/D");
1205  rootTree_->Branch("BeamWidthX",&BeamWidthX_,"BeamWidthX/D");
1206  rootTree_->Branch("BeamWidthY",&BeamWidthY_,"BeamWidthY/D");
1207  rootTree_->Branch("pt",&pt_,"pt[nTracks]/D");
1208  rootTree_->Branch("p",&p_,"p[nTracks]/D");
1209  rootTree_->Branch("nhits",&nhits_,"nhits[nTracks]/I");
1210  rootTree_->Branch("nhits1D",&nhits1D_,"nhits1D[nTracks]/I");
1211  rootTree_->Branch("nhits2D",&nhits2D_,"nhits2D[nTracks]/I");
1212  rootTree_->Branch("nhitsBPIX",&nhitsBPIX_,"nhitsBPIX[nTracks]/I");
1213  rootTree_->Branch("nhitsFPIX",&nhitsFPIX_,"nhitsFPIX[nTracks]/I");
1214  rootTree_->Branch("nhitsTIB",&nhitsTIB_,"nhitsTIB[nTracks]/I");
1215  rootTree_->Branch("nhitsTID",&nhitsTID_,"nhitsTID[nTracks]/I");
1216  rootTree_->Branch("nhitsTOB",&nhitsTOB_,"nhitsTOB[nTracks]/I");
1217  rootTree_->Branch("nhitsTEC",&nhitsTEC_,"nhitsTEC[nTracks]/I");
1218  rootTree_->Branch("eta",&eta_,"eta[nTracks]/D");
1219  rootTree_->Branch("theta",&theta_,"theta[nTracks]/D");
1220  rootTree_->Branch("phi",&phi_,"phi[nTracks]/D");
1221  rootTree_->Branch("chi2",&chi2_,"chi2[nTracks]/D");
1222  rootTree_->Branch("chi2ndof",&chi2ndof_,"chi2ndof[nTracks]/D");
1223  rootTree_->Branch("charge",&charge_,"charge[nTracks]/I");
1224  rootTree_->Branch("qoverp",&qoverp_,"qoverp[nTracks]/D");
1225  rootTree_->Branch("dz",&dz_,"dz[nTracks]/D");
1226  rootTree_->Branch("dxy",&dxy_,"dxy[nTracks]/D");
1227  rootTree_->Branch("dzBs",&dzBs_,"dzBs[nTracks]/D");
1228  rootTree_->Branch("dxyBs",&dxyBs_,"dxyBs[nTracks]/D");
1229  rootTree_->Branch("xPCA",&xPCA_,"xPCA[nTracks]/D");
1230  rootTree_->Branch("yPCA",&yPCA_,"yPCA[nTracks]/D");
1231  rootTree_->Branch("zPCA",&zPCA_,"zPCA[nTracks]/D");
1232  rootTree_->Branch("xUnbiasedVertex",&xUnbiasedVertex_,"xUnbiasedVertex[nTracks]/D");
1233  rootTree_->Branch("yUnbiasedVertex",&yUnbiasedVertex_,"yUnbiasedVertex[nTracks]/D");
1234  rootTree_->Branch("zUnbiasedVertex",&zUnbiasedVertex_,"zUnbiasedVertex[nTracks]/D");
1235  rootTree_->Branch("chi2normUnbiasedVertex",&chi2normUnbiasedVertex_,"chi2normUnbiasedVertex[nTracks]/F");
1236  rootTree_->Branch("chi2UnbiasedVertex",&chi2UnbiasedVertex_,"chi2UnbiasedVertex[nTracks]/F");
1237  rootTree_->Branch("DOFUnbiasedVertex",&DOFUnbiasedVertex_," DOFUnbiasedVertex[nTracks]/F");
1238  rootTree_->Branch("chi2ProbUnbiasedVertex",&chi2ProbUnbiasedVertex_,"chi2ProbUnbiasedVertex[nTracks]/F");
1239  rootTree_->Branch("sumOfWeightsUnbiasedVertex",&sumOfWeightsUnbiasedVertex_,"sumOfWeightsUnbiasedVertex[nTracks]/F");
1240  rootTree_->Branch("tracksUsedForVertexing",&tracksUsedForVertexing_,"tracksUsedForVertexing[nTracks]/I");
1241  rootTree_->Branch("dxyFromMyVertex",&dxyFromMyVertex_,"dxyFromMyVertex[nTracks]/D");
1242  rootTree_->Branch("dzFromMyVertex",&dzFromMyVertex_,"dzFromMyVertex[nTracks]/D");
1243  rootTree_->Branch("dxyErrorFromMyVertex",&dxyErrorFromMyVertex_,"dxyErrorFromMyVertex_[nTracks]/D");
1244  rootTree_->Branch("dzErrorFromMyVertex",&dzErrorFromMyVertex_,"dzErrorFromMyVertex_[nTracks]/D");
1245  rootTree_->Branch("IPTsigFromMyVertex",&IPTsigFromMyVertex_,"IPTsigFromMyVertex_[nTracks]/D");
1246  rootTree_->Branch("IPLsigFromMyVertex",&IPLsigFromMyVertex_,"IPLsigFromMyVertex_[nTracks]/D");
1247  rootTree_->Branch("hasRecVertex",&hasRecVertex_,"hasRecVertex[nTracks]/I");
1248  rootTree_->Branch("isGoodTrack",&isGoodTrack_,"isGoodTrack[nTracks]/I");
1249  }
1250 
1251  // event histograms
1252  TFileDirectory EventFeatures = fs->mkdir("EventFeatures");
1253 
1254  TH1F::SetDefaultSumw2(kTRUE);
1255 
1256  h_lumiFromConfig = EventFeatures.make<TH1F>("h_lumiFromConfig","luminosity from config;;luminosity of present run",1,-0.5,0.5);
1257  h_lumiFromConfig->SetBinContent(1,intLumi_);
1258 
1259  h_runFromConfig = EventFeatures.make<TH1I>("h_runFromConfig","run number from config;;run number (from configuration)",
1260  runControlNumbers_.size(),0.,runControlNumbers_.size());
1261  for(const auto r : runControlNumbers_){
1262  h_runFromConfig->SetBinContent(r+1, r);
1263  }
1264 
1265  h_runFromEvent = EventFeatures.make<TH1I>("h_runFromEvent","run number from config;;run number (from event)",1,-0.5,0.5);
1266  h_nTracks = EventFeatures.make<TH1F>("h_nTracks","number of tracks per event;n_{tracks}/event;n_{events}",300,-0.5,299.5);
1267  h_nClus = EventFeatures.make<TH1F>("h_nClus","number of track clusters;n_{clusters}/event;n_{events}",50,-0.5,49.5);
1268  h_nOfflineVertices = EventFeatures.make<TH1F>("h_nOfflineVertices","number of offline reconstructed vertices;n_{vertices}/event;n_{events}",50,-0.5,49.5);
1269  h_runNumber = EventFeatures.make<TH1F>("h_runNumber","run number;run number;n_{events}",100000,250000.,350000.);
1270  h_xOfflineVertex = EventFeatures.make<TH1F>("h_xOfflineVertex","x-coordinate of offline vertex;x_{vertex};n_{events}",100,-0.1,0.1);
1271  h_yOfflineVertex = EventFeatures.make<TH1F>("h_yOfflineVertex","y-coordinate of offline vertex;y_{vertex};n_{events}",100,-0.1,0.1);
1272  h_zOfflineVertex = EventFeatures.make<TH1F>("h_zOfflineVertex","z-coordinate of offline vertex;z_{vertex};n_{events}",100,-30.,30.);
1273  h_xErrOfflineVertex = EventFeatures.make<TH1F>("h_xErrOfflineVertex","x-coordinate error of offline vertex;err_{x}^{vtx};n_{events}",100,0.,0.01);
1274  h_yErrOfflineVertex = EventFeatures.make<TH1F>("h_yErrOfflineVertex","y-coordinate error of offline vertex;err_{y}^{vtx};n_{events}",100,0.,0.01);
1275  h_zErrOfflineVertex = EventFeatures.make<TH1F>("h_zErrOfflineVertex","z-coordinate error of offline vertex;err_{z}^{vtx};n_{events}",100,0.,10.);
1276  h_BSx0 = EventFeatures.make<TH1F>("h_BSx0","x-coordinate of reco beamspot;x^{BS}_{0};n_{events}",100,-0.1,0.1);
1277  h_BSy0 = EventFeatures.make<TH1F>("h_BSy0","y-coordinate of reco beamspot;y^{BS}_{0};n_{events}",100,-0.1,0.1);
1278  h_BSz0 = EventFeatures.make<TH1F>("h_BSz0","z-coordinate of reco beamspot;z^{BS}_{0};n_{events}",100,-1.,1.);
1279  h_Beamsigmaz = EventFeatures.make<TH1F>("h_Beamsigmaz","z-coordinate beam width;#sigma_{Z}^{beam};n_{events}",100,0.,1.);
1280  h_BeamWidthX = EventFeatures.make<TH1F>("h_BeamWidthX","x-coordinate beam width;#sigma_{X}^{beam};n_{events}",100,0.,0.01);
1281  h_BeamWidthY = EventFeatures.make<TH1F>("h_BeamWidthY","y-coordinate beam width;#sigma_{Y}^{beam};n_{events}",100,0.,0.01);
1282 
1283  h_etaMax = EventFeatures.make<TH1F>("etaMax","etaMax",1,-0.5,0.5);
1284  h_pTinfo = EventFeatures.make<TH1F>("pTinfo","pTinfo",3,-1.5,1.5);
1285  h_pTinfo->GetXaxis()->SetBinLabel(1,"n. bins");
1286  h_pTinfo->GetXaxis()->SetBinLabel(2,"pT min");
1287  h_pTinfo->GetXaxis()->SetBinLabel(3,"pT max");
1288 
1289  h_nbins = EventFeatures.make<TH1F>("nbins","nbins",1,-0.5,0.5);
1290  h_nLadders = EventFeatures.make<TH1F>("nladders","n. ladders",1,-0.5,0.5);
1291 
1292  // probe track histograms
1293  TFileDirectory ProbeFeatures = fs->mkdir("ProbeTrackFeatures");
1294 
1295  h_probePt_ = ProbeFeatures.make<TH1F>("h_probePt","p_{T} of probe track;track p_{T} (GeV); tracks",100,0.,50.);
1296  h_probePtRebin_ = ProbeFeatures.make<TH1F>("h_probePtRebin","p_{T} of probe track;track p_{T} (GeV); tracks",mypT_bins_.size()-1,mypT_bins_.data());
1297  h_probeP_ = ProbeFeatures.make<TH1F>("h_probeP","momentum of probe track;track p (GeV); tracks",100,0.,100.);
1298  h_probeEta_ = ProbeFeatures.make<TH1F>("h_probeEta","#eta of the probe track;track #eta;tracks",54,-2.8,2.8);
1299  h_probePhi_ = ProbeFeatures.make<TH1F>("h_probePhi","#phi of probe track;track #phi (rad);tracks",100,-3.15,3.15);
1300 
1301  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);
1302  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.);
1303 
1304  h_probeChi2_ = ProbeFeatures.make<TH1F>("h_probeChi2","#chi^{2} of probe track;track #chi^{2}; tracks",100,0.,100.);
1305  h_probeNormChi2_ = ProbeFeatures.make<TH1F>("h_probeNormChi2"," normalized #chi^{2} of probe track;track #chi^{2}/ndof; tracks",100,0.,10.);
1306  h_probeCharge_ = ProbeFeatures.make<TH1F>("h_probeCharge","charge of profe track;track charge Q;tracks",3,-1.5,1.5);
1307  h_probeQoverP_ = ProbeFeatures.make<TH1F>("h_probeQoverP","q/p of probe track; track Q/p (GeV^{-1});tracks",200,-1.,1.);
1308  h_probedzRecoV_ = ProbeFeatures.make<TH1F>("h_probedzRecoV","d_{z}(V_{offline}) of probe track;track d_{z}(V_{off}) (cm);tracks",200,-1.,1.);
1309  h_probedxyRecoV_ = ProbeFeatures.make<TH1F>("h_probedxyRecoV","d_{xy}(V_{offline}) of probe track;track d_{xy}(V_{off}) (cm);tracks",200,-1.,1.);
1310  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);
1311  h_probesignIP2DRefitV_ = ProbeFeatures.make<TH1F>("h_probesignIPRefitV","ip_{2D}(V_{refit}) of probe track;track ip_{2D}(V_{fit}) (cm);tracks",200,-1.,1.);
1312  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);
1313 
1314  h_probez0RefitV_ = ProbeFeatures.make<TH1F>("h_probez0RefitV","z_{0}(V_{refit}) of probe track;track z_{0}(V_{fit}) (cm);tracks",200,-1.,1.);
1315  h_probed0RefitV_ = ProbeFeatures.make<TH1F>("h_probed0RefitV","d_{0}(V_{refit}) of probe track;track d_{0}(V_{fit}) (cm);tracks",200,-1.,1.);
1316 
1317  h_probed3DRefitV_ = ProbeFeatures.make<TH1F>("h_probed3DRefitV","d_{3D}(V_{refit}) of probe track;track d_{3D}(V_{fit}) (cm);tracks",200,0.,1.);
1318  h_probereszRefitV_ = ProbeFeatures.make<TH1F>("h_probeReszRefitV","z_{track} -z_{V_{refit}};track res_{z}(V_{refit}) (cm);tracks",200,-1.,1.);
1319 
1320  h_probeRecoVSigZ_ = ProbeFeatures.make<TH1F>("h_probeRecoVSigZ" ,"Longitudinal DCA Significance (reco);d_{z}(V_{off})/#sigma_{dz};tracks",100,-8,8);
1321  h_probeRecoVSigXY_ = ProbeFeatures.make<TH1F>("h_probeRecoVSigXY" ,"Transverse DCA Significance (reco);d_{xy}(V_{off})/#sigma_{dxy};tracks",100,-8,8);
1322  h_probeRefitVSigZ_ = ProbeFeatures.make<TH1F>("h_probeRefitVSigZ" ,"Longitudinal DCA Significance (refit);d_{z}(V_{fit})/#sigma_{dz};tracks",100,-8,8);
1323  h_probeRefitVSigXY_= ProbeFeatures.make<TH1F>("h_probeRefitVSigXY","Transverse DCA Significance (refit);d_{xy}(V_{fit})/#sigma_{dxy};tracks",100,-8,8);
1324  h_probeRefitVSig3D_= ProbeFeatures.make<TH1F>("h_probeRefitVSig3D","3D DCA Significance (refit);d_{3D}/#sigma_{3D};tracks",100,0.,20.);
1325  h_probeRefitVLogSig3D_ = ProbeFeatures.make<TH1F>("h_probeRefitVLogSig3D","log_{10}(3D DCA-Significance) (refit);log_{10}(d_{3D}/#sigma_{3D});tracks",100,-5.,4.);
1326  h_probeRefitVSigResZ_ = ProbeFeatures.make<TH1F>("h_probeRefitVSigResZ" ,"Longitudinal residual significance (refit);(z_{track} -z_{V_{fit}})/#sigma_{res_{z}};tracks",100,-8,8);
1327 
1328  h_probeHits_ = ProbeFeatures.make<TH1F>("h_probeNRechits" ,"N_{hits} ;N_{hits} ;tracks",40,-0.5,39.5);
1329  h_probeHits1D_ = ProbeFeatures.make<TH1F>("h_probeNRechits1D" ,"N_{hits} 1D ;N_{hits} 1D ;tracks",40,-0.5,39.5);
1330  h_probeHits2D_ = ProbeFeatures.make<TH1F>("h_probeNRechits2D" ,"N_{hits} 2D ;N_{hits} 2D ;tracks",40,-0.5,39.5);
1331  h_probeHitsInTIB_ = ProbeFeatures.make<TH1F>("h_probeNRechitsTIB" ,"N_{hits} TIB ;N_{hits} TIB;tracks",40,-0.5,39.5);
1332  h_probeHitsInTOB_ = ProbeFeatures.make<TH1F>("h_probeNRechitsTOB" ,"N_{hits} TOB ;N_{hits} TOB;tracks",40,-0.5,39.5);
1333  h_probeHitsInTID_ = ProbeFeatures.make<TH1F>("h_probeNRechitsTID" ,"N_{hits} TID ;N_{hits} TID;tracks",40,-0.5,39.5);
1334  h_probeHitsInTEC_ = ProbeFeatures.make<TH1F>("h_probeNRechitsTEC" ,"N_{hits} TEC ;N_{hits} TEC;tracks",40,-0.5,39.5);
1335  h_probeHitsInBPIX_ = ProbeFeatures.make<TH1F>("h_probeNRechitsBPIX","N_{hits} BPIX;N_{hits} BPIX;tracks",40,-0.5,39.5);
1336  h_probeHitsInFPIX_ = ProbeFeatures.make<TH1F>("h_probeNRechitsFPIX","N_{hits} FPIX;N_{hits} FPIX;tracks",40,-0.5,39.5);
1337 
1338  h_probeL1Ladder_ = ProbeFeatures.make<TH1F>("h_probeL1Ladder","Ladder number (L1 hit); ladder number",22,-1.5,20.5);
1339  h_probeL1Module_ = ProbeFeatures.make<TH1F>("h_probeL1Module","Module number (L1 hit); module number",10,-1.5,8.5);
1340  h_probeHasBPixL1Overlap_ = ProbeFeatures.make<TH1I>("h_probeHasBPixL1Overlap","n. hits in L1;n. L1-BPix hits;tracks",5,0,5);
1341 
1342  // refit vertex features
1343  TFileDirectory RefitVertexFeatures = fs->mkdir("RefitVertexFeatures");
1344  h_fitVtxNtracks_ = RefitVertexFeatures.make<TH1F>("h_fitVtxNtracks" ,"N_{trks} used in vertex fit;N^{fit}_{tracks};vertices" ,100,-0.5,99.5);
1345  h_fitVtxNdof_ = RefitVertexFeatures.make<TH1F>("h_fitVtxNdof" ,"N_{DOF} of vertex fit;N_{DOF} of refit vertex;vertices" ,100,-0.5,99.5);
1346  h_fitVtxChi2_ = RefitVertexFeatures.make<TH1F>("h_fitVtxChi2" ,"#chi^{2} of vertex fit;vertex #chi^{2};vertices" ,100,-0.5,99.5);
1347  h_fitVtxChi2ndf_ = RefitVertexFeatures.make<TH1F>("h_fitVtxChi2ndf" ,"#chi^{2}/ndf of vertex fit;vertex #chi^{2}/ndf;vertices" ,100,-0.5,9.5);
1348  h_fitVtxChi2Prob_ = RefitVertexFeatures.make<TH1F>("h_fitVtxChi2Prob" ,"Prob(#chi^{2},ndf) of vertex fit;Prob(#chi^{2},ndf);vertices",40,0.,1.);
1349  h_fitVtxTrackWeights_ = RefitVertexFeatures.make<TH1F>("h_fitVtxTrackWeights","track weights associated to track;track weights;tracks",40,0.,1.);
1350  h_fitVtxTrackAverageWeight_ = RefitVertexFeatures.make<TH1F>("h_fitVtxTrackAverageWeight_","average track weight per vertex;#LT track weight #GT;vertices",40,0.,1.);
1351 
1352  if(useTracksFromRecoVtx_) {
1353 
1354  TFileDirectory RecoVertexFeatures = fs->mkdir("RecoVertexFeatures");
1355  h_recoVtxNtracks_ = RecoVertexFeatures.make<TH1F>("h_recoVtxNtracks" ,"N^{vtx}_{trks};N^{vtx}_{trks};vertices" ,100,-0.5,99.5);
1356  h_recoVtxChi2ndf_ = RecoVertexFeatures.make<TH1F>("h_recoVtxChi2ndf" ,"#chi^{2}/ndf vtx;#chi^{2}/ndf vtx;vertices" ,10,-0.5,9.5);
1357  h_recoVtxChi2Prob_ = RecoVertexFeatures.make<TH1F>("h_recoVtxChi2Prob" ,"Prob(#chi^{2},ndf);Prob(#chi^{2},ndf);vertices",40,0.,1.);
1358  h_recoVtxSumPt_ = RecoVertexFeatures.make<TH1F>("h_recoVtxSumPt" ,"Sum(p^{trks}_{T});Sum(p^{trks}_{T});vertices" ,100,0.,200.);
1359 
1360  }
1361 
1362 
1363  TFileDirectory DA = fs->mkdir("DA");
1364  //DA.cd();
1365  hDA=bookVertexHistograms(DA);
1366  //for(std::map<std::string,TH1*>::const_iterator hist=hDA.begin(); hist!=hDA.end(); hist++){
1367  //hist->second->SetDirectory(DA);
1368  // DA.make<TH1F>(hist->second);
1369  // }
1370 
1371  // initialize the residuals histograms
1372 
1373  const float dxymax_phi = theDetails_.getHigh(PVValHelper::dxy,PVValHelper::phi);
1374  const float dzmax_phi = theDetails_.getHigh(PVValHelper::dz ,PVValHelper::eta);
1375  const float dxymax_eta = theDetails_.getHigh(PVValHelper::dxy,PVValHelper::phi);
1376  const float dzmax_eta = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
1377  //const float d3Dmax_phi = theDetails_.getHigh(PVValHelper::d3D,PVValHelper::phi);
1378  const float d3Dmax_eta = theDetails_.getHigh(PVValHelper::d3D,PVValHelper::eta);
1379 
1381  //
1382  // Unbiased track-to-vertex residuals
1383  // The vertex is refit without the probe track
1384  //
1386 
1387  // _ _ _ _ ___ _ _ _
1388  // /_\ | |__ ___ ___| |_ _| |_ ___ | _ \___ __(_)__| |_ _ __ _| |___
1389  // / _ \| '_ (_-</ _ \ | || | _/ -_) | / -_|_-< / _` | || / _` | (_-<
1390  // /_/ \_\_.__/__/\___/_|\_,_|\__\___| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1391  //
1392 
1393  TFileDirectory AbsTransPhiRes = fs->mkdir("Abs_Transv_Phi_Residuals");
1394  a_dxyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes,nBins_,PVValHelper::dxy,PVValHelper::phi);
1395  a_dxPhiResiduals = bookResidualsHistogram(AbsTransPhiRes,nBins_,PVValHelper::dx,PVValHelper::phi);
1396  a_dyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes,nBins_,PVValHelper::dy,PVValHelper::phi);
1397  a_IP2DPhiResiduals = bookResidualsHistogram(AbsTransPhiRes,nBins_,PVValHelper::IP2D,PVValHelper::phi);
1398 
1399  TFileDirectory AbsTransEtaRes = fs->mkdir("Abs_Transv_Eta_Residuals");
1400  a_dxyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes,nBins_,PVValHelper::dxy,PVValHelper::eta);
1401  a_dxEtaResiduals = bookResidualsHistogram(AbsTransEtaRes,nBins_,PVValHelper::dx,PVValHelper::eta);
1402  a_dyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes,nBins_,PVValHelper::dy,PVValHelper::eta);
1403  a_IP2DEtaResiduals = bookResidualsHistogram(AbsTransEtaRes,nBins_,PVValHelper::IP2D,PVValHelper::eta);
1404 
1405  TFileDirectory AbsLongPhiRes = fs->mkdir("Abs_Long_Phi_Residuals");
1406  a_dzPhiResiduals = bookResidualsHistogram(AbsLongPhiRes,nBins_,PVValHelper::dz,PVValHelper::phi);
1407  a_reszPhiResiduals = bookResidualsHistogram(AbsLongPhiRes,nBins_,PVValHelper::resz,PVValHelper::phi);
1408 
1409  TFileDirectory AbsLongEtaRes = fs->mkdir("Abs_Long_Eta_Residuals");
1410  a_dzEtaResiduals = bookResidualsHistogram(AbsLongEtaRes,nBins_,PVValHelper::dz,PVValHelper::eta);
1411  a_reszEtaResiduals = bookResidualsHistogram(AbsLongEtaRes,nBins_,PVValHelper::resz,PVValHelper::eta);
1412 
1413  TFileDirectory Abs3DPhiRes = fs->mkdir("Abs_3D_Phi_Residuals");
1414  a_d3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes,nBins_,PVValHelper::d3D,PVValHelper::phi);
1415  a_IP3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes,nBins_,PVValHelper::IP3D,PVValHelper::phi);
1416 
1417  TFileDirectory Abs3DEtaRes = fs->mkdir("Abs_3D_Eta_Residuals");
1418  a_d3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes ,nBins_,PVValHelper::d3D,PVValHelper::eta);
1419  a_IP3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes ,nBins_,PVValHelper::IP3D,PVValHelper::eta);
1420 
1421  TFileDirectory NormTransPhiRes = fs->mkdir("Norm_Transv_Phi_Residuals");
1422  n_dxyPhiResiduals = bookResidualsHistogram(NormTransPhiRes,nBins_,PVValHelper::norm_dxy,PVValHelper::phi,true);
1423  n_IP2DPhiResiduals = bookResidualsHistogram(NormTransPhiRes,nBins_,PVValHelper::norm_IP2D,PVValHelper::phi,true);
1424 
1425  TFileDirectory NormTransEtaRes = fs->mkdir("Norm_Transv_Eta_Residuals");
1426  n_dxyEtaResiduals = bookResidualsHistogram(NormTransEtaRes,nBins_,PVValHelper::norm_dxy,PVValHelper::eta,true);
1427  n_IP2DEtaResiduals = bookResidualsHistogram(NormTransEtaRes,nBins_,PVValHelper::norm_IP2D,PVValHelper::eta,true);
1428 
1429  TFileDirectory NormLongPhiRes = fs->mkdir("Norm_Long_Phi_Residuals");
1430  n_dzPhiResiduals = bookResidualsHistogram(NormLongPhiRes,nBins_,PVValHelper::norm_dz,PVValHelper::phi,true);
1431  n_reszPhiResiduals = bookResidualsHistogram(NormLongPhiRes,nBins_,PVValHelper::norm_resz,PVValHelper::phi,true);
1432 
1433  TFileDirectory NormLongEtaRes = fs->mkdir("Norm_Long_Eta_Residuals");
1434  n_dzEtaResiduals = bookResidualsHistogram(NormLongEtaRes,nBins_,PVValHelper::norm_dz,PVValHelper::eta,true);
1435  n_reszEtaResiduals = bookResidualsHistogram(NormLongEtaRes,nBins_,PVValHelper::norm_resz,PVValHelper::eta,true);
1436 
1437  TFileDirectory Norm3DPhiRes = fs->mkdir("Norm_3D_Phi_Residuals");
1438  n_d3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes,nBins_,PVValHelper::norm_d3D,PVValHelper::phi,true);
1439  n_IP3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes,nBins_,PVValHelper::norm_IP3D,PVValHelper::phi,true);
1440 
1441  TFileDirectory Norm3DEtaRes = fs->mkdir("Norm_3D_Eta_Residuals");
1442  n_d3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes,nBins_,PVValHelper::norm_d3D,PVValHelper::eta,true);
1443  n_IP3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes,nBins_,PVValHelper::norm_IP3D,PVValHelper::eta,true);
1444 
1445  TFileDirectory AbsDoubleDiffRes = fs->mkdir("Abs_DoubleDiffResiduals");
1446  TFileDirectory NormDoubleDiffRes = fs->mkdir("Norm_DoubleDiffResiduals");
1447 
1448  // book residuals vs pT histograms
1449 
1450  TFileDirectory AbsTranspTRes = fs->mkdir("Abs_Transv_pT_Residuals");
1451  h_dxy_pT_ = bookResidualsHistogram(AbsTranspTRes,nPtBins_,PVValHelper::dxy,PVValHelper::pT);
1452 
1453  TFileDirectory AbsLongpTRes = fs->mkdir("Abs_Long_pT_Residuals");
1454  h_dz_pT_ = bookResidualsHistogram(AbsLongpTRes,nPtBins_,PVValHelper::dz,PVValHelper::pT);
1455 
1456  TFileDirectory NormTranspTRes = fs->mkdir("Norm_Transv_pT_Residuals");
1457  h_norm_dxy_pT_ = bookResidualsHistogram(NormTranspTRes,nPtBins_,PVValHelper::norm_dxy,PVValHelper::pT,true);
1458 
1459  TFileDirectory NormLongpTRes = fs->mkdir("Norm_Long_pT_Residuals");
1460  h_norm_dz_pT_ = bookResidualsHistogram(NormLongpTRes,nPtBins_,PVValHelper::norm_dz,PVValHelper::pT,true);
1461 
1462  // book residuals vs pT histograms in central region (|eta|<1.0)
1463 
1464  TFileDirectory AbsTranspTCentralRes = fs->mkdir("Abs_Transv_pTCentral_Residuals");
1465  h_dxy_Central_pT_ = bookResidualsHistogram(AbsTranspTCentralRes,nPtBins_,PVValHelper::dxy,PVValHelper::pTCentral);
1466 
1467  TFileDirectory AbsLongpTCentralRes = fs->mkdir("Abs_Long_pTCentral_Residuals");
1468  h_dz_Central_pT_ = bookResidualsHistogram(AbsLongpTCentralRes,nPtBins_,PVValHelper::dz,PVValHelper::pTCentral);
1469 
1470  TFileDirectory NormTranspTCentralRes = fs->mkdir("Norm_Transv_pTCentral_Residuals");
1471  h_norm_dxy_Central_pT_ = bookResidualsHistogram(NormTranspTCentralRes,nPtBins_,PVValHelper::norm_dxy,PVValHelper::pTCentral,true);
1472 
1473  TFileDirectory NormLongpTCentralRes = fs->mkdir("Norm_Long_pTCentral_Residuals");
1474  h_norm_dz_Central_pT_ = bookResidualsHistogram(NormLongpTCentralRes,nPtBins_,PVValHelper::norm_dz,PVValHelper::pTCentral,true);
1475 
1476  // book residuals vs module number
1477 
1478  TFileDirectory AbsTransModZRes = fs->mkdir("Abs_Transv_modZ_Residuals");
1479  h_dxy_modZ_ = bookResidualsHistogram(AbsTransModZRes,8,PVValHelper::dxy,PVValHelper::modZ);
1480 
1481  TFileDirectory AbsLongModZRes = fs->mkdir("Abs_Long_modZ_Residuals");
1482  h_dz_modZ_ = bookResidualsHistogram(AbsLongModZRes,8,PVValHelper::dz,PVValHelper::modZ);
1483 
1484 
1485  // _ _ _ _ _ ___ _ _ _
1486  // | \| |___ _ _ _ __ __ _| (_)______ __| | | _ \___ __(_)__| |_ _ __ _| |___
1487  // | .` / _ \ '_| ' \/ _` | | |_ / -_) _` | | / -_|_-< / _` | || / _` | (_-<
1488  // |_|\_\___/_| |_|_|_\__,_|_|_/__\___\__,_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1489  //
1490 
1491  TFileDirectory NormTransModZRes = fs->mkdir("Norm_Transv_modZ_Residuals");
1492  h_norm_dxy_modZ_ = bookResidualsHistogram(NormTransModZRes,8,PVValHelper::norm_dxy,PVValHelper::modZ,true);
1493 
1494  TFileDirectory NormLongModZRes = fs->mkdir("Norm_Long_modZ_Residuals");
1495  h_norm_dz_modZ_ = bookResidualsHistogram(NormLongModZRes,8,PVValHelper::norm_dz,PVValHelper::modZ,true);
1496 
1497  TFileDirectory AbsTransLadderRes = fs->mkdir("Abs_Transv_ladder_Residuals");
1498  h_dxy_ladder_ = bookResidualsHistogram(AbsTransLadderRes,nLadders_,PVValHelper::dxy,PVValHelper::ladder);
1499 
1500  TFileDirectory AbsTransLadderResOverlap = fs->mkdir("Abs_Transv_ladderOverlap_Residuals");
1501  h_dxy_ladderOverlap_ = bookResidualsHistogram(AbsTransLadderResOverlap,nLadders_,PVValHelper::dxy,PVValHelper::ladder);
1502 
1503  TFileDirectory AbsTransLadderResNoOverlap = fs->mkdir("Abs_Transv_ladderNoOverlap_Residuals");
1504  h_dxy_ladderNoOverlap_ = bookResidualsHistogram(AbsTransLadderResNoOverlap,nLadders_,PVValHelper::dxy,PVValHelper::ladder);
1505 
1506  TFileDirectory AbsLongLadderRes = fs->mkdir("Abs_Long_ladder_Residuals");
1507  h_dz_ladder_ = bookResidualsHistogram(AbsLongLadderRes,nLadders_,PVValHelper::dz,PVValHelper::ladder);
1508 
1509  TFileDirectory NormTransLadderRes = fs->mkdir("Norm_Transv_ladder_Residuals");
1510  h_norm_dxy_ladder_ = bookResidualsHistogram(NormTransLadderRes,nLadders_,PVValHelper::norm_dxy,PVValHelper::ladder,true);
1511 
1512  TFileDirectory NormLongLadderRes = fs->mkdir("Norm_Long_ladder_Residuals");
1513  h_norm_dz_ladder_ = bookResidualsHistogram(NormLongLadderRes,nLadders_,PVValHelper::norm_dz,PVValHelper::ladder,true);
1514 
1515 
1516  // book residuals as function of phi and eta
1517 
1518  for (int i=0; i<nBins_; ++i ) {
1519 
1520  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1521  float phiL = theDetails_.trendbins[PVValHelper::phi][i+1];
1522 
1523  // ___ _ _ ___ _ __ __ ___ _ _ _
1524  // | \ ___ _ _| |__| |___| \(_)/ _|/ _| | _ \___ __(_)__| |_ _ __ _| |___
1525  // | |) / _ \ || | '_ \ / -_) |) | | _| _| | / -_|_-< / _` | || / _` | (_-<
1526  // |___/\___/\_,_|_.__/_\___|___/|_|_| |_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1527 
1528  for ( int j=0; j<nBins_; ++j ) {
1529 
1530  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
1531  float etaL = theDetails_.trendbins[PVValHelper::eta][j+1];
1532 
1533  a_dxyResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(Form("histo_dxy_eta_plot%i_phi_plot%i",i,j),
1534  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy};tracks",etaF,etaL,phiF,phiL),
1535  theDetails_.histobins,-dzmax_eta,dzmax_eta);
1536 
1537  a_dzResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(Form("histo_dz_eta_plot%i_phi_plot%i",i,j),
1538  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z};tracks",etaF,etaL,phiF,phiL),
1539  theDetails_.histobins,-dzmax_eta,dzmax_eta);
1540 
1541  a_d3DResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(Form("histo_d3D_eta_plot%i_phi_plot%i",i,j),
1542  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D};tracks",etaF,etaL,phiF,phiL),
1543  theDetails_.histobins,0.,d3Dmax_eta);
1544 
1545  n_dxyResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(Form("histo_norm_dxy_eta_plot%i_phi_plot%i",i,j),
1546  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",etaF,etaL,phiF,phiL),
1547  theDetails_.histobins,-dzmax_eta/100,dzmax_eta/100);
1548 
1549  n_dzResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(Form("histo_norm_dz_eta_plot%i_phi_plot%i",i,j),
1550  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",etaF,etaL,phiF,phiL),
1551  theDetails_.histobins,-dzmax_eta/100,dzmax_eta/100);
1552 
1553  n_d3DResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(Form("histo_norm_d3D_eta_plot%i_phi_plot%i",i,j),
1554  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D}/#sigma_{d_{3D}};tracks",etaF,etaL,phiF,phiL),
1555  theDetails_.histobins,0.,d3Dmax_eta);
1556 
1557  }
1558  }
1559 
1560  // declaration of the directories
1561 
1562  TFileDirectory BiasVsParameter = fs->mkdir("BiasVsParameter");
1563 
1564  a_dxyVsPhi = BiasVsParameter.make<TH2F>("h2_dxy_vs_phi","d_{xy} vs track #phi;track #phi [rad];track d_{xy}(PV) [#mum]",
1565  nBins_,-M_PI,M_PI,theDetails_.histobins,-dxymax_phi,dxymax_phi);
1566 
1567  a_dzVsPhi = BiasVsParameter.make<TH2F>("h2_dz_vs_phi","d_{z} vs track #phi;track #phi [rad];track d_{z}(PV) [#mum]",
1568  nBins_,-M_PI,M_PI,theDetails_.histobins,-dzmax_phi,dzmax_phi);
1569 
1570  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}}",
1571  nBins_,-M_PI,M_PI,theDetails_.histobins,-dxymax_phi/100.,dxymax_phi/100.);
1572 
1573  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}}",
1574  nBins_,-M_PI,M_PI,theDetails_.histobins,-dzmax_phi/100.,dzmax_phi/100.);
1575 
1576  a_dxyVsEta = BiasVsParameter.make<TH2F>("h2_dxy_vs_eta","d_{xy} vs track #eta;track #eta;track d_{xy}(PV) [#mum]",
1577  nBins_,-etaOfProbe_,etaOfProbe_,theDetails_.histobins,-dxymax_eta,dzmax_eta);
1578 
1579  a_dzVsEta = BiasVsParameter.make<TH2F>("h2_dz_vs_eta","d_{z} vs track #eta;track #eta;track d_{z}(PV) [#mum]",
1580  nBins_,-etaOfProbe_,etaOfProbe_,theDetails_.histobins,-dzmax_eta,dzmax_eta);
1581 
1582  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}}",
1583  nBins_,-etaOfProbe_,etaOfProbe_,theDetails_.histobins,-dxymax_eta/100.,dxymax_eta/100.);
1584 
1585  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}}",
1586  nBins_,-etaOfProbe_,etaOfProbe_,theDetails_.histobins,-dzmax_eta/100.,dzmax_eta/100.);
1587 
1588  MeanTrendsDir = fs->mkdir("MeanTrends");
1589  WidthTrendsDir = fs->mkdir("WidthTrends");
1590  MedianTrendsDir = fs->mkdir("MedianTrends");
1591  MADTrendsDir = fs->mkdir("MADTrends");
1592 
1593  Mean2DMapsDir = fs->mkdir("MeanMaps");
1594  Width2DMapsDir = fs->mkdir("WidthMaps");
1595 
1596  double highedge=nBins_-0.5;
1597  double lowedge=-0.5;
1598 
1599  // means and widths from the fit
1600 
1601  a_dxyPhiMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_phi",
1602  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
1603  nBins_,lowedge,highedge);
1604 
1605  a_dxyPhiWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_phi",
1606  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
1607  nBins_,lowedge,highedge);
1608 
1609  a_dzPhiMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_phi",
1610  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
1611  nBins_,lowedge,highedge);
1612 
1613  a_dzPhiWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_phi","#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
1614  nBins_,lowedge,highedge);
1615 
1616  a_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_eta",
1617  "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]",
1618  nBins_,lowedge,highedge);
1619 
1620  a_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_eta",
1621  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
1622  nBins_,lowedge,highedge);
1623 
1624  a_dzEtaMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_eta",
1625  "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]"
1626  ,nBins_,lowedge,highedge);
1627 
1628  a_dzEtaWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_eta",
1629  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]",
1630  nBins_,lowedge,highedge);
1631 
1632  n_dxyPhiMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_phi",
1633  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1634  nBins_,lowedge,highedge);
1635 
1636  n_dxyPhiWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_phi",
1637  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
1638  nBins_,lowedge,highedge);
1639 
1640  n_dzPhiMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_phi",
1641  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
1642  nBins_,lowedge,highedge);
1643 
1644  n_dzPhiWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_phi",
1645  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
1646  nBins_,lowedge,highedge);
1647 
1648  n_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_eta",
1649  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
1650  nBins_,lowedge,highedge);
1651 
1652  n_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_eta",
1653  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
1654  nBins_,lowedge,highedge);
1655 
1656  n_dzEtaMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_eta",
1657  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
1658  nBins_,lowedge,highedge);
1659 
1660  n_dzEtaWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_eta",
1661  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
1662  nBins_,lowedge,highedge);
1663 
1664  // means and widhts vs pT and pTCentral
1665 
1666  a_dxypTMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_pT",
1667  "#LT d_{xy} #GT vs pT;p_{T} [GeV];#LT d_{xy} #GT [#mum]",
1668  mypT_bins_.size()-1,mypT_bins_.data());
1669 
1670  a_dxypTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_pT",
1671  "#sigma_{d_{xy}} vs pT;p_{T} [GeV];#sigma_{d_{xy}} [#mum]",
1672  mypT_bins_.size()-1,mypT_bins_.data());
1673 
1674  a_dzpTMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_pT",
1675  "#LT d_{z} #GT vs pT;p_{T} [GeV];#LT d_{z} #GT [#mum]",
1676  mypT_bins_.size()-1,mypT_bins_.data());
1677 
1678  a_dzpTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_pT","#sigma_{d_{z}} vs pT;p_{T} [GeV];#sigma_{d_{z}} [#mum]",
1679  mypT_bins_.size()-1,mypT_bins_.data());
1680 
1681 
1682  n_dxypTMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_pT",
1683  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs pT;p_{T} [GeV];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1684  mypT_bins_.size()-1,mypT_bins_.data());
1685 
1686  n_dxypTWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_pT",
1687  "width(d_{xy}/#sigma_{d_{xy}}) vs pT;p_{T} [GeV]; width(d_{xy}/#sigma_{d_{xy}})",
1688  mypT_bins_.size()-1,mypT_bins_.data());
1689 
1690  n_dzpTMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_pT",
1691  "#LT d_{z}/#sigma_{d_{z}} #GT vs pT;p_{T} [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
1692  mypT_bins_.size()-1,mypT_bins_.data());
1693 
1694  n_dzpTWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_pT",
1695  "width(d_{z}/#sigma_{d_{z}}) vs pT;p_{T} [GeV];width(d_{z}/#sigma_{d_{z}})",
1696  mypT_bins_.size()-1,mypT_bins_.data());
1697 
1698 
1699  a_dxypTCentralMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_pTCentral",
1700  "#LT d_{xy} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy} #GT [#mum]",
1701  mypT_bins_.size()-1,mypT_bins_.data());
1702 
1703  a_dxypTCentralWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_pTCentral",
1704  "#sigma_{d_{xy}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{xy}} [#mum]",
1705  mypT_bins_.size()-1,mypT_bins_.data());
1706 
1707  a_dzpTCentralMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_pTCentral",
1708  "#LT d_{z} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z} #GT [#mum]"
1709  ,mypT_bins_.size()-1,mypT_bins_.data());
1710 
1711  a_dzpTCentralWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_pTCentral",
1712  "#sigma_{d_{z}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{z}} [#mum]",
1713  mypT_bins_.size()-1,mypT_bins_.data());
1714 
1715  n_dxypTCentralMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_pTCentral",
1716  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy}/#sigma_{d_{z}} #GT",
1717  mypT_bins_.size()-1,mypT_bins_.data());
1718 
1719  n_dxypTCentralWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_pTCentral",
1720  "width(d_{xy}/#sigma_{d_{xy}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{xy}/#sigma_{d_{z}})",
1721  mypT_bins_.size()-1,mypT_bins_.data());
1722 
1723  n_dzpTCentralMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_pTCentral",
1724  "#LT d_{z}/#sigma_{d_{z}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
1725  mypT_bins_.size()-1,mypT_bins_.data());
1726 
1727  n_dzpTCentralWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_pTCentral",
1728  "width(d_{z}/#sigma_{d_{z}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{z}/#sigma_{d_{z}})",
1729  mypT_bins_.size()-1,mypT_bins_.data());
1730 
1731  // 2D maps
1732 
1733  a_dxyMeanMap = Mean2DMapsDir.make<TH2F> ("means_dxy_map",
1734  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
1735  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1736 
1737  a_dzMeanMap = Mean2DMapsDir.make<TH2F> ("means_dz_map",
1738  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
1739  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1740 
1741  n_dxyMeanMap = Mean2DMapsDir.make<TH2F> ("norm_means_dxy_map",
1742  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
1743  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1744 
1745  n_dzMeanMap = Mean2DMapsDir.make<TH2F> ("norm_means_dz_map",
1746  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
1747  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1748 
1749  a_dxyWidthMap = Width2DMapsDir.make<TH2F> ("widths_dxy_map",
1750  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
1751  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1752 
1753  a_dzWidthMap = Width2DMapsDir.make<TH2F> ("widths_dz_map",
1754  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
1755  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1756 
1757  n_dxyWidthMap = Width2DMapsDir.make<TH2F> ("norm_widths_dxy_map",
1758  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
1759  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1760 
1761  n_dzWidthMap = Width2DMapsDir.make<TH2F> ("norm_widths_dz_map",
1762  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
1763  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1764 
1765  // medians and MADs
1766 
1767  a_dxyPhiMedianTrend = MedianTrendsDir.make<TH1F>("medians_dxy_phi",
1768  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
1769  nBins_,lowedge,highedge);
1770 
1771  a_dxyPhiMADTrend = MADTrendsDir.make<TH1F> ("MADs_dxy_phi",
1772  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
1773  nBins_,lowedge,highedge);
1774 
1775  a_dzPhiMedianTrend = MedianTrendsDir.make<TH1F>("medians_dz_phi",
1776  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
1777  nBins_,lowedge,highedge);
1778 
1779  a_dzPhiMADTrend = MADTrendsDir.make<TH1F> ("MADs_dz_phi",
1780  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
1781  nBins_,lowedge,highedge);
1782 
1783  a_dxyEtaMedianTrend = MedianTrendsDir.make<TH1F>("medians_dxy_eta",
1784  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
1785  nBins_,lowedge,highedge);
1786 
1787  a_dxyEtaMADTrend = MADTrendsDir.make<TH1F> ("MADs_dxy_eta",
1788  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
1789  nBins_,lowedge,highedge);
1790 
1791  a_dzEtaMedianTrend = MedianTrendsDir.make<TH1F>("medians_dz_eta",
1792  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
1793  nBins_,lowedge,highedge);
1794 
1795  a_dzEtaMADTrend = MADTrendsDir.make<TH1F> ("MADs_dz_eta",
1796  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
1797  nBins_,lowedge,highedge);
1798 
1799  n_dxyPhiMedianTrend = MedianTrendsDir.make<TH1F>("norm_medians_dxy_phi",
1800  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
1801  nBins_,lowedge,highedge);
1802 
1803  n_dxyPhiMADTrend = MADTrendsDir.make<TH1F> ("norm_MADs_dxy_phi",
1804  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
1805  nBins_,lowedge,highedge);
1806 
1807  n_dzPhiMedianTrend = MedianTrendsDir.make<TH1F>("norm_medians_dz_phi",
1808  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
1809  nBins_,lowedge,highedge);
1810 
1811  n_dzPhiMADTrend = MADTrendsDir.make<TH1F> ("norm_MADs_dz_phi",
1812  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
1813  nBins_,lowedge,highedge);
1814 
1815  n_dxyEtaMedianTrend = MedianTrendsDir.make<TH1F>("norm_medians_dxy_eta",
1816  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
1817  nBins_,lowedge,highedge);
1818 
1819  n_dxyEtaMADTrend = MADTrendsDir.make<TH1F> ("norm_MADs_dxy_eta",
1820  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
1821  nBins_,lowedge,highedge);
1822 
1823  n_dzEtaMedianTrend = MedianTrendsDir.make<TH1F>("norm_medians_dz_eta",
1824  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
1825  nBins_,lowedge,highedge);
1826 
1827  n_dzEtaMADTrend = MADTrendsDir.make<TH1F> ("norm_MADs_dz_eta",
1828  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
1829  nBins_,lowedge,highedge);
1830 
1831 
1833  //
1834  // plots of biased residuals
1835  // The vertex includes the probe track
1836  //
1838 
1839  if (useTracksFromRecoVtx_){
1840 
1841  TFileDirectory AbsTransPhiBiasRes = fs->mkdir("Abs_Transv_Phi_BiasResiduals");
1842  a_dxyPhiBiasResiduals = bookResidualsHistogram(AbsTransPhiBiasRes,nBins_,PVValHelper::dxy,PVValHelper::phi);
1843 
1844  TFileDirectory AbsTransEtaBiasRes = fs->mkdir("Abs_Transv_Eta_BiasResiduals");
1845  a_dxyEtaBiasResiduals = bookResidualsHistogram(AbsTransEtaBiasRes,nBins_,PVValHelper::dxy,PVValHelper::eta);
1846 
1847  TFileDirectory AbsLongPhiBiasRes = fs->mkdir("Abs_Long_Phi_BiasResiduals");
1848  a_dzPhiBiasResiduals = bookResidualsHistogram(AbsLongPhiBiasRes,nBins_,PVValHelper::dz,PVValHelper::phi);
1849 
1850  TFileDirectory AbsLongEtaBiasRes = fs->mkdir("Abs_Long_Eta_BiasResiduals");
1851  a_dzEtaBiasResiduals = bookResidualsHistogram(AbsLongEtaBiasRes,nBins_,PVValHelper::dz,PVValHelper::eta);
1852 
1853  TFileDirectory NormTransPhiBiasRes = fs->mkdir("Norm_Transv_Phi_BiasResiduals");
1854  n_dxyPhiBiasResiduals = bookResidualsHistogram(NormTransPhiBiasRes,nBins_,PVValHelper::dxy,PVValHelper::phi);
1855 
1856  TFileDirectory NormTransEtaBiasRes = fs->mkdir("Norm_Transv_Eta_BiasResiduals");
1857  n_dxyEtaBiasResiduals = bookResidualsHistogram(NormTransEtaBiasRes,nBins_,PVValHelper::dxy,PVValHelper::eta);
1858 
1859  TFileDirectory NormLongPhiBiasRes = fs->mkdir("Norm_Long_Phi_BiasResiduals");
1860  n_dzPhiBiasResiduals = bookResidualsHistogram(NormLongPhiBiasRes,nBins_,PVValHelper::dz,PVValHelper::phi);
1861 
1862  TFileDirectory NormLongEtaBiasRes = fs->mkdir("Norm_Long_Eta_BiasResiduals");
1863  n_dzEtaBiasResiduals = bookResidualsHistogram(NormLongEtaBiasRes,nBins_,PVValHelper::dz,PVValHelper::eta);
1864 
1865  TFileDirectory AbsDoubleDiffBiasRes = fs->mkdir("Abs_DoubleDiffBiasResiduals");
1866  TFileDirectory NormDoubleDiffBiasRes = fs->mkdir("Norm_DoubleDiffBiasResiduals");
1867 
1868  for ( int i=0; i<nBins_; ++i ) {
1869 
1870  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1871  float phiL = theDetails_.trendbins[PVValHelper::phi][i+1];
1872 
1873  for ( int j=0; j<nBins_; ++j ) {
1874 
1875  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
1876  float etaL = theDetails_.trendbins[PVValHelper::eta][j+1];
1877 
1878  a_dxyBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(Form("histo_dxy_eta_plot%i_phi_plot%i",i,j),
1879  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy} [#mum];tracks",etaF,etaL,phiF,phiL),
1880  theDetails_.histobins,-dzmax_eta,dzmax_eta);
1881 
1882  a_dzBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(Form("histo_dxy_eta_plot%i_phi_plot%i",i,j),
1883  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z} [#mum];tracks",etaF,etaL,phiF,phiL),
1884  theDetails_.histobins,-dzmax_eta,dzmax_eta);
1885 
1886  n_dxyBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(Form("histo_norm_dxy_eta_plot%i_phi_plot%i",i,j),
1887  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",etaF,etaL,phiF,phiL),
1888  theDetails_.histobins,-dzmax_eta/100,dzmax_eta/100);
1889 
1890  n_dzBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(Form("histo_norm_dxy_eta_plot%i_phi_plot%i",i,j),
1891  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",etaF,etaL,phiF,phiL),
1892  theDetails_.histobins,-dzmax_eta/100,dzmax_eta/100);
1893  }
1894  }
1895 
1896  // declaration of the directories
1897 
1898  TFileDirectory MeanBiasTrendsDir = fs->mkdir("MeanBiasTrends");
1899  TFileDirectory WidthBiasTrendsDir = fs->mkdir("WidthBiasTrends");
1900  TFileDirectory MedianBiasTrendsDir = fs->mkdir("MedianBiasTrends");
1901  TFileDirectory MADBiasTrendsDir = fs->mkdir("MADBiasTrends");
1902 
1903  TFileDirectory Mean2DBiasMapsDir = fs->mkdir("MeanBiasMaps");
1904  TFileDirectory Width2DBiasMapsDir = fs->mkdir("WidthBiasMaps");
1905 
1906  // means and widths from the fit
1907 
1908  a_dxyPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("means_dxy_phi",
1909  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
1910  nBins_,lowedge,highedge);
1911 
1912  a_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("widths_dxy_phi",
1913  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
1914  nBins_,lowedge,highedge);
1915 
1916  a_dzPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("means_dz_phi",
1917  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
1918  nBins_,lowedge,highedge);
1919 
1920  a_dzPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("widths_dz_phi",
1921  "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
1922  nBins_,lowedge,highedge);
1923 
1924  a_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("means_dxy_eta",
1925  "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]",
1926  nBins_,lowedge,highedge);
1927 
1928  a_dxyEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("widths_dxy_eta",
1929  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
1930  nBins_,lowedge,highedge);
1931 
1932  a_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("means_dz_eta",
1933  "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]",
1934  nBins_,lowedge,highedge);
1935 
1936  a_dzEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("widths_dz_eta",
1937  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]",
1938  nBins_,lowedge,highedge);
1939 
1940  n_dxyPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("norm_means_dxy_phi",
1941  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1942  nBins_,lowedge,highedge);
1943 
1944  n_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("norm_widths_dxy_phi",
1945  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
1946  nBins_,lowedge,highedge);
1947 
1948  n_dzPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("norm_means_dz_phi",
1949  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
1950  nBins_,lowedge,highedge);
1951 
1952  n_dzPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("norm_widths_dz_phi",
1953  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
1954  nBins_,lowedge,highedge);
1955 
1956  n_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("norm_means_dxy_eta",
1957  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
1958  nBins_,lowedge,highedge);
1959 
1960  n_dxyEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("norm_widths_dxy_eta",
1961  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
1962  nBins_,lowedge,highedge);
1963 
1964  n_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F> ("norm_means_dz_eta",
1965  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
1966  nBins_,lowedge,highedge);
1967 
1968  n_dzEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>("norm_widths_dz_eta",
1969  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
1970  nBins_,lowedge,highedge);
1971 
1972  // 2D maps
1973 
1974  a_dxyMeanBiasMap = Mean2DBiasMapsDir.make<TH2F> ("means_dxy_map",
1975  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
1976  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1977 
1978  a_dzMeanBiasMap = Mean2DBiasMapsDir.make<TH2F> ("means_dz_map",
1979  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
1980  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1981 
1982  n_dxyMeanBiasMap = Mean2DBiasMapsDir.make<TH2F> ("norm_means_dxy_map",
1983  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
1984  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1985 
1986  n_dzMeanBiasMap = Mean2DBiasMapsDir.make<TH2F> ("norm_means_dz_map",
1987  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
1988  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1989 
1990  a_dxyWidthBiasMap = Width2DBiasMapsDir.make<TH2F> ("widths_dxy_map",
1991  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
1992  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1993 
1994  a_dzWidthBiasMap = Width2DBiasMapsDir.make<TH2F> ("widths_dz_map",
1995  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
1996  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
1997 
1998  n_dxyWidthBiasMap = Width2DBiasMapsDir.make<TH2F> ("norm_widths_dxy_map",
1999  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
2000  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
2001 
2002  n_dzWidthBiasMap = Width2DBiasMapsDir.make<TH2F> ("norm_widths_dz_map",
2003  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
2004  nBins_,lowedge,highedge,nBins_,lowedge,highedge);
2005 
2006  // medians and MADs
2007 
2008  a_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("medians_dxy_phi",
2009  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
2010  nBins_,lowedge,highedge);
2011 
2012  a_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("MADs_dxy_phi",
2013  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
2014  nBins_,lowedge,highedge);
2015 
2016  a_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("medians_dz_phi",
2017  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
2018  nBins_,lowedge,highedge);
2019 
2020  a_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("MADs_dz_phi",
2021  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
2022  nBins_,lowedge,highedge);
2023 
2024  a_dxyEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("medians_dxy_eta",
2025  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
2026  nBins_,lowedge,highedge);
2027 
2028  a_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("MADs_dxy_eta",
2029  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
2030  nBins_,lowedge,highedge);
2031 
2032  a_dzEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("medians_dz_eta",
2033  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
2034  nBins_,lowedge,highedge);
2035 
2036  a_dzEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("MADs_dz_eta",
2037  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
2038  nBins_,lowedge,highedge);
2039 
2040  n_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("norm_medians_dxy_phi",
2041  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
2042  nBins_,lowedge,highedge);
2043 
2044  n_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("norm_MADs_dxy_phi",
2045  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
2046  nBins_,lowedge,highedge);
2047 
2048  n_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("norm_medians_dz_phi",
2049  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2050  nBins_,lowedge,highedge);
2051 
2052  n_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("norm_MADs_dz_phi",
2053  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
2054  nBins_,lowedge,highedge);
2055 
2056  n_dxyEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("norm_medians_dxy_eta",
2057  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
2058  nBins_,lowedge,highedge);
2059 
2060  n_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("norm_MADs_dxy_eta",
2061  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
2062  nBins_,lowedge,highedge);
2063 
2064  n_dzEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>("norm_medians_dz_eta",
2065  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2066  nBins_,lowedge,highedge);
2067 
2068  n_dzEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F> ("norm_MADs_dz_eta",
2069  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
2070  nBins_,lowedge,highedge);
2071 
2072  }
2073 }
2074 // ------------ method called once each job just after ending the event loop ------------
2075 void PrimaryVertexValidation::endJob()
2076 {
2077 
2078  edm::LogInfo("PrimaryVertexValidation")
2079  <<"######################################\n"
2080  <<"# PrimaryVertexValidation::endJob()\n"
2081  <<"# Number of analyzed events: "<<Nevt_<<"\n"
2082  <<"######################################";
2083 
2084  // means and widhts vs ladder and module number
2085 
2086  a_dxymodZMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_modZ",
2087  "#LT d_{xy} #GT vs modZ;module number (Z);#LT d_{xy} #GT [#mum]",
2088  nModZ_,0.,nModZ_);
2089 
2090  a_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_modZ",
2091  "#sigma_{d_{xy}} vs modZ;module number (Z);#sigma_{d_{xy}} [#mum]",
2092  nModZ_,0.,nModZ_);
2093 
2094  a_dzmodZMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_modZ",
2095  "#LT d_{z} #GT vs modZ;module number (Z);#LT d_{z} #GT [#mum]",
2096  nModZ_,0.,nModZ_);
2097 
2098  a_dzmodZWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_modZ",
2099  "#sigma_{d_{z}} vs modZ;module number (Z);#sigma_{d_{z}} [#mum]",
2100  nModZ_,0.,nModZ_);
2101 
2102  a_dxyladderMeanTrend = MeanTrendsDir.make<TH1F> ("means_dxy_ladder",
2103  "#LT d_{xy} #GT vs ladder;ladder number (#phi);#LT d_{xy} #GT [#mum]",
2104  nLadders_,0.,nLadders_);
2105 
2106  a_dxyladderWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_ladder",
2107  "#sigma_{d_{xy}} vs ladder;ladder number (#phi);#sigma_{d_{xy}} [#mum]",
2108  nLadders_,0.,nLadders_);
2109 
2110  a_dzladderMeanTrend = MeanTrendsDir.make<TH1F> ("means_dz_ladder",
2111  "#LT d_{z} #GT vs ladder;ladder number (#phi);#LT d_{z} #GT [#mum]"
2112  ,nLadders_,0.,nLadders_);
2113 
2114  a_dzladderWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_ladder",
2115  "#sigma_{d_{z}} vs ladder;ladder number (#phi);#sigma_{d_{z}} [#mum]",
2116  nLadders_,0.,nLadders_);
2117 
2118  n_dxymodZMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_modZ",
2119  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs modZ;module number (Z);#LT d_{xy}/#sigma_{d_{xy}} #GT",
2120  nModZ_,0.,nModZ_);
2121 
2122  n_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_modZ",
2123  "width(d_{xy}/#sigma_{d_{xy}}) vs modZ;module number (Z); width(d_{xy}/#sigma_{d_{xy}})",
2124  nModZ_,0.,nModZ_);
2125 
2126  n_dzmodZMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_modZ",
2127  "#LT d_{z}/#sigma_{d_{z}} #GT vs modZ;module number (Z);#LT d_{z}/#sigma_{d_{z}} #GT",
2128  nModZ_,0.,nModZ_);
2129 
2130  n_dzmodZWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_modZ",
2131  "width(d_{z}/#sigma_{d_{z}}) vs pT;module number (Z);width(d_{z}/#sigma_{d_{z}})",
2132  nModZ_,0.,nModZ_);
2133 
2134  n_dxyladderMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dxy_ladder",
2135  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs ladder;ladder number (#phi);#LT d_{xy}/#sigma_{d_{z}} #GT",
2136  nLadders_,0.,nLadders_);
2137 
2138  n_dxyladderWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dxy_ladder",
2139  "width(d_{xy}/#sigma_{d_{xy}}) vs ladder;ladder number (#phi);width(d_{xy}/#sigma_{d_{z}})",
2140  nLadders_,0.,nLadders_);
2141 
2142  n_dzladderMeanTrend = MeanTrendsDir.make<TH1F> ("norm_means_dz_ladder",
2143  "#LT d_{z}/#sigma_{d_{z}} #GT vs ladder;ladder number (#phi);#LT d_{z}/#sigma_{d_{z}} #GT",
2144  nLadders_,0.,nLadders_);
2145 
2146  n_dzladderWidthTrend = WidthTrendsDir.make<TH1F>("norm_widths_dz_ladder",
2147  "width(d_{z}/#sigma_{d_{z}}) vs ladder;ladder number (#phi);width(d_{z}/#sigma_{d_{z}})",
2148  nLadders_,0.,nLadders_);
2149 
2150  if(useTracksFromRecoVtx_){
2151 
2152  fillTrendPlotByIndex(a_dxyPhiMeanBiasTrend ,a_dxyPhiBiasResiduals,PVValHelper::MEAN,PVValHelper::phi);
2153  fillTrendPlotByIndex(a_dxyPhiWidthBiasTrend,a_dxyPhiBiasResiduals,PVValHelper::WIDTH,PVValHelper::phi);
2154  fillTrendPlotByIndex(a_dzPhiMeanBiasTrend ,a_dzPhiBiasResiduals ,PVValHelper::MEAN,PVValHelper::phi);
2155  fillTrendPlotByIndex(a_dzPhiWidthBiasTrend ,a_dzPhiBiasResiduals ,PVValHelper::WIDTH,PVValHelper::phi);
2156 
2157  fillTrendPlotByIndex(a_dxyEtaMeanBiasTrend ,a_dxyEtaBiasResiduals,PVValHelper::MEAN,PVValHelper::eta);
2158  fillTrendPlotByIndex(a_dxyEtaWidthBiasTrend,a_dxyEtaBiasResiduals,PVValHelper::WIDTH,PVValHelper::eta);
2159  fillTrendPlotByIndex(a_dzEtaMeanBiasTrend ,a_dzEtaBiasResiduals ,PVValHelper::MEAN,PVValHelper::eta);
2160  fillTrendPlotByIndex(a_dzEtaWidthBiasTrend ,a_dzEtaBiasResiduals ,PVValHelper::WIDTH,PVValHelper::eta);
2161 
2162  fillTrendPlotByIndex(n_dxyPhiMeanBiasTrend ,n_dxyPhiBiasResiduals,PVValHelper::MEAN,PVValHelper::phi);
2163  fillTrendPlotByIndex(n_dxyPhiWidthBiasTrend,n_dxyPhiBiasResiduals,PVValHelper::WIDTH,PVValHelper::phi);
2164  fillTrendPlotByIndex(n_dzPhiMeanBiasTrend ,n_dzPhiBiasResiduals ,PVValHelper::MEAN,PVValHelper::phi);
2165  fillTrendPlotByIndex(n_dzPhiWidthBiasTrend ,n_dzPhiBiasResiduals ,PVValHelper::WIDTH,PVValHelper::phi);
2166 
2167  fillTrendPlotByIndex(n_dxyEtaMeanBiasTrend ,n_dxyEtaBiasResiduals,PVValHelper::MEAN,PVValHelper::eta);
2168  fillTrendPlotByIndex(n_dxyEtaWidthBiasTrend,n_dxyEtaBiasResiduals,PVValHelper::WIDTH,PVValHelper::eta);
2169  fillTrendPlotByIndex(n_dzEtaMeanBiasTrend ,n_dzEtaBiasResiduals ,PVValHelper::MEAN,PVValHelper::eta);
2170  fillTrendPlotByIndex(n_dzEtaWidthBiasTrend ,n_dzEtaBiasResiduals ,PVValHelper::WIDTH,PVValHelper::eta);
2171 
2172  // medians and MADs
2173 
2174  fillTrendPlotByIndex(a_dxyPhiMedianBiasTrend,a_dxyPhiBiasResiduals,PVValHelper::MEDIAN,PVValHelper::phi);
2175  fillTrendPlotByIndex(a_dxyPhiMADBiasTrend ,a_dxyPhiBiasResiduals,PVValHelper::MAD,PVValHelper::phi);
2176  fillTrendPlotByIndex(a_dzPhiMedianBiasTrend ,a_dzPhiBiasResiduals ,PVValHelper::MEDIAN,PVValHelper::phi);
2177  fillTrendPlotByIndex(a_dzPhiMADBiasTrend ,a_dzPhiBiasResiduals ,PVValHelper::MAD,PVValHelper::phi);
2178 
2179  fillTrendPlotByIndex(a_dxyEtaMedianBiasTrend,a_dxyEtaBiasResiduals,PVValHelper::MEDIAN,PVValHelper::eta);
2180  fillTrendPlotByIndex(a_dxyEtaMADBiasTrend ,a_dxyEtaBiasResiduals,PVValHelper::MAD,PVValHelper::eta);
2181  fillTrendPlotByIndex(a_dzEtaMedianBiasTrend ,a_dzEtaBiasResiduals ,PVValHelper::MEDIAN,PVValHelper::eta);
2182  fillTrendPlotByIndex(a_dzEtaMADBiasTrend ,a_dzEtaBiasResiduals ,PVValHelper::MAD,PVValHelper::eta);
2183 
2184  fillTrendPlotByIndex(n_dxyPhiMedianBiasTrend,n_dxyPhiBiasResiduals,PVValHelper::MEDIAN,PVValHelper::phi);
2185  fillTrendPlotByIndex(n_dxyPhiMADBiasTrend ,n_dxyPhiBiasResiduals,PVValHelper::MAD,PVValHelper::phi);
2186  fillTrendPlotByIndex(n_dzPhiMedianBiasTrend ,n_dzPhiBiasResiduals ,PVValHelper::MEDIAN,PVValHelper::phi);
2187  fillTrendPlotByIndex(n_dzPhiMADBiasTrend ,n_dzPhiBiasResiduals ,PVValHelper::MAD,PVValHelper::phi);
2188 
2189  fillTrendPlotByIndex(n_dxyEtaMedianBiasTrend,n_dxyEtaBiasResiduals,PVValHelper::MEDIAN,PVValHelper::eta);
2190  fillTrendPlotByIndex(n_dxyEtaMADBiasTrend ,n_dxyEtaBiasResiduals,PVValHelper::MAD,PVValHelper::eta);
2191  fillTrendPlotByIndex(n_dzEtaMedianBiasTrend ,n_dzEtaBiasResiduals ,PVValHelper::MEDIAN,PVValHelper::eta);
2192  fillTrendPlotByIndex(n_dzEtaMADBiasTrend ,n_dzEtaBiasResiduals ,PVValHelper::MAD,PVValHelper::eta);
2193 
2194  // 2d Maps
2195 
2196  fillMap(a_dxyMeanBiasMap ,a_dxyBiasResidualsMap,PVValHelper::MEAN);
2197  fillMap(a_dxyWidthBiasMap,a_dxyBiasResidualsMap,PVValHelper::WIDTH);
2198  fillMap(a_dzMeanBiasMap ,a_dzBiasResidualsMap,PVValHelper::MEAN);
2199  fillMap(a_dzWidthBiasMap ,a_dzBiasResidualsMap,PVValHelper::WIDTH);
2200 
2201  fillMap(n_dxyMeanBiasMap ,n_dxyBiasResidualsMap,PVValHelper::MEAN);
2202  fillMap(n_dxyWidthBiasMap,n_dxyBiasResidualsMap,PVValHelper::WIDTH);
2203  fillMap(n_dzMeanBiasMap ,n_dzBiasResidualsMap,PVValHelper::MEAN);
2204  fillMap(n_dzWidthBiasMap ,n_dzBiasResidualsMap,PVValHelper::WIDTH);
2205 
2206  }
2207 
2208  // do profiles
2209 
2210  fillTrendPlotByIndex(a_dxyPhiMeanTrend, a_dxyPhiResiduals,PVValHelper::MEAN,PVValHelper::phi);
2211  fillTrendPlotByIndex(a_dxyPhiWidthTrend,a_dxyPhiResiduals,PVValHelper::WIDTH,PVValHelper::phi);
2212  fillTrendPlotByIndex(a_dzPhiMeanTrend ,a_dzPhiResiduals ,PVValHelper::MEAN,PVValHelper::phi);
2213  fillTrendPlotByIndex(a_dzPhiWidthTrend ,a_dzPhiResiduals ,PVValHelper::WIDTH,PVValHelper::phi);
2214 
2215  fillTrendPlotByIndex(a_dxyEtaMeanTrend ,a_dxyEtaResiduals,PVValHelper::MEAN,PVValHelper::eta);
2216  fillTrendPlotByIndex(a_dxyEtaWidthTrend,a_dxyEtaResiduals,PVValHelper::WIDTH,PVValHelper::eta);
2217  fillTrendPlotByIndex(a_dzEtaMeanTrend ,a_dzEtaResiduals ,PVValHelper::MEAN,PVValHelper::eta);
2218  fillTrendPlotByIndex(a_dzEtaWidthTrend ,a_dzEtaResiduals ,PVValHelper::WIDTH,PVValHelper::eta);
2219 
2220  fillTrendPlotByIndex(n_dxyPhiMeanTrend ,n_dxyPhiResiduals,PVValHelper::MEAN,PVValHelper::phi);
2221  fillTrendPlotByIndex(n_dxyPhiWidthTrend,n_dxyPhiResiduals,PVValHelper::WIDTH,PVValHelper::phi);
2222  fillTrendPlotByIndex(n_dzPhiMeanTrend ,n_dzPhiResiduals ,PVValHelper::MEAN,PVValHelper::phi);
2223  fillTrendPlotByIndex(n_dzPhiWidthTrend ,n_dzPhiResiduals ,PVValHelper::WIDTH);
2224 
2225  fillTrendPlotByIndex(n_dxyEtaMeanTrend ,n_dxyEtaResiduals,PVValHelper::MEAN,PVValHelper::eta);
2226  fillTrendPlotByIndex(n_dxyEtaWidthTrend,n_dxyEtaResiduals,PVValHelper::WIDTH,PVValHelper::eta);
2227  fillTrendPlotByIndex(n_dzEtaMeanTrend ,n_dzEtaResiduals ,PVValHelper::MEAN,PVValHelper::eta);
2228  fillTrendPlotByIndex(n_dzEtaWidthTrend ,n_dzEtaResiduals ,PVValHelper::WIDTH,PVValHelper::eta);
2229 
2230  // vs transverse momentum
2231 
2232  fillTrendPlotByIndex(a_dxypTMeanTrend ,h_dxy_pT_,PVValHelper::MEAN );
2233  fillTrendPlotByIndex(a_dxypTWidthTrend,h_dxy_pT_,PVValHelper::WIDTH);
2234  fillTrendPlotByIndex(a_dzpTMeanTrend ,h_dz_pT_ ,PVValHelper::MEAN );
2235  fillTrendPlotByIndex(a_dzpTWidthTrend ,h_dz_pT_ ,PVValHelper::WIDTH);
2236 
2237  fillTrendPlotByIndex(a_dxypTCentralMeanTrend ,h_dxy_Central_pT_,PVValHelper::MEAN );
2238  fillTrendPlotByIndex(a_dxypTCentralWidthTrend,h_dxy_Central_pT_,PVValHelper::WIDTH);
2239  fillTrendPlotByIndex(a_dzpTCentralMeanTrend ,h_dz_Central_pT_ ,PVValHelper::MEAN );
2240  fillTrendPlotByIndex(a_dzpTCentralWidthTrend ,h_dz_Central_pT_ ,PVValHelper::WIDTH);
2241 
2242  fillTrendPlotByIndex(n_dxypTMeanTrend ,h_norm_dxy_pT_,PVValHelper::MEAN );
2243  fillTrendPlotByIndex(n_dxypTWidthTrend,h_norm_dxy_pT_,PVValHelper::WIDTH);
2244  fillTrendPlotByIndex(n_dzpTMeanTrend ,h_norm_dz_pT_ ,PVValHelper::MEAN );
2245  fillTrendPlotByIndex(n_dzpTWidthTrend ,h_norm_dz_pT_ ,PVValHelper::WIDTH);
2246 
2247  fillTrendPlotByIndex(n_dxypTCentralMeanTrend ,h_norm_dxy_Central_pT_,PVValHelper::MEAN );
2248  fillTrendPlotByIndex(n_dxypTCentralWidthTrend,h_norm_dxy_Central_pT_,PVValHelper::WIDTH);
2249  fillTrendPlotByIndex(n_dzpTCentralMeanTrend ,h_norm_dz_Central_pT_ ,PVValHelper::MEAN );
2250  fillTrendPlotByIndex(n_dzpTCentralWidthTrend ,h_norm_dz_Central_pT_ ,PVValHelper::WIDTH);
2251 
2252  // vs ladder and module number
2253 
2254  fillTrendPlotByIndex(a_dxymodZMeanTrend ,h_dxy_modZ_,PVValHelper::MEAN);
2255  fillTrendPlotByIndex(a_dxymodZWidthTrend ,h_dxy_modZ_,PVValHelper::WIDTH);
2256  fillTrendPlotByIndex(a_dzmodZMeanTrend ,h_dz_modZ_,PVValHelper::MEAN);
2257  fillTrendPlotByIndex(a_dzmodZWidthTrend ,h_dz_modZ_,PVValHelper::WIDTH);
2258 
2259  fillTrendPlotByIndex(a_dxyladderMeanTrend ,h_dxy_ladder_,PVValHelper::MEAN);
2260  fillTrendPlotByIndex(a_dxyladderWidthTrend,h_dxy_ladder_,PVValHelper::WIDTH);
2261  fillTrendPlotByIndex(a_dzladderMeanTrend ,h_dz_ladder_,PVValHelper::MEAN);
2262  fillTrendPlotByIndex(a_dzladderWidthTrend ,h_dz_ladder_,PVValHelper::WIDTH);
2263 
2264  fillTrendPlotByIndex(n_dxymodZMeanTrend ,h_norm_dxy_modZ_,PVValHelper::MEAN);
2265  fillTrendPlotByIndex(n_dxymodZWidthTrend ,h_norm_dxy_modZ_,PVValHelper::WIDTH);
2266  fillTrendPlotByIndex(n_dzmodZMeanTrend ,h_norm_dz_modZ_,PVValHelper::MEAN);
2267  fillTrendPlotByIndex(n_dzmodZWidthTrend ,h_norm_dz_modZ_,PVValHelper::WIDTH);
2268 
2269  fillTrendPlotByIndex(n_dxyladderMeanTrend ,h_norm_dxy_ladder_,PVValHelper::MEAN);
2270  fillTrendPlotByIndex(n_dxyladderWidthTrend,h_norm_dxy_ladder_,PVValHelper::WIDTH);
2271  fillTrendPlotByIndex(n_dzladderMeanTrend ,h_norm_dz_ladder_,PVValHelper::MEAN);
2272  fillTrendPlotByIndex(n_dzladderWidthTrend ,h_norm_dz_ladder_,PVValHelper::WIDTH);
2273 
2274  // medians and MADs
2275 
2276  fillTrendPlotByIndex(a_dxyPhiMedianTrend,a_dxyPhiResiduals,PVValHelper::MEDIAN,PVValHelper::phi);
2277  fillTrendPlotByIndex(a_dxyPhiMADTrend ,a_dxyPhiResiduals,PVValHelper::MAD,PVValHelper::phi);
2278 
2279  fillTrendPlotByIndex(a_dzPhiMedianTrend ,a_dzPhiResiduals ,PVValHelper::MEDIAN,PVValHelper::phi);
2280  fillTrendPlotByIndex(a_dzPhiMADTrend ,a_dzPhiResiduals ,PVValHelper::MAD,PVValHelper::phi);
2281 
2282  fillTrendPlotByIndex(a_dxyEtaMedianTrend,a_dxyEtaResiduals,PVValHelper::MEDIAN,PVValHelper::eta);
2283  fillTrendPlotByIndex(a_dxyEtaMADTrend ,a_dxyEtaResiduals,PVValHelper::MAD,PVValHelper::eta);
2284  fillTrendPlotByIndex(a_dzEtaMedianTrend ,a_dzEtaResiduals ,PVValHelper::MEDIAN,PVValHelper::eta);
2285  fillTrendPlotByIndex(a_dzEtaMADTrend ,a_dzEtaResiduals ,PVValHelper::MAD,PVValHelper::eta);
2286 
2287  fillTrendPlotByIndex(n_dxyPhiMedianTrend,n_dxyPhiResiduals,PVValHelper::MEDIAN,PVValHelper::phi);
2288  fillTrendPlotByIndex(n_dxyPhiMADTrend ,n_dxyPhiResiduals,PVValHelper::MAD,PVValHelper::phi);
2289  fillTrendPlotByIndex(n_dzPhiMedianTrend ,n_dzPhiResiduals ,PVValHelper::MEDIAN,PVValHelper::phi);
2290  fillTrendPlotByIndex(n_dzPhiMADTrend ,n_dzPhiResiduals ,PVValHelper::MAD,PVValHelper::phi);
2291 
2292  fillTrendPlotByIndex(n_dxyEtaMedianTrend,n_dxyEtaResiduals,PVValHelper::MEDIAN,PVValHelper::eta);
2293  fillTrendPlotByIndex(n_dxyEtaMADTrend ,n_dxyEtaResiduals,PVValHelper::MAD,PVValHelper::eta);
2294  fillTrendPlotByIndex(n_dzEtaMedianTrend ,n_dzEtaResiduals ,PVValHelper::MEDIAN,PVValHelper::eta);
2295  fillTrendPlotByIndex(n_dzEtaMADTrend ,n_dzEtaResiduals ,PVValHelper::MAD,PVValHelper::eta);
2296 
2297  // 2D Maps
2298 
2299  fillMap(a_dxyMeanMap ,a_dxyResidualsMap,PVValHelper::MEAN);
2300  fillMap(a_dxyWidthMap,a_dxyResidualsMap,PVValHelper::WIDTH);
2301  fillMap(a_dzMeanMap ,a_dzResidualsMap,PVValHelper::MEAN);
2302  fillMap(a_dzWidthMap ,a_dzResidualsMap,PVValHelper::WIDTH);
2303 
2304  fillMap(n_dxyMeanMap ,n_dxyResidualsMap,PVValHelper::MEAN);
2305  fillMap(n_dxyWidthMap,n_dxyResidualsMap,PVValHelper::WIDTH);
2306  fillMap(n_dzMeanMap ,n_dzResidualsMap,PVValHelper::MEAN);
2307  fillMap(n_dzWidthMap ,n_dzResidualsMap,PVValHelper::WIDTH);
2308 
2309 }
2310 
2311 //*************************************************************
2312 bool PrimaryVertexValidation::isBFieldConsistentWithMode(const edm::EventSetup& iSetup) const
2313 //*************************************************************
2314 {
2315  edm::ESHandle<RunInfo> runInfo;
2316  iSetup.get<RunInfoRcd>().get(runInfo);
2317 
2318  double average_current = runInfo.product()->m_avg_current;
2319  bool isOn = (average_current > 2000.);
2320  bool is0T = (ptOfProbe_==0.);
2321 
2322  return ( (isOn && !is0T) || (!isOn && is0T) );
2323 }
2324 
2325 //*************************************************************
2326 void PrimaryVertexValidation::SetVarToZero()
2327 //*************************************************************
2328 {
2329  nTracks_ = 0;
2330  nClus_ = 0;
2331  nOfflineVertices_=0;
2332  RunNumber_ =0;
2333  LuminosityBlockNumber_=0;
2334  xOfflineVertex_ =-999.;
2335  yOfflineVertex_ =-999.;
2336  zOfflineVertex_ =-999.;
2337  xErrOfflineVertex_=0.;
2338  yErrOfflineVertex_=0.;
2339  zErrOfflineVertex_=0.;
2340  BSx0_ = -999.;
2341  BSy0_ = -999.;
2342  BSz0_ = -999.;
2343  Beamsigmaz_=-999.;
2344  Beamdxdz_=-999.;
2345  BeamWidthX_=-999.;
2346  BeamWidthY_=-999.;
2347  wxy2_=-999.;
2348 
2349  for ( int i=0; i<nMaxtracks_; ++i ) {
2350 
2351  pt_[i] = 0;
2352  p_[i] = 0;
2353  nhits_[i] = 0;
2354  nhits1D_[i] = 0;
2355  nhits2D_[i] = 0;
2356  nhitsBPIX_[i] = 0;
2357  nhitsFPIX_[i] = 0;
2358  nhitsTIB_[i] = 0;
2359  nhitsTID_[i] = 0;
2360  nhitsTOB_[i] = 0;
2361  nhitsTEC_[i] = 0;
2362  isHighPurity_[i] = 0;
2363  eta_[i] = 0;
2364  theta_[i] = 0;
2365  phi_[i] = 0;
2366  chi2_[i] = 0;
2367  chi2ndof_[i] = 0;
2368  charge_[i] = 0;
2369  qoverp_[i] = 0;
2370  dz_[i] = 0;
2371  dxy_[i] = 0;
2372  dzBs_[i] = 0;
2373  dxyBs_[i] = 0;
2374  xPCA_[i] = 0;
2375  yPCA_[i] = 0;
2376  zPCA_[i] = 0;
2377  xUnbiasedVertex_[i] =0;
2378  yUnbiasedVertex_[i] =0;
2379  zUnbiasedVertex_[i] =0;
2380  chi2normUnbiasedVertex_[i]=0;
2381  chi2UnbiasedVertex_[i]=0;
2382  chi2ProbUnbiasedVertex_[i]=0;
2383  DOFUnbiasedVertex_[i]=0;
2384  sumOfWeightsUnbiasedVertex_[i]=0;
2385  tracksUsedForVertexing_[i]=0;
2386  dxyFromMyVertex_[i]=0;
2387  dzFromMyVertex_[i]=0;
2388  d3DFromMyVertex_[i]=0;
2389  dxyErrorFromMyVertex_[i]=0;
2390  dzErrorFromMyVertex_[i]=0;
2391  d3DErrorFromMyVertex_[i]=0;
2392  IPTsigFromMyVertex_[i]=0;
2393  IPLsigFromMyVertex_[i]=0;
2394  IP3DsigFromMyVertex_[i]=0;
2395  hasRecVertex_[i] = 0;
2396  isGoodTrack_[i] = 0;
2397  }
2398 }
2399 
2400 //*************************************************************
2401 void PrimaryVertexValidation::fillTrendPlot(TH1F* trendPlot, TH1F* residualsPlot[100], PVValHelper::estimator fitPar_, const std::string& var_)
2402 //*************************************************************
2403 {
2404 
2405  for ( int i=0; i<nBins_; ++i ) {
2406 
2407  char phibincenter[129];
2408  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
2409  sprintf(phibincenter,"%.f",(phiBins[i]+phiBins[i+1])/2.);
2410 
2411  char etabincenter[129];
2412  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
2413  sprintf(etabincenter,"%.1f",(etaBins[i]+etaBins[i+1])/2.);
2414 
2415  switch(fitPar_)
2416  {
2417  case PVValHelper::MEAN:
2418  {
2419  float mean_ = PVValHelper::fitResiduals(residualsPlot[i]).first.value();
2420  float meanErr_ = PVValHelper::fitResiduals(residualsPlot[i]).first.error();
2421  trendPlot->SetBinContent(i+1,mean_);
2422  trendPlot->SetBinError(i+1,meanErr_);
2423  break;
2424  }
2425  case PVValHelper::WIDTH:
2426  {
2427  float width_ = PVValHelper::fitResiduals(residualsPlot[i]).second.value();
2428  float widthErr_ = PVValHelper::fitResiduals(residualsPlot[i]).second.error();
2429  trendPlot->SetBinContent(i+1,width_);
2430  trendPlot->SetBinError(i+1,widthErr_);
2431  break;
2432  }
2433  case PVValHelper::MEDIAN:
2434  {
2435  float median_ = PVValHelper::getMedian(residualsPlot[i]).value();
2436  float medianErr_ = PVValHelper::getMedian(residualsPlot[i]).error();
2437  trendPlot->SetBinContent(i+1,median_);
2438  trendPlot->SetBinError(i+1,medianErr_);
2439  break;
2440  }
2441  case PVValHelper::MAD:
2442  {
2443  float mad_ = PVValHelper::getMAD(residualsPlot[i]).value();
2444  float madErr_ = PVValHelper::getMAD(residualsPlot[i]).error();
2445  trendPlot->SetBinContent(i+1,mad_);
2446  trendPlot->SetBinError(i+1,madErr_);
2447  break;
2448  }
2449  default:
2450  edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlot() "<<fitPar_<<" unknown estimator!"<<std::endl;
2451  break;
2452  }
2453 
2454  if(var_.find("eta") != std::string::npos){
2455  trendPlot->GetXaxis()->SetBinLabel(i+1,etabincenter);
2456  } else if(var_.find("phi") != std::string::npos){
2457  trendPlot->GetXaxis()->SetBinLabel(i+1,phibincenter);
2458  } else {
2459  edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlot() "<<var_<<" unknown track parameter!"<<std::endl;
2460  }
2461  }
2462 }
2463 
2464 //*************************************************************
2465 void PrimaryVertexValidation::fillTrendPlotByIndex(TH1F* trendPlot,std::vector<TH1F*>& h, PVValHelper::estimator fitPar_, PVValHelper::plotVariable plotVar)
2466 //*************************************************************
2467 {
2468 
2469  for(auto iterator = h.begin(); iterator != h.end(); iterator++) {
2470 
2471  unsigned int bin = std::distance(h.begin(),iterator)+1;
2472  std::pair<Measurement1D, Measurement1D> myFit = PVValHelper::fitResiduals((*iterator));
2473 
2474  switch(fitPar_)
2475  {
2476  case PVValHelper::MEAN:
2477  {
2478  float mean_ = myFit.first.value();
2479  float meanErr_ = myFit.first.error();
2480  trendPlot->SetBinContent(bin,mean_);
2481  trendPlot->SetBinError(bin,meanErr_);
2482  break;
2483  }
2484  case PVValHelper::WIDTH:
2485  {
2486  float width_ = myFit.second.value();
2487  float widthErr_ = myFit.second.error();
2488  trendPlot->SetBinContent(bin,width_);
2489  trendPlot->SetBinError(bin,widthErr_);
2490  break;
2491  }
2492  case PVValHelper::MEDIAN:
2493  {
2494  float median_ = PVValHelper::getMedian(*iterator).value();
2495  float medianErr_ = PVValHelper::getMedian(*iterator).error();
2496  trendPlot->SetBinContent(bin,median_);
2497  trendPlot->SetBinError(bin,medianErr_);
2498  break;
2499  }
2500  case PVValHelper::MAD:
2501  {
2502  float mad_ = PVValHelper::getMAD(*iterator).value();
2503  float madErr_ = PVValHelper::getMAD(*iterator).error();
2504  trendPlot->SetBinContent(bin,mad_);
2505  trendPlot->SetBinError(bin,madErr_);
2506  break;
2507  }
2508  default:
2509  edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlotByIndex() "<<fitPar_<<" unknown estimator!"<<std::endl;
2510  break;
2511  }
2512 
2513  char bincenter[129];
2514  if(plotVar == PVValHelper::eta){
2515  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
2516  sprintf(bincenter,"%.1f",(etaBins[bin-1]+etaBins[bin])/2.);
2517  trendPlot->GetXaxis()->SetBinLabel(bin,bincenter);
2518  } else if(plotVar == PVValHelper::phi){
2519  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
2520  sprintf(bincenter,"%.f",(phiBins[bin-1]+phiBins[bin])/2.);
2521  trendPlot->GetXaxis()->SetBinLabel(bin,bincenter);
2522  } else {
2524  //edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlotByIndex() "<< plotVar <<" unknown track parameter!"<<std::endl;
2525  }
2526 
2527  }
2528 }
2529 
2530 //*************************************************************
2531 void PrimaryVertexValidation::fillMap(TH2F* trendMap, TH1F* residualsMapPlot[100][100], PVValHelper::estimator fitPar_)
2532 //*************************************************************
2533 {
2534 
2535  for ( int i=0; i<nBins_; ++i ) {
2536 
2537  char phibincenter[129];
2538  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
2539  sprintf(phibincenter,"%.f",(phiBins[i]+phiBins[i+1])/2.);
2540 
2541  trendMap->GetYaxis()->SetBinLabel(i+1,phibincenter);
2542 
2543  for ( int j=0; j<nBins_; ++j ) {
2544 
2545  char etabincenter[129];
2546  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
2547  sprintf(etabincenter,"%.1f",(etaBins[j]+etaBins[j+1])/2.);
2548 
2549  if(i==0) { trendMap->GetXaxis()->SetBinLabel(j+1,etabincenter); }
2550 
2551  switch (fitPar_)
2552  {
2553  case PVValHelper::MEAN:
2554  {
2555  float mean_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.value();
2556  float meanErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.error();
2557  trendMap->SetBinContent(j+1,i+1,mean_);
2558  trendMap->SetBinError(j+1,i+1,meanErr_);
2559  break;
2560  }
2561  case PVValHelper::WIDTH:
2562  {
2563  float width_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.value();
2564  float widthErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.error();
2565  trendMap->SetBinContent(j+1,i+1,width_);
2566  trendMap->SetBinError(j+1,i+1,widthErr_);
2567  break;
2568  }
2569  case PVValHelper::MEDIAN:
2570  {
2571  float median_ = PVValHelper::getMedian(residualsMapPlot[i][j]).value();
2572  float medianErr_ = PVValHelper::getMedian(residualsMapPlot[i][j]).error();
2573  trendMap->SetBinContent(j+1,i+1,median_);
2574  trendMap->SetBinError(j+1,i+1,medianErr_);
2575  break;
2576  }
2577  case PVValHelper::MAD:
2578  {
2579  float mad_ = PVValHelper::getMAD(residualsMapPlot[i][j]).value();
2580  float madErr_ = PVValHelper::getMAD(residualsMapPlot[i][j]).error();
2581  trendMap->SetBinContent(j+1,i+1,mad_);
2582  trendMap->SetBinError(j+1,i+1,madErr_);
2583  break;
2584  }
2585  default:
2586  edm::LogWarning("PrimaryVertexValidation:") <<" fillMap() "<<fitPar_<<" unknown estimator!"<<std::endl;
2587  }
2588  } // closes loop on eta bins
2589  } // cloeses loop on phi bins
2590 }
2591 
2592 //*************************************************************
2593 bool PrimaryVertexValidation::vtxSort( const reco::Vertex & a, const reco::Vertex & b )
2594 //*************************************************************
2595 {
2596  if( a.tracksSize() != b.tracksSize() )
2597  return a.tracksSize() > b.tracksSize() ? true : false ;
2598  else
2599  return a.chi2() < b.chi2() ? true : false ;
2600 }
2601 
2602 //*************************************************************
2603 bool PrimaryVertexValidation::passesTrackCuts(const reco::Track & track, const reco::Vertex & vertex,const std::string& qualityString_, double dxyErrMax_,double dzErrMax_, double ptErrMax_)
2604 //*************************************************************
2605 {
2606 
2607  math::XYZPoint vtxPoint(0.0,0.0,0.0);
2608  double vzErr =0.0, vxErr=0.0, vyErr=0.0;
2609  vtxPoint=vertex.position();
2610  vzErr=vertex.zError();
2611  vxErr=vertex.xError();
2612  vyErr=vertex.yError();
2613 
2614  double dxy=0.0, dz=0.0, dxysigma=0.0, dzsigma=0.0;
2615  dxy = track.dxy(vtxPoint);
2616  dz = track.dz(vtxPoint);
2617  dxysigma = sqrt(track.d0Error()*track.d0Error()+vxErr*vyErr);
2618  dzsigma = sqrt(track.dzError()*track.dzError()+vzErr*vzErr);
2619 
2620  if(track.quality(reco::TrackBase::qualityByName(qualityString_)) != 1)return false;
2621  if(std::abs(dxy/dxysigma) > dxyErrMax_) return false;
2622  if(std::abs(dz/dzsigma) > dzErrMax_) return false;
2623  if(track.ptError() / track.pt() > ptErrMax_) return false;
2624 
2625  return true;
2626 }
2627 
2628 
2629 //*************************************************************
2630 std::map<std::string, TH1*> PrimaryVertexValidation::bookVertexHistograms(const TFileDirectory& dir)
2631 //*************************************************************
2632 {
2633 
2634  TH1F::SetDefaultSumw2(kTRUE);
2635 
2636  std::map<std::string, TH1*> h;
2637 
2638  // histograms of track quality (Data and MC)
2639  std::string types[] = {"all","sel"};
2640  for(const auto & type : types){
2641  h["pseudorapidity_"+type] =dir.make <TH1F>(("rapidity_"+type).c_str(),"track pseudorapidity; track #eta; tracks",100,-3., 3.);
2642  h["z0_"+type] = dir.make<TH1F>(("z0_"+type).c_str(),"track z_{0};track z_{0} (cm);tracks",80,-40., 40.);
2643  h["phi_"+type] = dir.make<TH1F>(("phi_"+type).c_str(),"track #phi; track #phi;tracks",80,-M_PI, M_PI);
2644  h["eta_"+type] = dir.make<TH1F>(("eta_"+type).c_str(),"track #eta; track #eta;tracks",80,-4., 4.);
2645  h["pt_"+type] = dir.make<TH1F>(("pt_"+type).c_str(),"track p_{T}; track p_{T} [GeV];tracks",100,0., 20.);
2646  h["p_"+type] = dir.make<TH1F>(("p_"+type).c_str(),"track p; track p [GeV];tracks",100,0., 20.);
2647  h["found_"+type] = dir.make<TH1F>(("found_"+type).c_str(),"n. found hits;n^{found}_{hits};tracks",30, 0., 30.);
2648  h["lost_"+type] = dir.make<TH1F>(("lost_"+type).c_str(),"n. lost hits;n^{lost}_{hits};tracks",20, 0., 20.);
2649  h["nchi2_"+type] = dir.make<TH1F>(("nchi2_"+type).c_str(),"normalized track #chi^{2};track #chi^{2}/ndf;tracks",100, 0., 20.);
2650  h["rstart_"+type] = dir.make<TH1F>(("rstart_"+type).c_str(),"track start radius; track innermost radius r (cm);tracks",100, 0., 20.);
2651  h["expectedInner_"+type] = dir.make<TH1F>(("expectedInner_"+type).c_str(),"n. expected inner hits;n^{expected}_{inner};tracks",10, 0., 10.);
2652  h["expectedOuter_"+type] = dir.make<TH1F>(("expectedOuter_"+type).c_str(),"n. expected outer hits;n^{expected}_{outer};tracks ",10, 0., 10.);
2653  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.);
2654  h["logtresz_"+type] = dir.make<TH1F>(("logtresz_"+type).c_str(),"log10(track z resolution/#mum);log10(track z resolution/#mum);tracks",100, 0., 5.);
2655  h["tpullxy_"+type] = dir.make<TH1F>(("tpullxy_"+type).c_str(),"track r-#phi pull;pull_{r-#phi};tracks",100, -10., 10.);
2656  h["tpullz_"+type] = dir.make<TH1F>(("tpullz_"+type).c_str(),"track r-z pull;pull_{r-z};tracks",100, -50., 50.);
2657  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.);
2658  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.);
2659  h["lvseta_"+type] = dir.make<TH2F>(("lvseta_"+type).c_str(),"cluster length vs #eta;track #eta;cluster length",60,-3., 3., 20, 0., 20);
2660  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);
2661  h["restrkz_"+type] = dir.make<TH1F>(("restrkz_"+type).c_str(),"z-residuals (track vs vertex);res_{z} (cm);tracks", 200, -5., 5.);
2662  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);
2663  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);
2664  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.);
2665  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.);
2666  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.);
2667  h["sigmatrkz0_"+type] = dir.make<TH1F>(("sigmatrkz0_"+type).c_str(),"z-resolution (excluding beam);#sigma^{trk}_{z_{0}} (cm);tracks", 100, 0., 5.);
2668  h["sigmatrkz_"+type] = dir.make<TH1F>(("sigmatrkz_"+type).c_str(),"z-resolution (including beam);#sigma^{trk}_{z} (cm);tracks", 100,0., 5.);
2669  h["nbarrelhits_"+type] = dir.make<TH1F>(("nbarrelhits_"+type).c_str(),"number of pixel barrel hits;n. hits Barrel Pixel;tracks", 10, 0., 10.);
2670  h["nbarrelLayers_"+type] = dir.make<TH1F>(("nbarrelLayers_"+type).c_str(),"number of pixel barrel layers;n. layers Barrel Pixel;tracks", 10, 0., 10.);
2671  h["nPxLayers_"+type] = dir.make<TH1F>(("nPxLayers_"+type).c_str(),"number of pixel layers (barrel+endcap);n. Pixel layers;tracks", 10, 0., 10.);
2672  h["nSiLayers_"+type] = dir.make<TH1F>(("nSiLayers_"+type).c_str(),"number of Tracker layers;n. Tracker layers;tracks", 20, 0., 20.);
2673  h["trackAlgo_"+type] = dir.make<TH1F>(("trackAlgo_"+type).c_str(),"track algorithm;track algo;tracks", 30, 0., 30.);
2674  h["trackQuality_"+type] = dir.make<TH1F>(("trackQuality_"+type).c_str(),"track quality;track quality;tracks", 7, -1., 6.);
2675  }
2676 
2677  return h;
2678 
2679 }
2680 
2681 //*************************************************************
2682 // Generic booker function
2683 //*************************************************************
2684 std::vector<TH1F*> PrimaryVertexValidation::bookResidualsHistogram(const TFileDirectory& dir,
2685  unsigned int theNOfBins,
2686  PVValHelper::residualType resType,
2687  PVValHelper::plotVariable varType,
2688  bool isNormalized){
2689 
2690  TH1F::SetDefaultSumw2(kTRUE);
2691 
2692  auto hash = std::make_pair(resType,varType);
2693 
2694  double down = theDetails_.range[hash].first;
2695  double up = theDetails_.range[hash].second;
2696 
2697  if(isNormalized){
2698  up = up/100.;
2699  down = down/100.;
2700  }
2701 
2702  std::vector<TH1F*> h;
2703  h.reserve(theNOfBins);
2704 
2705  if (theNOfBins==0) {
2706  edm::LogError("PrimaryVertexValidation") <<"bookResidualsHistogram() The number of bins cannot be identically 0" << std::endl;
2707  assert(false);
2708  }
2709 
2710  std::string s_resType = std::get<0>(PVValHelper::getTypeString(resType));
2711  std::string s_varType = std::get<0>(PVValHelper::getVarString(varType));
2712 
2713  std::string t_resType = std::get<1>(PVValHelper::getTypeString(resType));
2714  std::string t_varType = std::get<1>(PVValHelper::getVarString(varType));
2715  std::string units = std::get<2>(PVValHelper::getTypeString(resType));
2716 
2717  for(unsigned int i=0; i<theNOfBins;i++){
2718 
2719  TString title = (varType == PVValHelper::phi || varType == PVValHelper::eta) ?
2720  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());
2721 
2722  TH1F* htemp = dir.make<TH1F>(Form("histo_%s_%s_plot%i",s_resType.c_str(),s_varType.c_str(),i),
2723  //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()),
2724  title.Data(),
2725  theDetails_.histobins,down,up);
2726  h.push_back(htemp);
2727  }
2728 
2729  return h;
2730 
2731 }
2732 
2733 //*************************************************************
2734 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_)
2735 //*************************************************************
2736 {
2737 
2738  using namespace reco;
2739 
2740  PVValHelper::fill(h,"pseudorapidity_"+ttype,tt->track().eta());
2741  PVValHelper::fill(h,"z0_"+ttype,tt->track().vz());
2742  PVValHelper::fill(h,"phi_"+ttype,tt->track().phi());
2743  PVValHelper::fill(h,"eta_"+ttype,tt->track().eta());
2744  PVValHelper::fill(h,"pt_"+ttype,tt->track().pt());
2745  PVValHelper::fill(h,"p_"+ttype,tt->track().p());
2746  PVValHelper::fill(h,"found_"+ttype,tt->track().found());
2747  PVValHelper::fill(h,"lost_"+ttype,tt->track().lost());
2748  PVValHelper::fill(h,"nchi2_"+ttype,tt->track().normalizedChi2());
2749  PVValHelper::fill(h,"rstart_"+ttype,(tt->track().innerPosition()).Rho());
2750 
2751  double d0Error=tt->track().d0Error();
2752  double d0=tt->track().dxy(beamSpot.position());
2753  double dz=tt->track().dz(beamSpot.position());
2754  if (d0Error>0){
2755  PVValHelper::fill(h,"logtresxy_"+ttype,log(d0Error/0.0001)/log(10.));
2756  PVValHelper::fill(h,"tpullxy_"+ttype,d0/d0Error);
2757  PVValHelper::fill(h,"tlogDCAxy_"+ttype,log(std::abs(d0/d0Error)));
2758 
2759  }
2760  //double z0=tt->track().vz();
2761  double dzError=tt->track().dzError();
2762  if(dzError>0){
2763  PVValHelper::fill(h,"logtresz_"+ttype,log(dzError/0.0001)/log(10.));
2764  PVValHelper::fill(h,"tpullz_"+ttype,dz/dzError);
2765  PVValHelper::fill(h,"tlogDCAz_"+ttype,log(std::abs(dz/dzError)));
2766  }
2767 
2768  //
2769  double wxy2_=pow(beamSpot.BeamWidthX(),2)+pow(beamSpot.BeamWidthY(),2);
2770 
2771  PVValHelper::fill(h,"sigmatrkz_"+ttype,sqrt(pow(tt->track().dzError(),2)+wxy2_/pow(tan(tt->track().theta()),2)));
2772  PVValHelper::fill(h,"sigmatrkz0_"+ttype,tt->track().dzError());
2773 
2774  // track vs vertex
2775  if( v.isValid()){ // && (v.ndof()<10.)) {
2776  // emulate clusterizer input
2777  //const TransientTrack & tt = theB_->build(&t); wrong !!!!
2778  //reco::TransientTrack tt = theB_->build(&t);
2779  //ttt->track().setBeamSpot(beamSpot); // need the setBeamSpot !
2780  double z=(tt->stateAtBeamLine().trackStateAtPCA()).position().z();
2781  double tantheta=tan((tt->stateAtBeamLine().trackStateAtPCA()).momentum().theta());
2782  double dz2= pow(tt->track().dzError(),2)+wxy2_/pow(tantheta,2);
2783 
2784  PVValHelper::fill(h,"restrkz_"+ttype,z-v.position().z());
2785  PVValHelper::fill(h,"restrkzvsphi_"+ttype,tt->track().phi(), z-v.position().z());
2786  PVValHelper::fill(h,"restrkzvseta_"+ttype,tt->track().eta(), z-v.position().z());
2787  PVValHelper::fill(h,"pulltrkzvsphi_"+ttype,tt->track().phi(), (z-v.position().z())/sqrt(dz2));
2788  PVValHelper::fill(h,"pulltrkzvseta_"+ttype,tt->track().eta(), (z-v.position().z())/sqrt(dz2));
2789 
2790  PVValHelper::fill(h,"pulltrkz_"+ttype,(z-v.position().z())/sqrt(dz2));
2791 
2792  double x1=tt->track().vx()-beamSpot.x0(); double y1=tt->track().vy()-beamSpot.y0();
2793 
2794  double kappa=-0.002998*fBfield_*tt->track().qoverp()/cos(tt->track().theta());
2795  double D0=x1*sin(tt->track().phi())-y1*cos(tt->track().phi())-0.5*kappa*(x1*x1+y1*y1);
2796  double q=sqrt(1.-2.*kappa*D0);
2797  double s0=(x1*cos(tt->track().phi())+y1*sin(tt->track().phi()))/q;
2798  // double s1;
2799  if (std::abs(kappa*s0)>0.001){
2800  //s1=asin(kappa*s0)/kappa;
2801  }else{
2802  //double ks02=(kappa*s0)*(kappa*s0);
2803  //s1=s0*(1.+ks02/6.+3./40.*ks02*ks02+5./112.*pow(ks02,3));
2804  }
2805  // sp.ddcap=-2.*D0/(1.+q);
2806  //double zdcap=tt->track().vz()-s1/tan(tt->track().theta());
2807 
2808  }
2809  //
2810 
2811  // collect some info on hits and clusters
2812  PVValHelper::fill(h,"nbarrelLayers_"+ttype,tt->track().hitPattern().pixelBarrelLayersWithMeasurement());
2813  PVValHelper::fill(h,"nPxLayers_"+ttype,tt->track().hitPattern().pixelLayersWithMeasurement());
2814  PVValHelper::fill(h,"nSiLayers_"+ttype,tt->track().hitPattern().trackerLayersWithMeasurement());
2815  PVValHelper::fill(h,"expectedInner_"+ttype,tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS));
2816  PVValHelper::fill(h,"expectedOuter_"+ttype,tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_OUTER_HITS));
2817  PVValHelper::fill(h,"trackAlgo_"+ttype,tt->track().algo());
2818  PVValHelper::fill(h,"trackQuality_"+ttype,tt->track().qualityMask());
2819 
2820  //
2821  int longesthit=0, nbarrel=0;
2822  for(trackingRecHit_iterator hit=tt->track().recHitsBegin(); hit!=tt->track().recHitsEnd(); hit++){
2823  if ((**hit).isValid() && (**hit).geographicalId().det() == DetId::Tracker ){
2824  bool barrel = DetId((**hit).geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
2825  //bool endcap = DetId::DetId((**hit).geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
2826  if (barrel){
2827  const SiPixelRecHit *pixhit = dynamic_cast<const SiPixelRecHit*>( &(**hit));
2828  edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const& clust = (*pixhit).cluster();
2829  if (clust.isNonnull()) {
2830  nbarrel++;
2831  if (clust->sizeY()-longesthit>0) longesthit=clust->sizeY();
2832  if (clust->sizeY()>20.){
2833  PVValHelper::fill(h,"lvseta_"+ttype,tt->track().eta(), 19.9);
2834  PVValHelper::fill(h,"lvstanlambda_"+ttype,tan(tt->track().lambda()), 19.9);
2835  }else{
2836  PVValHelper::fill(h,"lvseta_"+ttype,tt->track().eta(), float(clust->sizeY()));
2837  PVValHelper::fill(h,"lvstanlambda_"+ttype,tan(tt->track().lambda()), float(clust->sizeY()));
2838  }
2839  }
2840  }
2841  }
2842  }
2843  PVValHelper::fill(h,"nbarrelhits_"+ttype,float(nbarrel));
2844  //-------------------------------------------------------------------
2845 }
2846 
2847 //define this as a plug-in
2848 DEFINE_FWK_MODULE(PrimaryVertexValidation);
2849 
2850 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:601
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:606
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:648
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:751
PrimaryVertexValidation::a_d3DEtaResiduals
std::vector< TH1F * > a_d3DEtaResiduals
Definition: PrimaryVertexValidation.h:303
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:847
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:93
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:253
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:277
reco::Track::lost
unsigned short lost() const
Number of lost (=invalid) hits on track.
Definition: Track.h:201
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:2593
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:594
PrimaryVertexValidation::fillTrendPlot
void fillTrendPlot(TH1F *trendPlot, TH1F *residualsPlot[100], PVValHelper::estimator fitPar_, const std::string &var_)
Definition: PrimaryVertexValidation.cc:2401
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:579
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:612
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
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:144
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:30
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:14
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:678
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:141
PrimaryVertexValidation::fillTrendPlotByIndex
void fillTrendPlotByIndex(TH1F *trendPlot, std::vector< TH1F * > &h, PVValHelper::estimator fitPar_, PVValHelper::plotVariable plotVar=PVValHelper::END_OF_PLOTS)
Definition: PrimaryVertexValidation.cc:2465
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:660
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:2630
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:605
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:2312
PrimaryVertexValidation::pixelHitsCheck
std::pair< bool, bool > pixelHitsCheck(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1121
reco::TransientTrack::stateAtBeamLine
TrajectoryStateClosestToBeamLine stateAtBeamLine() const
Definition: TransientTrack.h:124
reco::HitPattern::numberOfValidStripTOBHits
int numberOfValidStripTOBHits() const
Definition: HitPattern.h:938
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:2734
edm::EventAuxiliary::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventAuxiliary.h:63
reco::HitPattern::pixelEndcapHitFilter
static bool pixelEndcapHitFilter(uint16_t pattern)
Definition: HitPattern.h:615
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:847
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:530
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:732
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:230
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:684
PrimaryVertexValidation::a_dxyEtaBiasResiduals
std::vector< TH1F * > a_dxyEtaBiasResiduals
Definition: PrimaryVertexValidation.h:458
reco::HitPattern::numberOfValidPixelBarrelHits
int numberOfValidPixelBarrelHits() const
Definition: HitPattern.h:913
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:582
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:654
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:808
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:931
reco::HitPattern::numberOfAllHits
int numberOfAllHits(HitCategory category) const
Definition: HitPattern.h:867
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
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:933
reco::TrackBase::lambda
double lambda() const
Lambda angle.
Definition: TrackBase.h:618
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:889
reco::HitPattern::numberOfValidStripTECHits
int numberOfValidStripTECHits() const
Definition: HitPattern.h:943
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
reco::Track::recHitsBegin
trackingRecHit_iterator recHitsBegin() const
Iterator to first hit on the track.
Definition: Track.h:106
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:602
globals_cff.x1
x1
Definition: globals_cff.py:24
PrimaryVertexValidation::hasFirstLayerPixelHits
bool hasFirstLayerPixelHits(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1139
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:672
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:642
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:859
electrons_cff.bool
bool
Definition: electrons_cff.py:293
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:702
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:2531
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:479
HiIsolationCommonParameters_cff.track
track
Definition: HiIsolationCommonParameters_cff.py:9
PrimaryVertexValidation::isHit2D
bool isHit2D(const TrackingRecHit &hit) const
Definition: PrimaryVertexValidation.cc:1090
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:28
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:928
reco::TrackBase::quality
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:543
reco::HitPattern::numberOfLostHits
int numberOfLostHits(HitCategory category) const
Definition: HitPattern.h:982
reco::HitPattern::numberOfValidPixelEndcapHits
int numberOfValidPixelEndcapHits() const
Definition: HitPattern.h:918
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:696
units
TString units(TString variable, Char_t axis)
PrimaryVertexValidation::dzFromMyVertex_
double dzFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:247
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:43
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:196
edm::EventSetup::get
T get() const
Definition: EventSetup.h:68
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:2684
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:600
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:2603
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:545
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:624
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:84
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:666
reco::TrackBase::vx
double vx() const
x coordinate of the reference point on track
Definition: TrackBase.h:690
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
reco::Track::recHitsEnd
trackingRecHit_iterator recHitsEnd() const
Iterator to last hit on the track.
Definition: Track.h:111
PrimaryVertexValidation::IP3DsigFromMyVertex_
double IP3DsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:256
Generated for CMSSW Reference Manual by doxygen 1.8.11