PrimaryVertexValidation.h

Go to the documentation of this file.

#ifndef PrimaryVertexValidation_h
#define PrimaryVertexValidation_h

// system include files
#include <string>
#include <sstream>
#include <vector>
#include <map>

// ROOT Included
#include "TFile.h"
#include "TH1D.h"
#include "TH1I.h"
#include "TH2D.h"
#include "TTree.h"

// CMSSW includes
#include "CommonTools/UtilAlgos/interface/TFileService.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/GeometryVector/interface/LocalPoint.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidate.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h"
#include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2DCollection.h"
#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h"
#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeed.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "FWCore/Framework/interface/ConsumesCollector.h" 
#include "FWCore/Framework/interface/one/EDAnalyzer.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/MakerMacros.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "RecoVertex/AdaptiveVertexFit/interface/AdaptiveVertexFitter.h"
#include "RecoVertex/PrimaryVertexProducer/interface/PrimaryVertexProducerAlgorithm.h"
#include "RecoVertex/PrimaryVertexProducer/interface/TrackClusterizerInZ.h"
#include "RecoVertex/PrimaryVertexProducer/interface/TrackFilterForPVFinding.h"
#include "RecoVertex/PrimaryVertexProducer/interface/TrackFilterForPVFindingBase.h"
#include "RecoVertex/VertexPrimitives/interface/VertexFitter.h"
#include "TrackingTools/IPTools/interface/IPTools.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateClosestToPoint.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#include "Alignment/OfflineValidation/interface/PVValidationHelpers.h"

//
// ancyllary enum for 
// residuals moments estimation 
//

//
// class decleration
//

class PrimaryVertexValidation : public edm::one::EDAnalyzer<edm::one::SharedResources> {

 public:
  explicit PrimaryVertexValidation(const edm::ParameterSet&);
  ~PrimaryVertexValidation() override;

 private:
  virtual void beginJob() override;
  virtual void analyze(const edm::Event&, const edm::EventSetup&) override;
  virtual void endJob() override;
  bool isBFieldConsistentWithMode(const edm::EventSetup& iSetup) const;
  bool isHit2D(const TrackingRecHit &hit) const;
  bool hasFirstLayerPixelHits(const reco::TransientTrack& track);
  std::pair<bool,bool> pixelHitsCheck(const reco::TransientTrack& track);
  Measurement1D getMedian(TH1F *histo);
  Measurement1D getMAD(TH1F *histo);
  std::pair<Measurement1D, Measurement1D > fitResiduals(TH1 *hist);

  void fillTrendPlot(TH1F* trendPlot, TH1F *residualsPlot[100], PVValHelper::estimator fitPar_, const std::string& var_);
  void fillTrendPlotByIndex(TH1F* trendPlot,std::vector<TH1F*>& h, PVValHelper::estimator fitPar_,PVValHelper::plotVariable plotVar=PVValHelper::END_OF_PLOTS); 

  static bool vtxSort( const reco::Vertex &  a, const reco::Vertex & b );
  bool passesTrackCuts(const reco::Track & track, const reco::Vertex & vertex,const std::string& qualityString_, double dxyErrMax_,double dzErrMax_, double ptErrMax_);

  std::vector<TH1F*> bookResidualsHistogram(const TFileDirectory& dir,unsigned int theNOfBins,PVValHelper::residualType resType,PVValHelper::plotVariable varType, bool isNormalized=false); 
  std::map<std::string, TH1*> bookVertexHistograms(const TFileDirectory& dir);

  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);
  void add(std::map<std::string, TH1*>& h, TH1* hist);

  void fill(std::map<std::string, TH1*>& h,const std::string& s, double x);
  void fill(std::map<std::string, TH1*>& h,const std::string& s, double x, double y);
  void fillByIndex(std::vector<TH1F*>& h, unsigned int index, double x,std::string tag=""); 

  void shrinkHistVectorToFit(std::vector<TH1F*>&h,unsigned int desired_size);
  std::tuple<std::string,std::string,std::string> getTypeString (PVValHelper::residualType type);
  std::tuple<std::string,std::string,std::string> getVarString (PVValHelper::plotVariable var);

  void fillMap(TH2F* trendMap, TH1F* residualsMapPlot[100][100], PVValHelper::estimator fitPar_);
  
  inline double square(double x){
    return x*x;
  }

  // ----------member data ---------------------------
  edm::ParameterSet theConfig;
  int Nevt_;
 
  TrackFilterForPVFindingBase* theTrackFilter_; 
  TrackClusterizerInZ* theTrackClusterizer_;

  // setting of the number of plots 
  static const int nMaxBins_ = 100; // maximum number of bookable histograms
  
  // Output 
  bool storeNtuple_;
  bool lightNtupleSwitch_;   // switch to keep only info for daily validation     
  bool useTracksFromRecoVtx_; 
  
  // histogram details
  PVValHelper::histodetails theDetails_;
  
  // requirements on the vertex
  double vertexZMax_;

  // integrated lumi (if info available)
  double intLumi_;

  // requirements on the probe
  bool    askFirstLayerHit_;  // ask hit in the first layer of pixels
  bool    doBPix_;
  bool    doFPix_;
  double  ptOfProbe_;
  double  pOfProbe_;
  double  etaOfProbe_;
  double  nHitsOfProbe_;
  bool    isPhase1_;
  int nBins_;                 // actual number of histograms     
  std::vector<unsigned int> runControlNumbers_;

  bool debug_;
  bool runControl_;

  edm::EDGetTokenT<reco::TrackCollection>  theTrackCollectionToken; 
  edm::EDGetTokenT<reco::VertexCollection> theVertexCollectionToken; 
  edm::EDGetTokenT<reco::BeamSpot>         theBeamspotToken;

  TTree* rootTree_;
  
  // Root-Tuple variables :
  //=======================
  void SetVarToZero();  

  static const int nMaxtracks_ = 1000;
  static const int cmToum = 10000;
  static const int nPtBins_ = 48;

  unsigned int   nLadders_= 20;
  unsigned int   nModZ_   =  8;
  
  // pT binning as in paragraph 3.2 of CMS-PAS-TRK-10-005 (https://cds.cern.ch/record/1279383/files/TRK-10-005-pas.pdf)

  //                                      0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36   37  38   39  40  41  42  43  44  45   46  47  48
  const float mypT_bins_[nPtBins_+1] = {0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0,2.1,2.2,2.3,2.4,2.5,2.6,2.7,2.8,2.9,3.0,3.1,3.2,3.3,3.4,3.5,3.6,3.7,3.8,3.9,4.0,4.1,4.25,4.5,4.75,5.0,5.5,6.0,7.0,8.0,9.0,11.0,14.0,20.}; 

  // event-related quantities
  int nTracks_;
  int nTracksPerClus_;
  int nClus_;
  int nOfflineVertices_;
  unsigned int RunNumber_;
  unsigned int EventNumber_;
  unsigned int LuminosityBlockNumber_;
  double  xOfflineVertex_;
  double  yOfflineVertex_;
  double  zOfflineVertex_;

  double xErrOfflineVertex_; 
  double yErrOfflineVertex_;
  double zErrOfflineVertex_;

  double BSx0_;
  double BSy0_;
  double BSz0_;
  double Beamsigmaz_;
  double Beamdxdz_;   
  double BeamWidthX_;
  double BeamWidthY_;
  double wxy2_;

  // track-related quantities
  double pt_[nMaxtracks_];   
  double p_[nMaxtracks_];    
  int nhits_[nMaxtracks_];
  int nhits1D_[nMaxtracks_];
  int nhits2D_[nMaxtracks_];
  int nhitsBPIX_[nMaxtracks_]; 
  int nhitsFPIX_[nMaxtracks_];
  int nhitsTIB_[nMaxtracks_];
  int nhitsTID_[nMaxtracks_];
  int nhitsTOB_[nMaxtracks_];
  int nhitsTEC_[nMaxtracks_];    
  int isHighPurity_[nMaxtracks_];
  double eta_[nMaxtracks_];
  double theta_[nMaxtracks_];
  double phi_[nMaxtracks_];
  double chi2_[nMaxtracks_];
  double chi2ndof_[nMaxtracks_];
  int    charge_[nMaxtracks_];
  double qoverp_[nMaxtracks_];
  double dz_[nMaxtracks_];
  double dxy_[nMaxtracks_];
  double dxyBs_[nMaxtracks_]; 
  double dzBs_[nMaxtracks_];  
  double xPCA_[nMaxtracks_];
  double yPCA_[nMaxtracks_];
  double zPCA_[nMaxtracks_];
  double xUnbiasedVertex_[nMaxtracks_];
  double yUnbiasedVertex_[nMaxtracks_];
  double zUnbiasedVertex_[nMaxtracks_];
  float  chi2normUnbiasedVertex_[nMaxtracks_]; 
  float  chi2UnbiasedVertex_[nMaxtracks_];
  float  chi2ProbUnbiasedVertex_[nMaxtracks_];
  float  DOFUnbiasedVertex_[nMaxtracks_];
  float  sumOfWeightsUnbiasedVertex_[nMaxtracks_];
  int    tracksUsedForVertexing_[nMaxtracks_];
  
  double dxyFromMyVertex_[nMaxtracks_];
  double dzFromMyVertex_[nMaxtracks_];
  double d3DFromMyVertex_[nMaxtracks_];

  double dxyErrorFromMyVertex_[nMaxtracks_];
  double dzErrorFromMyVertex_[nMaxtracks_];
  double d3DErrorFromMyVertex_[nMaxtracks_];

  double IPTsigFromMyVertex_[nMaxtracks_];
  double IPLsigFromMyVertex_[nMaxtracks_];
  double IP3DsigFromMyVertex_[nMaxtracks_];

  int   hasRecVertex_[nMaxtracks_];
  int   isGoodTrack_[nMaxtracks_];

  edm::Service<TFileService> fs;

  TFileDirectory MeanTrendsDir;
  TFileDirectory WidthTrendsDir; 
  TFileDirectory MedianTrendsDir;
  TFileDirectory MADTrendsDir;   
                
  TFileDirectory Mean2DMapsDir;  
  TFileDirectory Width2DMapsDir; 

  // histogram for sanity check
  TH1F* h_etaMax;
  TH1F* h_nbins;
  TH1F* h_nLadders;

  // ---- directly histograms // ===> unbiased residuals
  
  // absolute residuals

  std::vector<TH1F*> a_dxyPhiResiduals;
  std::vector<TH1F*> a_dxyEtaResiduals;

  std::vector<TH1F*> a_dxPhiResiduals;
  std::vector<TH1F*> a_dxEtaResiduals;

  std::vector<TH1F*> a_dyPhiResiduals;
  std::vector<TH1F*> a_dyEtaResiduals;

  std::vector<TH1F*> a_dzPhiResiduals;
  std::vector<TH1F*> a_dzEtaResiduals;
  
  std::vector<TH1F*> a_IP2DPhiResiduals;
  std::vector<TH1F*> a_IP2DEtaResiduals;
  
  std::vector<TH1F*> a_IP3DPhiResiduals;
  std::vector<TH1F*> a_IP3DEtaResiduals;

  std::vector<TH1F*> a_reszPhiResiduals;
  std::vector<TH1F*> a_reszEtaResiduals;

  std::vector<TH1F*> a_d3DPhiResiduals;
  std::vector<TH1F*> a_d3DEtaResiduals;

  // normalized residuals

  std::vector<TH1F*> n_dxyPhiResiduals;
  std::vector<TH1F*> n_dxyEtaResiduals;
  
  std::vector<TH1F*> n_dzPhiResiduals;
  std::vector<TH1F*> n_dzEtaResiduals;
  
  std::vector<TH1F*> n_IP2DPhiResiduals;
  std::vector<TH1F*> n_IP2DEtaResiduals;
  
  std::vector<TH1F*> n_IP3DPhiResiduals;
  std::vector<TH1F*> n_IP3DEtaResiduals;

  std::vector<TH1F*> n_reszPhiResiduals;
  std::vector<TH1F*> n_reszEtaResiduals;

  std::vector<TH1F*> n_d3DPhiResiduals;
  std::vector<TH1F*> n_d3DEtaResiduals;

  // for the maps

  TH1F* a_dxyResidualsMap[nMaxBins_][nMaxBins_];
  TH1F* a_dzResidualsMap[nMaxBins_][nMaxBins_];
  TH1F* a_d3DResidualsMap[nMaxBins_][nMaxBins_];
                                        
  TH1F* n_dxyResidualsMap[nMaxBins_][nMaxBins_];                 
  TH1F* n_dzResidualsMap[nMaxBins_][nMaxBins_];
  TH1F* n_d3DResidualsMap[nMaxBins_][nMaxBins_];
  
  // ---- trends as function of phi and eta
  
  TH1F* a_dxyPhiMeanTrend;
  TH1F* a_dxyPhiWidthTrend;
  TH1F* a_dzPhiMeanTrend;
  TH1F* a_dzPhiWidthTrend;

  TH1F* a_dxyEtaMeanTrend;
  TH1F* a_dxyEtaWidthTrend;
  TH1F* a_dzEtaMeanTrend;
  TH1F* a_dzEtaWidthTrend;

  TH1F* n_dxyPhiMeanTrend;
  TH1F* n_dxyPhiWidthTrend;
  TH1F* n_dzPhiMeanTrend;
  TH1F* n_dzPhiWidthTrend;

  TH1F* n_dxyEtaMeanTrend;
  TH1F* n_dxyEtaWidthTrend;
  TH1F* n_dzEtaMeanTrend;
  TH1F* n_dzEtaWidthTrend;

  // ---- trends as a function of pT
  
  TH1F* a_dxypTMeanTrend;
  TH1F* a_dxypTWidthTrend;
  TH1F* a_dzpTMeanTrend;
  TH1F* a_dzpTWidthTrend;

  TH1F* a_dxypTCentralMeanTrend;
  TH1F* a_dxypTCentralWidthTrend;
  TH1F* a_dzpTCentralMeanTrend;
  TH1F* a_dzpTCentralWidthTrend;

  TH1F* n_dxypTMeanTrend;
  TH1F* n_dxypTWidthTrend;
  TH1F* n_dzpTMeanTrend;
  TH1F* n_dzpTWidthTrend;

  TH1F* n_dxypTCentralMeanTrend;
  TH1F* n_dxypTCentralWidthTrend;
  TH1F* n_dzpTCentralMeanTrend;
  TH1F* n_dzpTCentralWidthTrend;

  // --- trend as a function of the ladder/module number

  TH1F* a_dxymodZMeanTrend;                             
  TH1F* a_dxymodZWidthTrend;                                    
  TH1F* a_dzmodZMeanTrend;                                  
  TH1F* a_dzmodZWidthTrend; 
                                    
  TH1F* a_dxyladderMeanTrend;                                   
  TH1F* a_dxyladderWidthTrend;                                         
  TH1F* a_dzladderMeanTrend;                                        
  TH1F* a_dzladderWidthTrend;  
                                      
  TH1F* n_dxymodZMeanTrend;                                     
  TH1F* n_dxymodZWidthTrend;                                        
  TH1F* n_dzmodZMeanTrend;                                          
  TH1F* n_dzmodZWidthTrend;  
                                    
  TH1F* n_dxyladderMeanTrend;                                   
  TH1F* n_dxyladderWidthTrend;                                  
  TH1F* n_dzladderMeanTrend;                                    
  TH1F* n_dzladderWidthTrend; 

  // ---- medians and MAD

  TH1F* a_dxyPhiMedianTrend;
  TH1F* a_dxyPhiMADTrend;
  TH1F* a_dzPhiMedianTrend;
  TH1F* a_dzPhiMADTrend;

  TH1F* a_dxyEtaMedianTrend;
  TH1F* a_dxyEtaMADTrend;
  TH1F* a_dzEtaMedianTrend;
  TH1F* a_dzEtaMADTrend;

  TH1F* n_dxyPhiMedianTrend;
  TH1F* n_dxyPhiMADTrend;
  TH1F* n_dzPhiMedianTrend;
  TH1F* n_dzPhiMADTrend;

  TH1F* n_dxyEtaMedianTrend;
  TH1F* n_dxyEtaMADTrend;
  TH1F* n_dzEtaMedianTrend;
  TH1F* n_dzEtaMADTrend;

  // 2D residuals
  
  TH2F* a_dxyVsPhi;
  TH2F* a_dzVsPhi;

  TH2F* n_dxyVsPhi;
  TH2F* n_dzVsPhi;

  TH2F* a_dxyVsEta;
  TH2F* a_dzVsEta;

  TH2F* n_dxyVsEta;
  TH2F* n_dzVsEta;

  // 2D maps

  TH2F* a_dxyMeanMap;
  TH2F* a_dzMeanMap;

  TH2F* n_dxyMeanMap;
  TH2F* n_dzMeanMap;

  TH2F* a_dxyWidthMap;
  TH2F* a_dzWidthMap;

  TH2F* n_dxyWidthMap;
  TH2F* n_dzWidthMap;
  
  //
  // ---- directly histograms 
  // biased residuals
  
  // absolute residuals

  std::vector<TH1F*> a_dxyPhiBiasResiduals;
  std::vector<TH1F*> a_dxyEtaBiasResiduals;
  
  std::vector<TH1F*> a_dzPhiBiasResiduals;
  std::vector<TH1F*> a_dzEtaBiasResiduals;
  
  // normalized BiasResiduals

  std::vector<TH1F*> n_dxyPhiBiasResiduals;
  std::vector<TH1F*> n_dxyEtaBiasResiduals;
  
  std::vector<TH1F*> n_dzPhiBiasResiduals;
  std::vector<TH1F*> n_dzEtaBiasResiduals;
  
  // for the maps

  TH1F* a_dxyBiasResidualsMap[nMaxBins_][nMaxBins_];
  TH1F* a_dzBiasResidualsMap[nMaxBins_][nMaxBins_];
                                            
  TH1F* n_dxyBiasResidualsMap[nMaxBins_][nMaxBins_];                 
  TH1F* n_dzBiasResidualsMap[nMaxBins_][nMaxBins_];

  // ---- trends as function of phi / eta
  
  TH1F* a_dxyPhiMeanBiasTrend;
  TH1F* a_dxyPhiWidthBiasTrend;
  TH1F* a_dzPhiMeanBiasTrend;
  TH1F* a_dzPhiWidthBiasTrend;

  TH1F* a_dxyEtaMeanBiasTrend;
  TH1F* a_dxyEtaWidthBiasTrend;
  TH1F* a_dzEtaMeanBiasTrend;
  TH1F* a_dzEtaWidthBiasTrend;

  TH1F* n_dxyPhiMeanBiasTrend;
  TH1F* n_dxyPhiWidthBiasTrend;
  TH1F* n_dzPhiMeanBiasTrend;
  TH1F* n_dzPhiWidthBiasTrend;

  TH1F* n_dxyEtaMeanBiasTrend;
  TH1F* n_dxyEtaWidthBiasTrend;
  TH1F* n_dzEtaMeanBiasTrend;
  TH1F* n_dzEtaWidthBiasTrend;

  // ---- medians and MAD

  TH1F* a_dxyPhiMedianBiasTrend;
  TH1F* a_dxyPhiMADBiasTrend;
  TH1F* a_dzPhiMedianBiasTrend;
  TH1F* a_dzPhiMADBiasTrend;

  TH1F* a_dxyEtaMedianBiasTrend;
  TH1F* a_dxyEtaMADBiasTrend;
  TH1F* a_dzEtaMedianBiasTrend;
  TH1F* a_dzEtaMADBiasTrend;

  TH1F* n_dxyPhiMedianBiasTrend;
  TH1F* n_dxyPhiMADBiasTrend;
  TH1F* n_dzPhiMedianBiasTrend;
  TH1F* n_dzPhiMADBiasTrend;

  TH1F* n_dxyEtaMedianBiasTrend;
  TH1F* n_dxyEtaMADBiasTrend;
  TH1F* n_dzEtaMedianBiasTrend;
  TH1F* n_dzEtaMADBiasTrend;

  // 2D maps

  TH2F* a_dxyMeanBiasMap;
  TH2F* a_dzMeanBiasMap;

  TH2F* n_dxyMeanBiasMap;
  TH2F* n_dzMeanBiasMap;

  TH2F* a_dxyWidthBiasMap;
  TH2F* a_dzWidthBiasMap;

  TH2F* n_dxyWidthBiasMap;
  TH2F* n_dzWidthBiasMap;

  // check event
  TH1F* h_nTracks;
  TH1F* h_nClus;
  TH1F* h_nOfflineVertices;
  TH1F* h_runNumber;
  TH1F* h_lumiFromConfig;
  TH1I* h_runFromConfig;
  TH1I* h_runFromEvent;
  TH1F* h_xOfflineVertex;
  TH1F* h_yOfflineVertex;
  TH1F* h_zOfflineVertex;
  TH1F* h_xErrOfflineVertex;
  TH1F* h_yErrOfflineVertex;
  TH1F* h_zErrOfflineVertex;
  TH1F* h_BSx0;    
  TH1F* h_BSy0;    
  TH1F* h_BSz0;    
  TH1F* h_Beamsigmaz; 
  TH1F* h_BeamWidthX;
  TH1F* h_BeamWidthY;          

  // check probe 

  TH2F* h2_probeEtaPhi_;
  TH2F* h2_probeEtaPt_;

  TH1F* h_probeP_;
  TH1F* h_probePt_;
  TH1F* h_probeEta_;
  TH1F* h_probePhi_;
  TH1F* h_probeChi2_;
  TH1F* h_probeNormChi2_;
  TH1F* h_probeCharge_;
  TH1F* h_probeQoverP_;
  
  TH1F* h_probedzRecoV_;
  TH1F* h_probedxyRecoV_;

  TH1F* h_probedzRefitV_;
  TH1F* h_probedxyRefitV_;

  TH1F* h_probed0RefitV_;
  TH1F* h_probez0RefitV_;

  TH1F* h_probesignIP2DRefitV_;
  TH1F* h_probed3DRefitV_;
  TH1F* h_probereszRefitV_;
  
  TH1F* h_probeRecoVSigZ_;
  TH1F* h_probeRecoVSigXY_;
  TH1F* h_probeRefitVSigZ_;
  TH1F* h_probeRefitVSigXY_;
  TH1F* h_probeRefitVSig3D_;
  TH1F* h_probeRefitVLogSig3D_;
  TH1F* h_probeRefitVSigResZ_;

  TH1F* h_probeHits_;  
  TH1F* h_probeHits1D_; 
  TH1F* h_probeHits2D_; 
  TH1F* h_probeHitsInTIB_;  
  TH1F* h_probeHitsInTOB_;  
  TH1F* h_probeHitsInTID_;  
  TH1F* h_probeHitsInTEC_;  
  TH1F* h_probeHitsInBPIX_; 
  TH1F* h_probeHitsInFPIX_; 

  TH1F* h_probeL1Ladder_;
  TH1F* h_probeL1Module_;
  TH1I* h_probeHasBPixL1Overlap_;  

  // check vertex

  TH1F* h_fitVtxNdof_;
  TH1F* h_fitVtxChi2_;
  TH1F* h_fitVtxNtracks_;  
  TH1F* h_fitVtxChi2ndf_;  
  TH1F* h_fitVtxChi2Prob_; 
  TH1F* h_fitVtxTrackWeights_;
  TH1F* h_fitVtxTrackAverageWeight_;

  TH1F* h_recoVtxNtracks_; 
  TH1F* h_recoVtxChi2ndf_; 
  TH1F* h_recoVtxChi2Prob_;
  TH1F* h_recoVtxSumPt_;   

  std::map<std::string, TH1*> hDA;
  
  // histograms for the plots as function of pT

  std::vector<TH1F*> h_dxy_pT_;
  std::vector<TH1F*> h_dz_pT_;
  std::vector<TH1F*> h_norm_dxy_pT_;
  std::vector<TH1F*> h_norm_dz_pT_;

  std::vector<TH1F*> h_dxy_Central_pT_;
  std::vector<TH1F*> h_dz_Central_pT_;
  std::vector<TH1F*> h_norm_dxy_Central_pT_;
  std::vector<TH1F*> h_norm_dz_Central_pT_;   

  // histograms for the plots as function of module ladder and number

  std::vector<TH1F*> h_dxy_modZ_;
  std::vector<TH1F*> h_dz_modZ_;
  std::vector<TH1F*> h_norm_dxy_modZ_;
  std::vector<TH1F*> h_norm_dz_modZ_;

  std::vector<TH1F*> h_dxy_ladderOverlap_;
  std::vector<TH1F*> h_dxy_ladderNoOverlap_;

  std::vector<TH1F*> h_dxy_ladder_;
  std::vector<TH1F*> h_dz_ladder_;
  std::vector<TH1F*> h_norm_dxy_ladder_;
  std::vector<TH1F*> h_norm_dz_ladder_;   

};

#endif