CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes
PrimaryVertexValidation Class Reference

#include <Alignment/OfflineValidation/plugins/PrimaryVertexValidation.cc>

Inheritance diagram for PrimaryVertexValidation:
edm::one::EDAnalyzer< edm::one::SharedResources > edm::one::EDAnalyzerBase edm::EDConsumerBase

Public Member Functions

 PrimaryVertexValidation (const edm::ParameterSet &)
 
 ~PrimaryVertexValidation () override
 
- Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
 EDAnalyzer ()=default
 
SerialTaskQueue * globalLuminosityBlocksQueue () final
 
SerialTaskQueue * globalRunsQueue () final
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
bool wantsInputProcessBlocks () const final
 
bool wantsProcessBlocks () const final
 
- Public Member Functions inherited from edm::one::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDAnalyzerBase () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase &&)=default
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
std::vector< ESProxyIndex > const & esGetTokenIndicesVector (edm::Transition iTrans) const
 
std::vector< ESRecordIndex > const & esGetTokenRecordIndicesVector (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 

Private Member Functions

void add (std::map< std::string, TH1 * > &h, TH1 *hist)
 
void analyze (const edm::Event &, const edm::EventSetup &) override
 
void beginJob () override
 
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 endJob () override
 
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 fillMap (TH2F *trendMap, TH1F *residualsMapPlot[100][100], PVValHelper::estimator fitPar_, const int nXBins_, const int nYBins_)
 
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 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)
 
std::pair< Measurement1D, Measurement1D > fitResiduals (TH1 *hist)
 
Measurement1D getMAD (TH1F *histo)
 
Measurement1D getMedian (TH1F *histo)
 
std::pair< long long, long long > getRunTime (const edm::EventSetup &iSetup) const
 
std::tuple< std::string, std::string, std::string > getTypeString (PVValHelper::residualType type)
 
std::tuple< std::string, std::string, std::string > getVarString (PVValHelper::plotVariable var)
 
bool hasFirstLayerPixelHits (const reco::TransientTrack &track)
 
bool isBFieldConsistentWithMode (const edm::EventSetup &iSetup) const
 
bool isHit2D (const TrackingRecHit &hit) const
 
bool passesTrackCuts (const reco::Track &track, const reco::Vertex &vertex, const std::string &qualityString_, double dxyErrMax_, double dzErrMax_, double ptErrMax_)
 
std::pair< bool, bool > pixelHitsCheck (const reco::TransientTrack &track)
 
void SetVarToZero ()
 
void shrinkHistVectorToFit (std::vector< TH1F * > &h, unsigned int desired_size)
 
double square (double x)
 

Static Private Member Functions

static bool vtxSort (const reco::Vertex &a, const reco::Vertex &b)
 

Private Attributes

std::vector< TH1F * > a_d3DEtaResiduals
 
std::vector< TH1F * > a_d3DPhiResiduals
 
TH1F * a_d3DResidualsMap [nMaxBins_][nMaxBins_]
 
std::vector< TH1F * > a_dxEtaResiduals
 
std::vector< TH1F * > a_dxPhiResiduals
 
TH1F * a_dxyBiasResidualsMap [nMaxBins_][nMaxBins_]
 
std::vector< TH1F * > a_dxyEtaBiasResiduals
 
TH1F * a_dxyEtaMADBiasTrend
 
TH1F * a_dxyEtaMADTrend
 
TH1F * a_dxyEtaMeanBiasTrend
 
TH1F * a_dxyEtaMeanTrend
 
TH1F * a_dxyEtaMedianBiasTrend
 
TH1F * a_dxyEtaMedianTrend
 
std::vector< TH1F * > a_dxyEtaResiduals
 
TH1F * a_dxyEtaWidthBiasTrend
 
TH1F * a_dxyEtaWidthTrend
 
TH2F * a_dxyL1MeanMap
 
TH1F * a_dxyL1ResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * a_dxyL1WidthMap
 
TH1F * a_dxyladderMeanTrend
 
TH1F * a_dxyladderWidthTrend
 
TH2F * a_dxyMeanBiasMap
 
TH2F * a_dxyMeanMap
 
TH1F * a_dxymodZMeanTrend
 
TH1F * a_dxymodZWidthTrend
 
std::vector< TH1F * > a_dxyPhiBiasResiduals
 
TH1F * a_dxyPhiMADBiasTrend
 
TH1F * a_dxyPhiMADTrend
 
TH1F * a_dxyPhiMeanBiasTrend
 
TH1F * a_dxyPhiMeanTrend
 
TH1F * a_dxyPhiMedianBiasTrend
 
TH1F * a_dxyPhiMedianTrend
 
std::vector< TH1F * > a_dxyPhiResiduals
 
TH1F * a_dxyPhiWidthBiasTrend
 
TH1F * a_dxyPhiWidthTrend
 
TH1F * a_dxypTCentralMeanTrend
 
TH1F * a_dxypTCentralWidthTrend
 
TH1F * a_dxypTMeanTrend
 
TH1F * a_dxypTWidthTrend
 
TH1F * a_dxyResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * a_dxyVsEta
 
TH2F * a_dxyVsPhi
 
TH2F * a_dxyWidthBiasMap
 
TH2F * a_dxyWidthMap
 
std::vector< TH1F * > a_dyEtaResiduals
 
std::vector< TH1F * > a_dyPhiResiduals
 
TH1F * a_dzBiasResidualsMap [nMaxBins_][nMaxBins_]
 
std::vector< TH1F * > a_dzEtaBiasResiduals
 
TH1F * a_dzEtaMADBiasTrend
 
TH1F * a_dzEtaMADTrend
 
TH1F * a_dzEtaMeanBiasTrend
 
TH1F * a_dzEtaMeanTrend
 
TH1F * a_dzEtaMedianBiasTrend
 
TH1F * a_dzEtaMedianTrend
 
std::vector< TH1F * > a_dzEtaResiduals
 
TH1F * a_dzEtaWidthBiasTrend
 
TH1F * a_dzEtaWidthTrend
 
TH2F * a_dzL1MeanMap
 
TH1F * a_dzL1ResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * a_dzL1WidthMap
 
TH1F * a_dzladderMeanTrend
 
TH1F * a_dzladderWidthTrend
 
TH2F * a_dzMeanBiasMap
 
TH2F * a_dzMeanMap
 
TH1F * a_dzmodZMeanTrend
 
TH1F * a_dzmodZWidthTrend
 
std::vector< TH1F * > a_dzPhiBiasResiduals
 
TH1F * a_dzPhiMADBiasTrend
 
TH1F * a_dzPhiMADTrend
 
TH1F * a_dzPhiMeanBiasTrend
 
TH1F * a_dzPhiMeanTrend
 
TH1F * a_dzPhiMedianBiasTrend
 
TH1F * a_dzPhiMedianTrend
 
std::vector< TH1F * > a_dzPhiResiduals
 
TH1F * a_dzPhiWidthBiasTrend
 
TH1F * a_dzPhiWidthTrend
 
TH1F * a_dzpTCentralMeanTrend
 
TH1F * a_dzpTCentralWidthTrend
 
TH1F * a_dzpTMeanTrend
 
TH1F * a_dzpTWidthTrend
 
TH1F * a_dzResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * a_dzVsEta
 
TH2F * a_dzVsPhi
 
TH2F * a_dzWidthBiasMap
 
TH2F * a_dzWidthMap
 
std::vector< TH1F * > a_IP2DEtaResiduals
 
std::vector< TH1F * > a_IP2DPhiResiduals
 
std::vector< TH1F * > a_IP3DEtaResiduals
 
std::vector< TH1F * > a_IP3DPhiResiduals
 
std::vector< TH1F * > a_reszEtaResiduals
 
std::vector< TH1F * > a_reszPhiResiduals
 
bool askFirstLayerHit_
 
double Beamdxdz_
 
double Beamsigmaz_
 
double BeamWidthX_
 
double BeamWidthY_
 
double BSx0_
 
double BSy0_
 
double BSz0_
 
int charge_ [nMaxtracks_]
 
double chi2_ [nMaxtracks_]
 
double chi2ndof_ [nMaxtracks_]
 
float chi2normUnbiasedVertex_ [nMaxtracks_]
 
float chi2ProbUnbiasedVertex_ [nMaxtracks_]
 
float chi2UnbiasedVertex_ [nMaxtracks_]
 
const int compressionSettings_
 
double d3DErrorFromMyVertex_ [nMaxtracks_]
 
double d3DFromMyVertex_ [nMaxtracks_]
 
bool debug_
 
bool doBPix_
 
bool doFPix_
 
float DOFUnbiasedVertex_ [nMaxtracks_]
 
double dxy_ [nMaxtracks_]
 
double dxyBs_ [nMaxtracks_]
 
double dxyErrorFromMyVertex_ [nMaxtracks_]
 
double dxyFromMyVertex_ [nMaxtracks_]
 
double dz_ [nMaxtracks_]
 
double dzBs_ [nMaxtracks_]
 
double dzErrorFromMyVertex_ [nMaxtracks_]
 
double dzFromMyVertex_ [nMaxtracks_]
 
double eta_ [nMaxtracks_]
 
double etaOfProbe_
 
unsigned int EventNumber_
 
bool forceBeamSpotContraint_
 
edm::Service< TFileService > fs
 
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomToken_
 
TH2F * h2_probeEtaPhi_
 
TH2F * h2_probeEtaPt_
 
TH2F * h2_probeLayer1Map_
 
TH2F * h2_probePassingLayer1Map_
 
TH1F * h_Beamsigmaz
 
TH1F * h_BeamWidthX
 
TH1F * h_BeamWidthY
 
TH1F * h_BSx0
 
TH1F * h_BSy0
 
TH1F * h_BSz0
 
std::vector< TH1F * > h_dxy_Central_pT_
 
std::vector< TH1F * > h_dxy_ladder_
 
std::vector< TH1F * > h_dxy_ladderNoOverlap_
 
std::vector< TH1F * > h_dxy_ladderOverlap_
 
std::vector< TH1F * > h_dxy_modZ_
 
std::vector< TH1F * > h_dxy_pT_
 
std::vector< TH1F * > h_dz_Central_pT_
 
std::vector< TH1F * > h_dz_ladder_
 
std::vector< TH1F * > h_dz_modZ_
 
std::vector< TH1F * > h_dz_pT_
 
TH1F * h_etaMax
 
TH1F * h_fitVtxChi2_
 
TH1F * h_fitVtxChi2ndf_
 
TH1F * h_fitVtxChi2Prob_
 
TH1F * h_fitVtxNdof_
 
TH1F * h_fitVtxNtracks_
 
TH1F * h_fitVtxTrackAverageWeight_
 
TH1F * h_fitVtxTrackWeights_
 
TH1F * h_lumiFromConfig
 
TH1F * h_nbins
 
TH1F * h_nClus
 
TH1F * h_nLadders
 
TH1F * h_nOfflineVertices
 
std::vector< TH1F * > h_norm_dxy_Central_pT_
 
std::vector< TH1F * > h_norm_dxy_ladder_
 
std::vector< TH1F * > h_norm_dxy_modZ_
 
std::vector< TH1F * > h_norm_dxy_pT_
 
std::vector< TH1F * > h_norm_dz_Central_pT_
 
std::vector< TH1F * > h_norm_dz_ladder_
 
std::vector< TH1F * > h_norm_dz_modZ_
 
std::vector< TH1F * > h_norm_dz_pT_
 
TH1F * h_nTracks
 
TH1F * h_probeCharge_
 
TH1F * h_probeChi2_
 
TH1F * h_probed0RefitV_
 
TH1F * h_probed3DRefitV_
 
TH1F * h_probedxyRecoV_
 
TH1F * h_probedxyRefitV_
 
TH1F * h_probedzRecoV_
 
TH1F * h_probedzRefitV_
 
TH1F * h_probeEta_
 
TH1I * h_probeHasBPixL1Overlap_
 
TH1F * h_probeHits1D_
 
TH1F * h_probeHits2D_
 
TH1F * h_probeHits_
 
TH1F * h_probeHitsInBPIX_
 
TH1F * h_probeHitsInFPIX_
 
TH1F * h_probeHitsInTEC_
 
TH1F * h_probeHitsInTIB_
 
TH1F * h_probeHitsInTID_
 
TH1F * h_probeHitsInTOB_
 
TH1F * h_probeL1ClusterProb_
 
TH1F * h_probeL1Ladder_
 
TH1F * h_probeL1Module_
 
TH1F * h_probeNormChi2_
 
TH1F * h_probeP_
 
TH1F * h_probePhi_
 
TH1F * h_probePt_
 
TH1F * h_probePtRebin_
 
TH1F * h_probeQoverP_
 
TH1F * h_probeRecoVSigXY_
 
TH1F * h_probeRecoVSigZ_
 
TH1F * h_probeRefitVLogSig3D_
 
TH1F * h_probeRefitVSig3D_
 
TH1F * h_probeRefitVSigResZ_
 
TH1F * h_probeRefitVSigXY_
 
TH1F * h_probeRefitVSigZ_
 
TH1F * h_probereszRefitV_
 
TH1F * h_probesignIP2DRefitV_
 
TH1F * h_probez0RefitV_
 
TH1F * h_pTinfo
 
TH1F * h_recoVtxChi2ndf_
 
TH1F * h_recoVtxChi2Prob_
 
TH1F * h_recoVtxNtracks_
 
TH1F * h_recoVtxSumPt_
 
TH1I * h_runEndTimes
 
TH1I * h_runFromConfig
 
TH1I * h_runFromEvent
 
TH1F * h_runNumber
 
TH1I * h_runStartTimes
 
TH1F * h_xErrOfflineVertex
 
TH1F * h_xOfflineVertex
 
TH1F * h_yErrOfflineVertex
 
TH1F * h_yOfflineVertex
 
TH1F * h_zErrOfflineVertex
 
TH1F * h_zOfflineVertex
 
int hasRecVertex_ [nMaxtracks_]
 
std::map< std::string, TH1 * > hDA
 
double intLumi_
 
double IP3DsigFromMyVertex_ [nMaxtracks_]
 
double IPLsigFromMyVertex_ [nMaxtracks_]
 
double IPTsigFromMyVertex_ [nMaxtracks_]
 
int isGoodTrack_ [nMaxtracks_]
 
int isHighPurity_ [nMaxtracks_]
 
bool isPhase1_
 
bool lightNtupleSwitch_
 
unsigned int LuminosityBlockNumber_
 
TFileDirectory MADTrendsDir
 
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
 
const double maxPt_
 
TFileDirectory Mean2DMapsDir
 
TFileDirectory MeanTrendsDir
 
TFileDirectory MedianTrendsDir
 
const double minPt_
 
std::array< float, nPtBins_+1 > mypT_bins_
 
std::vector< TH1F * > n_d3DEtaResiduals
 
std::vector< TH1F * > n_d3DPhiResiduals
 
TH1F * n_d3DResidualsMap [nMaxBins_][nMaxBins_]
 
TH1F * n_dxyBiasResidualsMap [nMaxBins_][nMaxBins_]
 
std::vector< TH1F * > n_dxyEtaBiasResiduals
 
TH1F * n_dxyEtaMADBiasTrend
 
TH1F * n_dxyEtaMADTrend
 
TH1F * n_dxyEtaMeanBiasTrend
 
TH1F * n_dxyEtaMeanTrend
 
TH1F * n_dxyEtaMedianBiasTrend
 
TH1F * n_dxyEtaMedianTrend
 
std::vector< TH1F * > n_dxyEtaResiduals
 
TH1F * n_dxyEtaWidthBiasTrend
 
TH1F * n_dxyEtaWidthTrend
 
TH2F * n_dxyL1MeanMap
 
TH1F * n_dxyL1ResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * n_dxyL1WidthMap
 
TH1F * n_dxyladderMeanTrend
 
TH1F * n_dxyladderWidthTrend
 
TH2F * n_dxyMeanBiasMap
 
TH2F * n_dxyMeanMap
 
TH1F * n_dxymodZMeanTrend
 
TH1F * n_dxymodZWidthTrend
 
std::vector< TH1F * > n_dxyPhiBiasResiduals
 
TH1F * n_dxyPhiMADBiasTrend
 
TH1F * n_dxyPhiMADTrend
 
TH1F * n_dxyPhiMeanBiasTrend
 
TH1F * n_dxyPhiMeanTrend
 
TH1F * n_dxyPhiMedianBiasTrend
 
TH1F * n_dxyPhiMedianTrend
 
std::vector< TH1F * > n_dxyPhiResiduals
 
TH1F * n_dxyPhiWidthBiasTrend
 
TH1F * n_dxyPhiWidthTrend
 
TH1F * n_dxypTCentralMeanTrend
 
TH1F * n_dxypTCentralWidthTrend
 
TH1F * n_dxypTMeanTrend
 
TH1F * n_dxypTWidthTrend
 
TH1F * n_dxyResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * n_dxyVsEta
 
TH2F * n_dxyVsPhi
 
TH2F * n_dxyWidthBiasMap
 
TH2F * n_dxyWidthMap
 
TH1F * n_dzBiasResidualsMap [nMaxBins_][nMaxBins_]
 
std::vector< TH1F * > n_dzEtaBiasResiduals
 
TH1F * n_dzEtaMADBiasTrend
 
TH1F * n_dzEtaMADTrend
 
TH1F * n_dzEtaMeanBiasTrend
 
TH1F * n_dzEtaMeanTrend
 
TH1F * n_dzEtaMedianBiasTrend
 
TH1F * n_dzEtaMedianTrend
 
std::vector< TH1F * > n_dzEtaResiduals
 
TH1F * n_dzEtaWidthBiasTrend
 
TH1F * n_dzEtaWidthTrend
 
TH2F * n_dzL1MeanMap
 
TH1F * n_dzL1ResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * n_dzL1WidthMap
 
TH1F * n_dzladderMeanTrend
 
TH1F * n_dzladderWidthTrend
 
TH2F * n_dzMeanBiasMap
 
TH2F * n_dzMeanMap
 
TH1F * n_dzmodZMeanTrend
 
TH1F * n_dzmodZWidthTrend
 
std::vector< TH1F * > n_dzPhiBiasResiduals
 
TH1F * n_dzPhiMADBiasTrend
 
TH1F * n_dzPhiMADTrend
 
TH1F * n_dzPhiMeanBiasTrend
 
TH1F * n_dzPhiMeanTrend
 
TH1F * n_dzPhiMedianBiasTrend
 
TH1F * n_dzPhiMedianTrend
 
std::vector< TH1F * > n_dzPhiResiduals
 
TH1F * n_dzPhiWidthBiasTrend
 
TH1F * n_dzPhiWidthTrend
 
TH1F * n_dzpTCentralMeanTrend
 
TH1F * n_dzpTCentralWidthTrend
 
TH1F * n_dzpTMeanTrend
 
TH1F * n_dzpTWidthTrend
 
TH1F * n_dzResidualsMap [nMaxBins_][nMaxBins_]
 
TH2F * n_dzVsEta
 
TH2F * n_dzVsPhi
 
TH2F * n_dzWidthBiasMap
 
TH2F * n_dzWidthMap
 
std::vector< TH1F * > n_IP2DEtaResiduals
 
std::vector< TH1F * > n_IP2DPhiResiduals
 
std::vector< TH1F * > n_IP3DEtaResiduals
 
std::vector< TH1F * > n_IP3DPhiResiduals
 
std::vector< TH1F * > n_reszEtaResiduals
 
std::vector< TH1F * > n_reszPhiResiduals
 
int nBins_
 
int nClus_
 
int Nevt_
 
int nhits1D_ [nMaxtracks_]
 
int nhits2D_ [nMaxtracks_]
 
int nhits_ [nMaxtracks_]
 
int nhitsBPIX_ [nMaxtracks_]
 
int nhitsFPIX_ [nMaxtracks_]
 
double nHitsOfProbe_
 
int nhitsTEC_ [nMaxtracks_]
 
int nhitsTIB_ [nMaxtracks_]
 
int nhitsTID_ [nMaxtracks_]
 
int nhitsTOB_ [nMaxtracks_]
 
unsigned int nLadders_ = 20
 
unsigned int nModZ_ = 8
 
int nOfflineVertices_
 
int nTracks_
 
int nTracksPerClus_
 
double p_ [nMaxtracks_]
 
double phi_ [nMaxtracks_]
 
double pOfProbe_
 
double pt_ [nMaxtracks_]
 
double ptOfProbe_
 
double qoverp_ [nMaxtracks_]
 
TTree * rootTree_
 
bool runControl_
 
std::vector< unsigned int > runControlNumbers_
 
const edm::ESGetToken< RunInfo, RunInfoRcd > runInfoToken_
 
unsigned int RunNumber_
 
std::map< unsigned int, std::pair< long long, long long > > runNumbersTimesLog_
 
bool storeNtuple_
 
float sumOfWeightsUnbiasedVertex_ [nMaxtracks_]
 
edm::EDGetTokenT< reco::BeamSpot > theBeamspotToken
 
PVValHelper::histodetails theDetails_
 
double theta_ [nMaxtracks_]
 
std::unique_ptr< TrackClusterizerInZ > theTrackClusterizer_
 
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken
 
std::unique_ptr< TrackFilterForPVFindingBase > theTrackFilter_
 
edm::EDGetTokenT< reco::VertexCollection > theVertexCollectionToken
 
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > topoToken_
 
const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > trackingGeomToken_
 
int tracksUsedForVertexing_ [nMaxtracks_]
 
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > ttkToken_
 
bool useTracksFromRecoVtx_
 
double vertexZMax_
 
TFileDirectory Width2DMapsDir
 
TFileDirectory WidthTrendsDir
 
double wxy2_
 
double xErrOfflineVertex_
 
double xOfflineVertex_
 
double xPCA_ [nMaxtracks_]
 
double xUnbiasedVertex_ [nMaxtracks_]
 
double yErrOfflineVertex_
 
double yOfflineVertex_
 
double yPCA_ [nMaxtracks_]
 
double yUnbiasedVertex_ [nMaxtracks_]
 
double zErrOfflineVertex_
 
double zOfflineVertex_
 
double zPCA_ [nMaxtracks_]
 
double zUnbiasedVertex_ [nMaxtracks_]
 

Static Private Attributes

static const int cmToum = 10000
 
static const int nMaxBins_ = 100
 
static const int nMaxtracks_ = 1000
 
static const int nPtBins_ = 48
 

Additional Inherited Members

- Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B > consumes (edm::InputTag tag) noexcept
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes () noexcept
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag) noexcept
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 

Detailed Description

Description: Validate alignment constants using unbiased vertex residuals

Implementation: <Notes on="" implementation>="">

Definition at line 74 of file PrimaryVertexValidation.h.

Constructor & Destructor Documentation

◆ PrimaryVertexValidation()

PrimaryVertexValidation::PrimaryVertexValidation ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 66 of file PrimaryVertexValidation.cc.

67  : magFieldToken_(esConsumes<MagneticField, IdealMagneticFieldRecord>()),
68  trackingGeomToken_(esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>()),
69  geomToken_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()),
70  ttkToken_(esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))),
71  topoToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>()),
72  runInfoToken_(esConsumes<RunInfo, RunInfoRcd>()),
73  compressionSettings_(iConfig.getUntrackedParameter<int>("compressionSettings", -1)),
74  storeNtuple_(iConfig.getParameter<bool>("storeNtuple")),
75  lightNtupleSwitch_(iConfig.getParameter<bool>("isLightNtuple")),
76  useTracksFromRecoVtx_(iConfig.getParameter<bool>("useTracksFromRecoVtx")),
77  vertexZMax_(iConfig.getUntrackedParameter<double>("vertexZMax", 99.)),
78  intLumi_(iConfig.getUntrackedParameter<double>("intLumi", 0.)),
79  askFirstLayerHit_(iConfig.getParameter<bool>("askFirstLayerHit")),
80  doBPix_(iConfig.getUntrackedParameter<bool>("doBPix", true)),
81  doFPix_(iConfig.getUntrackedParameter<bool>("doFPix", true)),
82  ptOfProbe_(iConfig.getUntrackedParameter<double>("probePt", 0.)),
83  pOfProbe_(iConfig.getUntrackedParameter<double>("probeP", 0.)),
84  etaOfProbe_(iConfig.getUntrackedParameter<double>("probeEta", 2.4)),
85  nHitsOfProbe_(iConfig.getUntrackedParameter<double>("probeNHits", 0.)),
86  nBins_(iConfig.getUntrackedParameter<int>("numberOfBins", 24)),
87  minPt_(iConfig.getUntrackedParameter<double>("minPt", 1.)),
88  maxPt_(iConfig.getUntrackedParameter<double>("maxPt", 20.)),
89  debug_(iConfig.getParameter<bool>("Debug")),
90  runControl_(iConfig.getUntrackedParameter<bool>("runControl", false)),
91  forceBeamSpotContraint_(iConfig.getUntrackedParameter<bool>("forceBeamSpot", false)) {
92  // now do what ever initialization is needed
93  // initialize phase space boundaries
94 
95  usesResource(TFileService::kSharedResource);
96 
97  std::vector<unsigned int> defaultRuns;
98  defaultRuns.push_back(0);
99  runControlNumbers_ = iConfig.getUntrackedParameter<std::vector<unsigned int>>("runControlNumber", defaultRuns);
100 
101  edm::InputTag TrackCollectionTag_ = iConfig.getParameter<edm::InputTag>("TrackCollectionTag");
102  theTrackCollectionToken = consumes<reco::TrackCollection>(TrackCollectionTag_);
103 
104  edm::InputTag VertexCollectionTag_ = iConfig.getParameter<edm::InputTag>("VertexCollectionTag");
105  theVertexCollectionToken = consumes<reco::VertexCollection>(VertexCollectionTag_);
106 
107  edm::InputTag BeamspotTag_ = iConfig.getParameter<edm::InputTag>("BeamSpotTag");
108  theBeamspotToken = consumes<reco::BeamSpot>(BeamspotTag_);
109 
110  // select and configure the track filter
111  theTrackFilter_ =
112  std::make_unique<TrackFilterForPVFinding>(iConfig.getParameter<edm::ParameterSet>("TkFilterParameters"));
113  // select and configure the track clusterizer
114  std::string clusteringAlgorithm =
115  iConfig.getParameter<edm::ParameterSet>("TkClusParameters").getParameter<std::string>("algorithm");
116  if (clusteringAlgorithm == "gap") {
117  theTrackClusterizer_ =
118  std::make_unique<GapClusterizerInZ>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
119  .getParameter<edm::ParameterSet>("TkGapClusParameters"));
120  } else if (clusteringAlgorithm == "DA") {
121  theTrackClusterizer_ =
122  std::make_unique<DAClusterizerInZ>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
123  .getParameter<edm::ParameterSet>("TkDAClusParameters"));
124  // provide the vectorized version of the clusterizer, if supported by the build
125  } else if (clusteringAlgorithm == "DA_vect") {
126  theTrackClusterizer_ =
127  std::make_unique<DAClusterizerInZ_vect>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
128  .getParameter<edm::ParameterSet>("TkDAClusParameters"));
129  } else {
130  throw VertexException("PrimaryVertexProducerAlgorithm: unknown clustering algorithm: " + clusteringAlgorithm);
131  }
132 
133  theDetails_.histobins = 500;
134  theDetails_.setMap(PVValHelper::dxy, PVValHelper::phi, -2000., 2000.);
135  theDetails_.setMap(PVValHelper::dxy, PVValHelper::eta, -3000., 3000.);
136  theDetails_.setMap(PVValHelper::dxy, PVValHelper::pT, -1000., 1000.);
137  theDetails_.setMap(PVValHelper::dxy, PVValHelper::pTCentral, -1000., 1000.);
138  theDetails_.setMap(PVValHelper::dxy, PVValHelper::ladder, -1000., 1000.);
139  theDetails_.setMap(PVValHelper::dxy, PVValHelper::modZ, -1000., 1000.);
140 
141  for (int i = PVValHelper::phi; i < PVValHelper::END_OF_PLOTS; i++) {
142  for (int j = PVValHelper::dx; j < PVValHelper::END_OF_TYPES; j++) {
143  auto plot_index = static_cast<PVValHelper::plotVariable>(i);
144  auto res_index = static_cast<PVValHelper::residualType>(j);
145 
146  if (debug_) {
147  edm::LogInfo("PrimaryVertexValidation")
148  << "==> " << std::get<0>(PVValHelper::getTypeString(res_index)) << " " << std::setw(10)
149  << std::get<0>(PVValHelper::getVarString(plot_index)) << std::endl;
150  }
151  if (res_index != PVValHelper::d3D && res_index != PVValHelper::norm_d3D)
152  theDetails_.setMap(res_index,
153  plot_index,
154  theDetails_.getLow(PVValHelper::dxy, plot_index),
155  theDetails_.getHigh(PVValHelper::dxy, plot_index));
156  else
157  theDetails_.setMap(res_index, plot_index, 0., theDetails_.getHigh(PVValHelper::dxy, plot_index));
158  }
159  }
160 
161  edm::LogVerbatim("PrimaryVertexValidation") << "######################################";
162  for (const auto& it : theDetails_.range) {
163  edm::LogVerbatim("PrimaryVertexValidation")
164  << "|" << std::setw(10) << std::get<0>(PVValHelper::getTypeString(it.first.first)) << "|" << std::setw(10)
165  << std::get<0>(PVValHelper::getVarString(it.first.second)) << "| (" << std::setw(5) << it.second.first << ";"
166  << std::setw(5) << it.second.second << ") |" << std::endl;
167  }
168 
169  theDetails_.trendbins[PVValHelper::phi] = PVValHelper::generateBins(nBins_ + 1, -180., 360.);
170  theDetails_.trendbins[PVValHelper::eta] = PVValHelper::generateBins(nBins_ + 1, -etaOfProbe_, 2 * etaOfProbe_);
171 
172  if (debug_) {
173  edm::LogVerbatim("PrimaryVertexValidation") << "etaBins: ";
174  for (auto ieta : theDetails_.trendbins[PVValHelper::eta]) {
175  edm::LogVerbatim("PrimaryVertexValidation") << ieta << " ";
176  }
177  edm::LogVerbatim("PrimaryVertexValidation") << "\n";
178 
179  edm::LogVerbatim("PrimaryVertexValidation") << "phiBins: ";
180  for (auto iphi : theDetails_.trendbins[PVValHelper::phi]) {
181  edm::LogVerbatim("PrimaryVertexValidation") << iphi << " ";
182  }
183  edm::LogVerbatim("PrimaryVertexValidation") << "\n";
184  }
185 
186  // create the bins of the pT-binned distributions
187 
188  mypT_bins_ = PVValHelper::makeLogBins<float, nPtBins_>(minPt_, maxPt_);
189 
190  std::string toOutput = "";
191  for (auto ptbin : mypT_bins_) {
192  toOutput += " ";
193  toOutput += std::to_string(ptbin);
194  toOutput += ",";
195  }
196 
197  edm::LogVerbatim("PrimaryVertexValidation") << "######################################\n";
198  edm::LogVerbatim("PrimaryVertexValidation") << "The pT binning is: [" << toOutput << "] \n";
199 }

References PVValHelper::d3D, debug_, PVValHelper::dx, PVValHelper::dxy, PVValHelper::END_OF_PLOTS, PVValHelper::END_OF_TYPES, PVValHelper::eta, etaOfProbe_, PVValHelper::generateBins(), PVValHelper::histodetails::getHigh(), PVValHelper::histodetails::getLow(), edm::ParameterSet::getParameter(), PVValHelper::getTypeString(), edm::ParameterSet::getUntrackedParameter(), PVValHelper::getVarString(), PVValHelper::histodetails::histobins, mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, dqmiolumiharvest::j, TFileService::kSharedResource, PVValHelper::ladder, maxPt_, minPt_, PVValHelper::modZ, mypT_bins_, nBins_, PVValHelper::norm_d3D, PVValHelper::phi, PVValHelper::pT, PVValHelper::pTCentral, PVValHelper::histodetails::range, runControlNumbers_, PVValHelper::histodetails::setMap(), AlCaHLTBitMon_QueryRunRegistry::string, theBeamspotToken, theDetails_, theTrackClusterizer_, theTrackCollectionToken, theTrackFilter_, theVertexCollectionToken, and PVValHelper::histodetails::trendbins.

◆ ~PrimaryVertexValidation()

PrimaryVertexValidation::~PrimaryVertexValidation ( )
override

Definition at line 202 of file PrimaryVertexValidation.cc.

202  {
203  // do anything here that needs to be done at desctruction time
204  // (e.g. close files, deallocate resources etc.)
205 }

Member Function Documentation

◆ add()

void PrimaryVertexValidation::add ( std::map< std::string, TH1 * > &  h,
TH1 *  hist 
)
private

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

◆ analyze()

void PrimaryVertexValidation::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 212 of file PrimaryVertexValidation.cc.

212  {
213  using namespace std;
214  using namespace reco;
215  using namespace IPTools;
216 
217  if (!isBFieldConsistentWithMode(iSetup)) {
218  edm::LogWarning("PrimaryVertexValidation")
219  << "*********************************************************************************\n"
220  << "* The configuration (ptOfProbe > " << ptOfProbe_
221  << "GeV) is not correctly set for current value of magnetic field \n"
222  << "* Switching it to 0. !!! \n"
223  << "*********************************************************************************" << std::endl;
224  ptOfProbe_ = 0.;
225  }
226 
227  if (nBins_ != 24 && debug_) {
228  edm::LogInfo("PrimaryVertexValidation") << "Using: " << nBins_ << " bins plots";
229  }
230 
231  bool passesRunControl = false;
232 
233  if (runControl_) {
234  for (const auto& runControlNumber : runControlNumbers_) {
235  if (iEvent.eventAuxiliary().run() == runControlNumber) {
236  if (debug_) {
237  edm::LogInfo("PrimaryVertexValidation")
238  << " run number: " << iEvent.eventAuxiliary().run() << " keeping run:" << runControlNumber;
239  }
240  passesRunControl = true;
241  break;
242  }
243  }
244  if (!passesRunControl)
245  return;
246  }
247 
248  Nevt_++;
249 
250  //=======================================================
251  // Initialize Root-tuple variables
252  //=======================================================
253 
254  SetVarToZero();
255 
256  //=======================================================
257  // Retrieve the Magnetic Field information
258  //=======================================================
259 
260  edm::ESHandle<MagneticField> theMGField = iSetup.getHandle(magFieldToken_);
261 
262  //=======================================================
263  // Retrieve the Tracking Geometry information
264  //=======================================================
265 
266  edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry = iSetup.getHandle(trackingGeomToken_);
267 
268  //=======================================================
269  // Retrieve geometry information
270  //=======================================================
271 
272  edm::LogInfo("read tracker geometry...");
273  edm::ESHandle<TrackerGeometry> pDD = iSetup.getHandle(geomToken_);
274  edm::LogInfo("tracker geometry read") << "There are: " << pDD->dets().size() << " detectors";
275 
276  // switch on the phase1
277  if ((pDD->isThere(GeomDetEnumerators::P1PXB)) || (pDD->isThere(GeomDetEnumerators::P1PXEC))) {
278  isPhase1_ = true;
279  nLadders_ = 12;
280 
281  if (h_dxy_ladderOverlap_.size() != nLadders_) {
282  PVValHelper::shrinkHistVectorToFit(h_dxy_ladderOverlap_, nLadders_);
283  PVValHelper::shrinkHistVectorToFit(h_dxy_ladderNoOverlap_, nLadders_);
284  PVValHelper::shrinkHistVectorToFit(h_dxy_ladder_, nLadders_);
285  PVValHelper::shrinkHistVectorToFit(h_dz_ladder_, nLadders_);
286  PVValHelper::shrinkHistVectorToFit(h_norm_dxy_ladder_, nLadders_);
287  PVValHelper::shrinkHistVectorToFit(h_norm_dz_ladder_, nLadders_);
288 
289  if (debug_) {
290  edm::LogInfo("PrimaryVertexValidation") << "checking size:" << h_dxy_ladder_.size() << std::endl;
291  }
292  }
293 
294  if (debug_) {
295  edm::LogInfo("PrimaryVertexValidation") << " pixel phase1 setup, nLadders: " << nLadders_;
296  }
297 
298  } else {
299  isPhase1_ = false;
300  nLadders_ = 20;
301  if (debug_) {
302  edm::LogInfo("PrimaryVertexValidation") << " pixel phase0 setup, nLadders: " << nLadders_;
303  }
304  }
305 
306  if (isPhase1_) {
307  etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase1);
308  } else {
309  etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase0);
310  }
311 
312  if (h_etaMax->GetEntries() == 0.) {
313  h_etaMax->SetBinContent(1., etaOfProbe_);
314  h_nbins->SetBinContent(1., nBins_);
315  h_nLadders->SetBinContent(1., nLadders_);
316  h_pTinfo->SetBinContent(1., mypT_bins_.size());
317  h_pTinfo->SetBinContent(2., minPt_);
318  h_pTinfo->SetBinContent(3., maxPt_);
319  }
320 
321  //=======================================================
322  // Retrieve the Transient Track Builder information
323  //=======================================================
324 
325  edm::ESHandle<TransientTrackBuilder> theB_ = iSetup.getHandle(ttkToken_);
326  double fBfield_ = ((*theB_).field()->inTesla(GlobalPoint(0., 0., 0.))).z();
327 
328  //=======================================================
329  // Retrieve the Track information
330  //=======================================================
331 
332  edm::Handle<TrackCollection> trackCollectionHandle;
333  iEvent.getByToken(theTrackCollectionToken, trackCollectionHandle);
334  if (!trackCollectionHandle.isValid())
335  return;
336  auto const& tracks = *trackCollectionHandle;
337 
338  //=======================================================
339  // Retrieve tracker topology from geometry
340  //=======================================================
341 
342  edm::ESHandle<TrackerTopology> tTopoHandle = iSetup.getHandle(topoToken_);
343  const TrackerTopology* const tTopo = tTopoHandle.product();
344 
345  //=======================================================
346  // Retrieve offline vartex information (only for reco)
347  //=======================================================
348 
349  //edm::Handle<VertexCollection> vertices;
350  edm::Handle<std::vector<Vertex>> vertices;
351 
352  try {
353  iEvent.getByToken(theVertexCollectionToken, vertices);
354  } catch (cms::Exception& er) {
355  LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
356  }
357 
358  std::vector<Vertex> vsorted = *(vertices);
359  // sort the vertices by number of tracks in descending order
360  // use chi2 as tiebreaker
361  std::sort(vsorted.begin(), vsorted.end(), PrimaryVertexValidation::vtxSort);
362 
363  // skip events with no PV, this should not happen
364 
365  if (vsorted.empty())
366  return;
367 
368  // skip events failing vertex cut
369  if (std::abs(vsorted[0].z()) > vertexZMax_)
370  return;
371 
372  if (vsorted[0].isValid()) {
373  xOfflineVertex_ = (vsorted)[0].x();
374  yOfflineVertex_ = (vsorted)[0].y();
375  zOfflineVertex_ = (vsorted)[0].z();
376 
377  xErrOfflineVertex_ = (vsorted)[0].xError();
378  yErrOfflineVertex_ = (vsorted)[0].yError();
379  zErrOfflineVertex_ = (vsorted)[0].zError();
380  }
381 
382  h_xOfflineVertex->Fill(xOfflineVertex_);
383  h_yOfflineVertex->Fill(yOfflineVertex_);
384  h_zOfflineVertex->Fill(zOfflineVertex_);
385  h_xErrOfflineVertex->Fill(xErrOfflineVertex_);
386  h_yErrOfflineVertex->Fill(yErrOfflineVertex_);
387  h_zErrOfflineVertex->Fill(zErrOfflineVertex_);
388 
389  unsigned int vertexCollectionSize = vsorted.size();
390  int nvvertex = 0;
391 
392  for (unsigned int i = 0; i < vertexCollectionSize; i++) {
393  const Vertex& vertex = vsorted.at(i);
394  if (vertex.isValid())
395  nvvertex++;
396  }
397 
398  nOfflineVertices_ = nvvertex;
399  h_nOfflineVertices->Fill(nvvertex);
400 
401  if (!vsorted.empty() && useTracksFromRecoVtx_) {
402  double sumpt = 0;
403  size_t ntracks = 0;
404  double chi2ndf = 0.;
405  double chi2prob = 0.;
406 
407  if (!vsorted.at(0).isFake()) {
408  Vertex pv = vsorted.at(0);
409 
410  ntracks = pv.tracksSize();
411  chi2ndf = pv.normalizedChi2();
412  chi2prob = TMath::Prob(pv.chi2(), (int)pv.ndof());
413 
414  h_recoVtxNtracks_->Fill(ntracks);
415  h_recoVtxChi2ndf_->Fill(chi2ndf);
416  h_recoVtxChi2Prob_->Fill(chi2prob);
417 
418  for (Vertex::trackRef_iterator itrk = pv.tracks_begin(); itrk != pv.tracks_end(); ++itrk) {
419  double pt = (**itrk).pt();
420  sumpt += pt * pt;
421 
422  const math::XYZPoint myVertex(pv.position().x(), pv.position().y(), pv.position().z());
423 
424  double dxyRes = (**itrk).dxy(myVertex);
425  double dzRes = (**itrk).dz(myVertex);
426 
427  double dxy_err = (**itrk).dxyError();
428  double dz_err = (**itrk).dzError();
429 
430  float trackphi = ((**itrk).phi()) * (180 / M_PI);
431  float tracketa = (**itrk).eta();
432 
433  for (int i = 0; i < nBins_; i++) {
434  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
435  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
436 
437  float etaF = theDetails_.trendbins[PVValHelper::eta][i];
438  float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
439 
440  if (tracketa >= etaF && tracketa < etaL) {
441  PVValHelper::fillByIndex(a_dxyEtaBiasResiduals, i, dxyRes * cmToum);
442  PVValHelper::fillByIndex(a_dzEtaBiasResiduals, i, dzRes * cmToum);
443  PVValHelper::fillByIndex(n_dxyEtaBiasResiduals, i, (dxyRes) / dxy_err);
444  PVValHelper::fillByIndex(n_dzEtaBiasResiduals, i, (dzRes) / dz_err);
445  }
446 
447  if (trackphi >= phiF && trackphi < phiL) {
448  PVValHelper::fillByIndex(a_dxyPhiBiasResiduals, i, dxyRes * cmToum);
449  PVValHelper::fillByIndex(a_dzPhiBiasResiduals, i, dzRes * cmToum);
450  PVValHelper::fillByIndex(n_dxyPhiBiasResiduals, i, (dxyRes) / dxy_err);
451  PVValHelper::fillByIndex(n_dzPhiBiasResiduals, i, (dzRes) / dz_err);
452 
453  for (int j = 0; j < nBins_; j++) {
454  float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
455  float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
456 
457  if (tracketa >= etaJ && tracketa < etaK) {
458  a_dxyBiasResidualsMap[i][j]->Fill(dxyRes * cmToum);
459  a_dzBiasResidualsMap[i][j]->Fill(dzRes * cmToum);
460 
461  n_dxyBiasResidualsMap[i][j]->Fill((dxyRes) / dxy_err);
462  n_dzBiasResidualsMap[i][j]->Fill((dzRes) / dz_err);
463  }
464  }
465  }
466  }
467  }
468 
469  h_recoVtxSumPt_->Fill(sumpt);
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 (!runNumbersTimesLog_.count(RunNumber_)) {
515  auto times = getRunTime(iSetup);
516 
517  if (debug_) {
518  const time_t start_time = times.first / 1000000;
519  edm::LogInfo("PrimaryVertexValidation")
520  << RunNumber_ << " has start time: " << times.first << " - " << times.second << std::endl;
521  edm::LogInfo("PrimaryVertexValidation")
522  << "human readable time: " << std::asctime(std::gmtime(&start_time)) << std::endl;
523  }
524 
525  runNumbersTimesLog_[RunNumber_] = times;
526  }
527 
528  if (h_runFromEvent->GetEntries() == 0) {
529  h_runFromEvent->SetBinContent(1, RunNumber_);
530  }
531 
532  LuminosityBlockNumber_ = iEvent.eventAuxiliary().luminosityBlock();
533  EventNumber_ = iEvent.eventAuxiliary().id().event();
534 
535  if (debug_)
536  edm::LogInfo("PrimaryVertexValidation") << " looping over " << trackCollectionHandle->size() << "tracks";
537 
538  h_nTracks->Fill(trackCollectionHandle->size());
539 
540  //======================================================
541  // Interface RECO tracks to vertex reconstruction
542  //======================================================
543 
544  std::vector<TransientTrack> t_tks;
545  for (const auto& track : tracks) {
546  TransientTrack tt = theB_->build(&(track));
547  tt.setBeamSpot(beamSpot);
548  t_tks.push_back(tt);
549  }
550 
551  if (debug_) {
552  edm::LogInfo("PrimaryVertexValidation") << "Found: " << t_tks.size() << " reconstructed tracks";
553  }
554 
555  //======================================================
556  // select the tracks
557  //======================================================
558 
559  std::vector<TransientTrack> seltks = theTrackFilter_->select(t_tks);
560 
561  //======================================================
562  // clusterize tracks in Z
563  //======================================================
564 
565  vector<vector<TransientTrack>> clusters = theTrackClusterizer_->clusterize(seltks);
566 
567  if (debug_) {
568  edm::LogInfo("PrimaryVertexValidation")
569  << " looping over: " << clusters.size() << " clusters from " << t_tks.size() << " selected tracks";
570  }
571 
572  nClus_ = clusters.size();
573  h_nClus->Fill(nClus_);
574 
575  //======================================================
576  // Starts loop on clusters
577  //======================================================
578  for (const auto& iclus : clusters) {
579  nTracksPerClus_ = 0;
580 
581  unsigned int i = 0;
582  for (const auto& theTTrack : iclus) {
583  i++;
584 
585  if (nTracks_ >= nMaxtracks_) {
586  edm::LogError("PrimaryVertexValidation")
587  << " Warning - Number of tracks: " << nTracks_ << " , greater than " << nMaxtracks_;
588  continue;
589  }
590 
591  const Track& theTrack = theTTrack.track();
592 
593  pt_[nTracks_] = theTrack.pt();
594  p_[nTracks_] = theTrack.p();
595  nhits_[nTracks_] = theTrack.numberOfValidHits();
596  eta_[nTracks_] = theTrack.eta();
597  theta_[nTracks_] = theTrack.theta();
598  phi_[nTracks_] = theTrack.phi();
599  chi2_[nTracks_] = theTrack.chi2();
600  chi2ndof_[nTracks_] = theTrack.normalizedChi2();
601  charge_[nTracks_] = theTrack.charge();
602  qoverp_[nTracks_] = theTrack.qoverp();
603  dz_[nTracks_] = theTrack.dz();
604  dxy_[nTracks_] = theTrack.dxy();
605 
606  TrackBase::TrackQuality _trackQuality = TrackBase::qualityByName("highPurity");
607  isHighPurity_[nTracks_] = theTrack.quality(_trackQuality);
608 
609  math::XYZPoint point(BSx0_, BSy0_, BSz0_);
610  dxyBs_[nTracks_] = theTrack.dxy(point);
611  dzBs_[nTracks_] = theTrack.dz(point);
612 
613  xPCA_[nTracks_] = theTrack.vertex().x();
614  yPCA_[nTracks_] = theTrack.vertex().y();
615  zPCA_[nTracks_] = theTrack.vertex().z();
616 
617  //=======================================================
618  // Retrieve rechit information
619  //=======================================================
620 
621  const reco::HitPattern& hits = theTrack.hitPattern();
622 
623  int nRecHit1D = 0;
624  int nRecHit2D = 0;
625  int nhitinTIB = hits.numberOfValidStripTIBHits();
626  int nhitinTOB = hits.numberOfValidStripTOBHits();
627  int nhitinTID = hits.numberOfValidStripTIDHits();
628  int nhitinTEC = hits.numberOfValidStripTECHits();
629  int nhitinBPIX = hits.numberOfValidPixelBarrelHits();
630  int nhitinFPIX = hits.numberOfValidPixelEndcapHits();
631  for (trackingRecHit_iterator iHit = theTTrack.recHitsBegin(); iHit != theTTrack.recHitsEnd(); ++iHit) {
632  if ((*iHit)->isValid()) {
633  if (this->isHit2D(**iHit)) {
634  ++nRecHit2D;
635  } else {
636  ++nRecHit1D;
637  }
638  }
639  }
640 
641  nhits1D_[nTracks_] = nRecHit1D;
642  nhits2D_[nTracks_] = nRecHit2D;
643  nhitsBPIX_[nTracks_] = nhitinBPIX;
644  nhitsFPIX_[nTracks_] = nhitinFPIX;
645  nhitsTIB_[nTracks_] = nhitinTIB;
646  nhitsTID_[nTracks_] = nhitinTID;
647  nhitsTOB_[nTracks_] = nhitinTOB;
648  nhitsTEC_[nTracks_] = nhitinTEC;
649 
650  //=======================================================
651  // Good tracks for vertexing selection
652  //=======================================================
653 
654  bool pass = true;
655  if (askFirstLayerHit_)
656  pass = this->hasFirstLayerPixelHits(theTTrack);
657  if (pass && (theTrack.pt() >= ptOfProbe_) && std::abs(theTrack.eta()) <= etaOfProbe_ &&
658  (theTrack.numberOfValidHits()) >= nHitsOfProbe_ && (theTrack.p()) >= pOfProbe_) {
659  isGoodTrack_[nTracks_] = 1;
660  }
661 
662  //=======================================================
663  // Fit unbiased vertex
664  //=======================================================
665 
666  vector<TransientTrack> theFinalTracks;
667  theFinalTracks.clear();
668 
669  for (const auto& tk : iclus) {
670  pass = this->hasFirstLayerPixelHits(tk);
671  if (pass) {
672  if (tk == theTTrack)
673  continue;
674  else {
675  theFinalTracks.push_back(tk);
676  }
677  }
678  }
679 
680  if (theFinalTracks.size() > 1) {
681  if (debug_)
682  edm::LogInfo("PrimaryVertexValidation") << "Transient Track Collection size: " << theFinalTracks.size();
683  try {
684  //AdaptiveVertexFitter* theFitter = new AdaptiveVertexFitter;
685  auto theFitter = std::unique_ptr<VertexFitter<5>>(new AdaptiveVertexFitter());
686  TransientVertex theFittedVertex;
687 
688  if (forceBeamSpotContraint_) {
689  theFittedVertex = theFitter->vertex(theFinalTracks, beamSpot); // if you want the beam constraint
690  } else {
691  theFittedVertex = theFitter->vertex(theFinalTracks);
692  }
693 
694  double totalTrackWeights = 0;
695  if (theFittedVertex.isValid()) {
696  if (theFittedVertex.hasTrackWeight()) {
697  for (const auto& theFinalTrack : theFinalTracks) {
698  sumOfWeightsUnbiasedVertex_[nTracks_] += theFittedVertex.trackWeight(theFinalTrack);
699  totalTrackWeights += theFittedVertex.trackWeight(theFinalTrack);
700  h_fitVtxTrackWeights_->Fill(theFittedVertex.trackWeight(theFinalTrack));
701  }
702  }
703 
704  h_fitVtxTrackAverageWeight_->Fill(totalTrackWeights / theFinalTracks.size());
705 
706  const math::XYZPoint theRecoVertex(xOfflineVertex_, yOfflineVertex_, zOfflineVertex_);
707  const math::XYZPoint myVertex(
708  theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
709 
710  const Vertex vertex = theFittedVertex;
711  fillTrackHistos(hDA, "all", &theTTrack, vertex, beamSpot, fBfield_);
712 
713  hasRecVertex_[nTracks_] = 1;
714  xUnbiasedVertex_[nTracks_] = theFittedVertex.position().x();
715  yUnbiasedVertex_[nTracks_] = theFittedVertex.position().y();
716  zUnbiasedVertex_[nTracks_] = theFittedVertex.position().z();
717 
718  chi2normUnbiasedVertex_[nTracks_] = theFittedVertex.normalisedChiSquared();
719  chi2UnbiasedVertex_[nTracks_] = theFittedVertex.totalChiSquared();
720  DOFUnbiasedVertex_[nTracks_] = theFittedVertex.degreesOfFreedom();
721  chi2ProbUnbiasedVertex_[nTracks_] =
722  TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom());
723  tracksUsedForVertexing_[nTracks_] = theFinalTracks.size();
724 
725  h_fitVtxNtracks_->Fill(theFinalTracks.size());
726  h_fitVtxChi2_->Fill(theFittedVertex.totalChiSquared());
727  h_fitVtxNdof_->Fill(theFittedVertex.degreesOfFreedom());
728  h_fitVtxChi2ndf_->Fill(theFittedVertex.normalisedChiSquared());
729  h_fitVtxChi2Prob_->Fill(
730  TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom()));
731 
732  // from my Vertex
733  double dxyFromMyVertex = theTrack.dxy(myVertex);
734  double dzFromMyVertex = theTrack.dz(myVertex);
735 
736  GlobalPoint vert(
737  theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
738 
739  //FreeTrajectoryState theTrackNearVertex = theTTrack.trajectoryStateClosestToPoint(vert).theState();
740  //double dz_err = sqrt(theFittedVertex.positionError().czz() + theTrackNearVertex.cartesianError().position().czz());
741  //double dz_err = hypot(theTrack.dzError(),theFittedVertex.positionError().czz());
742 
743  double dz_err = sqrt(std::pow(theTrack.dzError(), 2) + theFittedVertex.positionError().czz());
744 
745  // PV2D
746  std::pair<bool, Measurement1D> s_ip2dpv = signedTransverseImpactParameter(
747  theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
748 
749  double s_ip2dpv_corr = s_ip2dpv.second.value();
750  double s_ip2dpv_err = s_ip2dpv.second.error();
751 
752  // PV3D
753  std::pair<bool, Measurement1D> s_ip3dpv = signedImpactParameter3D(
754  theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
755 
756  double s_ip3dpv_corr = s_ip3dpv.second.value();
757  double s_ip3dpv_err = s_ip3dpv.second.error();
758 
759  // PV3D absolute
760  std::pair<bool, Measurement1D> ip3dpv = absoluteImpactParameter3D(theTTrack, theFittedVertex);
761  double ip3d_corr = ip3dpv.second.value();
762  double ip3d_err = ip3dpv.second.error();
763 
764  // with respect to any specified vertex, such as primary vertex
765  TrajectoryStateClosestToPoint traj = (theTTrack).trajectoryStateClosestToPoint(vert);
766 
767  GlobalPoint refPoint = traj.position();
768  GlobalPoint cPToVtx = traj.theState().position();
769 
770  float my_dx = refPoint.x() - myVertex.x();
771  float my_dy = refPoint.y() - myVertex.y();
772 
773  float my_dx2 = cPToVtx.x() - myVertex.x();
774  float my_dy2 = cPToVtx.y() - myVertex.y();
775 
776  float my_dxy = std::sqrt(my_dx * my_dx + my_dy * my_dy);
777 
778  double d0 = traj.perigeeParameters().transverseImpactParameter();
779  //double d0_error = traj.perigeeError().transverseImpactParameterError();
780  double z0 = traj.perigeeParameters().longitudinalImpactParameter();
781  double z0_error = traj.perigeeError().longitudinalImpactParameterError();
782 
783  if (debug_) {
784  edm::LogInfo("PrimaryVertexValidation")
785  << "my_dx:" << my_dx << " my_dy:" << my_dy << " my_dxy:" << my_dxy << " my_dx2:" << my_dx2
786  << " my_dy2:" << my_dy2 << " d0: " << d0 << " dxyFromVtx:" << dxyFromMyVertex << "\n"
787  << " ============================== "
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 (auto const& hit : theTrack.recHits()) {
824  const DetId& detId = hit->geographicalId();
825  unsigned int subid = detId.subdetId();
826 
827  if (hit->isValid() && (subid == PixelSubdetector::PixelBarrel)) {
828  int layer = tTopo->pxbLayer(detId);
829  if (layer == 1) {
830  const SiPixelRecHit* prechit = dynamic_cast<const SiPixelRecHit*>(
831  hit); //to be used to get the associated cluster and the cluster probability
832  double clusterProbability = prechit->clusterProbability(0);
833  if (clusterProbability > 0) {
834  h_probeL1ClusterProb_->Fill(log10(clusterProbability));
835  }
836 
837  L1BPixHitCount += 1;
838  ladder_num = tTopo->pxbLadder(detId);
839  module_num = tTopo->pxbModule(detId);
840  }
841  }
842  }
843 
844  h_probeL1Ladder_->Fill(ladder_num);
845  h_probeL1Module_->Fill(module_num);
846  h2_probeLayer1Map_->Fill(module_num, ladder_num);
847  h_probeHasBPixL1Overlap_->Fill(L1BPixHitCount);
848 
849  // residuals vs ladder and module number for map
850  if (module_num > 0 && ladder_num > 0) { // only if we are on BPix Layer 1
851  a_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex * cmToum);
852  a_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex * cmToum);
853  n_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex / s_ip2dpv_err);
854  n_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex / dz_err);
855  }
856 
857  // filling the pT-binned distributions
858 
859  for (int ipTBin = 0; ipTBin < nPtBins_; ipTBin++) {
860  float pTF = mypT_bins_[ipTBin];
861  float pTL = mypT_bins_[ipTBin + 1];
862 
863  if (debug_)
864  edm::LogInfo("PrimaryVertexValidation") << "ipTBin:" << ipTBin << " " << mypT_bins_[ipTBin]
865  << " < pT < " << mypT_bins_[ipTBin + 1] << std::endl;
866 
867  if (std::abs(tracketa) < 1.5 && (trackpt >= pTF && trackpt < pTL)) {
868  if (debug_)
869  edm::LogInfo("PrimaryVertexValidation") << "passes this cut: " << mypT_bins_[ipTBin] << std::endl;
870  PVValHelper::fillByIndex(h_dxy_pT_, ipTBin, dxyFromMyVertex * cmToum);
871  PVValHelper::fillByIndex(h_dz_pT_, ipTBin, dzFromMyVertex * cmToum);
872  PVValHelper::fillByIndex(h_norm_dxy_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err);
873  PVValHelper::fillByIndex(h_norm_dz_pT_, ipTBin, dzFromMyVertex / dz_err);
874 
875  if (std::abs(tracketa) < 1.) {
876  if (debug_)
877  edm::LogInfo("PrimaryVertexValidation")
878  << "passes tight eta cut: " << mypT_bins_[ipTBin] << std::endl;
879  PVValHelper::fillByIndex(h_dxy_Central_pT_, ipTBin, dxyFromMyVertex * cmToum);
880  PVValHelper::fillByIndex(h_dz_Central_pT_, ipTBin, dzFromMyVertex * cmToum);
881  PVValHelper::fillByIndex(h_norm_dxy_Central_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err);
882  PVValHelper::fillByIndex(h_norm_dz_Central_pT_, ipTBin, dzFromMyVertex / dz_err);
883  }
884  }
885  }
886 
887  // checks on the probe track quality
888  if (trackpt >= ptOfProbe_ && std::abs(tracketa) <= etaOfProbe_ && tracknhits >= nHitsOfProbe_ &&
889  trackp >= pOfProbe_) {
890  std::pair<bool, bool> pixelOcc = pixelHitsCheck((theTTrack));
891 
892  if (debug_) {
893  if (pixelOcc.first == true)
894  edm::LogInfo("PrimaryVertexValidation") << "has BPIx hits" << std::endl;
895  if (pixelOcc.second == true)
896  edm::LogInfo("PrimaryVertexValidation") << "has FPix hits" << std::endl;
897  }
898 
899  if (!doBPix_ && (pixelOcc.first == true))
900  continue;
901  if (!doFPix_ && (pixelOcc.second == true))
902  continue;
903 
904  fillTrackHistos(hDA, "sel", &(theTTrack), vertex, beamSpot, fBfield_);
905 
906  // probe checks
907  h_probePt_->Fill(theTrack.pt());
908  h_probePtRebin_->Fill(theTrack.pt());
909  h_probeP_->Fill(theTrack.p());
910  h_probeEta_->Fill(theTrack.eta());
911  h_probePhi_->Fill(theTrack.phi());
912  h2_probeEtaPhi_->Fill(theTrack.eta(), theTrack.phi());
913  h2_probeEtaPt_->Fill(theTrack.eta(), theTrack.pt());
914 
915  h_probeChi2_->Fill(theTrack.chi2());
916  h_probeNormChi2_->Fill(theTrack.normalizedChi2());
917  h_probeCharge_->Fill(theTrack.charge());
918  h_probeQoverP_->Fill(theTrack.qoverp());
919  h_probeHits_->Fill(theTrack.numberOfValidHits());
920  h_probeHits1D_->Fill(nRecHit1D);
921  h_probeHits2D_->Fill(nRecHit2D);
922  h_probeHitsInTIB_->Fill(nhitinBPIX);
923  h_probeHitsInTOB_->Fill(nhitinFPIX);
924  h_probeHitsInTID_->Fill(nhitinTIB);
925  h_probeHitsInTEC_->Fill(nhitinTID);
926  h_probeHitsInBPIX_->Fill(nhitinTOB);
927  h_probeHitsInFPIX_->Fill(nhitinTEC);
928 
929  float dxyRecoV = theTrack.dz(theRecoVertex);
930  float dzRecoV = theTrack.dxy(theRecoVertex);
931  float dxysigmaRecoV =
932  TMath::Sqrt(theTrack.d0Error() * theTrack.d0Error() + xErrOfflineVertex_ * yErrOfflineVertex_);
933  float dzsigmaRecoV =
934  TMath::Sqrt(theTrack.dzError() * theTrack.dzError() + zErrOfflineVertex_ * zErrOfflineVertex_);
935 
936  double zTrack = (theTTrack.stateAtBeamLine().trackStateAtPCA()).position().z();
937  double zVertex = theFittedVertex.position().z();
938  double tantheta = tan((theTTrack.stateAtBeamLine().trackStateAtPCA()).momentum().theta());
939 
940  double dz2 = pow(theTrack.dzError(), 2) + wxy2_ / pow(tantheta, 2);
941  double restrkz = zTrack - zVertex;
942  double pulltrkz = (zTrack - zVertex) / TMath::Sqrt(dz2);
943 
944  h_probedxyRecoV_->Fill(dxyRecoV);
945  h_probedzRecoV_->Fill(dzRecoV);
946 
947  h_probedzRefitV_->Fill(dxyFromMyVertex);
948  h_probedxyRefitV_->Fill(dzFromMyVertex);
949 
950  h_probed0RefitV_->Fill(d0);
951  h_probez0RefitV_->Fill(z0);
952 
953  h_probesignIP2DRefitV_->Fill(s_ip2dpv_corr);
954  h_probed3DRefitV_->Fill(ip3d_corr);
955  h_probereszRefitV_->Fill(restrkz);
956 
957  h_probeRecoVSigZ_->Fill(dzRecoV / dzsigmaRecoV);
958  h_probeRecoVSigXY_->Fill(dxyRecoV / dxysigmaRecoV);
959  h_probeRefitVSigZ_->Fill(dzFromMyVertex / dz_err);
960  h_probeRefitVSigXY_->Fill(dxyFromMyVertex / s_ip2dpv_err);
961  h_probeRefitVSig3D_->Fill(ip3d_corr / ip3d_err);
962  h_probeRefitVLogSig3D_->Fill(log10(ip3d_corr / ip3d_err));
963  h_probeRefitVSigResZ_->Fill(pulltrkz);
964 
965  a_dxyVsPhi->Fill(trackphi, dxyFromMyVertex * cmToum);
966  a_dzVsPhi->Fill(trackphi, z0 * cmToum);
967  n_dxyVsPhi->Fill(trackphi, dxyFromMyVertex / s_ip2dpv_err);
968  n_dzVsPhi->Fill(trackphi, z0 / z0_error);
969 
970  a_dxyVsEta->Fill(tracketa, dxyFromMyVertex * cmToum);
971  a_dzVsEta->Fill(tracketa, z0 * cmToum);
972  n_dxyVsEta->Fill(tracketa, dxyFromMyVertex / s_ip2dpv_err);
973  n_dzVsEta->Fill(tracketa, z0 / z0_error);
974 
975  if (ladder_num > 0 && module_num > 0) {
976  LogDebug("PrimaryVertexValidation")
977  << " ladder_num" << ladder_num << " module_num" << module_num << std::endl;
978 
979  PVValHelper::fillByIndex(h_dxy_modZ_, module_num - 1, dxyFromMyVertex * cmToum);
980  PVValHelper::fillByIndex(h_dz_modZ_, module_num - 1, dzFromMyVertex * cmToum);
981  PVValHelper::fillByIndex(h_norm_dxy_modZ_, module_num - 1, dxyFromMyVertex / s_ip2dpv_err);
982  PVValHelper::fillByIndex(h_norm_dz_modZ_, module_num - 1, dzFromMyVertex / dz_err);
983 
984  PVValHelper::fillByIndex(h_dxy_ladder_, ladder_num - 1, dxyFromMyVertex * cmToum);
985 
986  LogDebug("PrimaryVertexValidation") << "h_dxy_ladder size:" << h_dxy_ladder_.size() << std::endl;
987 
988  if (L1BPixHitCount == 1) {
989  PVValHelper::fillByIndex(h_dxy_ladderNoOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
990  } else {
991  PVValHelper::fillByIndex(h_dxy_ladderOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
992  }
993 
994  PVValHelper::fillByIndex(h_dz_ladder_, ladder_num - 1, dzFromMyVertex * cmToum);
995  PVValHelper::fillByIndex(h_norm_dxy_ladder_, ladder_num - 1, dxyFromMyVertex / s_ip2dpv_err);
996  PVValHelper::fillByIndex(h_norm_dz_ladder_, ladder_num - 1, dzFromMyVertex / dz_err);
997 
998  h2_probePassingLayer1Map_->Fill(module_num, ladder_num);
999  }
1000 
1001  // filling the binned distributions
1002  for (int i = 0; i < nBins_; i++) {
1003  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1004  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
1005 
1006  float etaF = theDetails_.trendbins[PVValHelper::eta][i];
1007  float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
1008 
1009  if (tracketa >= etaF && tracketa < etaL) {
1010  PVValHelper::fillByIndex(a_dxyEtaResiduals, i, dxyFromMyVertex * cmToum, "1");
1011  PVValHelper::fillByIndex(a_dxEtaResiduals, i, my_dx * cmToum, "2");
1012  PVValHelper::fillByIndex(a_dyEtaResiduals, i, my_dy * cmToum, "3");
1013  PVValHelper::fillByIndex(a_dzEtaResiduals, i, dzFromMyVertex * cmToum, "4");
1014  PVValHelper::fillByIndex(n_dxyEtaResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "5");
1015  PVValHelper::fillByIndex(n_dzEtaResiduals, i, dzFromMyVertex / dz_err, "6");
1016  PVValHelper::fillByIndex(a_IP2DEtaResiduals, i, s_ip2dpv_corr * cmToum, "7");
1017  PVValHelper::fillByIndex(n_IP2DEtaResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "8");
1018  PVValHelper::fillByIndex(a_reszEtaResiduals, i, restrkz * cmToum, "9");
1019  PVValHelper::fillByIndex(n_reszEtaResiduals, i, pulltrkz, "10");
1020  PVValHelper::fillByIndex(a_d3DEtaResiduals, i, ip3d_corr * cmToum, "11");
1021  PVValHelper::fillByIndex(n_d3DEtaResiduals, i, ip3d_corr / ip3d_err, "12");
1022  PVValHelper::fillByIndex(a_IP3DEtaResiduals, i, s_ip3dpv_corr * cmToum, "13");
1023  PVValHelper::fillByIndex(n_IP3DEtaResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "14");
1024  }
1025 
1026  if (trackphi >= phiF && trackphi < phiL) {
1027  PVValHelper::fillByIndex(a_dxyPhiResiduals, i, dxyFromMyVertex * cmToum, "15");
1028  PVValHelper::fillByIndex(a_dxPhiResiduals, i, my_dx * cmToum, "16");
1029  PVValHelper::fillByIndex(a_dyPhiResiduals, i, my_dy * cmToum, "17");
1030  PVValHelper::fillByIndex(a_dzPhiResiduals, i, dzFromMyVertex * cmToum, "18");
1031  PVValHelper::fillByIndex(n_dxyPhiResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "19");
1032  PVValHelper::fillByIndex(n_dzPhiResiduals, i, dzFromMyVertex / dz_err, "20");
1033  PVValHelper::fillByIndex(a_IP2DPhiResiduals, i, s_ip2dpv_corr * cmToum, "21");
1034  PVValHelper::fillByIndex(n_IP2DPhiResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "22");
1035  PVValHelper::fillByIndex(a_reszPhiResiduals, i, restrkz * cmToum, "23");
1036  PVValHelper::fillByIndex(n_reszPhiResiduals, i, pulltrkz, "24");
1037  PVValHelper::fillByIndex(a_d3DPhiResiduals, i, ip3d_corr * cmToum, "25");
1038  PVValHelper::fillByIndex(n_d3DPhiResiduals, i, ip3d_corr / ip3d_err, "26");
1039  PVValHelper::fillByIndex(a_IP3DPhiResiduals, i, s_ip3dpv_corr * cmToum, "27");
1040  PVValHelper::fillByIndex(n_IP3DPhiResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "28");
1041 
1042  for (int j = 0; j < nBins_; j++) {
1043  float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
1044  float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
1045 
1046  if (tracketa >= etaJ && tracketa < etaK) {
1047  a_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex * cmToum);
1048  a_dzResidualsMap[i][j]->Fill(dzFromMyVertex * cmToum);
1049  n_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex / s_ip2dpv_err);
1050  n_dzResidualsMap[i][j]->Fill(dzFromMyVertex / dz_err);
1051  a_d3DResidualsMap[i][j]->Fill(ip3d_corr * cmToum);
1052  n_d3DResidualsMap[i][j]->Fill(ip3d_corr / ip3d_err);
1053  }
1054  }
1055  }
1056  }
1057  }
1058 
1059  if (debug_) {
1060  edm::LogInfo("PrimaryVertexValidation")
1061  << " myVertex.x()= " << myVertex.x() << "\n"
1062  << " myVertex.y()= " << myVertex.y() << " \n"
1063  << " myVertex.z()= " << myVertex.z() << " \n"
1064  << " theTrack.dz(myVertex)= " << theTrack.dz(myVertex) << " \n"
1065  << " zPCA -myVertex.z() = " << (theTrack.vertex().z() - myVertex.z());
1066 
1067  } // ends if debug_
1068  } // ends if the fitted vertex is Valid
1069 
1070  //delete theFitter;
1071 
1072  } catch (cms::Exception& er) {
1073  LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
1074  }
1075 
1076  } //ends if theFinalTracks.size() > 2
1077 
1078  else {
1079  if (debug_)
1080  edm::LogInfo("PrimaryVertexValidation") << "Not enough tracks to make a vertex. Returns no vertex info";
1081  }
1082 
1083  ++nTracks_;
1084  ++nTracksPerClus_;
1085 
1086  if (debug_)
1087  edm::LogInfo("PrimaryVertexValidation") << "Track " << i << " : pT = " << theTrack.pt();
1088 
1089  } // for loop on tracks
1090  } // for loop on track clusters
1091 
1092  // Fill the TTree if needed
1093 
1094  if (storeNtuple_) {
1095  rootTree_->Fill();
1096  }
1097 }

References a_d3DEtaResiduals, a_d3DPhiResiduals, a_d3DResidualsMap, a_dxEtaResiduals, a_dxPhiResiduals, a_dxyBiasResidualsMap, a_dxyEtaBiasResiduals, a_dxyEtaResiduals, a_dxyL1ResidualsMap, a_dxyPhiBiasResiduals, a_dxyPhiResiduals, a_dxyResidualsMap, a_dxyVsEta, a_dxyVsPhi, a_dyEtaResiduals, a_dyPhiResiduals, a_dzBiasResidualsMap, a_dzEtaBiasResiduals, a_dzEtaResiduals, a_dzL1ResidualsMap, a_dzPhiBiasResiduals, a_dzPhiResiduals, a_dzResidualsMap, a_dzVsEta, a_dzVsPhi, a_IP2DEtaResiduals, a_IP2DPhiResiduals, a_IP3DEtaResiduals, a_IP3DPhiResiduals, a_reszEtaResiduals, a_reszPhiResiduals, funct::abs(), IPTools::absoluteImpactParameter3D(), askFirstLayerHit_, Beamdxdz_, Beamsigmaz_, pwdgSkimBPark_cfi::beamSpot, BeamWidthX_, BeamWidthY_, BSx0_, BSy0_, BSz0_, TransientTrackBuilder::build(), reco::TrackBase::charge(), charge_, reco::TrackBase::chi2(), chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2ProbUnbiasedVertex_, chi2UnbiasedVertex_, SiPixelRecHit::clusterProbability(), bsc_activity_cfg::clusters, cmToum, d0, reco::TrackBase::d0Error(), d3DErrorFromMyVertex_, d3DFromMyVertex_, debug_, TrackerGeometry::dets(), doBPix_, doFPix_, DOFUnbiasedVertex_, reco::TrackBase::dxy(), dxy_, dxyBs_, dxyErrorFromMyVertex_, dxyFromMyVertex_, reco::TrackBase::dz(), dz_, dzBs_, reco::TrackBase::dzError(), dzErrorFromMyVertex_, dzFromMyVertex_, PVValHelper::eta, reco::TrackBase::eta(), eta_, etaOfProbe_, EventNumber_, PVValHelper::fillByIndex(), fillTrackHistos(), forceBeamSpotContraint_, geomToken_, edm::EventSetup::getHandle(), getRunTime(), h2_probeEtaPhi_, h2_probeEtaPt_, h2_probeLayer1Map_, h2_probePassingLayer1Map_, h_Beamsigmaz, h_BeamWidthX, h_BeamWidthY, h_BSx0, h_BSy0, h_BSz0, h_dxy_Central_pT_, h_dxy_ladder_, h_dxy_ladderNoOverlap_, h_dxy_ladderOverlap_, h_dxy_modZ_, h_dxy_pT_, h_dz_Central_pT_, h_dz_ladder_, h_dz_modZ_, h_dz_pT_, h_etaMax, h_fitVtxChi2_, h_fitVtxChi2ndf_, h_fitVtxChi2Prob_, h_fitVtxNdof_, h_fitVtxNtracks_, h_fitVtxTrackAverageWeight_, h_fitVtxTrackWeights_, h_nbins, h_nClus, h_nLadders, h_nOfflineVertices, h_norm_dxy_Central_pT_, h_norm_dxy_ladder_, h_norm_dxy_modZ_, h_norm_dxy_pT_, h_norm_dz_Central_pT_, h_norm_dz_ladder_, h_norm_dz_modZ_, h_norm_dz_pT_, h_nTracks, h_probeCharge_, h_probeChi2_, h_probed0RefitV_, h_probed3DRefitV_, h_probedxyRecoV_, h_probedxyRefitV_, h_probedzRecoV_, h_probedzRefitV_, h_probeEta_, h_probeHasBPixL1Overlap_, h_probeHits1D_, h_probeHits2D_, h_probeHits_, h_probeHitsInBPIX_, h_probeHitsInFPIX_, h_probeHitsInTEC_, h_probeHitsInTIB_, h_probeHitsInTID_, h_probeHitsInTOB_, h_probeL1ClusterProb_, h_probeL1Ladder_, h_probeL1Module_, h_probeNormChi2_, h_probeP_, h_probePhi_, h_probePt_, h_probePtRebin_, h_probeQoverP_, h_probeRecoVSigXY_, h_probeRecoVSigZ_, h_probeRefitVLogSig3D_, h_probeRefitVSig3D_, h_probeRefitVSigResZ_, h_probeRefitVSigXY_, h_probeRefitVSigZ_, h_probereszRefitV_, h_probesignIP2DRefitV_, h_probez0RefitV_, h_pTinfo, h_recoVtxChi2ndf_, h_recoVtxChi2Prob_, h_recoVtxNtracks_, h_recoVtxSumPt_, h_runFromEvent, h_runNumber, h_xErrOfflineVertex, h_xOfflineVertex, h_yErrOfflineVertex, h_yOfflineVertex, h_zErrOfflineVertex, h_zOfflineVertex, hasFirstLayerPixelHits(), hasRecVertex_, hDA, reco::TrackBase::hitPattern(), hfClusterShapes_cfi::hits, mps_fire::i, iEvent, createfilelist::int, IP3DsigFromMyVertex_, IPLsigFromMyVertex_, IPTsigFromMyVertex_, isBFieldConsistentWithMode(), isGoodTrack_, isHighPurity_, isHit2D(), isPhase1_, TrackerGeometry::isThere(), edm::HandleBase::isValid(), dqmiolumiharvest::j, LogDebug, LogTrace, PerigeeTrajectoryParameters::longitudinalImpactParameter(), PerigeeTrajectoryError::longitudinalImpactParameterError(), LuminosityBlockNumber_, M_PI, magFieldToken_, PVValHelper::max_eta_phase0, PVValHelper::max_eta_phase1, maxPt_, min(), minPt_, mypT_bins_, n_d3DEtaResiduals, n_d3DPhiResiduals, n_d3DResidualsMap, n_dxyBiasResidualsMap, n_dxyEtaBiasResiduals, n_dxyEtaResiduals, n_dxyL1ResidualsMap, n_dxyPhiBiasResiduals, n_dxyPhiResiduals, n_dxyResidualsMap, n_dxyVsEta, n_dxyVsPhi, n_dzBiasResidualsMap, n_dzEtaBiasResiduals, n_dzEtaResiduals, n_dzL1ResidualsMap, n_dzPhiBiasResiduals, n_dzPhiResiduals, n_dzResidualsMap, n_dzVsEta, n_dzVsPhi, n_IP2DEtaResiduals, n_IP2DPhiResiduals, n_IP3DEtaResiduals, n_IP3DPhiResiduals, n_reszEtaResiduals, n_reszPhiResiduals, nBins_, nClus_, Nevt_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nHitsOfProbe_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nLadders_, nMaxtracks_, nOfflineVertices_, reco::TrackBase::normalizedChi2(), nPtBins_, vertices_cff::ntracks, nTracks_, nTracksPerClus_, reco::TrackBase::numberOfValidHits(), reco::TrackBase::p(), GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, p_, TrajectoryStateClosestToPoint::perigeeError(), TrajectoryStateClosestToPoint::perigeeParameters(), PVValHelper::phi, reco::TrackBase::phi(), phi_, PixelSubdetector::PixelBarrel, pixelHitsCheck(), pOfProbe_, point, FreeTrajectoryState::position(), TrajectoryStateClosestToPoint::position(), position, funct::pow(), edm::ESHandle< T >::product(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), pt_, ptOfProbe_, MetAnalyzer::pv(), reco::TrackBase::px(), TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), reco::TrackBase::py(), reco::TrackBase::pz(), reco::TrackBase::qoverp(), qoverp_, reco::TrackBase::quality(), reco::Track::recHits(), rootTree_, runControl_, runControlNumbers_, RunNumber_, runNumbersTimesLog_, SetVarToZero(), PVValHelper::shrinkHistVectorToFit(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), mathSSE::sqrt(), storeNtuple_, DetId::subdetId(), sumOfWeightsUnbiasedVertex_, funct::tan(), theBeamspotToken, theDetails_, TrajectoryStateClosestToPoint::theState(), reco::TrackBase::theta(), theta_, theTrackClusterizer_, theTrackCollectionToken, theTrackFilter_, theVertexCollectionToken, topoToken_, HLT_FULL_cff::track, trackingGeomToken_, PDWG_EXOHSCP_cff::tracks, tracksUsedForVertexing_, PerigeeConversions::trajectoryStateClosestToPoint(), PerigeeTrajectoryParameters::transverseImpactParameter(), PVValHelper::histodetails::trendbins, groupFilesInBlocks::tt, ttkToken_, useTracksFromRecoVtx_, bphysicsOniaDQM_cfi::vertex, reco::TrackBase::vertex(), vertexZMax_, pwdgSkimBPark_cfi::vertices, vtxSort(), cms::Exception::what(), wxy2_, x, PV3DBase< T, PVType, FrameType >::x(), xErrOfflineVertex_, xOfflineVertex_, xPCA_, xUnbiasedVertex_, y, PV3DBase< T, PVType, FrameType >::y(), yErrOfflineVertex_, yOfflineVertex_, yPCA_, yUnbiasedVertex_, z, HLTMuonOfflineAnalyzer_cfi::z0, zErrOfflineVertex_, zOfflineVertex_, zPCA_, zUnbiasedVertex_, and HLT_FULL_cff::zVertex.

◆ beginJob()

void PrimaryVertexValidation::beginJob ( void  )
overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1165 of file PrimaryVertexValidation.cc.

1165  {
1166  edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
1167  << "Begin Job \n"
1168  << "######################################";
1169 
1170  // Define TTree for output
1171  Nevt_ = 0;
1172  if (compressionSettings_ > 0) {
1173  fs->file().SetCompressionSettings(compressionSettings_);
1174  }
1175 
1176  // rootFile_ = new TFile(filename_.c_str(),"recreate");
1177  rootTree_ = fs->make<TTree>("tree", "PV Validation tree");
1178 
1179  // Track Paramters
1180 
1181  if (lightNtupleSwitch_) {
1182  rootTree_->Branch("EventNumber", &EventNumber_, "EventNumber/i");
1183  rootTree_->Branch("RunNumber", &RunNumber_, "RunNumber/i");
1184  rootTree_->Branch("LuminosityBlockNumber", &LuminosityBlockNumber_, "LuminosityBlockNumber/i");
1185  rootTree_->Branch("nOfflineVertices", &nOfflineVertices_, "nOfflineVertices/I");
1186  rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
1187  rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
1188  rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
1189  rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
1190  rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
1191  rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
1192  rootTree_->Branch("d3DFromMyVertex", &d3DFromMyVertex_, "d3DFromMyVertex[nTracks]/D");
1193  rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
1194  rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
1195  rootTree_->Branch("IP3DsigFromMyVertex", &IP3DsigFromMyVertex_, "IP3DsigFromMyVertex_[nTracks]/D");
1196  rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
1197  rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
1198  rootTree_->Branch("isHighPurity", &isHighPurity_, "isHighPurity_[nTracks]/I");
1199 
1200  } else {
1201  rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
1202  rootTree_->Branch("nTracksPerClus", &nTracksPerClus_, "nTracksPerClus/I");
1203  rootTree_->Branch("nClus", &nClus_, "nClus/I");
1204  rootTree_->Branch("xOfflineVertex", &xOfflineVertex_, "xOfflineVertex/D");
1205  rootTree_->Branch("yOfflineVertex", &yOfflineVertex_, "yOfflineVertex/D");
1206  rootTree_->Branch("zOfflineVertex", &zOfflineVertex_, "zOfflineVertex/D");
1207  rootTree_->Branch("BSx0", &BSx0_, "BSx0/D");
1208  rootTree_->Branch("BSy0", &BSy0_, "BSy0/D");
1209  rootTree_->Branch("BSz0", &BSz0_, "BSz0/D");
1210  rootTree_->Branch("Beamsigmaz", &Beamsigmaz_, "Beamsigmaz/D");
1211  rootTree_->Branch("Beamdxdz", &Beamdxdz_, "Beamdxdz/D");
1212  rootTree_->Branch("BeamWidthX", &BeamWidthX_, "BeamWidthX/D");
1213  rootTree_->Branch("BeamWidthY", &BeamWidthY_, "BeamWidthY/D");
1214  rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
1215  rootTree_->Branch("p", &p_, "p[nTracks]/D");
1216  rootTree_->Branch("nhits", &nhits_, "nhits[nTracks]/I");
1217  rootTree_->Branch("nhits1D", &nhits1D_, "nhits1D[nTracks]/I");
1218  rootTree_->Branch("nhits2D", &nhits2D_, "nhits2D[nTracks]/I");
1219  rootTree_->Branch("nhitsBPIX", &nhitsBPIX_, "nhitsBPIX[nTracks]/I");
1220  rootTree_->Branch("nhitsFPIX", &nhitsFPIX_, "nhitsFPIX[nTracks]/I");
1221  rootTree_->Branch("nhitsTIB", &nhitsTIB_, "nhitsTIB[nTracks]/I");
1222  rootTree_->Branch("nhitsTID", &nhitsTID_, "nhitsTID[nTracks]/I");
1223  rootTree_->Branch("nhitsTOB", &nhitsTOB_, "nhitsTOB[nTracks]/I");
1224  rootTree_->Branch("nhitsTEC", &nhitsTEC_, "nhitsTEC[nTracks]/I");
1225  rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
1226  rootTree_->Branch("theta", &theta_, "theta[nTracks]/D");
1227  rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
1228  rootTree_->Branch("chi2", &chi2_, "chi2[nTracks]/D");
1229  rootTree_->Branch("chi2ndof", &chi2ndof_, "chi2ndof[nTracks]/D");
1230  rootTree_->Branch("charge", &charge_, "charge[nTracks]/I");
1231  rootTree_->Branch("qoverp", &qoverp_, "qoverp[nTracks]/D");
1232  rootTree_->Branch("dz", &dz_, "dz[nTracks]/D");
1233  rootTree_->Branch("dxy", &dxy_, "dxy[nTracks]/D");
1234  rootTree_->Branch("dzBs", &dzBs_, "dzBs[nTracks]/D");
1235  rootTree_->Branch("dxyBs", &dxyBs_, "dxyBs[nTracks]/D");
1236  rootTree_->Branch("xPCA", &xPCA_, "xPCA[nTracks]/D");
1237  rootTree_->Branch("yPCA", &yPCA_, "yPCA[nTracks]/D");
1238  rootTree_->Branch("zPCA", &zPCA_, "zPCA[nTracks]/D");
1239  rootTree_->Branch("xUnbiasedVertex", &xUnbiasedVertex_, "xUnbiasedVertex[nTracks]/D");
1240  rootTree_->Branch("yUnbiasedVertex", &yUnbiasedVertex_, "yUnbiasedVertex[nTracks]/D");
1241  rootTree_->Branch("zUnbiasedVertex", &zUnbiasedVertex_, "zUnbiasedVertex[nTracks]/D");
1242  rootTree_->Branch("chi2normUnbiasedVertex", &chi2normUnbiasedVertex_, "chi2normUnbiasedVertex[nTracks]/F");
1243  rootTree_->Branch("chi2UnbiasedVertex", &chi2UnbiasedVertex_, "chi2UnbiasedVertex[nTracks]/F");
1244  rootTree_->Branch("DOFUnbiasedVertex", &DOFUnbiasedVertex_, " DOFUnbiasedVertex[nTracks]/F");
1245  rootTree_->Branch("chi2ProbUnbiasedVertex", &chi2ProbUnbiasedVertex_, "chi2ProbUnbiasedVertex[nTracks]/F");
1246  rootTree_->Branch(
1247  "sumOfWeightsUnbiasedVertex", &sumOfWeightsUnbiasedVertex_, "sumOfWeightsUnbiasedVertex[nTracks]/F");
1248  rootTree_->Branch("tracksUsedForVertexing", &tracksUsedForVertexing_, "tracksUsedForVertexing[nTracks]/I");
1249  rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
1250  rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
1251  rootTree_->Branch("dxyErrorFromMyVertex", &dxyErrorFromMyVertex_, "dxyErrorFromMyVertex_[nTracks]/D");
1252  rootTree_->Branch("dzErrorFromMyVertex", &dzErrorFromMyVertex_, "dzErrorFromMyVertex_[nTracks]/D");
1253  rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
1254  rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
1255  rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
1256  rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
1257  }
1258 
1259  // event histograms
1260  TFileDirectory EventFeatures = fs->mkdir("EventFeatures");
1261 
1262  TH1F::SetDefaultSumw2(kTRUE);
1263 
1264  h_lumiFromConfig =
1265  EventFeatures.make<TH1F>("h_lumiFromConfig", "luminosity from config;;luminosity of present run", 1, -0.5, 0.5);
1266  h_lumiFromConfig->SetBinContent(1, intLumi_);
1267 
1268  h_runFromConfig = EventFeatures.make<TH1I>("h_runFromConfig",
1269  "run number from config;;run number (from configuration)",
1270  runControlNumbers_.size(),
1271  0.,
1272  runControlNumbers_.size());
1273 
1274  for (const auto& run : runControlNumbers_ | boost::adaptors::indexed(1)) {
1275  h_runFromConfig->SetBinContent(run.index(), run.value());
1276  }
1277 
1278  h_runFromEvent =
1279  EventFeatures.make<TH1I>("h_runFromEvent", "run number from config;;run number (from event)", 1, -0.5, 0.5);
1280  h_nTracks =
1281  EventFeatures.make<TH1F>("h_nTracks", "number of tracks per event;n_{tracks}/event;n_{events}", 300, -0.5, 299.5);
1282  h_nClus =
1283  EventFeatures.make<TH1F>("h_nClus", "number of track clusters;n_{clusters}/event;n_{events}", 50, -0.5, 49.5);
1284  h_nOfflineVertices = EventFeatures.make<TH1F>(
1285  "h_nOfflineVertices", "number of offline reconstructed vertices;n_{vertices}/event;n_{events}", 50, -0.5, 49.5);
1286  h_runNumber = EventFeatures.make<TH1F>("h_runNumber", "run number;run number;n_{events}", 100000, 250000., 350000.);
1287  h_xOfflineVertex = EventFeatures.make<TH1F>(
1288  "h_xOfflineVertex", "x-coordinate of offline vertex;x_{vertex};n_{events}", 100, -0.1, 0.1);
1289  h_yOfflineVertex = EventFeatures.make<TH1F>(
1290  "h_yOfflineVertex", "y-coordinate of offline vertex;y_{vertex};n_{events}", 100, -0.1, 0.1);
1291  h_zOfflineVertex = EventFeatures.make<TH1F>(
1292  "h_zOfflineVertex", "z-coordinate of offline vertex;z_{vertex};n_{events}", 100, -30., 30.);
1293  h_xErrOfflineVertex = EventFeatures.make<TH1F>(
1294  "h_xErrOfflineVertex", "x-coordinate error of offline vertex;err_{x}^{vtx};n_{events}", 100, 0., 0.01);
1295  h_yErrOfflineVertex = EventFeatures.make<TH1F>(
1296  "h_yErrOfflineVertex", "y-coordinate error of offline vertex;err_{y}^{vtx};n_{events}", 100, 0., 0.01);
1297  h_zErrOfflineVertex = EventFeatures.make<TH1F>(
1298  "h_zErrOfflineVertex", "z-coordinate error of offline vertex;err_{z}^{vtx};n_{events}", 100, 0., 10.);
1299  h_BSx0 = EventFeatures.make<TH1F>("h_BSx0", "x-coordinate of reco beamspot;x^{BS}_{0};n_{events}", 100, -0.1, 0.1);
1300  h_BSy0 = EventFeatures.make<TH1F>("h_BSy0", "y-coordinate of reco beamspot;y^{BS}_{0};n_{events}", 100, -0.1, 0.1);
1301  h_BSz0 = EventFeatures.make<TH1F>("h_BSz0", "z-coordinate of reco beamspot;z^{BS}_{0};n_{events}", 100, -1., 1.);
1302  h_Beamsigmaz =
1303  EventFeatures.make<TH1F>("h_Beamsigmaz", "z-coordinate beam width;#sigma_{Z}^{beam};n_{events}", 100, 0., 1.);
1304  h_BeamWidthX =
1305  EventFeatures.make<TH1F>("h_BeamWidthX", "x-coordinate beam width;#sigma_{X}^{beam};n_{events}", 100, 0., 0.01);
1306  h_BeamWidthY =
1307  EventFeatures.make<TH1F>("h_BeamWidthY", "y-coordinate beam width;#sigma_{Y}^{beam};n_{events}", 100, 0., 0.01);
1308 
1309  h_etaMax = EventFeatures.make<TH1F>("etaMax", "etaMax", 1, -0.5, 0.5);
1310  h_pTinfo = EventFeatures.make<TH1F>("pTinfo", "pTinfo", 3, -1.5, 1.5);
1311  h_pTinfo->GetXaxis()->SetBinLabel(1, "n. bins");
1312  h_pTinfo->GetXaxis()->SetBinLabel(2, "pT min");
1313  h_pTinfo->GetXaxis()->SetBinLabel(3, "pT max");
1314 
1315  h_nbins = EventFeatures.make<TH1F>("nbins", "nbins", 1, -0.5, 0.5);
1316  h_nLadders = EventFeatures.make<TH1F>("nladders", "n. ladders", 1, -0.5, 0.5);
1317 
1318  // probe track histograms
1319  TFileDirectory ProbeFeatures = fs->mkdir("ProbeTrackFeatures");
1320 
1321  h_probePt_ = ProbeFeatures.make<TH1F>("h_probePt", "p_{T} of probe track;track p_{T} (GeV); tracks", 100, 0., 50.);
1322  h_probePtRebin_ = ProbeFeatures.make<TH1F>(
1323  "h_probePtRebin", "p_{T} of probe track;track p_{T} (GeV); tracks", mypT_bins_.size() - 1, mypT_bins_.data());
1324  h_probeP_ = ProbeFeatures.make<TH1F>("h_probeP", "momentum of probe track;track p (GeV); tracks", 100, 0., 100.);
1325  h_probeEta_ = ProbeFeatures.make<TH1F>("h_probeEta", "#eta of the probe track;track #eta;tracks", 54, -2.8, 2.8);
1326  h_probePhi_ = ProbeFeatures.make<TH1F>("h_probePhi", "#phi of probe track;track #phi (rad);tracks", 100, -3.15, 3.15);
1327 
1328  h2_probeEtaPhi_ =
1329  ProbeFeatures.make<TH2F>("h2_probeEtaPhi",
1330  "probe track #phi vs #eta;#eta of probe track;track #phi of probe track (rad); tracks",
1331  54,
1332  -2.8,
1333  2.8,
1334  100,
1335  -3.15,
1336  3.15);
1337  h2_probeEtaPt_ = ProbeFeatures.make<TH2F>("h2_probeEtaPt",
1338  "probe track p_{T} vs #eta;#eta of probe track;track p_{T} (GeV); tracks",
1339  54,
1340  -2.8,
1341  2.8,
1342  100,
1343  0.,
1344  50.);
1345 
1346  h_probeChi2_ =
1347  ProbeFeatures.make<TH1F>("h_probeChi2", "#chi^{2} of probe track;track #chi^{2}; tracks", 100, 0., 100.);
1348  h_probeNormChi2_ = ProbeFeatures.make<TH1F>(
1349  "h_probeNormChi2", " normalized #chi^{2} of probe track;track #chi^{2}/ndof; tracks", 100, 0., 10.);
1350  h_probeCharge_ =
1351  ProbeFeatures.make<TH1F>("h_probeCharge", "charge of probe track;track charge Q;tracks", 3, -1.5, 1.5);
1352  h_probeQoverP_ =
1353  ProbeFeatures.make<TH1F>("h_probeQoverP", "q/p of probe track; track Q/p (GeV^{-1});tracks", 200, -1., 1.);
1354  h_probedzRecoV_ = ProbeFeatures.make<TH1F>(
1355  "h_probedzRecoV", "d_{z}(V_{offline}) of probe track;track d_{z}(V_{off}) (cm);tracks", 200, -1., 1.);
1356  h_probedxyRecoV_ = ProbeFeatures.make<TH1F>(
1357  "h_probedxyRecoV", "d_{xy}(V_{offline}) of probe track;track d_{xy}(V_{off}) (cm);tracks", 200, -1., 1.);
1358  h_probedzRefitV_ = ProbeFeatures.make<TH1F>(
1359  "h_probedzRefitV", "d_{z}(V_{refit}) of probe track;track d_{z}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
1360  h_probesignIP2DRefitV_ = ProbeFeatures.make<TH1F>(
1361  "h_probesignIPRefitV", "ip_{2D}(V_{refit}) of probe track;track ip_{2D}(V_{fit}) (cm);tracks", 200, -1., 1.);
1362  h_probedxyRefitV_ = ProbeFeatures.make<TH1F>(
1363  "h_probedxyRefitV", "d_{xy}(V_{refit}) of probe track;track d_{xy}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
1364 
1365  h_probez0RefitV_ = ProbeFeatures.make<TH1F>(
1366  "h_probez0RefitV", "z_{0}(V_{refit}) of probe track;track z_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
1367  h_probed0RefitV_ = ProbeFeatures.make<TH1F>(
1368  "h_probed0RefitV", "d_{0}(V_{refit}) of probe track;track d_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
1369 
1370  h_probed3DRefitV_ = ProbeFeatures.make<TH1F>(
1371  "h_probed3DRefitV", "d_{3D}(V_{refit}) of probe track;track d_{3D}(V_{fit}) (cm);tracks", 200, 0., 1.);
1372  h_probereszRefitV_ = ProbeFeatures.make<TH1F>(
1373  "h_probeReszRefitV", "z_{track} -z_{V_{refit}};track res_{z}(V_{refit}) (cm);tracks", 200, -1., 1.);
1374 
1375  h_probeRecoVSigZ_ = ProbeFeatures.make<TH1F>(
1376  "h_probeRecoVSigZ", "Longitudinal DCA Significance (reco);d_{z}(V_{off})/#sigma_{dz};tracks", 100, -8, 8);
1377  h_probeRecoVSigXY_ = ProbeFeatures.make<TH1F>(
1378  "h_probeRecoVSigXY", "Transverse DCA Significance (reco);d_{xy}(V_{off})/#sigma_{dxy};tracks", 100, -8, 8);
1379  h_probeRefitVSigZ_ = ProbeFeatures.make<TH1F>(
1380  "h_probeRefitVSigZ", "Longitudinal DCA Significance (refit);d_{z}(V_{fit})/#sigma_{dz};tracks", 100, -8, 8);
1381  h_probeRefitVSigXY_ = ProbeFeatures.make<TH1F>(
1382  "h_probeRefitVSigXY", "Transverse DCA Significance (refit);d_{xy}(V_{fit})/#sigma_{dxy};tracks", 100, -8, 8);
1383  h_probeRefitVSig3D_ = ProbeFeatures.make<TH1F>(
1384  "h_probeRefitVSig3D", "3D DCA Significance (refit);d_{3D}/#sigma_{3D};tracks", 100, 0., 20.);
1385  h_probeRefitVLogSig3D_ =
1386  ProbeFeatures.make<TH1F>("h_probeRefitVLogSig3D",
1387  "log_{10}(3D DCA-Significance) (refit);log_{10}(d_{3D}/#sigma_{3D});tracks",
1388  100,
1389  -5.,
1390  4.);
1391  h_probeRefitVSigResZ_ = ProbeFeatures.make<TH1F>(
1392  "h_probeRefitVSigResZ",
1393  "Longitudinal residual significance (refit);(z_{track} -z_{V_{fit}})/#sigma_{res_{z}};tracks",
1394  100,
1395  -8,
1396  8);
1397 
1398  h_probeHits_ = ProbeFeatures.make<TH1F>("h_probeNRechits", "N_{hits} ;N_{hits} ;tracks", 40, -0.5, 39.5);
1399  h_probeHits1D_ = ProbeFeatures.make<TH1F>("h_probeNRechits1D", "N_{hits} 1D ;N_{hits} 1D ;tracks", 40, -0.5, 39.5);
1400  h_probeHits2D_ = ProbeFeatures.make<TH1F>("h_probeNRechits2D", "N_{hits} 2D ;N_{hits} 2D ;tracks", 40, -0.5, 39.5);
1401  h_probeHitsInTIB_ =
1402  ProbeFeatures.make<TH1F>("h_probeNRechitsTIB", "N_{hits} TIB ;N_{hits} TIB;tracks", 40, -0.5, 39.5);
1403  h_probeHitsInTOB_ =
1404  ProbeFeatures.make<TH1F>("h_probeNRechitsTOB", "N_{hits} TOB ;N_{hits} TOB;tracks", 40, -0.5, 39.5);
1405  h_probeHitsInTID_ =
1406  ProbeFeatures.make<TH1F>("h_probeNRechitsTID", "N_{hits} TID ;N_{hits} TID;tracks", 40, -0.5, 39.5);
1407  h_probeHitsInTEC_ =
1408  ProbeFeatures.make<TH1F>("h_probeNRechitsTEC", "N_{hits} TEC ;N_{hits} TEC;tracks", 40, -0.5, 39.5);
1409  h_probeHitsInBPIX_ =
1410  ProbeFeatures.make<TH1F>("h_probeNRechitsBPIX", "N_{hits} BPIX;N_{hits} BPIX;tracks", 40, -0.5, 39.5);
1411  h_probeHitsInFPIX_ =
1412  ProbeFeatures.make<TH1F>("h_probeNRechitsFPIX", "N_{hits} FPIX;N_{hits} FPIX;tracks", 40, -0.5, 39.5);
1413 
1414  h_probeL1Ladder_ =
1415  ProbeFeatures.make<TH1F>("h_probeL1Ladder", "Ladder number (L1 hit); ladder number", 22, -1.5, 20.5);
1416  h_probeL1Module_ =
1417  ProbeFeatures.make<TH1F>("h_probeL1Module", "Module number (L1 hit); module number", 10, -1.5, 8.5);
1418 
1419  h2_probeLayer1Map_ = ProbeFeatures.make<TH2F>(
1420  "h2_probeLayer1Map", "Position in Layer 1 of first hit;module number;ladder number", 8, 0.5, 8.5, 12, 0.5, 12.5);
1421  h2_probePassingLayer1Map_ = ProbeFeatures.make<TH2F>("h2_probePassingLayer1Map",
1422  "Position in Layer 1 of first hit;module number;ladder number",
1423  8,
1424  0.5,
1425  8.5,
1426  12,
1427  0.5,
1428  12.5);
1429  h_probeHasBPixL1Overlap_ =
1430  ProbeFeatures.make<TH1I>("h_probeHasBPixL1Overlap", "n. hits in L1;n. L1-BPix hits;tracks", 5, -0.5, 4.5);
1431  h_probeL1ClusterProb_ = ProbeFeatures.make<TH1F>(
1432  "h_probeL1ClusterProb",
1433  "log_{10}(Cluster Probability) for Layer1 hits;log_{10}(cluster probability); n. Layer1 hits",
1434  100,
1435  -10.,
1436  0.);
1437 
1438  // refit vertex features
1439  TFileDirectory RefitVertexFeatures = fs->mkdir("RefitVertexFeatures");
1440  h_fitVtxNtracks_ = RefitVertexFeatures.make<TH1F>(
1441  "h_fitVtxNtracks", "N_{trks} used in vertex fit;N^{fit}_{tracks};vertices", 100, -0.5, 99.5);
1442  h_fitVtxNdof_ = RefitVertexFeatures.make<TH1F>(
1443  "h_fitVtxNdof", "N_{DOF} of vertex fit;N_{DOF} of refit vertex;vertices", 100, -0.5, 99.5);
1444  h_fitVtxChi2_ = RefitVertexFeatures.make<TH1F>(
1445  "h_fitVtxChi2", "#chi^{2} of vertex fit;vertex #chi^{2};vertices", 100, -0.5, 99.5);
1446  h_fitVtxChi2ndf_ = RefitVertexFeatures.make<TH1F>(
1447  "h_fitVtxChi2ndf", "#chi^{2}/ndf of vertex fit;vertex #chi^{2}/ndf;vertices", 100, -0.5, 9.5);
1448  h_fitVtxChi2Prob_ = RefitVertexFeatures.make<TH1F>(
1449  "h_fitVtxChi2Prob", "Prob(#chi^{2},ndf) of vertex fit;Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
1450  h_fitVtxTrackWeights_ = RefitVertexFeatures.make<TH1F>(
1451  "h_fitVtxTrackWeights", "track weights associated to track;track weights;tracks", 40, 0., 1.);
1452  h_fitVtxTrackAverageWeight_ = RefitVertexFeatures.make<TH1F>(
1453  "h_fitVtxTrackAverageWeight_", "average track weight per vertex;#LT track weight #GT;vertices", 40, 0., 1.);
1454 
1455  if (useTracksFromRecoVtx_) {
1456  TFileDirectory RecoVertexFeatures = fs->mkdir("RecoVertexFeatures");
1457  h_recoVtxNtracks_ =
1458  RecoVertexFeatures.make<TH1F>("h_recoVtxNtracks", "N^{vtx}_{trks};N^{vtx}_{trks};vertices", 100, -0.5, 99.5);
1459  h_recoVtxChi2ndf_ =
1460  RecoVertexFeatures.make<TH1F>("h_recoVtxChi2ndf", "#chi^{2}/ndf vtx;#chi^{2}/ndf vtx;vertices", 10, -0.5, 9.5);
1461  h_recoVtxChi2Prob_ = RecoVertexFeatures.make<TH1F>(
1462  "h_recoVtxChi2Prob", "Prob(#chi^{2},ndf);Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
1463  h_recoVtxSumPt_ =
1464  RecoVertexFeatures.make<TH1F>("h_recoVtxSumPt", "Sum(p^{trks}_{T});Sum(p^{trks}_{T});vertices", 100, 0., 200.);
1465  }
1466 
1467  TFileDirectory DA = fs->mkdir("DA");
1468  //DA.cd();
1469  hDA = bookVertexHistograms(DA);
1470  //for(std::map<std::string,TH1*>::const_iterator hist=hDA.begin(); hist!=hDA.end(); hist++){
1471  //hist->second->SetDirectory(DA);
1472  // DA.make<TH1F>(hist->second);
1473  // }
1474 
1475  // initialize the residuals histograms
1476 
1477  const float dxymax_phi = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
1478  const float dzmax_phi = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
1479  const float dxymax_eta = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
1480  const float dzmax_eta = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
1481  //const float d3Dmax_phi = theDetails_.getHigh(PVValHelper::d3D,PVValHelper::phi);
1482  const float d3Dmax_eta = theDetails_.getHigh(PVValHelper::d3D, PVValHelper::eta);
1483 
1485  //
1486  // Unbiased track-to-vertex residuals
1487  // The vertex is refit without the probe track
1488  //
1490 
1491  // _ _ _ _ ___ _ _ _
1492  // /_\ | |__ ___ ___| |_ _| |_ ___ | _ \___ __(_)__| |_ _ __ _| |___
1493  // / _ \| '_ (_-</ _ \ | || | _/ -_) | / -_|_-< / _` | || / _` | (_-<
1494  // /_/ \_\_.__/__/\___/_|\_,_|\__\___| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1495  //
1496 
1497  TFileDirectory AbsTransPhiRes = fs->mkdir("Abs_Transv_Phi_Residuals");
1498  a_dxyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
1499  a_dxPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dx, PVValHelper::phi);
1500  a_dyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dy, PVValHelper::phi);
1501  a_IP2DPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::IP2D, PVValHelper::phi);
1502 
1503  TFileDirectory AbsTransEtaRes = fs->mkdir("Abs_Transv_Eta_Residuals");
1504  a_dxyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
1505  a_dxEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dx, PVValHelper::eta);
1506  a_dyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dy, PVValHelper::eta);
1507  a_IP2DEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::IP2D, PVValHelper::eta);
1508 
1509  TFileDirectory AbsLongPhiRes = fs->mkdir("Abs_Long_Phi_Residuals");
1510  a_dzPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::dz, PVValHelper::phi);
1511  a_reszPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::resz, PVValHelper::phi);
1512 
1513  TFileDirectory AbsLongEtaRes = fs->mkdir("Abs_Long_Eta_Residuals");
1514  a_dzEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::dz, PVValHelper::eta);
1515  a_reszEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::resz, PVValHelper::eta);
1516 
1517  TFileDirectory Abs3DPhiRes = fs->mkdir("Abs_3D_Phi_Residuals");
1518  a_d3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::d3D, PVValHelper::phi);
1519  a_IP3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::IP3D, PVValHelper::phi);
1520 
1521  TFileDirectory Abs3DEtaRes = fs->mkdir("Abs_3D_Eta_Residuals");
1522  a_d3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::d3D, PVValHelper::eta);
1523  a_IP3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::IP3D, PVValHelper::eta);
1524 
1525  TFileDirectory NormTransPhiRes = fs->mkdir("Norm_Transv_Phi_Residuals");
1526  n_dxyPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_dxy, PVValHelper::phi, true);
1527  n_IP2DPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::phi, true);
1528 
1529  TFileDirectory NormTransEtaRes = fs->mkdir("Norm_Transv_Eta_Residuals");
1530  n_dxyEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_dxy, PVValHelper::eta, true);
1531  n_IP2DEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::eta, true);
1532 
1533  TFileDirectory NormLongPhiRes = fs->mkdir("Norm_Long_Phi_Residuals");
1534  n_dzPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_dz, PVValHelper::phi, true);
1535  n_reszPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_resz, PVValHelper::phi, true);
1536 
1537  TFileDirectory NormLongEtaRes = fs->mkdir("Norm_Long_Eta_Residuals");
1538  n_dzEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_dz, PVValHelper::eta, true);
1539  n_reszEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_resz, PVValHelper::eta, true);
1540 
1541  TFileDirectory Norm3DPhiRes = fs->mkdir("Norm_3D_Phi_Residuals");
1542  n_d3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_d3D, PVValHelper::phi, true);
1543  n_IP3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::phi, true);
1544 
1545  TFileDirectory Norm3DEtaRes = fs->mkdir("Norm_3D_Eta_Residuals");
1546  n_d3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_d3D, PVValHelper::eta, true);
1547  n_IP3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::eta, true);
1548 
1549  TFileDirectory AbsDoubleDiffRes = fs->mkdir("Abs_DoubleDiffResiduals");
1550  TFileDirectory NormDoubleDiffRes = fs->mkdir("Norm_DoubleDiffResiduals");
1551 
1552  TFileDirectory AbsL1Map = fs->mkdir("Abs_L1Residuals");
1553  TFileDirectory NormL1Map = fs->mkdir("Norm_L1Residuals");
1554 
1555  // book residuals vs pT histograms
1556 
1557  TFileDirectory AbsTranspTRes = fs->mkdir("Abs_Transv_pT_Residuals");
1558  h_dxy_pT_ = bookResidualsHistogram(AbsTranspTRes, nPtBins_, PVValHelper::dxy, PVValHelper::pT);
1559 
1560  TFileDirectory AbsLongpTRes = fs->mkdir("Abs_Long_pT_Residuals");
1561  h_dz_pT_ = bookResidualsHistogram(AbsLongpTRes, nPtBins_, PVValHelper::dz, PVValHelper::pT);
1562 
1563  TFileDirectory NormTranspTRes = fs->mkdir("Norm_Transv_pT_Residuals");
1564  h_norm_dxy_pT_ = bookResidualsHistogram(NormTranspTRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pT, true);
1565 
1566  TFileDirectory NormLongpTRes = fs->mkdir("Norm_Long_pT_Residuals");
1567  h_norm_dz_pT_ = bookResidualsHistogram(NormLongpTRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pT, true);
1568 
1569  // book residuals vs pT histograms in central region (|eta|<1.0)
1570 
1571  TFileDirectory AbsTranspTCentralRes = fs->mkdir("Abs_Transv_pTCentral_Residuals");
1572  h_dxy_Central_pT_ = bookResidualsHistogram(AbsTranspTCentralRes, nPtBins_, PVValHelper::dxy, PVValHelper::pTCentral);
1573 
1574  TFileDirectory AbsLongpTCentralRes = fs->mkdir("Abs_Long_pTCentral_Residuals");
1575  h_dz_Central_pT_ = bookResidualsHistogram(AbsLongpTCentralRes, nPtBins_, PVValHelper::dz, PVValHelper::pTCentral);
1576 
1577  TFileDirectory NormTranspTCentralRes = fs->mkdir("Norm_Transv_pTCentral_Residuals");
1578  h_norm_dxy_Central_pT_ =
1579  bookResidualsHistogram(NormTranspTCentralRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pTCentral, true);
1580 
1581  TFileDirectory NormLongpTCentralRes = fs->mkdir("Norm_Long_pTCentral_Residuals");
1582  h_norm_dz_Central_pT_ =
1583  bookResidualsHistogram(NormLongpTCentralRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pTCentral, true);
1584 
1585  // book residuals vs module number
1586 
1587  TFileDirectory AbsTransModZRes = fs->mkdir("Abs_Transv_modZ_Residuals");
1588  h_dxy_modZ_ = bookResidualsHistogram(AbsTransModZRes, 8, PVValHelper::dxy, PVValHelper::modZ);
1589 
1590  TFileDirectory AbsLongModZRes = fs->mkdir("Abs_Long_modZ_Residuals");
1591  h_dz_modZ_ = bookResidualsHistogram(AbsLongModZRes, 8, PVValHelper::dz, PVValHelper::modZ);
1592 
1593  // _ _ _ _ _ ___ _ _ _
1594  // | \| |___ _ _ _ __ __ _| (_)______ __| | | _ \___ __(_)__| |_ _ __ _| |___
1595  // | .` / _ \ '_| ' \/ _` | | |_ / -_) _` | | / -_|_-< / _` | || / _` | (_-<
1596  // |_|\_\___/_| |_|_|_\__,_|_|_/__\___\__,_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1597  //
1598 
1599  TFileDirectory NormTransModZRes = fs->mkdir("Norm_Transv_modZ_Residuals");
1600  h_norm_dxy_modZ_ = bookResidualsHistogram(NormTransModZRes, 8, PVValHelper::norm_dxy, PVValHelper::modZ, true);
1601 
1602  TFileDirectory NormLongModZRes = fs->mkdir("Norm_Long_modZ_Residuals");
1603  h_norm_dz_modZ_ = bookResidualsHistogram(NormLongModZRes, 8, PVValHelper::norm_dz, PVValHelper::modZ, true);
1604 
1605  TFileDirectory AbsTransLadderRes = fs->mkdir("Abs_Transv_ladder_Residuals");
1606  h_dxy_ladder_ = bookResidualsHistogram(AbsTransLadderRes, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1607 
1608  TFileDirectory AbsTransLadderResOverlap = fs->mkdir("Abs_Transv_ladderOverlap_Residuals");
1609  h_dxy_ladderOverlap_ =
1610  bookResidualsHistogram(AbsTransLadderResOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1611 
1612  TFileDirectory AbsTransLadderResNoOverlap = fs->mkdir("Abs_Transv_ladderNoOverlap_Residuals");
1613  h_dxy_ladderNoOverlap_ =
1614  bookResidualsHistogram(AbsTransLadderResNoOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
1615 
1616  TFileDirectory AbsLongLadderRes = fs->mkdir("Abs_Long_ladder_Residuals");
1617  h_dz_ladder_ = bookResidualsHistogram(AbsLongLadderRes, nLadders_, PVValHelper::dz, PVValHelper::ladder);
1618 
1619  TFileDirectory NormTransLadderRes = fs->mkdir("Norm_Transv_ladder_Residuals");
1620  h_norm_dxy_ladder_ =
1621  bookResidualsHistogram(NormTransLadderRes, nLadders_, PVValHelper::norm_dxy, PVValHelper::ladder, true);
1622 
1623  TFileDirectory NormLongLadderRes = fs->mkdir("Norm_Long_ladder_Residuals");
1624  h_norm_dz_ladder_ =
1625  bookResidualsHistogram(NormLongLadderRes, nLadders_, PVValHelper::norm_dz, PVValHelper::ladder, true);
1626 
1627  // book residuals as function of nLadders and nModules
1628 
1629  for (unsigned int iLadder = 0; iLadder < nLadders_; iLadder++) {
1630  for (unsigned int iModule = 0; iModule < 8; iModule++) {
1631  a_dxyL1ResidualsMap[iLadder][iModule] =
1632  AbsL1Map.make<TH1F>(Form("histo_dxy_ladder%i_module%i", iLadder, iModule),
1633  Form("d_{xy} ladder=%i module=%i;d_{xy} [#mum];tracks", iLadder, iModule),
1634  theDetails_.histobins,
1635  -dzmax_eta,
1636  dzmax_eta);
1637 
1638  a_dzL1ResidualsMap[iLadder][iModule] =
1639  AbsL1Map.make<TH1F>(Form("histo_dz_ladder%i_module%i", iLadder, iModule),
1640  Form("d_{z} ladder=%i module=%i;d_{z} [#mum];tracks", iLadder, iModule),
1641  theDetails_.histobins,
1642  -dzmax_eta,
1643  dzmax_eta);
1644 
1645  n_dxyL1ResidualsMap[iLadder][iModule] =
1646  NormL1Map.make<TH1F>(Form("histo_norm_dxy_ladder%i_module%i", iLadder, iModule),
1647  Form("d_{xy} ladder=%i module=%i;d_{xy}/#sigma_{d_{xy}};tracks", iLadder, iModule),
1648  theDetails_.histobins,
1649  -dzmax_eta / 100,
1650  dzmax_eta / 100);
1651 
1652  n_dzL1ResidualsMap[iLadder][iModule] =
1653  NormL1Map.make<TH1F>(Form("histo_norm_dz_ladder%i_module%i", iLadder, iModule),
1654  Form("d_{z} ladder=%i module=%i;d_{z}/#sigma_{d_{z}};tracks", iLadder, iModule),
1655  theDetails_.histobins,
1656  -dzmax_eta / 100,
1657  dzmax_eta / 100);
1658  }
1659  }
1660 
1661  // book residuals as function of phi and eta
1662 
1663  for (int i = 0; i < nBins_; ++i) {
1664  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
1665  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
1666 
1667  // ___ _ _ ___ _ __ __ ___ _ _ _
1668  // | \ ___ _ _| |__| |___| \(_)/ _|/ _| | _ \___ __(_)__| |_ _ __ _| |___
1669  // | |) / _ \ || | '_ \ / -_) |) | | _| _| | / -_|_-< / _` | || / _` | (_-<
1670  // |___/\___/\_,_|_.__/_\___|___/|_|_| |_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
1671 
1672  for (int j = 0; j < nBins_; ++j) {
1673  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
1674  float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
1675 
1676  a_dxyResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1677  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
1678  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy};tracks", etaF, etaL, phiF, phiL),
1679  theDetails_.histobins,
1680  -dzmax_eta,
1681  dzmax_eta);
1682 
1683  a_dzResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1684  Form("histo_dz_eta_plot%i_phi_plot%i", i, j),
1685  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z};tracks", etaF, etaL, phiF, phiL),
1686  theDetails_.histobins,
1687  -dzmax_eta,
1688  dzmax_eta);
1689 
1690  a_d3DResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
1691  Form("histo_d3D_eta_plot%i_phi_plot%i", i, j),
1692  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D};tracks", etaF, etaL, phiF, phiL),
1693  theDetails_.histobins,
1694  0.,
1695  d3Dmax_eta);
1696 
1697  n_dxyResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1698  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
1699  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
1700  etaF,
1701  etaL,
1702  phiF,
1703  phiL),
1704  theDetails_.histobins,
1705  -dzmax_eta / 100,
1706  dzmax_eta / 100);
1707 
1708  n_dzResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1709  Form("histo_norm_dz_eta_plot%i_phi_plot%i", i, j),
1710  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
1711  etaF,
1712  etaL,
1713  phiF,
1714  phiL),
1715  theDetails_.histobins,
1716  -dzmax_eta / 100,
1717  dzmax_eta / 100);
1718 
1719  n_d3DResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
1720  Form("histo_norm_d3D_eta_plot%i_phi_plot%i", i, j),
1721  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D}/#sigma_{d_{3D}};tracks",
1722  etaF,
1723  etaL,
1724  phiF,
1725  phiL),
1726  theDetails_.histobins,
1727  0.,
1728  d3Dmax_eta);
1729  }
1730  }
1731 
1732  // declaration of the directories
1733 
1734  TFileDirectory BiasVsParameter = fs->mkdir("BiasVsParameter");
1735 
1736  a_dxyVsPhi = BiasVsParameter.make<TH2F>("h2_dxy_vs_phi",
1737  "d_{xy} vs track #phi;track #phi [rad];track d_{xy}(PV) [#mum]",
1738  nBins_,
1739  -M_PI,
1740  M_PI,
1741  theDetails_.histobins,
1742  -dxymax_phi,
1743  dxymax_phi);
1744 
1745  a_dzVsPhi = BiasVsParameter.make<TH2F>("h2_dz_vs_phi",
1746  "d_{z} vs track #phi;track #phi [rad];track d_{z}(PV) [#mum]",
1747  nBins_,
1748  -M_PI,
1749  M_PI,
1750  theDetails_.histobins,
1751  -dzmax_phi,
1752  dzmax_phi);
1753 
1754  n_dxyVsPhi = BiasVsParameter.make<TH2F>(
1755  "h2_n_dxy_vs_phi",
1756  "d_{xy}/#sigma_{d_{xy}} vs track #phi;track #phi [rad];track d_{xy}(PV)/#sigma_{d_{xy}}",
1757  nBins_,
1758  -M_PI,
1759  M_PI,
1760  theDetails_.histobins,
1761  -dxymax_phi / 100.,
1762  dxymax_phi / 100.);
1763 
1764  n_dzVsPhi =
1765  BiasVsParameter.make<TH2F>("h2_n_dz_vs_phi",
1766  "d_{z}/#sigma_{d_{z}} vs track #phi;track #phi [rad];track d_{z}(PV)/#sigma_{d_{z}}",
1767  nBins_,
1768  -M_PI,
1769  M_PI,
1770  theDetails_.histobins,
1771  -dzmax_phi / 100.,
1772  dzmax_phi / 100.);
1773 
1774  a_dxyVsEta = BiasVsParameter.make<TH2F>("h2_dxy_vs_eta",
1775  "d_{xy} vs track #eta;track #eta;track d_{xy}(PV) [#mum]",
1776  nBins_,
1777  -etaOfProbe_,
1778  etaOfProbe_,
1779  theDetails_.histobins,
1780  -dxymax_eta,
1781  dzmax_eta);
1782 
1783  a_dzVsEta = BiasVsParameter.make<TH2F>("h2_dz_vs_eta",
1784  "d_{z} vs track #eta;track #eta;track d_{z}(PV) [#mum]",
1785  nBins_,
1786  -etaOfProbe_,
1787  etaOfProbe_,
1788  theDetails_.histobins,
1789  -dzmax_eta,
1790  dzmax_eta);
1791 
1792  n_dxyVsEta =
1793  BiasVsParameter.make<TH2F>("h2_n_dxy_vs_eta",
1794  "d_{xy}/#sigma_{d_{xy}} vs track #eta;track #eta;track d_{xy}(PV)/#sigma_{d_{xy}}",
1795  nBins_,
1796  -etaOfProbe_,
1797  etaOfProbe_,
1798  theDetails_.histobins,
1799  -dxymax_eta / 100.,
1800  dxymax_eta / 100.);
1801 
1802  n_dzVsEta = BiasVsParameter.make<TH2F>("h2_n_dz_vs_eta",
1803  "d_{z}/#sigma_{d_{z}} vs track #eta;track #eta;track d_{z}(PV)/#sigma_{d_{z}}",
1804  nBins_,
1805  -etaOfProbe_,
1806  etaOfProbe_,
1807  theDetails_.histobins,
1808  -dzmax_eta / 100.,
1809  dzmax_eta / 100.);
1810 
1811  MeanTrendsDir = fs->mkdir("MeanTrends");
1812  WidthTrendsDir = fs->mkdir("WidthTrends");
1813  MedianTrendsDir = fs->mkdir("MedianTrends");
1814  MADTrendsDir = fs->mkdir("MADTrends");
1815 
1816  Mean2DMapsDir = fs->mkdir("MeanMaps");
1817  Width2DMapsDir = fs->mkdir("WidthMaps");
1818 
1819  double highedge = nBins_ - 0.5;
1820  double lowedge = -0.5;
1821 
1822  // means and widths from the fit
1823 
1824  a_dxyPhiMeanTrend =
1825  MeanTrendsDir.make<TH1F>("means_dxy_phi",
1826  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
1827  nBins_,
1828  lowedge,
1829  highedge);
1830 
1831  a_dxyPhiWidthTrend =
1832  WidthTrendsDir.make<TH1F>("widths_dxy_phi",
1833  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
1834  nBins_,
1835  lowedge,
1836  highedge);
1837 
1838  a_dzPhiMeanTrend =
1839  MeanTrendsDir.make<TH1F>("means_dz_phi",
1840  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
1841  nBins_,
1842  lowedge,
1843  highedge);
1844 
1845  a_dzPhiWidthTrend =
1846  WidthTrendsDir.make<TH1F>("widths_dz_phi",
1847  "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
1848  nBins_,
1849  lowedge,
1850  highedge);
1851 
1852  a_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1853  "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
1854 
1855  a_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_eta",
1856  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
1857  nBins_,
1858  lowedge,
1859  highedge);
1860 
1861  a_dzEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1862  "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
1863 
1864  a_dzEtaWidthTrend = WidthTrendsDir.make<TH1F>(
1865  "widths_dz_eta", "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]", nBins_, lowedge, highedge);
1866 
1867  n_dxyPhiMeanTrend = MeanTrendsDir.make<TH1F>(
1868  "norm_means_dxy_phi",
1869  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1870  nBins_,
1871  lowedge,
1872  highedge);
1873 
1874  n_dxyPhiWidthTrend = WidthTrendsDir.make<TH1F>(
1875  "norm_widths_dxy_phi",
1876  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
1877  nBins_,
1878  lowedge,
1879  highedge);
1880 
1881  n_dzPhiMeanTrend = MeanTrendsDir.make<TH1F>(
1882  "norm_means_dz_phi",
1883  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
1884  nBins_,
1885  lowedge,
1886  highedge);
1887 
1888  n_dzPhiWidthTrend = WidthTrendsDir.make<TH1F>(
1889  "norm_widths_dz_phi",
1890  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
1891  nBins_,
1892  lowedge,
1893  highedge);
1894 
1895  n_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
1896  "norm_means_dxy_eta",
1897  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
1898  nBins_,
1899  lowedge,
1900  highedge);
1901 
1902  n_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>(
1903  "norm_widths_dxy_eta",
1904  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
1905  nBins_,
1906  lowedge,
1907  highedge);
1908 
1909  n_dzEtaMeanTrend =
1910  MeanTrendsDir.make<TH1F>("norm_means_dz_eta",
1911  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
1912  nBins_,
1913  lowedge,
1914  highedge);
1915 
1916  n_dzEtaWidthTrend =
1917  WidthTrendsDir.make<TH1F>("norm_widths_dz_eta",
1918  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
1919  nBins_,
1920  lowedge,
1921  highedge);
1922 
1923  // means and widhts vs pT and pTCentral
1924 
1925  a_dxypTMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_pT",
1926  "#LT d_{xy} #GT vs pT;p_{T} [GeV];#LT d_{xy} #GT [#mum]",
1927  mypT_bins_.size() - 1,
1928  mypT_bins_.data());
1929 
1930  a_dxypTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_pT",
1931  "#sigma_{d_{xy}} vs pT;p_{T} [GeV];#sigma_{d_{xy}} [#mum]",
1932  mypT_bins_.size() - 1,
1933  mypT_bins_.data());
1934 
1935  a_dzpTMeanTrend = MeanTrendsDir.make<TH1F>(
1936  "means_dz_pT", "#LT d_{z} #GT vs pT;p_{T} [GeV];#LT d_{z} #GT [#mum]", mypT_bins_.size() - 1, mypT_bins_.data());
1937 
1938  a_dzpTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_pT",
1939  "#sigma_{d_{z}} vs pT;p_{T} [GeV];#sigma_{d_{z}} [#mum]",
1940  mypT_bins_.size() - 1,
1941  mypT_bins_.data());
1942 
1943  n_dxypTMeanTrend =
1944  MeanTrendsDir.make<TH1F>("norm_means_dxy_pT",
1945  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs pT;p_{T} [GeV];#LT d_{xy}/#sigma_{d_{xy}} #GT",
1946  mypT_bins_.size() - 1,
1947  mypT_bins_.data());
1948 
1949  n_dxypTWidthTrend =
1950  WidthTrendsDir.make<TH1F>("norm_widths_dxy_pT",
1951  "width(d_{xy}/#sigma_{d_{xy}}) vs pT;p_{T} [GeV]; width(d_{xy}/#sigma_{d_{xy}})",
1952  mypT_bins_.size() - 1,
1953  mypT_bins_.data());
1954 
1955  n_dzpTMeanTrend =
1956  MeanTrendsDir.make<TH1F>("norm_means_dz_pT",
1957  "#LT d_{z}/#sigma_{d_{z}} #GT vs pT;p_{T} [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
1958  mypT_bins_.size() - 1,
1959  mypT_bins_.data());
1960 
1961  n_dzpTWidthTrend =
1962  WidthTrendsDir.make<TH1F>("norm_widths_dz_pT",
1963  "width(d_{z}/#sigma_{d_{z}}) vs pT;p_{T} [GeV];width(d_{z}/#sigma_{d_{z}})",
1964  mypT_bins_.size() - 1,
1965  mypT_bins_.data());
1966 
1967  a_dxypTCentralMeanTrend =
1968  MeanTrendsDir.make<TH1F>("means_dxy_pTCentral",
1969  "#LT d_{xy} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy} #GT [#mum]",
1970  mypT_bins_.size() - 1,
1971  mypT_bins_.data());
1972 
1973  a_dxypTCentralWidthTrend =
1974  WidthTrendsDir.make<TH1F>("widths_dxy_pTCentral",
1975  "#sigma_{d_{xy}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{xy}} [#mum]",
1976  mypT_bins_.size() - 1,
1977  mypT_bins_.data());
1978 
1979  a_dzpTCentralMeanTrend =
1980  MeanTrendsDir.make<TH1F>("means_dz_pTCentral",
1981  "#LT d_{z} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z} #GT [#mum]",
1982  mypT_bins_.size() - 1,
1983  mypT_bins_.data());
1984 
1985  a_dzpTCentralWidthTrend =
1986  WidthTrendsDir.make<TH1F>("widths_dz_pTCentral",
1987  "#sigma_{d_{z}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{z}} [#mum]",
1988  mypT_bins_.size() - 1,
1989  mypT_bins_.data());
1990 
1991  n_dxypTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
1992  "norm_means_dxy_pTCentral",
1993  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy}/#sigma_{d_{z}} #GT",
1994  mypT_bins_.size() - 1,
1995  mypT_bins_.data());
1996 
1997  n_dxypTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
1998  "norm_widths_dxy_pTCentral",
1999  "width(d_{xy}/#sigma_{d_{xy}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{xy}/#sigma_{d_{z}})",
2000  mypT_bins_.size() - 1,
2001  mypT_bins_.data());
2002 
2003  n_dzpTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
2004  "norm_means_dz_pTCentral",
2005  "#LT d_{z}/#sigma_{d_{z}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
2006  mypT_bins_.size() - 1,
2007  mypT_bins_.data());
2008 
2009  n_dzpTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
2010  "norm_widths_dz_pTCentral",
2011  "width(d_{z}/#sigma_{d_{z}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{z}/#sigma_{d_{z}})",
2012  mypT_bins_.size() - 1,
2013  mypT_bins_.data());
2014 
2015  // 2D maps
2016 
2017  a_dxyMeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_map",
2018  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
2019  nBins_,
2020  lowedge,
2021  highedge,
2022  nBins_,
2023  lowedge,
2024  highedge);
2025 
2026  a_dzMeanMap = Mean2DMapsDir.make<TH2F>("means_dz_map",
2027  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
2028  nBins_,
2029  lowedge,
2030  highedge,
2031  nBins_,
2032  lowedge,
2033  highedge);
2034 
2035  n_dxyMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dxy_map",
2036  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2037  nBins_,
2038  lowedge,
2039  highedge,
2040  nBins_,
2041  lowedge,
2042  highedge);
2043 
2044  n_dzMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_map",
2045  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2046  nBins_,
2047  lowedge,
2048  highedge,
2049  nBins_,
2050  lowedge,
2051  highedge);
2052 
2053  a_dxyWidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_map",
2054  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
2055  nBins_,
2056  lowedge,
2057  highedge,
2058  nBins_,
2059  lowedge,
2060  highedge);
2061 
2062  a_dzWidthMap = Width2DMapsDir.make<TH2F>("widths_dz_map",
2063  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
2064  nBins_,
2065  lowedge,
2066  highedge,
2067  nBins_,
2068  lowedge,
2069  highedge);
2070 
2071  n_dxyWidthMap =
2072  Width2DMapsDir.make<TH2F>("norm_widths_dxy_map",
2073  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
2074  nBins_,
2075  lowedge,
2076  highedge,
2077  nBins_,
2078  lowedge,
2079  highedge);
2080 
2081  n_dzWidthMap = Width2DMapsDir.make<TH2F>("norm_widths_dz_map",
2082  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
2083  nBins_,
2084  lowedge,
2085  highedge,
2086  nBins_,
2087  lowedge,
2088  highedge);
2089 
2090  // medians and MADs
2091 
2092  a_dxyPhiMedianTrend =
2093  MedianTrendsDir.make<TH1F>("medians_dxy_phi",
2094  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
2095  nBins_,
2096  lowedge,
2097  highedge);
2098 
2099  a_dxyPhiMADTrend = MADTrendsDir.make<TH1F>(
2100  "MADs_dxy_phi",
2101  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
2102  nBins_,
2103  lowedge,
2104  highedge);
2105 
2106  a_dzPhiMedianTrend =
2107  MedianTrendsDir.make<TH1F>("medians_dz_phi",
2108  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
2109  nBins_,
2110  lowedge,
2111  highedge);
2112 
2113  a_dzPhiMADTrend = MADTrendsDir.make<TH1F>(
2114  "MADs_dz_phi",
2115  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
2116  nBins_,
2117  lowedge,
2118  highedge);
2119 
2120  a_dxyEtaMedianTrend =
2121  MedianTrendsDir.make<TH1F>("medians_dxy_eta",
2122  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
2123  nBins_,
2124  lowedge,
2125  highedge);
2126 
2127  a_dxyEtaMADTrend =
2128  MADTrendsDir.make<TH1F>("MADs_dxy_eta",
2129  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
2130  nBins_,
2131  lowedge,
2132  highedge);
2133 
2134  a_dzEtaMedianTrend =
2135  MedianTrendsDir.make<TH1F>("medians_dz_eta",
2136  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
2137  nBins_,
2138  lowedge,
2139  highedge);
2140 
2141  a_dzEtaMADTrend =
2142  MADTrendsDir.make<TH1F>("MADs_dz_eta",
2143  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
2144  nBins_,
2145  lowedge,
2146  highedge);
2147 
2148  n_dxyPhiMedianTrend = MedianTrendsDir.make<TH1F>(
2149  "norm_medians_dxy_phi",
2150  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
2151  nBins_,
2152  lowedge,
2153  highedge);
2154 
2155  n_dxyPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
2156  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
2157  "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
2158  nBins_,
2159  lowedge,
2160  highedge);
2161 
2162  n_dzPhiMedianTrend = MedianTrendsDir.make<TH1F>(
2163  "norm_medians_dz_phi",
2164  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2165  nBins_,
2166  lowedge,
2167  highedge);
2168 
2169  n_dzPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dz_phi",
2170  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi "
2171  "(sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
2172  nBins_,
2173  lowedge,
2174  highedge);
2175 
2176  n_dxyEtaMedianTrend = MedianTrendsDir.make<TH1F>(
2177  "norm_medians_dxy_eta",
2178  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
2179  nBins_,
2180  lowedge,
2181  highedge);
2182 
2183  n_dxyEtaMADTrend = MADTrendsDir.make<TH1F>(
2184  "norm_MADs_dxy_eta",
2185  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
2186  nBins_,
2187  lowedge,
2188  highedge);
2189 
2190  n_dzEtaMedianTrend = MedianTrendsDir.make<TH1F>(
2191  "norm_medians_dz_eta",
2192  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2193  nBins_,
2194  lowedge,
2195  highedge);
2196 
2197  n_dzEtaMADTrend = MADTrendsDir.make<TH1F>(
2198  "norm_MADs_dz_eta",
2199  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
2200  nBins_,
2201  lowedge,
2202  highedge);
2203 
2205  //
2206  // plots of biased residuals
2207  // The vertex includes the probe track
2208  //
2210 
2211  if (useTracksFromRecoVtx_) {
2212  TFileDirectory AbsTransPhiBiasRes = fs->mkdir("Abs_Transv_Phi_BiasResiduals");
2213  a_dxyPhiBiasResiduals = bookResidualsHistogram(AbsTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
2214 
2215  TFileDirectory AbsTransEtaBiasRes = fs->mkdir("Abs_Transv_Eta_BiasResiduals");
2216  a_dxyEtaBiasResiduals = bookResidualsHistogram(AbsTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
2217 
2218  TFileDirectory AbsLongPhiBiasRes = fs->mkdir("Abs_Long_Phi_BiasResiduals");
2219  a_dzPhiBiasResiduals = bookResidualsHistogram(AbsLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
2220 
2221  TFileDirectory AbsLongEtaBiasRes = fs->mkdir("Abs_Long_Eta_BiasResiduals");
2222  a_dzEtaBiasResiduals = bookResidualsHistogram(AbsLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
2223 
2224  TFileDirectory NormTransPhiBiasRes = fs->mkdir("Norm_Transv_Phi_BiasResiduals");
2225  n_dxyPhiBiasResiduals = bookResidualsHistogram(NormTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
2226 
2227  TFileDirectory NormTransEtaBiasRes = fs->mkdir("Norm_Transv_Eta_BiasResiduals");
2228  n_dxyEtaBiasResiduals = bookResidualsHistogram(NormTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
2229 
2230  TFileDirectory NormLongPhiBiasRes = fs->mkdir("Norm_Long_Phi_BiasResiduals");
2231  n_dzPhiBiasResiduals = bookResidualsHistogram(NormLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
2232 
2233  TFileDirectory NormLongEtaBiasRes = fs->mkdir("Norm_Long_Eta_BiasResiduals");
2234  n_dzEtaBiasResiduals = bookResidualsHistogram(NormLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
2235 
2236  TFileDirectory AbsDoubleDiffBiasRes = fs->mkdir("Abs_DoubleDiffBiasResiduals");
2237  TFileDirectory NormDoubleDiffBiasRes = fs->mkdir("Norm_DoubleDiffBiasResiduals");
2238 
2239  for (int i = 0; i < nBins_; ++i) {
2240  float phiF = theDetails_.trendbins[PVValHelper::phi][i];
2241  float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
2242 
2243  for (int j = 0; j < nBins_; ++j) {
2244  float etaF = theDetails_.trendbins[PVValHelper::eta][j];
2245  float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
2246 
2247  a_dxyBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
2248  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
2249  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy} [#mum];tracks", etaF, etaL, phiF, phiL),
2250  theDetails_.histobins,
2251  -dzmax_eta,
2252  dzmax_eta);
2253 
2254  a_dzBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
2255  Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
2256  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z} [#mum];tracks", etaF, etaL, phiF, phiL),
2257  theDetails_.histobins,
2258  -dzmax_eta,
2259  dzmax_eta);
2260 
2261  n_dxyBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
2262  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
2263  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
2264  etaF,
2265  etaL,
2266  phiF,
2267  phiL),
2268  theDetails_.histobins,
2269  -dzmax_eta / 100,
2270  dzmax_eta / 100);
2271 
2272  n_dzBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
2273  Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
2274  Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
2275  etaF,
2276  etaL,
2277  phiF,
2278  phiL),
2279  theDetails_.histobins,
2280  -dzmax_eta / 100,
2281  dzmax_eta / 100);
2282  }
2283  }
2284 
2285  // declaration of the directories
2286 
2287  TFileDirectory MeanBiasTrendsDir = fs->mkdir("MeanBiasTrends");
2288  TFileDirectory WidthBiasTrendsDir = fs->mkdir("WidthBiasTrends");
2289  TFileDirectory MedianBiasTrendsDir = fs->mkdir("MedianBiasTrends");
2290  TFileDirectory MADBiasTrendsDir = fs->mkdir("MADBiasTrends");
2291 
2292  TFileDirectory Mean2DBiasMapsDir = fs->mkdir("MeanBiasMaps");
2293  TFileDirectory Width2DBiasMapsDir = fs->mkdir("WidthBiasMaps");
2294 
2295  // means and widths from the fit
2296 
2297  a_dxyPhiMeanBiasTrend =
2298  MeanBiasTrendsDir.make<TH1F>("means_dxy_phi",
2299  "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
2300  nBins_,
2301  lowedge,
2302  highedge);
2303 
2304  a_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2305  "widths_dxy_phi",
2306  "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
2307  nBins_,
2308  lowedge,
2309  highedge);
2310 
2311  a_dzPhiMeanBiasTrend =
2312  MeanBiasTrendsDir.make<TH1F>("means_dz_phi",
2313  "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
2314  nBins_,
2315  lowedge,
2316  highedge);
2317 
2318  a_dzPhiWidthBiasTrend =
2319  WidthBiasTrendsDir.make<TH1F>("widths_dz_phi",
2320  "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
2321  nBins_,
2322  lowedge,
2323  highedge);
2324 
2325  a_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2326  "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
2327 
2328  a_dxyEtaWidthBiasTrend =
2329  WidthBiasTrendsDir.make<TH1F>("widths_dxy_eta",
2330  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
2331  nBins_,
2332  lowedge,
2333  highedge);
2334 
2335  a_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2336  "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
2337 
2338  a_dzEtaWidthBiasTrend =
2339  WidthBiasTrendsDir.make<TH1F>("widths_dz_eta",
2340  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]",
2341  nBins_,
2342  lowedge,
2343  highedge);
2344 
2345  n_dxyPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2346  "norm_means_dxy_phi",
2347  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
2348  nBins_,
2349  lowedge,
2350  highedge);
2351 
2352  n_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2353  "norm_widths_dxy_phi",
2354  "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
2355  nBins_,
2356  lowedge,
2357  highedge);
2358 
2359  n_dzPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2360  "norm_means_dz_phi",
2361  "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
2362  nBins_,
2363  lowedge,
2364  highedge);
2365 
2366  n_dzPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2367  "norm_widths_dz_phi",
2368  "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
2369  nBins_,
2370  lowedge,
2371  highedge);
2372 
2373  n_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2374  "norm_means_dxy_eta",
2375  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
2376  nBins_,
2377  lowedge,
2378  highedge);
2379 
2380  n_dxyEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2381  "norm_widths_dxy_eta",
2382  "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
2383  nBins_,
2384  lowedge,
2385  highedge);
2386 
2387  n_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
2388  "norm_means_dz_eta",
2389  "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
2390  nBins_,
2391  lowedge,
2392  highedge);
2393 
2394  n_dzEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
2395  "norm_widths_dz_eta",
2396  "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
2397  nBins_,
2398  lowedge,
2399  highedge);
2400 
2401  // 2D maps
2402 
2403  a_dxyMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dxy_map",
2404  "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
2405  nBins_,
2406  lowedge,
2407  highedge,
2408  nBins_,
2409  lowedge,
2410  highedge);
2411 
2412  a_dzMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dz_map",
2413  "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
2414  nBins_,
2415  lowedge,
2416  highedge,
2417  nBins_,
2418  lowedge,
2419  highedge);
2420 
2421  n_dxyMeanBiasMap =
2422  Mean2DBiasMapsDir.make<TH2F>("norm_means_dxy_map",
2423  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2424  nBins_,
2425  lowedge,
2426  highedge,
2427  nBins_,
2428  lowedge,
2429  highedge);
2430 
2431  n_dzMeanBiasMap =
2432  Mean2DBiasMapsDir.make<TH2F>("norm_means_dz_map",
2433  "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
2434  nBins_,
2435  lowedge,
2436  highedge,
2437  nBins_,
2438  lowedge,
2439  highedge);
2440 
2441  a_dxyWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dxy_map",
2442  "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
2443  nBins_,
2444  lowedge,
2445  highedge,
2446  nBins_,
2447  lowedge,
2448  highedge);
2449 
2450  a_dzWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dz_map",
2451  "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
2452  nBins_,
2453  lowedge,
2454  highedge,
2455  nBins_,
2456  lowedge,
2457  highedge);
2458 
2459  n_dxyWidthBiasMap =
2460  Width2DBiasMapsDir.make<TH2F>("norm_widths_dxy_map",
2461  "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
2462  nBins_,
2463  lowedge,
2464  highedge,
2465  nBins_,
2466  lowedge,
2467  highedge);
2468 
2469  n_dzWidthBiasMap =
2470  Width2DBiasMapsDir.make<TH2F>("norm_widths_dz_map",
2471  "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
2472  nBins_,
2473  lowedge,
2474  highedge,
2475  nBins_,
2476  lowedge,
2477  highedge);
2478 
2479  // medians and MADs
2480 
2481  a_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2482  "medians_dxy_phi",
2483  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
2484  nBins_,
2485  lowedge,
2486  highedge);
2487 
2488  a_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2489  "MADs_dxy_phi",
2490  "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
2491  nBins_,
2492  lowedge,
2493  highedge);
2494 
2495  a_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2496  "medians_dz_phi",
2497  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
2498  nBins_,
2499  lowedge,
2500  highedge);
2501 
2502  a_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2503  "MADs_dz_phi",
2504  "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
2505  nBins_,
2506  lowedge,
2507  highedge);
2508 
2509  a_dxyEtaMedianBiasTrend =
2510  MedianBiasTrendsDir.make<TH1F>("medians_dxy_eta",
2511  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
2512  nBins_,
2513  lowedge,
2514  highedge);
2515 
2516  a_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2517  "MADs_dxy_eta",
2518  "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
2519  nBins_,
2520  lowedge,
2521  highedge);
2522 
2523  a_dzEtaMedianBiasTrend =
2524  MedianBiasTrendsDir.make<TH1F>("medians_dz_eta",
2525  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
2526  nBins_,
2527  lowedge,
2528  highedge);
2529 
2530  a_dzEtaMADBiasTrend =
2531  MADBiasTrendsDir.make<TH1F>("MADs_dz_eta",
2532  "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
2533  nBins_,
2534  lowedge,
2535  highedge);
2536 
2537  n_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2538  "norm_medians_dxy_phi",
2539  "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
2540  nBins_,
2541  lowedge,
2542  highedge);
2543 
2544  n_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
2545  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
2546  "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
2547  nBins_,
2548  lowedge,
2549  highedge);
2550 
2551  n_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2552  "norm_medians_dz_phi",
2553  "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2554  nBins_,
2555  lowedge,
2556  highedge);
2557 
2558  n_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dz_phi",
2559  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi "
2560  "sector;#varphi (sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
2561  nBins_,
2562  lowedge,
2563  highedge);
2564 
2565  n_dxyEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2566  "norm_medians_dxy_eta",
2567  "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
2568  nBins_,
2569  lowedge,
2570  highedge);
2571 
2572  n_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2573  "norm_MADs_dxy_eta",
2574  "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
2575  nBins_,
2576  lowedge,
2577  highedge);
2578 
2579  n_dzEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
2580  "norm_medians_dz_eta",
2581  "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
2582  nBins_,
2583  lowedge,
2584  highedge);
2585 
2586  n_dzEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
2587  "norm_MADs_dz_eta",
2588  "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
2589  nBins_,
2590  lowedge,
2591  highedge);
2592  }
2593 }

References a_d3DEtaResiduals, a_d3DPhiResiduals, a_d3DResidualsMap, a_dxEtaResiduals, a_dxPhiResiduals, a_dxyBiasResidualsMap, a_dxyEtaBiasResiduals, a_dxyEtaMADBiasTrend, a_dxyEtaMADTrend, a_dxyEtaMeanBiasTrend, a_dxyEtaMeanTrend, a_dxyEtaMedianBiasTrend, a_dxyEtaMedianTrend, a_dxyEtaResiduals, a_dxyEtaWidthBiasTrend, a_dxyEtaWidthTrend, a_dxyL1ResidualsMap, a_dxyMeanBiasMap, a_dxyMeanMap, a_dxyPhiBiasResiduals, a_dxyPhiMADBiasTrend, a_dxyPhiMADTrend, a_dxyPhiMeanBiasTrend, a_dxyPhiMeanTrend, a_dxyPhiMedianBiasTrend, a_dxyPhiMedianTrend, a_dxyPhiResiduals, a_dxyPhiWidthBiasTrend, a_dxyPhiWidthTrend, a_dxypTCentralMeanTrend, a_dxypTCentralWidthTrend, a_dxypTMeanTrend, a_dxypTWidthTrend, a_dxyResidualsMap, a_dxyVsEta, a_dxyVsPhi, a_dxyWidthBiasMap, a_dxyWidthMap, a_dyEtaResiduals, a_dyPhiResiduals, a_dzBiasResidualsMap, a_dzEtaBiasResiduals, a_dzEtaMADBiasTrend, a_dzEtaMADTrend, a_dzEtaMeanBiasTrend, a_dzEtaMeanTrend, a_dzEtaMedianBiasTrend, a_dzEtaMedianTrend, a_dzEtaResiduals, a_dzEtaWidthBiasTrend, a_dzEtaWidthTrend, a_dzL1ResidualsMap, a_dzMeanBiasMap, a_dzMeanMap, a_dzPhiBiasResiduals, a_dzPhiMADBiasTrend, a_dzPhiMADTrend, a_dzPhiMeanBiasTrend, a_dzPhiMeanTrend, a_dzPhiMedianBiasTrend, a_dzPhiMedianTrend, a_dzPhiResiduals, a_dzPhiWidthBiasTrend, a_dzPhiWidthTrend, a_dzpTCentralMeanTrend, a_dzpTCentralWidthTrend, a_dzpTMeanTrend, a_dzpTWidthTrend, a_dzResidualsMap, a_dzVsEta, a_dzVsPhi, a_dzWidthBiasMap, a_dzWidthMap, a_IP2DEtaResiduals, a_IP2DPhiResiduals, a_IP3DEtaResiduals, a_IP3DPhiResiduals, a_reszEtaResiduals, a_reszPhiResiduals, Beamdxdz_, Beamsigmaz_, BeamWidthX_, BeamWidthY_, bookResidualsHistogram(), bookVertexHistograms(), BSx0_, BSy0_, BSz0_, charge_, chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2ProbUnbiasedVertex_, chi2UnbiasedVertex_, compressionSettings_, PVValHelper::d3D, d3DFromMyVertex_, DOFUnbiasedVertex_, PVValHelper::dx, PVValHelper::dxy, dxy_, dxyBs_, dxyErrorFromMyVertex_, dxyFromMyVertex_, PVValHelper::dy, PVValHelper::dz, dz_, dzBs_, dzErrorFromMyVertex_, dzFromMyVertex_, PVValHelper::eta, eta_, etaOfProbe_, EventNumber_, TFileService::file(), fs, PVValHelper::histodetails::getHigh(), h2_probeEtaPhi_, h2_probeEtaPt_, h2_probeLayer1Map_, h2_probePassingLayer1Map_, h_Beamsigmaz, h_BeamWidthX, h_BeamWidthY, h_BSx0, h_BSy0, h_BSz0, h_dxy_Central_pT_, h_dxy_ladder_, h_dxy_ladderNoOverlap_, h_dxy_ladderOverlap_, h_dxy_modZ_, h_dxy_pT_, h_dz_Central_pT_, h_dz_ladder_, h_dz_modZ_, h_dz_pT_, h_etaMax, h_fitVtxChi2_, h_fitVtxChi2ndf_, h_fitVtxChi2Prob_, h_fitVtxNdof_, h_fitVtxNtracks_, h_fitVtxTrackAverageWeight_, h_fitVtxTrackWeights_, h_lumiFromConfig, h_nbins, h_nClus, h_nLadders, h_nOfflineVertices, h_norm_dxy_Central_pT_, h_norm_dxy_ladder_, h_norm_dxy_modZ_, h_norm_dxy_pT_, h_norm_dz_Central_pT_, h_norm_dz_ladder_, h_norm_dz_modZ_, h_norm_dz_pT_, h_nTracks, h_probeCharge_, h_probeChi2_, h_probed0RefitV_, h_probed3DRefitV_, h_probedxyRecoV_, h_probedxyRefitV_, h_probedzRecoV_, h_probedzRefitV_, h_probeEta_, h_probeHasBPixL1Overlap_, h_probeHits1D_, h_probeHits2D_, h_probeHits_, h_probeHitsInBPIX_, h_probeHitsInFPIX_, h_probeHitsInTEC_, h_probeHitsInTIB_, h_probeHitsInTID_, h_probeHitsInTOB_, h_probeL1ClusterProb_, h_probeL1Ladder_, h_probeL1Module_, h_probeNormChi2_, h_probeP_, h_probePhi_, h_probePt_, h_probePtRebin_, h_probeQoverP_, h_probeRecoVSigXY_, h_probeRecoVSigZ_, h_probeRefitVLogSig3D_, h_probeRefitVSig3D_, h_probeRefitVSigResZ_, h_probeRefitVSigXY_, h_probeRefitVSigZ_, h_probereszRefitV_, h_probesignIP2DRefitV_, h_probez0RefitV_, h_pTinfo, h_recoVtxChi2ndf_, h_recoVtxChi2Prob_, h_recoVtxNtracks_, h_recoVtxSumPt_, h_runFromConfig, h_runFromEvent, h_runNumber, h_xErrOfflineVertex, h_xOfflineVertex, h_yErrOfflineVertex, h_yOfflineVertex, h_zErrOfflineVertex, h_zOfflineVertex, hasRecVertex_, hDA, MonitorHOAlCaRecoStream_cfi::highedge, PVValHelper::histodetails::histobins, mps_fire::i, intLumi_, PVValHelper::IP2D, PVValHelper::IP3D, IP3DsigFromMyVertex_, IPLsigFromMyVertex_, IPTsigFromMyVertex_, isGoodTrack_, isHighPurity_, dqmiolumiharvest::j, PVValHelper::ladder, lightNtupleSwitch_, MonitorHOAlCaRecoStream_cfi::lowedge, LuminosityBlockNumber_, M_PI, MADTrendsDir, TFileDirectory::make(), TFileService::make(), Mean2DMapsDir, MeanTrendsDir, MedianTrendsDir, TFileService::mkdir(), PVValHelper::modZ, mypT_bins_, n_d3DEtaResiduals, n_d3DPhiResiduals, n_d3DResidualsMap, n_dxyBiasResidualsMap, n_dxyEtaBiasResiduals, n_dxyEtaMADBiasTrend, n_dxyEtaMADTrend, n_dxyEtaMeanBiasTrend, n_dxyEtaMeanTrend, n_dxyEtaMedianBiasTrend, n_dxyEtaMedianTrend, n_dxyEtaResiduals, n_dxyEtaWidthBiasTrend, n_dxyEtaWidthTrend, n_dxyL1ResidualsMap, n_dxyMeanBiasMap, n_dxyMeanMap, n_dxyPhiBiasResiduals, n_dxyPhiMADBiasTrend, n_dxyPhiMADTrend, n_dxyPhiMeanBiasTrend, n_dxyPhiMeanTrend, n_dxyPhiMedianBiasTrend, n_dxyPhiMedianTrend, n_dxyPhiResiduals, n_dxyPhiWidthBiasTrend, n_dxyPhiWidthTrend, n_dxypTCentralMeanTrend, n_dxypTCentralWidthTrend, n_dxypTMeanTrend, n_dxypTWidthTrend, n_dxyResidualsMap, n_dxyVsEta, n_dxyVsPhi, n_dxyWidthBiasMap, n_dxyWidthMap, n_dzBiasResidualsMap, n_dzEtaBiasResiduals, n_dzEtaMADBiasTrend, n_dzEtaMADTrend, n_dzEtaMeanBiasTrend, n_dzEtaMeanTrend, n_dzEtaMedianBiasTrend, n_dzEtaMedianTrend, n_dzEtaResiduals, n_dzEtaWidthBiasTrend, n_dzEtaWidthTrend, n_dzL1ResidualsMap, n_dzMeanBiasMap, n_dzMeanMap, n_dzPhiBiasResiduals, n_dzPhiMADBiasTrend, n_dzPhiMADTrend, n_dzPhiMeanBiasTrend, n_dzPhiMeanTrend, n_dzPhiMedianBiasTrend, n_dzPhiMedianTrend, n_dzPhiResiduals, n_dzPhiWidthBiasTrend, n_dzPhiWidthTrend, n_dzpTCentralMeanTrend, n_dzpTCentralWidthTrend, n_dzpTMeanTrend, n_dzpTWidthTrend, n_dzResidualsMap, n_dzVsEta, n_dzVsPhi, n_dzWidthBiasMap, n_dzWidthMap, n_IP2DEtaResiduals, n_IP2DPhiResiduals, n_IP3DEtaResiduals, n_IP3DPhiResiduals, n_reszEtaResiduals, n_reszPhiResiduals, nBins_, nClus_, Nevt_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nLadders_, nOfflineVertices_, PVValHelper::norm_d3D, PVValHelper::norm_dxy, PVValHelper::norm_dz, PVValHelper::norm_IP2D, PVValHelper::norm_IP3D, PVValHelper::norm_resz, nPtBins_, nTracks_, nTracksPerClus_, p_, PVValHelper::phi, phi_, PVValHelper::pT, pt_, PVValHelper::pTCentral, qoverp_, PVValHelper::resz, rootTree_, writedatasetfile::run, runControlNumbers_, RunNumber_, sumOfWeightsUnbiasedVertex_, theDetails_, theta_, tracksUsedForVertexing_, PVValHelper::histodetails::trendbins, useTracksFromRecoVtx_, Width2DMapsDir, WidthTrendsDir, xOfflineVertex_, xPCA_, xUnbiasedVertex_, yOfflineVertex_, yPCA_, yUnbiasedVertex_, zOfflineVertex_, zPCA_, and zUnbiasedVertex_.

◆ bookResidualsHistogram()

std::vector< TH1F * > PrimaryVertexValidation::bookResidualsHistogram ( const TFileDirectory &  dir,
unsigned int  theNOfBins,
PVValHelper::residualType  resType,
PVValHelper::plotVariable  varType,
bool  isNormalized = false 
)
private

Definition at line 3412 of file PrimaryVertexValidation.cc.

3416  {
3417  TH1F::SetDefaultSumw2(kTRUE);
3418 
3419  auto hash = std::make_pair(resType, varType);
3420 
3421  double down = theDetails_.range[hash].first;
3422  double up = theDetails_.range[hash].second;
3423 
3424  if (isNormalized) {
3425  up = up / 100.;
3426  down = down / 100.;
3427  }
3428 
3429  std::vector<TH1F*> h;
3430  h.reserve(theNOfBins);
3431 
3432  if (theNOfBins == 0) {
3433  edm::LogError("PrimaryVertexValidation")
3434  << "bookResidualsHistogram() The number of bins cannot be identically 0" << std::endl;
3435  assert(false);
3436  }
3437 
3438  std::string s_resType = std::get<0>(PVValHelper::getTypeString(resType));
3439  std::string s_varType = std::get<0>(PVValHelper::getVarString(varType));
3440 
3441  std::string t_resType = std::get<1>(PVValHelper::getTypeString(resType));
3442  std::string t_varType = std::get<1>(PVValHelper::getVarString(varType));
3443  std::string units = std::get<2>(PVValHelper::getTypeString(resType));
3444 
3445  for (unsigned int i = 0; i < theNOfBins; i++) {
3446  TString title = (varType == PVValHelper::phi || varType == PVValHelper::eta)
3447  ? Form("%s vs %s - bin %i (%f < %s < %f);%s %s;tracks",
3448  t_resType.c_str(),
3449  t_varType.c_str(),
3450  i,
3451  theDetails_.trendbins[varType][i],
3452  t_varType.c_str(),
3453  theDetails_.trendbins[varType][i + 1],
3454  t_resType.c_str(),
3455  units.c_str())
3456  : Form("%s vs %s - bin %i;%s %s;tracks",
3457  t_resType.c_str(),
3458  t_varType.c_str(),
3459  i,
3460  t_resType.c_str(),
3461  units.c_str());
3462 
3463  TH1F* htemp = dir.make<TH1F>(
3464  Form("histo_%s_%s_plot%i", s_resType.c_str(), s_varType.c_str(), i),
3465  //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()),
3466  title.Data(),
3467  theDetails_.histobins,
3468  down,
3469  up);
3470  h.push_back(htemp);
3471  }
3472 
3473  return h;
3474 }

References cms::cuda::assert(), DeadROC_duringRun::dir, down, PVValHelper::eta, PVValHelper::getTypeString(), PVValHelper::getVarString(), h, cond::hash, PVValHelper::histodetails::histobins, mps_fire::i, PVValHelper::phi, PVValHelper::histodetails::range, AlCaHLTBitMon_QueryRunRegistry::string, theDetails_, runGCPTkAlMap::title, PVValHelper::histodetails::trendbins, units(), up, and dumpRecoGeometry_cfg::varType.

Referenced by beginJob().

◆ bookVertexHistograms()

std::map< std::string, TH1 * > PrimaryVertexValidation::bookVertexHistograms ( const TFileDirectory &  dir)
private

Definition at line 3290 of file PrimaryVertexValidation.cc.

3292 {
3293  TH1F::SetDefaultSumw2(kTRUE);
3294 
3295  std::map<std::string, TH1*> h;
3296 
3297  // histograms of track quality (Data and MC)
3298  std::string types[] = {"all", "sel"};
3299  for (const auto& type : types) {
3300  h["pseudorapidity_" + type] =
3301  dir.make<TH1F>(("rapidity_" + type).c_str(), "track pseudorapidity; track #eta; tracks", 100, -3., 3.);
3302  h["z0_" + type] = dir.make<TH1F>(("z0_" + type).c_str(), "track z_{0};track z_{0} (cm);tracks", 80, -40., 40.);
3303  h["phi_" + type] = dir.make<TH1F>(("phi_" + type).c_str(), "track #phi; track #phi;tracks", 80, -M_PI, M_PI);
3304  h["eta_" + type] = dir.make<TH1F>(("eta_" + type).c_str(), "track #eta; track #eta;tracks", 80, -4., 4.);
3305  h["pt_" + type] = dir.make<TH1F>(("pt_" + type).c_str(), "track p_{T}; track p_{T} [GeV];tracks", 100, 0., 20.);
3306  h["p_" + type] = dir.make<TH1F>(("p_" + type).c_str(), "track p; track p [GeV];tracks", 100, 0., 20.);
3307  h["found_" + type] =
3308  dir.make<TH1F>(("found_" + type).c_str(), "n. found hits;n^{found}_{hits};tracks", 30, 0., 30.);
3309  h["lost_" + type] = dir.make<TH1F>(("lost_" + type).c_str(), "n. lost hits;n^{lost}_{hits};tracks", 20, 0., 20.);
3310  h["nchi2_" + type] =
3311  dir.make<TH1F>(("nchi2_" + type).c_str(), "normalized track #chi^{2};track #chi^{2}/ndf;tracks", 100, 0., 20.);
3312  h["rstart_" + type] = dir.make<TH1F>(
3313  ("rstart_" + type).c_str(), "track start radius; track innermost radius r (cm);tracks", 100, 0., 20.);
3314  h["expectedInner_" + type] = dir.make<TH1F>(
3315  ("expectedInner_" + type).c_str(), "n. expected inner hits;n^{expected}_{inner};tracks", 10, 0., 10.);
3316  h["expectedOuter_" + type] = dir.make<TH1F>(
3317  ("expectedOuter_" + type).c_str(), "n. expected outer hits;n^{expected}_{outer};tracks ", 10, 0., 10.);
3318  h["logtresxy_" + type] =
3319  dir.make<TH1F>(("logtresxy_" + type).c_str(),
3320  "log10(track r-#phi resolution/#mum);log10(track r-#phi resolution/#mum);tracks",
3321  100,
3322  0.,
3323  5.);
3324  h["logtresz_" + type] = dir.make<TH1F>(("logtresz_" + type).c_str(),
3325  "log10(track z resolution/#mum);log10(track z resolution/#mum);tracks",
3326  100,
3327  0.,
3328  5.);
3329  h["tpullxy_" + type] =
3330  dir.make<TH1F>(("tpullxy_" + type).c_str(), "track r-#phi pull;pull_{r-#phi};tracks", 100, -10., 10.);
3331  h["tpullz_" + type] =
3332  dir.make<TH1F>(("tpullz_" + type).c_str(), "track r-z pull;pull_{r-z};tracks", 100, -50., 50.);
3333  h["tlogDCAxy_" + type] = dir.make<TH1F>(
3334  ("tlogDCAxy_" + type).c_str(), "track log_{10}(DCA_{r-#phi});track log_{10}(DCA_{r-#phi});tracks", 200, -5., 3.);
3335  h["tlogDCAz_" + type] = dir.make<TH1F>(
3336  ("tlogDCAz_" + type).c_str(), "track log_{10}(DCA_{r-z});track log_{10}(DCA_{r-z});tracks", 200, -5., 5.);
3337  h["lvseta_" + type] = dir.make<TH2F>(
3338  ("lvseta_" + type).c_str(), "cluster length vs #eta;track #eta;cluster length", 60, -3., 3., 20, 0., 20);
3339  h["lvstanlambda_" + type] = dir.make<TH2F>(("lvstanlambda_" + type).c_str(),
3340  "cluster length vs tan #lambda; tan#lambda;cluster length",
3341  60,
3342  -6.,
3343  6.,
3344  20,
3345  0.,
3346  20);
3347  h["restrkz_" + type] =
3348  dir.make<TH1F>(("restrkz_" + type).c_str(), "z-residuals (track vs vertex);res_{z} (cm);tracks", 200, -5., 5.);
3349  h["restrkzvsphi_" + type] = dir.make<TH2F>(("restrkzvsphi_" + type).c_str(),
3350  "z-residuals (track - vertex) vs track #phi;track #phi;res_{z} (cm)",
3351  12,
3352  -M_PI,
3353  M_PI,
3354  100,
3355  -0.5,
3356  0.5);
3357  h["restrkzvseta_" + type] = dir.make<TH2F>(("restrkzvseta_" + type).c_str(),
3358  "z-residuals (track - vertex) vs track #eta;track #eta;res_{z} (cm)",
3359  12,
3360  -3.,
3361  3.,
3362  200,
3363  -0.5,
3364  0.5);
3365  h["pulltrkzvsphi_" + type] =
3366  dir.make<TH2F>(("pulltrkzvsphi_" + type).c_str(),
3367  "normalized z-residuals (track - vertex) vs track #phi;track #phi;res_{z}/#sigma_{res_{z}}",
3368  12,
3369  -M_PI,
3370  M_PI,
3371  100,
3372  -5.,
3373  5.);
3374  h["pulltrkzvseta_" + type] =
3375  dir.make<TH2F>(("pulltrkzvseta_" + type).c_str(),
3376  "normalized z-residuals (track - vertex) vs track #eta;track #eta;res_{z}/#sigma_{res_{z}}",
3377  12,
3378  -3.,
3379  3.,
3380  100,
3381  -5.,
3382  5.);
3383  h["pulltrkz_" + type] = dir.make<TH1F>(("pulltrkz_" + type).c_str(),
3384  "normalized z-residuals (track vs vertex);res_{z}/#sigma_{res_{z}};tracks",
3385  100,
3386  -5.,
3387  5.);
3388  h["sigmatrkz0_" + type] = dir.make<TH1F>(
3389  ("sigmatrkz0_" + type).c_str(), "z-resolution (excluding beam);#sigma^{trk}_{z_{0}} (cm);tracks", 100, 0., 5.);
3390  h["sigmatrkz_" + type] = dir.make<TH1F>(
3391  ("sigmatrkz_" + type).c_str(), "z-resolution (including beam);#sigma^{trk}_{z} (cm);tracks", 100, 0., 5.);
3392  h["nbarrelhits_" + type] = dir.make<TH1F>(
3393  ("nbarrelhits_" + type).c_str(), "number of pixel barrel hits;n. hits Barrel Pixel;tracks", 10, 0., 10.);
3394  h["nbarrelLayers_" + type] = dir.make<TH1F>(
3395  ("nbarrelLayers_" + type).c_str(), "number of pixel barrel layers;n. layers Barrel Pixel;tracks", 10, 0., 10.);
3396  h["nPxLayers_" + type] = dir.make<TH1F>(
3397  ("nPxLayers_" + type).c_str(), "number of pixel layers (barrel+endcap);n. Pixel layers;tracks", 10, 0., 10.);
3398  h["nSiLayers_" + type] =
3399  dir.make<TH1F>(("nSiLayers_" + type).c_str(), "number of Tracker layers;n. Tracker layers;tracks", 20, 0., 20.);
3400  h["trackAlgo_" + type] =
3401  dir.make<TH1F>(("trackAlgo_" + type).c_str(), "track algorithm;track algo;tracks", 30, 0., 30.);
3402  h["trackQuality_" + type] =
3403  dir.make<TH1F>(("trackQuality_" + type).c_str(), "track quality;track quality;tracks", 7, -1., 6.);
3404  }
3405 
3406  return h;
3407 }

References DeadROC_duringRun::dir, h, M_PI, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginJob().

◆ endJob()

void PrimaryVertexValidation::endJob ( void  )
overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 2595 of file PrimaryVertexValidation.cc.

2595  {
2596  TFileDirectory RunFeatures = fs->mkdir("RunFeatures");
2597  h_runStartTimes = RunFeatures.make<TH1I>(
2598  "runStartTimes", "run start times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
2599  h_runEndTimes =
2600  RunFeatures.make<TH1I>("runEndTimes", "run end times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
2601 
2602  unsigned int count = 1;
2603  for (const auto& run : runNumbersTimesLog_) {
2604  // strip down the microseconds
2605  h_runStartTimes->SetBinContent(count, run.second.first / 10e6);
2606  h_runStartTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
2607 
2608  h_runEndTimes->SetBinContent(count, run.second.second / 10e6);
2609  h_runEndTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
2610 
2611  count++;
2612  }
2613 
2614  edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
2615  << "# PrimaryVertexValidation::endJob()\n"
2616  << "# Number of analyzed events: " << Nevt_ << "\n"
2617  << "######################################";
2618 
2619  // means and widhts vs ladder and module number
2620 
2621  a_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
2622  "means_dxy_modZ", "#LT d_{xy} #GT vs modZ;module number (Z);#LT d_{xy} #GT [#mum]", nModZ_, 0., nModZ_);
2623 
2624  a_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
2625  "widths_dxy_modZ", "#sigma_{d_{xy}} vs modZ;module number (Z);#sigma_{d_{xy}} [#mum]", nModZ_, 0., nModZ_);
2626 
2627  a_dzmodZMeanTrend = MeanTrendsDir.make<TH1F>(
2628  "means_dz_modZ", "#LT d_{z} #GT vs modZ;module number (Z);#LT d_{z} #GT [#mum]", nModZ_, 0., nModZ_);
2629 
2630  a_dzmodZWidthTrend = WidthTrendsDir.make<TH1F>(
2631  "widths_dz_modZ", "#sigma_{d_{z}} vs modZ;module number (Z);#sigma_{d_{z}} [#mum]", nModZ_, 0., nModZ_);
2632 
2633  a_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_ladder",
2634  "#LT d_{xy} #GT vs ladder;ladder number (#phi);#LT d_{xy} #GT [#mum]",
2635  nLadders_,
2636  0.,
2637  nLadders_);
2638 
2639  a_dxyladderWidthTrend =
2640  WidthTrendsDir.make<TH1F>("widths_dxy_ladder",
2641  "#sigma_{d_{xy}} vs ladder;ladder number (#phi);#sigma_{d_{xy}} [#mum]",
2642  nLadders_,
2643  0.,
2644  nLadders_);
2645 
2646  a_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
2647  "means_dz_ladder", "#LT d_{z} #GT vs ladder;ladder number (#phi);#LT d_{z} #GT [#mum]", nLadders_, 0., nLadders_);
2648 
2649  a_dzladderWidthTrend =
2650  WidthTrendsDir.make<TH1F>("widths_dz_ladder",
2651  "#sigma_{d_{z}} vs ladder;ladder number (#phi);#sigma_{d_{z}} [#mum]",
2652  nLadders_,
2653  0.,
2654  nLadders_);
2655 
2656  n_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
2657  "norm_means_dxy_modZ",
2658  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs modZ;module number (Z);#LT d_{xy}/#sigma_{d_{xy}} #GT",
2659  nModZ_,
2660  0.,
2661  nModZ_);
2662 
2663  n_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
2664  "norm_widths_dxy_modZ",
2665  "width(d_{xy}/#sigma_{d_{xy}}) vs modZ;module number (Z); width(d_{xy}/#sigma_{d_{xy}})",
2666  nModZ_,
2667  0.,
2668  nModZ_);
2669 
2670  n_dzmodZMeanTrend =
2671  MeanTrendsDir.make<TH1F>("norm_means_dz_modZ",
2672  "#LT d_{z}/#sigma_{d_{z}} #GT vs modZ;module number (Z);#LT d_{z}/#sigma_{d_{z}} #GT",
2673  nModZ_,
2674  0.,
2675  nModZ_);
2676 
2677  n_dzmodZWidthTrend =
2678  WidthTrendsDir.make<TH1F>("norm_widths_dz_modZ",
2679  "width(d_{z}/#sigma_{d_{z}}) vs pT;module number (Z);width(d_{z}/#sigma_{d_{z}})",
2680  nModZ_,
2681  0.,
2682  nModZ_);
2683 
2684  n_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>(
2685  "norm_means_dxy_ladder",
2686  "#LT d_{xy}/#sigma_{d_{xy}} #GT vs ladder;ladder number (#phi);#LT d_{xy}/#sigma_{d_{z}} #GT",
2687  nLadders_,
2688  0.,
2689  nLadders_);
2690 
2691  n_dxyladderWidthTrend = WidthTrendsDir.make<TH1F>(
2692  "norm_widths_dxy_ladder",
2693  "width(d_{xy}/#sigma_{d_{xy}}) vs ladder;ladder number (#phi);width(d_{xy}/#sigma_{d_{z}})",
2694  nLadders_,
2695  0.,
2696  nLadders_);
2697 
2698  n_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
2699  "norm_means_dz_ladder",
2700  "#LT d_{z}/#sigma_{d_{z}} #GT vs ladder;ladder number (#phi);#LT d_{z}/#sigma_{d_{z}} #GT",
2701  nLadders_,
2702  0.,
2703  nLadders_);
2704 
2705  n_dzladderWidthTrend = WidthTrendsDir.make<TH1F>(
2706  "norm_widths_dz_ladder",
2707  "width(d_{z}/#sigma_{d_{z}}) vs ladder;ladder number (#phi);width(d_{z}/#sigma_{d_{z}})",
2708  nLadders_,
2709  0.,
2710  nLadders_);
2711 
2712  // 2D maps of residuals in bins of L1 modules
2713 
2714  a_dxyL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_l1map",
2715  "#LT d_{xy} #GT map;module number [z];ladder number [#varphi]",
2716  8,
2717  0.,
2718  8.,
2719  nLadders_,
2720  0.,
2721  nLadders_);
2722 
2723  a_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dz_l1map",
2724  "#LT d_{z} #GT map;module number [z];ladder number [#varphi]",
2725  8,
2726  0.,
2727  8.,
2728  nLadders_,
2729  0.,
2730  nLadders_);
2731 
2732  n_dxyL1MeanMap =
2733  Mean2DMapsDir.make<TH2F>("norm_means_dxy_l1map",
2734  "#LT d_{xy}/#sigma_{d_{xy}} #GT map;module number [z];ladder number [#varphi]",
2735  8,
2736  0.,
2737  8.,
2738  nLadders_,
2739  0.,
2740  nLadders_);
2741 
2742  n_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_l1map",
2743  "#LT d_{z}/#sigma_{d_{z}} #GT map;module number [z];ladder number [#varphi]",
2744  8,
2745  0.,
2746  8.,
2747  nLadders_,
2748  0.,
2749  nLadders_);
2750 
2751  a_dxyL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_l1map",
2752  "#sigma_{d_{xy}} map;module number [z];ladder number [#varphi]",
2753  8,
2754  0.,
2755  8.,
2756  nLadders_,
2757  0.,
2758  nLadders_);
2759 
2760  a_dzL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dz_l1map",
2761  "#sigma_{d_{z}} map;module number [z];ladder number [#varphi]",
2762  8,
2763  0.,
2764  8.,
2765  nLadders_,
2766  0.,
2767  nLadders_);
2768 
2769  n_dxyL1WidthMap =
2770  Width2DMapsDir.make<TH2F>("norm_widths_dxy_l1map",
2771  "width(d_{xy}/#sigma_{d_{xy}}) map;module number [z];ladder number [#varphi]",
2772  8,
2773  0.,
2774  8.,
2775  nLadders_,
2776  0.,
2777  nLadders_);
2778 
2779  n_dzL1WidthMap =
2780  Width2DMapsDir.make<TH2F>("norm_widths_dz_l1map",
2781  "width(d_{z}/#sigma_{d_{z}}) map;module number [z];ladder number [#varphi]",
2782  8,
2783  0.,
2784  8.,
2785  nLadders_,
2786  0.,
2787  nLadders_);
2788 
2789  if (useTracksFromRecoVtx_) {
2790  fillTrendPlotByIndex(a_dxyPhiMeanBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2791  fillTrendPlotByIndex(a_dxyPhiWidthBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2792  fillTrendPlotByIndex(a_dzPhiMeanBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2793  fillTrendPlotByIndex(a_dzPhiWidthBiasTrend, a_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2794 
2795  fillTrendPlotByIndex(a_dxyEtaMeanBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2796  fillTrendPlotByIndex(a_dxyEtaWidthBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2797  fillTrendPlotByIndex(a_dzEtaMeanBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2798  fillTrendPlotByIndex(a_dzEtaWidthBiasTrend, a_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2799 
2800  fillTrendPlotByIndex(n_dxyPhiMeanBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2801  fillTrendPlotByIndex(n_dxyPhiWidthBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2802  fillTrendPlotByIndex(n_dzPhiMeanBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
2803  fillTrendPlotByIndex(n_dzPhiWidthBiasTrend, n_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2804 
2805  fillTrendPlotByIndex(n_dxyEtaMeanBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2806  fillTrendPlotByIndex(n_dxyEtaWidthBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2807  fillTrendPlotByIndex(n_dzEtaMeanBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
2808  fillTrendPlotByIndex(n_dzEtaWidthBiasTrend, n_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2809 
2810  // medians and MADs
2811 
2812  fillTrendPlotByIndex(a_dxyPhiMedianBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2813  fillTrendPlotByIndex(a_dxyPhiMADBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2814  fillTrendPlotByIndex(a_dzPhiMedianBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2815  fillTrendPlotByIndex(a_dzPhiMADBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2816 
2817  fillTrendPlotByIndex(a_dxyEtaMedianBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2818  fillTrendPlotByIndex(a_dxyEtaMADBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2819  fillTrendPlotByIndex(a_dzEtaMedianBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2820  fillTrendPlotByIndex(a_dzEtaMADBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2821 
2822  fillTrendPlotByIndex(n_dxyPhiMedianBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2823  fillTrendPlotByIndex(n_dxyPhiMADBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2824  fillTrendPlotByIndex(n_dzPhiMedianBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2825  fillTrendPlotByIndex(n_dzPhiMADBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
2826 
2827  fillTrendPlotByIndex(n_dxyEtaMedianBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2828  fillTrendPlotByIndex(n_dxyEtaMADBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2829  fillTrendPlotByIndex(n_dzEtaMedianBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2830  fillTrendPlotByIndex(n_dzEtaMADBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
2831 
2832  // 2d Maps
2833 
2834  fillMap(a_dxyMeanBiasMap, a_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2835  fillMap(a_dxyWidthBiasMap, a_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2836  fillMap(a_dzMeanBiasMap, a_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2837  fillMap(a_dzWidthBiasMap, a_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2838 
2839  fillMap(n_dxyMeanBiasMap, n_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2840  fillMap(n_dxyWidthBiasMap, n_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2841  fillMap(n_dzMeanBiasMap, n_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2842  fillMap(n_dzWidthBiasMap, n_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2843  }
2844 
2845  // do profiles
2846 
2847  fillTrendPlotByIndex(a_dxyPhiMeanTrend, a_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2848  fillTrendPlotByIndex(a_dxyPhiWidthTrend, a_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2849  fillTrendPlotByIndex(a_dzPhiMeanTrend, a_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2850  fillTrendPlotByIndex(a_dzPhiWidthTrend, a_dzPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2851 
2852  fillTrendPlotByIndex(a_dxyEtaMeanTrend, a_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2853  fillTrendPlotByIndex(a_dxyEtaWidthTrend, a_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2854  fillTrendPlotByIndex(a_dzEtaMeanTrend, a_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2855  fillTrendPlotByIndex(a_dzEtaWidthTrend, a_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2856 
2857  fillTrendPlotByIndex(n_dxyPhiMeanTrend, n_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2858  fillTrendPlotByIndex(n_dxyPhiWidthTrend, n_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
2859  fillTrendPlotByIndex(n_dzPhiMeanTrend, n_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
2860  fillTrendPlotByIndex(n_dzPhiWidthTrend, n_dzPhiResiduals, PVValHelper::WIDTH);
2861 
2862  fillTrendPlotByIndex(n_dxyEtaMeanTrend, n_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2863  fillTrendPlotByIndex(n_dxyEtaWidthTrend, n_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2864  fillTrendPlotByIndex(n_dzEtaMeanTrend, n_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
2865  fillTrendPlotByIndex(n_dzEtaWidthTrend, n_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
2866 
2867  // vs transverse momentum
2868 
2869  fillTrendPlotByIndex(a_dxypTMeanTrend, h_dxy_pT_, PVValHelper::MEAN);
2870  fillTrendPlotByIndex(a_dxypTWidthTrend, h_dxy_pT_, PVValHelper::WIDTH);
2871  fillTrendPlotByIndex(a_dzpTMeanTrend, h_dz_pT_, PVValHelper::MEAN);
2872  fillTrendPlotByIndex(a_dzpTWidthTrend, h_dz_pT_, PVValHelper::WIDTH);
2873 
2874  fillTrendPlotByIndex(a_dxypTCentralMeanTrend, h_dxy_Central_pT_, PVValHelper::MEAN);
2875  fillTrendPlotByIndex(a_dxypTCentralWidthTrend, h_dxy_Central_pT_, PVValHelper::WIDTH);
2876  fillTrendPlotByIndex(a_dzpTCentralMeanTrend, h_dz_Central_pT_, PVValHelper::MEAN);
2877  fillTrendPlotByIndex(a_dzpTCentralWidthTrend, h_dz_Central_pT_, PVValHelper::WIDTH);
2878 
2879  fillTrendPlotByIndex(n_dxypTMeanTrend, h_norm_dxy_pT_, PVValHelper::MEAN);
2880  fillTrendPlotByIndex(n_dxypTWidthTrend, h_norm_dxy_pT_, PVValHelper::WIDTH);
2881  fillTrendPlotByIndex(n_dzpTMeanTrend, h_norm_dz_pT_, PVValHelper::MEAN);
2882  fillTrendPlotByIndex(n_dzpTWidthTrend, h_norm_dz_pT_, PVValHelper::WIDTH);
2883 
2884  fillTrendPlotByIndex(n_dxypTCentralMeanTrend, h_norm_dxy_Central_pT_, PVValHelper::MEAN);
2885  fillTrendPlotByIndex(n_dxypTCentralWidthTrend, h_norm_dxy_Central_pT_, PVValHelper::WIDTH);
2886  fillTrendPlotByIndex(n_dzpTCentralMeanTrend, h_norm_dz_Central_pT_, PVValHelper::MEAN);
2887  fillTrendPlotByIndex(n_dzpTCentralWidthTrend, h_norm_dz_Central_pT_, PVValHelper::WIDTH);
2888 
2889  // vs ladder and module number
2890 
2891  fillTrendPlotByIndex(a_dxymodZMeanTrend, h_dxy_modZ_, PVValHelper::MEAN);
2892  fillTrendPlotByIndex(a_dxymodZWidthTrend, h_dxy_modZ_, PVValHelper::WIDTH);
2893  fillTrendPlotByIndex(a_dzmodZMeanTrend, h_dz_modZ_, PVValHelper::MEAN);
2894  fillTrendPlotByIndex(a_dzmodZWidthTrend, h_dz_modZ_, PVValHelper::WIDTH);
2895 
2896  fillTrendPlotByIndex(a_dxyladderMeanTrend, h_dxy_ladder_, PVValHelper::MEAN);
2897  fillTrendPlotByIndex(a_dxyladderWidthTrend, h_dxy_ladder_, PVValHelper::WIDTH);
2898  fillTrendPlotByIndex(a_dzladderMeanTrend, h_dz_ladder_, PVValHelper::MEAN);
2899  fillTrendPlotByIndex(a_dzladderWidthTrend, h_dz_ladder_, PVValHelper::WIDTH);
2900 
2901  fillTrendPlotByIndex(n_dxymodZMeanTrend, h_norm_dxy_modZ_, PVValHelper::MEAN);
2902  fillTrendPlotByIndex(n_dxymodZWidthTrend, h_norm_dxy_modZ_, PVValHelper::WIDTH);
2903  fillTrendPlotByIndex(n_dzmodZMeanTrend, h_norm_dz_modZ_, PVValHelper::MEAN);
2904  fillTrendPlotByIndex(n_dzmodZWidthTrend, h_norm_dz_modZ_, PVValHelper::WIDTH);
2905 
2906  fillTrendPlotByIndex(n_dxyladderMeanTrend, h_norm_dxy_ladder_, PVValHelper::MEAN);
2907  fillTrendPlotByIndex(n_dxyladderWidthTrend, h_norm_dxy_ladder_, PVValHelper::WIDTH);
2908  fillTrendPlotByIndex(n_dzladderMeanTrend, h_norm_dz_ladder_, PVValHelper::MEAN);
2909  fillTrendPlotByIndex(n_dzladderWidthTrend, h_norm_dz_ladder_, PVValHelper::WIDTH);
2910 
2911  // medians and MADs
2912 
2913  fillTrendPlotByIndex(a_dxyPhiMedianTrend, a_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2914  fillTrendPlotByIndex(a_dxyPhiMADTrend, a_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2915 
2916  fillTrendPlotByIndex(a_dzPhiMedianTrend, a_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2917  fillTrendPlotByIndex(a_dzPhiMADTrend, a_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2918 
2919  fillTrendPlotByIndex(a_dxyEtaMedianTrend, a_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2920  fillTrendPlotByIndex(a_dxyEtaMADTrend, a_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2921  fillTrendPlotByIndex(a_dzEtaMedianTrend, a_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2922  fillTrendPlotByIndex(a_dzEtaMADTrend, a_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2923 
2924  fillTrendPlotByIndex(n_dxyPhiMedianTrend, n_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2925  fillTrendPlotByIndex(n_dxyPhiMADTrend, n_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2926  fillTrendPlotByIndex(n_dzPhiMedianTrend, n_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
2927  fillTrendPlotByIndex(n_dzPhiMADTrend, n_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
2928 
2929  fillTrendPlotByIndex(n_dxyEtaMedianTrend, n_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2930  fillTrendPlotByIndex(n_dxyEtaMADTrend, n_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2931  fillTrendPlotByIndex(n_dzEtaMedianTrend, n_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
2932  fillTrendPlotByIndex(n_dzEtaMADTrend, n_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
2933 
2934  // 2D Maps
2935 
2936  fillMap(a_dxyMeanMap, a_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2937  fillMap(a_dxyWidthMap, a_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2938  fillMap(a_dzMeanMap, a_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2939  fillMap(a_dzWidthMap, a_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2940 
2941  fillMap(n_dxyMeanMap, n_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2942  fillMap(n_dxyWidthMap, n_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2943  fillMap(n_dzMeanMap, n_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
2944  fillMap(n_dzWidthMap, n_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
2945 
2946  // 2D Maps of residuals in bins of L1 modules
2947 
2948  fillMap(a_dxyL1MeanMap, a_dxyL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2949  fillMap(a_dxyL1WidthMap, a_dxyL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2950  fillMap(a_dzL1MeanMap, a_dzL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2951  fillMap(a_dzL1WidthMap, a_dzL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2952 
2953  fillMap(n_dxyL1MeanMap, n_dxyL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2954  fillMap(n_dxyL1WidthMap, n_dxyL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2955  fillMap(n_dzL1MeanMap, n_dzL1ResidualsMap, PVValHelper::MEAN, 8, nLadders_);
2956  fillMap(n_dzL1WidthMap, n_dzL1ResidualsMap, PVValHelper::WIDTH, 8, nLadders_);
2957 }

References a_dxyBiasResidualsMap, a_dxyEtaBiasResiduals, a_dxyEtaMADBiasTrend, a_dxyEtaMADTrend, a_dxyEtaMeanBiasTrend, a_dxyEtaMeanTrend, a_dxyEtaMedianBiasTrend, a_dxyEtaMedianTrend, a_dxyEtaResiduals, a_dxyEtaWidthBiasTrend, a_dxyEtaWidthTrend, a_dxyL1MeanMap, a_dxyL1ResidualsMap, a_dxyL1WidthMap, a_dxyladderMeanTrend, a_dxyladderWidthTrend, a_dxyMeanBiasMap, a_dxyMeanMap, a_dxymodZMeanTrend, a_dxymodZWidthTrend, a_dxyPhiBiasResiduals, a_dxyPhiMADBiasTrend, a_dxyPhiMADTrend, a_dxyPhiMeanBiasTrend, a_dxyPhiMeanTrend, a_dxyPhiMedianBiasTrend, a_dxyPhiMedianTrend, a_dxyPhiResiduals, a_dxyPhiWidthBiasTrend, a_dxyPhiWidthTrend, a_dxypTCentralMeanTrend, a_dxypTCentralWidthTrend, a_dxypTMeanTrend, a_dxypTWidthTrend, a_dxyResidualsMap, a_dxyWidthBiasMap, a_dxyWidthMap, a_dzBiasResidualsMap, a_dzEtaBiasResiduals, a_dzEtaMADBiasTrend, a_dzEtaMADTrend, a_dzEtaMeanBiasTrend, a_dzEtaMeanTrend, a_dzEtaMedianBiasTrend, a_dzEtaMedianTrend, a_dzEtaResiduals, a_dzEtaWidthBiasTrend, a_dzEtaWidthTrend, a_dzL1MeanMap, a_dzL1ResidualsMap, a_dzL1WidthMap, a_dzladderMeanTrend, a_dzladderWidthTrend, a_dzMeanBiasMap, a_dzMeanMap, a_dzmodZMeanTrend, a_dzmodZWidthTrend, a_dzPhiBiasResiduals, a_dzPhiMADBiasTrend, a_dzPhiMADTrend, a_dzPhiMeanBiasTrend, a_dzPhiMeanTrend, a_dzPhiMedianBiasTrend, a_dzPhiMedianTrend, a_dzPhiResiduals, a_dzPhiWidthBiasTrend, a_dzPhiWidthTrend, a_dzpTCentralMeanTrend, a_dzpTCentralWidthTrend, a_dzpTMeanTrend, a_dzpTWidthTrend, a_dzResidualsMap, a_dzWidthBiasMap, a_dzWidthMap, submitPVResolutionJobs::count, PVValHelper::eta, fillMap(), fillTrendPlotByIndex(), fs, h_dxy_Central_pT_, h_dxy_ladder_, h_dxy_modZ_, h_dxy_pT_, h_dz_Central_pT_, h_dz_ladder_, h_dz_modZ_, h_dz_pT_, h_norm_dxy_Central_pT_, h_norm_dxy_ladder_, h_norm_dxy_modZ_, h_norm_dxy_pT_, h_norm_dz_Central_pT_, h_norm_dz_ladder_, h_norm_dz_modZ_, h_norm_dz_pT_, h_runEndTimes, h_runStartTimes, PVValHelper::MAD, TFileDirectory::make(), PVValHelper::MEAN, Mean2DMapsDir, MeanTrendsDir, PVValHelper::MEDIAN, TFileService::mkdir(), n_dxyBiasResidualsMap, n_dxyEtaBiasResiduals, n_dxyEtaMADBiasTrend, n_dxyEtaMADTrend, n_dxyEtaMeanBiasTrend, n_dxyEtaMeanTrend, n_dxyEtaMedianBiasTrend, n_dxyEtaMedianTrend, n_dxyEtaResiduals, n_dxyEtaWidthBiasTrend, n_dxyEtaWidthTrend, n_dxyL1MeanMap, n_dxyL1ResidualsMap, n_dxyL1WidthMap, n_dxyladderMeanTrend, n_dxyladderWidthTrend, n_dxyMeanBiasMap, n_dxyMeanMap, n_dxymodZMeanTrend, n_dxymodZWidthTrend, n_dxyPhiBiasResiduals, n_dxyPhiMADBiasTrend, n_dxyPhiMADTrend, n_dxyPhiMeanBiasTrend, n_dxyPhiMeanTrend, n_dxyPhiMedianBiasTrend, n_dxyPhiMedianTrend, n_dxyPhiResiduals, n_dxyPhiWidthBiasTrend, n_dxyPhiWidthTrend, n_dxypTCentralMeanTrend, n_dxypTCentralWidthTrend, n_dxypTMeanTrend, n_dxypTWidthTrend, n_dxyResidualsMap, n_dxyWidthBiasMap, n_dxyWidthMap, n_dzBiasResidualsMap, n_dzEtaBiasResiduals, n_dzEtaMADBiasTrend, n_dzEtaMADTrend, n_dzEtaMeanBiasTrend, n_dzEtaMeanTrend, n_dzEtaMedianBiasTrend, n_dzEtaMedianTrend, n_dzEtaResiduals, n_dzEtaWidthBiasTrend, n_dzEtaWidthTrend, n_dzL1MeanMap, n_dzL1ResidualsMap, n_dzL1WidthMap, n_dzladderMeanTrend, n_dzladderWidthTrend, n_dzMeanBiasMap, n_dzMeanMap, n_dzmodZMeanTrend, n_dzmodZWidthTrend, n_dzPhiBiasResiduals, n_dzPhiMADBiasTrend, n_dzPhiMADTrend, n_dzPhiMeanBiasTrend, n_dzPhiMeanTrend, n_dzPhiMedianBiasTrend, n_dzPhiMedianTrend, n_dzPhiResiduals, n_dzPhiWidthBiasTrend, n_dzPhiWidthTrend, n_dzpTCentralMeanTrend, n_dzpTCentralWidthTrend, n_dzpTMeanTrend, n_dzpTWidthTrend, n_dzResidualsMap, n_dzWidthBiasMap, n_dzWidthMap, nBins_, Nevt_, nLadders_, nModZ_, PVValHelper::phi, writedatasetfile::run, runNumbersTimesLog_, useTracksFromRecoVtx_, PVValHelper::WIDTH, Width2DMapsDir, and WidthTrendsDir.

Referenced by o2olib.O2ORunMgr::executeJob().

◆ fill() [1/2]

void PrimaryVertexValidation::fill ( std::map< std::string, TH1 * > &  h,
const std::string &  s,
double  x 
)
private

◆ fill() [2/2]

void PrimaryVertexValidation::fill ( std::map< std::string, TH1 * > &  h,
const std::string &  s,
double  x,
double  y 
)
private

◆ fillByIndex()

void PrimaryVertexValidation::fillByIndex ( std::vector< TH1F * > &  h,
unsigned int  index,
double  x,
std::string  tag = "" 
)
private

◆ fillDescriptions()

void PrimaryVertexValidation::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 3597 of file PrimaryVertexValidation.cc.

3597  {
3598  edm::ParameterSetDescription desc;
3599  desc.setComment("Validates alignment payloads by evaluating unbiased track paramter resisuals to vertices");
3600 
3601  // PV Validation specific
3602 
3603  desc.addUntracked<int>("compressionSettings", -1);
3604  desc.add<bool>("storeNtuple", false);
3605  desc.add<bool>("isLightNtuple", true);
3606  desc.add<bool>("useTracksFromRecoVtx", false);
3607  desc.addUntracked<double>("vertexZMax", 99);
3608  desc.addUntracked<double>("intLumi", 0.);
3609  desc.add<bool>("askFirstLayerHit", false);
3610  desc.addUntracked<bool>("doBPix", true);
3611  desc.addUntracked<bool>("doFPix", true);
3612  desc.addUntracked<double>("probePt", 0.);
3613  desc.addUntracked<double>("probeP", 0.);
3614  desc.addUntracked<double>("probeEta", 2.4);
3615  desc.addUntracked<double>("probeNHits", 0.);
3616  desc.addUntracked<int>("numberOfBins", 24);
3617  desc.addUntracked<double>("minPt", 1.);
3618  desc.addUntracked<double>("maxPt", 20.);
3619  desc.add<bool>("Debug", false);
3620  desc.addUntracked<bool>("runControl", false);
3621  desc.addUntracked<bool>("forceBeamSpot", false);
3622 
3623  std::vector<unsigned int> defaultRuns;
3624  defaultRuns.push_back(0);
3625  desc.addUntracked<std::vector<unsigned int>>("runControlNumber", defaultRuns);
3626 
3627  // event sources
3628 
3629  desc.add<edm::InputTag>("TrackCollectionTag", edm::InputTag("ALCARECOTkAlMinBias"));
3630  desc.add<edm::InputTag>("VertexCollectionTag", edm::InputTag("offlinePrimaryVertices"));
3631  desc.add<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
3632 
3633  // track filtering
3634 
3635  edm::ParameterSetDescription psd0;
3636  psd0.add<double>("maxNormalizedChi2", 5.0);
3637  psd0.add<double>("minPt", 0.0);
3638  psd0.add<std::string>("algorithm", "filter");
3639  psd0.add<double>("maxEta", 5.0);
3640  psd0.add<double>("maxD0Significance", 5.0);
3641  psd0.add<double>("maxD0Error", 1.0);
3642  psd0.add<double>("maxDzError", 1.0);
3643  psd0.add<std::string>("trackQuality", "any");
3644  psd0.add<int>("minPixelLayersWithHits", 2);
3645  psd0.add<int>("minSiliconLayersWithHits", 5);
3646  psd0.add<int>("numTracksThreshold", 0); // HI only
3647  desc.add<edm::ParameterSetDescription>("TkFilterParameters", psd0);
3648 
3649  // PV Clusterization
3650  {
3651  edm::ParameterSetDescription psd0;
3652  {
3653  edm::ParameterSetDescription psd1;
3654  psd1.addUntracked<bool>("verbose", false);
3655  psd1.addUntracked<double>("zdumpcenter", 0.);
3656  psd1.addUntracked<double>("zdumpwidth", 20.);
3657  psd1.addUntracked<bool>("use_vdt", false); // obsolete, appears in HLT configs
3658  psd1.add<double>("d0CutOff", 3.0);
3659  psd1.add<double>("Tmin", 2.0);
3660  psd1.add<double>("delta_lowT", 0.001);
3661  psd1.add<double>("zmerge", 0.01);
3662  psd1.add<double>("dzCutOff", 3.0);
3663  psd1.add<double>("Tpurge", 2.0);
3664  psd1.add<int>("convergence_mode", 0);
3665  psd1.add<double>("delta_highT", 0.01);
3666  psd1.add<double>("Tstop", 0.5);
3667  psd1.add<double>("coolingFactor", 0.6);
3668  psd1.add<double>("vertexSize", 0.006);
3669  psd1.add<double>("uniquetrkweight", 0.8);
3670  psd1.add<double>("zrange", 4.0);
3671  psd1.add<double>("tmerge", 0.01); // 4D only
3672  psd1.add<double>("dtCutOff", 4.); // 4D only
3673  psd1.add<double>("t0Max", 1.0); // 4D only
3674  psd1.add<double>("vertexSizeTime", 0.008); // 4D only
3675  psd0.add<edm::ParameterSetDescription>("TkDAClusParameters", psd1);
3676  edm::ParameterSetDescription psd2;
3677  psd2.add<double>("zSeparation", 1.0);
3678  psd0.add<edm::ParameterSetDescription>("TkGapClusParameters", psd2);
3679  }
3680  psd0.add<std::string>("algorithm", "DA_vect");
3681  desc.add<edm::ParameterSetDescription>("TkClusParameters", psd0);
3682  }
3683 
3684  descriptions.add("primaryVertexValidation", desc);
3685 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ fillMap()

void PrimaryVertexValidation::fillMap ( TH2F *  trendMap,
TH1F *  residualsMapPlot[100][100],
PVValHelper::estimator  fitPar_,
const int  nXBins_,
const int  nYBins_ 
)
private

Definition at line 3182 of file PrimaryVertexValidation.cc.

3188 {
3189  for (int i = 0; i < nYBins_; ++i) {
3190  char phibincenter[129];
3191  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3192  sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
3193 
3194  if (nXBins_ == nYBins_) {
3195  trendMap->GetYaxis()->SetBinLabel(i + 1, phibincenter);
3196  }
3197 
3198  for (int j = 0; j < nXBins_; ++j) {
3199  char etabincenter[129];
3200  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3201  sprintf(etabincenter, "%.1f", (etaBins[j] + etaBins[j + 1]) / 2.);
3202 
3203  if (i == 0) {
3204  if (nXBins_ == nYBins_) {
3205  trendMap->GetXaxis()->SetBinLabel(j + 1, etabincenter);
3206  }
3207  }
3208 
3209  switch (fitPar_) {
3210  case PVValHelper::MEAN: {
3211  float mean_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.value();
3212  float meanErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.error();
3213  trendMap->SetBinContent(j + 1, i + 1, mean_);
3214  trendMap->SetBinError(j + 1, i + 1, meanErr_);
3215  break;
3216  }
3217  case PVValHelper::WIDTH: {
3218  float width_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.value();
3219  float widthErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.error();
3220  trendMap->SetBinContent(j + 1, i + 1, width_);
3221  trendMap->SetBinError(j + 1, i + 1, widthErr_);
3222  break;
3223  }
3224  case PVValHelper::MEDIAN: {
3225  float median_ = PVValHelper::getMedian(residualsMapPlot[i][j]).value();
3226  float medianErr_ = PVValHelper::getMedian(residualsMapPlot[i][j]).error();
3227  trendMap->SetBinContent(j + 1, i + 1, median_);
3228  trendMap->SetBinError(j + 1, i + 1, medianErr_);
3229  break;
3230  }
3231  case PVValHelper::MAD: {
3232  float mad_ = PVValHelper::getMAD(residualsMapPlot[i][j]).value();
3233  float madErr_ = PVValHelper::getMAD(residualsMapPlot[i][j]).error();
3234  trendMap->SetBinContent(j + 1, i + 1, mad_);
3235  trendMap->SetBinError(j + 1, i + 1, madErr_);
3236  break;
3237  }
3238  default:
3239  edm::LogWarning("PrimaryVertexValidation:") << " fillMap() " << fitPar_ << " unknown estimator!" << std::endl;
3240  }
3241  } // closes loop on eta bins
3242  } // cloeses loop on phi bins
3243 }

References Measurement1D::error(), PVValHelper::eta, HLT_FULL_cff::etaBins, PVValHelper::fitResiduals(), PVValHelper::getMAD(), PVValHelper::getMedian(), mps_fire::i, dqmiolumiharvest::j, PVValHelper::MAD, PVValHelper::MEAN, PVValHelper::MEDIAN, PVValHelper::phi, theDetails_, PVValHelper::histodetails::trendbins, Measurement1D::value(), and PVValHelper::WIDTH.

Referenced by endJob().

◆ fillTrackHistos()

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 
)
private

Definition at line 3477 of file PrimaryVertexValidation.cc.

3484 {
3485  using namespace reco;
3486 
3487  PVValHelper::fill(h, "pseudorapidity_" + ttype, tt->track().eta());
3488  PVValHelper::fill(h, "z0_" + ttype, tt->track().vz());
3489  PVValHelper::fill(h, "phi_" + ttype, tt->track().phi());
3490  PVValHelper::fill(h, "eta_" + ttype, tt->track().eta());
3491  PVValHelper::fill(h, "pt_" + ttype, tt->track().pt());
3492  PVValHelper::fill(h, "p_" + ttype, tt->track().p());
3493  PVValHelper::fill(h, "found_" + ttype, tt->track().found());
3494  PVValHelper::fill(h, "lost_" + ttype, tt->track().lost());
3495  PVValHelper::fill(h, "nchi2_" + ttype, tt->track().normalizedChi2());
3496  PVValHelper::fill(h, "rstart_" + ttype, (tt->track().innerPosition()).Rho());
3497 
3498  double d0Error = tt->track().d0Error();
3499  double d0 = tt->track().dxy(beamSpot.position());
3500  double dz = tt->track().dz(beamSpot.position());
3501  if (d0Error > 0) {
3502  PVValHelper::fill(h, "logtresxy_" + ttype, log(d0Error / 0.0001) / log(10.));
3503  PVValHelper::fill(h, "tpullxy_" + ttype, d0 / d0Error);
3504  PVValHelper::fill(h, "tlogDCAxy_" + ttype, log(std::abs(d0 / d0Error)));
3505  }
3506  //double z0=tt->track().vz();
3507  double dzError = tt->track().dzError();
3508  if (dzError > 0) {
3509  PVValHelper::fill(h, "logtresz_" + ttype, log(dzError / 0.0001) / log(10.));
3510  PVValHelper::fill(h, "tpullz_" + ttype, dz / dzError);
3511  PVValHelper::fill(h, "tlogDCAz_" + ttype, log(std::abs(dz / dzError)));
3512  }
3513 
3514  //
3515  double wxy2_ = pow(beamSpot.BeamWidthX(), 2) + pow(beamSpot.BeamWidthY(), 2);
3516 
3517  PVValHelper::fill(
3518  h, "sigmatrkz_" + ttype, sqrt(pow(tt->track().dzError(), 2) + wxy2_ / pow(tan(tt->track().theta()), 2)));
3519  PVValHelper::fill(h, "sigmatrkz0_" + ttype, tt->track().dzError());
3520 
3521  // track vs vertex
3522  if (v.isValid()) { // && (v.ndof()<10.)) {
3523  // emulate clusterizer input
3524  //const TransientTrack & tt = theB_->build(&t); wrong !!!!
3525  //reco::TransientTrack tt = theB_->build(&t);
3526  //ttt->track().setBeamSpot(beamSpot); // need the setBeamSpot !
3527  double z = (tt->stateAtBeamLine().trackStateAtPCA()).position().z();
3528  double tantheta = tan((tt->stateAtBeamLine().trackStateAtPCA()).momentum().theta());
3529  double dz2 = pow(tt->track().dzError(), 2) + wxy2_ / pow(tantheta, 2);
3530 
3531  PVValHelper::fill(h, "restrkz_" + ttype, z - v.position().z());
3532  PVValHelper::fill(h, "restrkzvsphi_" + ttype, tt->track().phi(), z - v.position().z());
3533  PVValHelper::fill(h, "restrkzvseta_" + ttype, tt->track().eta(), z - v.position().z());
3534  PVValHelper::fill(h, "pulltrkzvsphi_" + ttype, tt->track().phi(), (z - v.position().z()) / sqrt(dz2));
3535  PVValHelper::fill(h, "pulltrkzvseta_" + ttype, tt->track().eta(), (z - v.position().z()) / sqrt(dz2));
3536 
3537  PVValHelper::fill(h, "pulltrkz_" + ttype, (z - v.position().z()) / sqrt(dz2));
3538 
3539  double x1 = tt->track().vx() - beamSpot.x0();
3540  double y1 = tt->track().vy() - beamSpot.y0();
3541 
3542  double kappa = -0.002998 * fBfield_ * tt->track().qoverp() / cos(tt->track().theta());
3543  double D0 = x1 * sin(tt->track().phi()) - y1 * cos(tt->track().phi()) - 0.5 * kappa * (x1 * x1 + y1 * y1);
3544  double q = sqrt(1. - 2. * kappa * D0);
3545  double s0 = (x1 * cos(tt->track().phi()) + y1 * sin(tt->track().phi())) / q;
3546  // double s1;
3547  if (std::abs(kappa * s0) > 0.001) {
3548  //s1=asin(kappa*s0)/kappa;
3549  } else {
3550  //double ks02=(kappa*s0)*(kappa*s0);
3551  //s1=s0*(1.+ks02/6.+3./40.*ks02*ks02+5./112.*pow(ks02,3));
3552  }
3553  // sp.ddcap=-2.*D0/(1.+q);
3554  //double zdcap=tt->track().vz()-s1/tan(tt->track().theta());
3555  }
3556  //
3557 
3558  // collect some info on hits and clusters
3559  PVValHelper::fill(h, "nbarrelLayers_" + ttype, tt->track().hitPattern().pixelBarrelLayersWithMeasurement());
3560  PVValHelper::fill(h, "nPxLayers_" + ttype, tt->track().hitPattern().pixelLayersWithMeasurement());
3561  PVValHelper::fill(h, "nSiLayers_" + ttype, tt->track().hitPattern().trackerLayersWithMeasurement());
3562  PVValHelper::fill(
3563  h, "expectedInner_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS));
3564  PVValHelper::fill(
3565  h, "expectedOuter_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_OUTER_HITS));
3566  PVValHelper::fill(h, "trackAlgo_" + ttype, tt->track().algo());
3567  PVValHelper::fill(h, "trackQuality_" + ttype, tt->track().qualityMask());
3568 
3569  //
3570  int longesthit = 0, nbarrel = 0;
3571  for (auto const& hit : tt->track().recHits()) {
3572  if (hit->isValid() && hit->geographicalId().det() == DetId::Tracker) {
3573  bool barrel = DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
3574  //bool endcap = DetId::DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
3575  if (barrel) {
3576  const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>(&(*hit));
3577  edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const& clust = (*pixhit).cluster();
3578  if (clust.isNonnull()) {
3579  nbarrel++;
3580  if (clust->sizeY() - longesthit > 0)
3581  longesthit = clust->sizeY();
3582  if (clust->sizeY() > 20.) {
3583  PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), 19.9);
3584  PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), 19.9);
3585  } else {
3586  PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), float(clust->sizeY()));
3587  PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), float(clust->sizeY()));
3588  }
3589  }
3590  }
3591  }
3592  }
3593  PVValHelper::fill(h, "nbarrelhits_" + ttype, float(nbarrel));
3594  //-------------------------------------------------------------------
3595 }

References funct::abs(), Reference_intrackfit_cff::barrel, pwdgSkimBPark_cfi::beamSpot, funct::cos(), d0, PVValHelper::dz, PVValHelper::fill(), dqmMemoryStats::float, edm::Ref< C, T, F >::isNonnull(), kappa, dqm-mbProfile::log, PixelSubdetector::PixelBarrel, position, funct::pow(), submitPVResolutionJobs::q, funct::sin(), mathSSE::sqrt(), funct::tan(), DetId::Tracker, groupFilesInBlocks::tt, findQualityFiles::v, wxy2_, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::y1, and z.

Referenced by analyze().

◆ fillTrendPlot()

void PrimaryVertexValidation::fillTrendPlot ( TH1F *  trendPlot,
TH1F *  residualsPlot[100],
PVValHelper::estimator  fitPar_,
const std::string &  var_ 
)
private

Definition at line 3058 of file PrimaryVertexValidation.cc.

3063 {
3064  for (int i = 0; i < nBins_; ++i) {
3065  char phibincenter[129];
3066  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3067  sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
3068 
3069  char etabincenter[129];
3070  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3071  sprintf(etabincenter, "%.1f", (etaBins[i] + etaBins[i + 1]) / 2.);
3072 
3073  switch (fitPar_) {
3074  case PVValHelper::MEAN: {
3075  float mean_ = PVValHelper::fitResiduals(residualsPlot[i]).first.value();
3076  float meanErr_ = PVValHelper::fitResiduals(residualsPlot[i]).first.error();
3077  trendPlot->SetBinContent(i + 1, mean_);
3078  trendPlot->SetBinError(i + 1, meanErr_);
3079  break;
3080  }
3081  case PVValHelper::WIDTH: {
3082  float width_ = PVValHelper::fitResiduals(residualsPlot[i]).second.value();
3083  float widthErr_ = PVValHelper::fitResiduals(residualsPlot[i]).second.error();
3084  trendPlot->SetBinContent(i + 1, width_);
3085  trendPlot->SetBinError(i + 1, widthErr_);
3086  break;
3087  }
3088  case PVValHelper::MEDIAN: {
3089  float median_ = PVValHelper::getMedian(residualsPlot[i]).value();
3090  float medianErr_ = PVValHelper::getMedian(residualsPlot[i]).error();
3091  trendPlot->SetBinContent(i + 1, median_);
3092  trendPlot->SetBinError(i + 1, medianErr_);
3093  break;
3094  }
3095  case PVValHelper::MAD: {
3096  float mad_ = PVValHelper::getMAD(residualsPlot[i]).value();
3097  float madErr_ = PVValHelper::getMAD(residualsPlot[i]).error();
3098  trendPlot->SetBinContent(i + 1, mad_);
3099  trendPlot->SetBinError(i + 1, madErr_);
3100  break;
3101  }
3102  default:
3103  edm::LogWarning("PrimaryVertexValidation")
3104  << "fillTrendPlot() " << fitPar_ << " unknown estimator!" << std::endl;
3105  break;
3106  }
3107 
3108  if (var_.find("eta") != std::string::npos) {
3109  trendPlot->GetXaxis()->SetBinLabel(i + 1, etabincenter);
3110  } else if (var_.find("phi") != std::string::npos) {
3111  trendPlot->GetXaxis()->SetBinLabel(i + 1, phibincenter);
3112  } else {
3113  edm::LogWarning("PrimaryVertexValidation")
3114  << "fillTrendPlot() " << var_ << " unknown track parameter!" << std::endl;
3115  }
3116  }
3117 }

References Measurement1D::error(), PVValHelper::eta, HLT_FULL_cff::etaBins, PVValHelper::fitResiduals(), PVValHelper::getMAD(), PVValHelper::getMedian(), mps_fire::i, PVValHelper::MAD, PVValHelper::MEAN, PVValHelper::MEDIAN, nBins_, PVValHelper::phi, theDetails_, PVValHelper::histodetails::trendbins, Measurement1D::value(), and PVValHelper::WIDTH.

◆ fillTrendPlotByIndex()

void PrimaryVertexValidation::fillTrendPlotByIndex ( TH1F *  trendPlot,
std::vector< TH1F * > &  h,
PVValHelper::estimator  fitPar_,
PVValHelper::plotVariable  plotVar = PVValHelper::END_OF_PLOTS 
)
private

FIXME DO SOMETHING HERE

Definition at line 3120 of file PrimaryVertexValidation.cc.

3125 {
3126  for (auto iterator = h.begin(); iterator != h.end(); iterator++) {
3127  unsigned int bin = std::distance(h.begin(), iterator) + 1;
3128  std::pair<Measurement1D, Measurement1D> myFit = PVValHelper::fitResiduals((*iterator));
3129 
3130  switch (fitPar_) {
3131  case PVValHelper::MEAN: {
3132  float mean_ = myFit.first.value();
3133  float meanErr_ = myFit.first.error();
3134  trendPlot->SetBinContent(bin, mean_);
3135  trendPlot->SetBinError(bin, meanErr_);
3136  break;
3137  }
3138  case PVValHelper::WIDTH: {
3139  float width_ = myFit.second.value();
3140  float widthErr_ = myFit.second.error();
3141  trendPlot->SetBinContent(bin, width_);
3142  trendPlot->SetBinError(bin, widthErr_);
3143  break;
3144  }
3145  case PVValHelper::MEDIAN: {
3146  float median_ = PVValHelper::getMedian(*iterator).value();
3147  float medianErr_ = PVValHelper::getMedian(*iterator).error();
3148  trendPlot->SetBinContent(bin, median_);
3149  trendPlot->SetBinError(bin, medianErr_);
3150  break;
3151  }
3152  case PVValHelper::MAD: {
3153  float mad_ = PVValHelper::getMAD(*iterator).value();
3154  float madErr_ = PVValHelper::getMAD(*iterator).error();
3155  trendPlot->SetBinContent(bin, mad_);
3156  trendPlot->SetBinError(bin, madErr_);
3157  break;
3158  }
3159  default:
3160  edm::LogWarning("PrimaryVertexValidation")
3161  << "fillTrendPlotByIndex() " << fitPar_ << " unknown estimator!" << std::endl;
3162  break;
3163  }
3164 
3165  char bincenter[129];
3166  if (plotVar == PVValHelper::eta) {
3167  auto etaBins = theDetails_.trendbins[PVValHelper::eta];
3168  sprintf(bincenter, "%.1f", (etaBins[bin - 1] + etaBins[bin]) / 2.);
3169  trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
3170  } else if (plotVar == PVValHelper::phi) {
3171  auto phiBins = theDetails_.trendbins[PVValHelper::phi];
3172  sprintf(bincenter, "%.f", (phiBins[bin - 1] + phiBins[bin]) / 2.);
3173  trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
3174  } else {
3176  //edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlotByIndex() "<< plotVar <<" unknown track parameter!"<<std::endl;
3177  }
3178  }
3179 }

References newFWLiteAna::bin, HLT_FULL_cff::distance, Measurement1D::error(), PVValHelper::eta, HLT_FULL_cff::etaBins, PVValHelper::fitResiduals(), PVValHelper::getMAD(), PVValHelper::getMedian(), PVValHelper::MAD, PVValHelper::MEAN, PVValHelper::MEDIAN, PVValHelper::phi, theDetails_, PVValHelper::histodetails::trendbins, Measurement1D::value(), and PVValHelper::WIDTH.

Referenced by endJob().

◆ fitResiduals()

std::pair<Measurement1D, Measurement1D> PrimaryVertexValidation::fitResiduals ( TH1 *  hist)
private

◆ getMAD()

Measurement1D PrimaryVertexValidation::getMAD ( TH1F *  histo)
private

◆ getMedian()

Measurement1D PrimaryVertexValidation::getMedian ( TH1F *  histo)
private

◆ getRunTime()

std::pair< long long, long long > PrimaryVertexValidation::getRunTime ( const edm::EventSetup &  iSetup) const
private

Definition at line 2960 of file PrimaryVertexValidation.cc.

2962 {
2963  edm::ESHandle<RunInfo> runInfo = iSetup.getHandle(runInfoToken_);
2964  if (debug_) {
2965  edm::LogInfo("PrimaryVertexValidation")
2966  << runInfo.product()->m_start_time_str << " " << runInfo.product()->m_stop_time_str << std::endl;
2967  }
2968  return std::make_pair(runInfo.product()->m_start_time_ll, runInfo.product()->m_stop_time_ll);
2969 }

References debug_, submitPVValidationJobs::runInfo, and runInfoToken_.

Referenced by analyze().

◆ getTypeString()

std::tuple<std::string, std::string, std::string> PrimaryVertexValidation::getTypeString ( PVValHelper::residualType  type)
private

◆ getVarString()

std::tuple<std::string, std::string, std::string> PrimaryVertexValidation::getVarString ( PVValHelper::plotVariable  var)
private

◆ hasFirstLayerPixelHits()

bool PrimaryVertexValidation::hasFirstLayerPixelHits ( const reco::TransientTrack &  track)
private

Definition at line 1148 of file PrimaryVertexValidation.cc.

1148  {
1149  using namespace reco;
1150  const HitPattern& p = track.hitPattern();
1151  for (int i = 0; i < p.numberOfAllHits(HitPattern::TRACK_HITS); i++) {
1152  uint32_t pattern = p.getHitPattern(HitPattern::TRACK_HITS, i);
1153  if (p.pixelBarrelHitFilter(pattern) || p.pixelEndcapHitFilter(pattern)) {
1154  if (p.getLayer(pattern) == 1) {
1155  if (p.validHitFilter(pattern)) {
1156  return true;
1157  }
1158  }
1159  }
1160  }
1161  return false;
1162 }

References mps_fire::i, AlCaHLTBitMon_ParallelJobs::p, topSingleLeptonDQM_PU_cfi::pattern, and HLT_FULL_cff::track.

Referenced by analyze().

◆ isBFieldConsistentWithMode()

bool PrimaryVertexValidation::isBFieldConsistentWithMode ( const edm::EventSetup &  iSetup) const
private

Definition at line 2972 of file PrimaryVertexValidation.cc.

2974 {
2975  edm::ESHandle<RunInfo> runInfo = iSetup.getHandle(runInfoToken_);
2976  double average_current = runInfo.product()->m_avg_current;
2977  bool isOn = (average_current > 2000.);
2978  bool is0T = (ptOfProbe_ == 0.);
2979 
2980  return ((isOn && !is0T) || (!isOn && is0T));
2981 }

References ptOfProbe_, submitPVValidationJobs::runInfo, and runInfoToken_.

Referenced by analyze().

◆ isHit2D()

bool PrimaryVertexValidation::isHit2D ( const TrackingRecHit &  hit) const
private

Definition at line 1100 of file PrimaryVertexValidation.cc.

1100  {
1101  if (hit.dimension() < 2) {
1102  return false; // some (muon...) stuff really has RecHit1D
1103  } else {
1104  const DetId detId(hit.geographicalId());
1105  if (detId.det() == DetId::Tracker) {
1106  if (detId.subdetId() == PixelSubdetector::PixelBarrel || detId.subdetId() == PixelSubdetector::PixelEndcap) {
1107  return true; // pixel is always 2D
1108  } else { // should be SiStrip now
1109  if (dynamic_cast<const SiStripRecHit2D*>(&hit))
1110  return false; // normal hit
1111  else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit))
1112  return true; // matched is 2D
1113  else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit))
1114  return false; // crazy hit...
1115  else {
1116  edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
1117  << "Tracker hit not in pixel and neither SiStripRecHit2D nor "
1118  << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
1119  return false;
1120  }
1121  }
1122  } else { // not tracker??
1123  edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
1124  << "Hit not in tracker with 'official' dimension >=2.";
1125  return true; // dimension() >= 2 so accept that...
1126  }
1127  }
1128  // never reached...
1129 }

References PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, and DetId::Tracker.

Referenced by analyze().

◆ passesTrackCuts()

bool PrimaryVertexValidation::passesTrackCuts ( const reco::Track &  track,
const reco::Vertex &  vertex,
const std::string &  qualityString_,
double  dxyErrMax_,
double  dzErrMax_,
double  ptErrMax_ 
)
private

Definition at line 3256 of file PrimaryVertexValidation.cc.

3263 {
3264  math::XYZPoint vtxPoint(0.0, 0.0, 0.0);
3265  double vzErr = 0.0, vxErr = 0.0, vyErr = 0.0;
3266  vtxPoint = vertex.position();
3267  vzErr = vertex.zError();
3268  vxErr = vertex.xError();
3269  vyErr = vertex.yError();
3270 
3271  double dxy = 0.0, dz = 0.0, dxysigma = 0.0, dzsigma = 0.0;
3272  dxy = track.dxy(vtxPoint);
3273  dz = track.dz(vtxPoint);
3274  dxysigma = sqrt(track.d0Error() * track.d0Error() + vxErr * vyErr);
3275  dzsigma = sqrt(track.dzError() * track.dzError() + vzErr * vzErr);
3276 
3277  if (track.quality(reco::TrackBase::qualityByName(qualityString_)) != 1)
3278  return false;
3279  if (std::abs(dxy / dxysigma) > dxyErrMax_)
3280  return false;
3281  if (std::abs(dz / dzsigma) > dzErrMax_)
3282  return false;
3283  if (track.ptError() / track.pt() > ptErrMax_)
3284  return false;
3285 
3286  return true;
3287 }

References funct::abs(), PVValHelper::dxy, PVValHelper::dz, reco::TrackBase::qualityByName(), mathSSE::sqrt(), HLT_FULL_cff::track, and bphysicsOniaDQM_cfi::vertex.

◆ pixelHitsCheck()

std::pair< bool, bool > PrimaryVertexValidation::pixelHitsCheck ( const reco::TransientTrack &  track)
private

Definition at line 1132 of file PrimaryVertexValidation.cc.

1132  {
1133  bool hasBPixHits = false;
1134  bool hasFPixHits = false;
1135 
1136  const reco::HitPattern& p = track.hitPattern();
1137  if (p.numberOfValidPixelEndcapHits() != 0) {
1138  hasFPixHits = true;
1139  }
1140  if (p.numberOfValidPixelBarrelHits() != 0) {
1141  hasBPixHits = true;
1142  }
1143 
1144  return std::make_pair(hasBPixHits, hasFPixHits);
1145 }

References AlCaHLTBitMon_ParallelJobs::p, and HLT_FULL_cff::track.

Referenced by analyze().

◆ SetVarToZero()

void PrimaryVertexValidation::SetVarToZero ( )
private

Definition at line 2984 of file PrimaryVertexValidation.cc.

2986 {
2987  nTracks_ = 0;
2988  nClus_ = 0;
2989  nOfflineVertices_ = 0;
2990  RunNumber_ = 0;
2991  LuminosityBlockNumber_ = 0;
2992  xOfflineVertex_ = -999.;
2993  yOfflineVertex_ = -999.;
2994  zOfflineVertex_ = -999.;
2995  xErrOfflineVertex_ = 0.;
2996  yErrOfflineVertex_ = 0.;
2997  zErrOfflineVertex_ = 0.;
2998  BSx0_ = -999.;
2999  BSy0_ = -999.;
3000  BSz0_ = -999.;
3001  Beamsigmaz_ = -999.;
3002  Beamdxdz_ = -999.;
3003  BeamWidthX_ = -999.;
3004  BeamWidthY_ = -999.;
3005  wxy2_ = -999.;
3006 
3007  for (int i = 0; i < nMaxtracks_; ++i) {
3008  pt_[i] = 0;
3009  p_[i] = 0;
3010  nhits_[i] = 0;
3011  nhits1D_[i] = 0;
3012  nhits2D_[i] = 0;
3013  nhitsBPIX_[i] = 0;
3014  nhitsFPIX_[i] = 0;
3015  nhitsTIB_[i] = 0;
3016  nhitsTID_[i] = 0;
3017  nhitsTOB_[i] = 0;
3018  nhitsTEC_[i] = 0;
3019  isHighPurity_[i] = 0;
3020  eta_[i] = 0;
3021  theta_[i] = 0;
3022  phi_[i] = 0;
3023  chi2_[i] = 0;
3024  chi2ndof_[i] = 0;
3025  charge_[i] = 0;
3026  qoverp_[i] = 0;
3027  dz_[i] = 0;
3028  dxy_[i] = 0;
3029  dzBs_[i] = 0;
3030  dxyBs_[i] = 0;
3031  xPCA_[i] = 0;
3032  yPCA_[i] = 0;
3033  zPCA_[i] = 0;
3034  xUnbiasedVertex_[i] = 0;
3035  yUnbiasedVertex_[i] = 0;
3036  zUnbiasedVertex_[i] = 0;
3037  chi2normUnbiasedVertex_[i] = 0;
3038  chi2UnbiasedVertex_[i] = 0;
3039  chi2ProbUnbiasedVertex_[i] = 0;
3040  DOFUnbiasedVertex_[i] = 0;
3041  sumOfWeightsUnbiasedVertex_[i] = 0;
3042  tracksUsedForVertexing_[i] = 0;
3043  dxyFromMyVertex_[i] = 0;
3044  dzFromMyVertex_[i] = 0;
3045  d3DFromMyVertex_[i] = 0;
3046  dxyErrorFromMyVertex_[i] = 0;
3047  dzErrorFromMyVertex_[i] = 0;
3048  d3DErrorFromMyVertex_[i] = 0;
3049  IPTsigFromMyVertex_[i] = 0;
3050  IPLsigFromMyVertex_[i] = 0;
3051  IP3DsigFromMyVertex_[i] = 0;
3052  hasRecVertex_[i] = 0;
3053  isGoodTrack_[i] = 0;
3054  }
3055 }

References Beamdxdz_, Beamsigmaz_, BeamWidthX_, BeamWidthY_, BSx0_, BSy0_, BSz0_, charge_, chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2ProbUnbiasedVertex_, chi2UnbiasedVertex_, d3DErrorFromMyVertex_, d3DFromMyVertex_, DOFUnbiasedVertex_, dxy_, dxyBs_, dxyErrorFromMyVertex_, dxyFromMyVertex_, dz_, dzBs_, dzErrorFromMyVertex_, dzFromMyVertex_, eta_, hasRecVertex_, mps_fire::i, IP3DsigFromMyVertex_, IPLsigFromMyVertex_, IPTsigFromMyVertex_, isGoodTrack_, isHighPurity_, LuminosityBlockNumber_, nClus_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nMaxtracks_, nOfflineVertices_, nTracks_, p_, phi_, pt_, qoverp_, RunNumber_, sumOfWeightsUnbiasedVertex_, theta_, tracksUsedForVertexing_, wxy2_, xErrOfflineVertex_, xOfflineVertex_, xPCA_, xUnbiasedVertex_, yErrOfflineVertex_, yOfflineVertex_, yPCA_, yUnbiasedVertex_, zErrOfflineVertex_, zOfflineVertex_, zPCA_, and zUnbiasedVertex_.

Referenced by analyze().

◆ shrinkHistVectorToFit()

void PrimaryVertexValidation::shrinkHistVectorToFit ( std::vector< TH1F * > &  h,
unsigned int  desired_size 
)
private

◆ square()

double PrimaryVertexValidation::square ( double  x)
inlineprivate

Definition at line 136 of file PrimaryVertexValidation.h.

136 { return x * x; }

References x.

◆ vtxSort()

bool PrimaryVertexValidation::vtxSort ( const reco::Vertex &  a,
const reco::Vertex &  b 
)
staticprivate

Definition at line 3246 of file PrimaryVertexValidation.cc.

3248 {
3249  if (a.tracksSize() != b.tracksSize())
3250  return a.tracksSize() > b.tracksSize() ? true : false;
3251  else
3252  return a.chi2() < b.chi2() ? true : false;
3253 }

References a, b, and funct::true.

Referenced by analyze().

Member Data Documentation

◆ a_d3DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_d3DEtaResiduals
private

Definition at line 343 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_d3DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_d3DPhiResiduals
private

Definition at line 342 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_d3DResidualsMap

TH1F* PrimaryVertexValidation::a_d3DResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 369 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxEtaResiduals
private

Definition at line 325 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxPhiResiduals
private

Definition at line 324 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyBiasResidualsMap

TH1F* PrimaryVertexValidation::a_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 534 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyEtaBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxyEtaBiasResiduals
private

Definition at line 519 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyEtaMADBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMADBiasTrend
private

Definition at line 570 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMADTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMADTrend
private

Definition at line 456 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMeanBiasTrend
private

Definition at line 547 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMeanTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMeanTrend
private

Definition at line 389 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMedianBiasTrend
private

Definition at line 569 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMedianTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMedianTrend
private

Definition at line 455 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxyEtaResiduals
private

Definition at line 322 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaWidthBiasTrend
private

Definition at line 548 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaWidthTrend

TH1F* PrimaryVertexValidation::a_dxyEtaWidthTrend
private

Definition at line 390 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyL1MeanMap

TH2F* PrimaryVertexValidation::a_dxyL1MeanMap
private

Definition at line 500 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyL1ResidualsMap

TH1F* PrimaryVertexValidation::a_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 377 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyL1WidthMap

TH2F* PrimaryVertexValidation::a_dxyL1WidthMap
private

Definition at line 506 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyladderMeanTrend

TH1F* PrimaryVertexValidation::a_dxyladderMeanTrend
private

Definition at line 433 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyladderWidthTrend

TH1F* PrimaryVertexValidation::a_dxyladderWidthTrend
private

Definition at line 434 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyMeanBiasMap

TH2F* PrimaryVertexValidation::a_dxyMeanBiasMap
private

Definition at line 586 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyMeanMap

TH2F* PrimaryVertexValidation::a_dxyMeanMap
private

Definition at line 486 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxymodZMeanTrend

TH1F* PrimaryVertexValidation::a_dxymodZMeanTrend
private

Definition at line 428 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxymodZWidthTrend

TH1F* PrimaryVertexValidation::a_dxymodZWidthTrend
private

Definition at line 429 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyPhiBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxyPhiBiasResiduals
private

Definition at line 518 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyPhiMADBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMADBiasTrend
private

Definition at line 565 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMADTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMADTrend
private

Definition at line 451 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMeanBiasTrend
private

Definition at line 542 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMeanTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMeanTrend
private

Definition at line 384 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMedianBiasTrend
private

Definition at line 564 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMedianTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMedianTrend
private

Definition at line 450 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dxyPhiResiduals
private

Definition at line 321 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiWidthBiasTrend
private

Definition at line 543 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiWidthTrend

TH1F* PrimaryVertexValidation::a_dxyPhiWidthTrend
private

Definition at line 385 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTCentralMeanTrend

TH1F* PrimaryVertexValidation::a_dxypTCentralMeanTrend
private

Definition at line 411 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTCentralWidthTrend

TH1F* PrimaryVertexValidation::a_dxypTCentralWidthTrend
private

Definition at line 412 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTMeanTrend

TH1F* PrimaryVertexValidation::a_dxypTMeanTrend
private

Definition at line 406 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTWidthTrend

TH1F* PrimaryVertexValidation::a_dxypTWidthTrend
private

Definition at line 407 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyResidualsMap

TH1F* PrimaryVertexValidation::a_dxyResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 367 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dxyVsEta

TH2F* PrimaryVertexValidation::a_dxyVsEta
private

Definition at line 478 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyVsPhi

TH2F* PrimaryVertexValidation::a_dxyVsPhi
private

Definition at line 472 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyWidthBiasMap

TH2F* PrimaryVertexValidation::a_dxyWidthBiasMap
private

Definition at line 592 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyWidthMap

TH2F* PrimaryVertexValidation::a_dxyWidthMap
private

Definition at line 492 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dyEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dyEtaResiduals
private

Definition at line 328 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dyPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dyPhiResiduals
private

Definition at line 327 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzBiasResidualsMap

TH1F* PrimaryVertexValidation::a_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 535 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzEtaBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dzEtaBiasResiduals
private

Definition at line 522 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzEtaMADBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMADBiasTrend
private

Definition at line 572 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMADTrend

TH1F* PrimaryVertexValidation::a_dzEtaMADTrend
private

Definition at line 458 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMeanBiasTrend
private

Definition at line 549 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMeanTrend

TH1F* PrimaryVertexValidation::a_dzEtaMeanTrend
private

Definition at line 391 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMedianBiasTrend
private

Definition at line 571 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMedianTrend

TH1F* PrimaryVertexValidation::a_dzEtaMedianTrend
private

Definition at line 457 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dzEtaResiduals
private

Definition at line 331 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaWidthBiasTrend
private

Definition at line 550 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaWidthTrend

TH1F* PrimaryVertexValidation::a_dzEtaWidthTrend
private

Definition at line 392 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzL1MeanMap

TH2F* PrimaryVertexValidation::a_dzL1MeanMap
private

Definition at line 501 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzL1ResidualsMap

TH1F* PrimaryVertexValidation::a_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 378 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzL1WidthMap

TH2F* PrimaryVertexValidation::a_dzL1WidthMap
private

Definition at line 507 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzladderMeanTrend

TH1F* PrimaryVertexValidation::a_dzladderMeanTrend
private

Definition at line 435 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzladderWidthTrend

TH1F* PrimaryVertexValidation::a_dzladderWidthTrend
private

Definition at line 436 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzMeanBiasMap

TH2F* PrimaryVertexValidation::a_dzMeanBiasMap
private

Definition at line 587 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzMeanMap

TH2F* PrimaryVertexValidation::a_dzMeanMap
private

Definition at line 487 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzmodZMeanTrend

TH1F* PrimaryVertexValidation::a_dzmodZMeanTrend
private

Definition at line 430 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzmodZWidthTrend

TH1F* PrimaryVertexValidation::a_dzmodZWidthTrend
private

Definition at line 431 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzPhiBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dzPhiBiasResiduals
private

Definition at line 521 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzPhiMADBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMADBiasTrend
private

Definition at line 567 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMADTrend

TH1F* PrimaryVertexValidation::a_dzPhiMADTrend
private

Definition at line 453 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMeanBiasTrend
private

Definition at line 544 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMeanTrend

TH1F* PrimaryVertexValidation::a_dzPhiMeanTrend
private

Definition at line 386 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMedianBiasTrend
private

Definition at line 566 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMedianTrend

TH1F* PrimaryVertexValidation::a_dzPhiMedianTrend
private

Definition at line 452 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_dzPhiResiduals
private

Definition at line 330 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiWidthBiasTrend
private

Definition at line 545 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiWidthTrend

TH1F* PrimaryVertexValidation::a_dzPhiWidthTrend
private

Definition at line 387 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTCentralMeanTrend

TH1F* PrimaryVertexValidation::a_dzpTCentralMeanTrend
private

Definition at line 413 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTCentralWidthTrend

TH1F* PrimaryVertexValidation::a_dzpTCentralWidthTrend
private

Definition at line 414 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTMeanTrend

TH1F* PrimaryVertexValidation::a_dzpTMeanTrend
private

Definition at line 408 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTWidthTrend

TH1F* PrimaryVertexValidation::a_dzpTWidthTrend
private

Definition at line 409 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzResidualsMap

TH1F* PrimaryVertexValidation::a_dzResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 368 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ a_dzVsEta

TH2F* PrimaryVertexValidation::a_dzVsEta
private

Definition at line 479 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzVsPhi

TH2F* PrimaryVertexValidation::a_dzVsPhi
private

Definition at line 473 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzWidthBiasMap

TH2F* PrimaryVertexValidation::a_dzWidthBiasMap
private

Definition at line 593 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzWidthMap

TH2F* PrimaryVertexValidation::a_dzWidthMap
private

Definition at line 493 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_IP2DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_IP2DEtaResiduals
private

Definition at line 334 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP2DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_IP2DPhiResiduals
private

Definition at line 333 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP3DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_IP3DEtaResiduals
private

Definition at line 337 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP3DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_IP3DPhiResiduals
private

Definition at line 336 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_reszEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_reszEtaResiduals
private

Definition at line 340 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_reszPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::a_reszPhiResiduals
private

Definition at line 339 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ askFirstLayerHit_

bool PrimaryVertexValidation::askFirstLayerHit_
private

Definition at line 172 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ Beamdxdz_

double PrimaryVertexValidation::Beamdxdz_
private

Definition at line 240 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ Beamsigmaz_

double PrimaryVertexValidation::Beamsigmaz_
private

Definition at line 239 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ BeamWidthX_

double PrimaryVertexValidation::BeamWidthX_
private

Definition at line 241 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ BeamWidthY_

double PrimaryVertexValidation::BeamWidthY_
private

Definition at line 242 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ BSx0_

double PrimaryVertexValidation::BSx0_
private

Definition at line 236 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ BSy0_

double PrimaryVertexValidation::BSy0_
private

Definition at line 237 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ BSz0_

double PrimaryVertexValidation::BSz0_
private

Definition at line 238 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ charge_

int PrimaryVertexValidation::charge_[nMaxtracks_]
private

Definition at line 263 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ chi2_

double PrimaryVertexValidation::chi2_[nMaxtracks_]
private

Definition at line 261 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ chi2ndof_

double PrimaryVertexValidation::chi2ndof_[nMaxtracks_]
private

Definition at line 262 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ chi2normUnbiasedVertex_

float PrimaryVertexValidation::chi2normUnbiasedVertex_[nMaxtracks_]
private

Definition at line 275 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ chi2ProbUnbiasedVertex_

float PrimaryVertexValidation::chi2ProbUnbiasedVertex_[nMaxtracks_]
private

Definition at line 277 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ chi2UnbiasedVertex_

float PrimaryVertexValidation::chi2UnbiasedVertex_[nMaxtracks_]
private

Definition at line 276 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ cmToum

const int PrimaryVertexValidation::cmToum = 10000
staticprivate

Definition at line 207 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ compressionSettings_

const int PrimaryVertexValidation::compressionSettings_
private

Definition at line 157 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ d3DErrorFromMyVertex_

double PrimaryVertexValidation::d3DErrorFromMyVertex_[nMaxtracks_]
private

Definition at line 288 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ d3DFromMyVertex_

double PrimaryVertexValidation::d3DFromMyVertex_[nMaxtracks_]
private

Definition at line 284 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ debug_

bool PrimaryVertexValidation::debug_
private

Definition at line 190 of file PrimaryVertexValidation.h.

Referenced by analyze(), getRunTime(), and PrimaryVertexValidation().

◆ doBPix_

bool PrimaryVertexValidation::doBPix_
private

Definition at line 173 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ doFPix_

bool PrimaryVertexValidation::doFPix_
private

Definition at line 174 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ DOFUnbiasedVertex_

float PrimaryVertexValidation::DOFUnbiasedVertex_[nMaxtracks_]
private

Definition at line 278 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dxy_

double PrimaryVertexValidation::dxy_[nMaxtracks_]
private

Definition at line 266 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dxyBs_

double PrimaryVertexValidation::dxyBs_[nMaxtracks_]
private

Definition at line 267 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dxyErrorFromMyVertex_

double PrimaryVertexValidation::dxyErrorFromMyVertex_[nMaxtracks_]
private

Definition at line 286 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dxyFromMyVertex_

double PrimaryVertexValidation::dxyFromMyVertex_[nMaxtracks_]
private

Definition at line 282 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dz_

double PrimaryVertexValidation::dz_[nMaxtracks_]
private

Definition at line 265 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dzBs_

double PrimaryVertexValidation::dzBs_[nMaxtracks_]
private

Definition at line 268 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dzErrorFromMyVertex_

double PrimaryVertexValidation::dzErrorFromMyVertex_[nMaxtracks_]
private

Definition at line 287 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ dzFromMyVertex_

double PrimaryVertexValidation::dzFromMyVertex_[nMaxtracks_]
private

Definition at line 283 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ eta_

double PrimaryVertexValidation::eta_[nMaxtracks_]
private

Definition at line 258 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ etaOfProbe_

double PrimaryVertexValidation::etaOfProbe_
private

Definition at line 177 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and PrimaryVertexValidation().

◆ EventNumber_

unsigned int PrimaryVertexValidation::EventNumber_
private

Definition at line 226 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ forceBeamSpotContraint_

bool PrimaryVertexValidation::forceBeamSpotContraint_
private

Definition at line 194 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ fs

edm::Service<TFileService> PrimaryVertexValidation::fs
private

Definition at line 297 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ geomToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> PrimaryVertexValidation::geomToken_
private

Definition at line 152 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ h2_probeEtaPhi_

TH2F* PrimaryVertexValidation::h2_probeEtaPhi_
private

Definition at line 621 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h2_probeEtaPt_

TH2F* PrimaryVertexValidation::h2_probeEtaPt_
private

Definition at line 622 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h2_probeLayer1Map_

TH2F* PrimaryVertexValidation::h2_probeLayer1Map_
private

Definition at line 670 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h2_probePassingLayer1Map_

TH2F* PrimaryVertexValidation::h2_probePassingLayer1Map_
private

Definition at line 671 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_Beamsigmaz

TH1F* PrimaryVertexValidation::h_Beamsigmaz
private

Definition at line 615 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BeamWidthX

TH1F* PrimaryVertexValidation::h_BeamWidthX
private

Definition at line 616 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BeamWidthY

TH1F* PrimaryVertexValidation::h_BeamWidthY
private

Definition at line 617 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSx0

TH1F* PrimaryVertexValidation::h_BSx0
private

Definition at line 612 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSy0

TH1F* PrimaryVertexValidation::h_BSy0
private

Definition at line 613 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSz0

TH1F* PrimaryVertexValidation::h_BSz0
private

Definition at line 614 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_dxy_Central_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_Central_pT_
private

Definition at line 697 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dxy_ladder_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_ladder_
private

Definition at line 712 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dxy_ladderNoOverlap_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_ladderNoOverlap_
private

Definition at line 710 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_dxy_ladderOverlap_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_ladderOverlap_
private

Definition at line 709 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_dxy_modZ_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_modZ_
private

Definition at line 704 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dxy_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_dxy_pT_
private

Definition at line 692 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dz_Central_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_dz_Central_pT_
private

Definition at line 698 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dz_ladder_

std::vector<TH1F*> PrimaryVertexValidation::h_dz_ladder_
private

Definition at line 713 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dz_modZ_

std::vector<TH1F*> PrimaryVertexValidation::h_dz_modZ_
private

Definition at line 705 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_dz_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_dz_pT_
private

Definition at line 693 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_etaMax

TH1F* PrimaryVertexValidation::h_etaMax
private

Definition at line 308 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxChi2_

TH1F* PrimaryVertexValidation::h_fitVtxChi2_
private

Definition at line 676 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxChi2ndf_

TH1F* PrimaryVertexValidation::h_fitVtxChi2ndf_
private

Definition at line 678 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxChi2Prob_

TH1F* PrimaryVertexValidation::h_fitVtxChi2Prob_
private

Definition at line 679 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxNdof_

TH1F* PrimaryVertexValidation::h_fitVtxNdof_
private

Definition at line 675 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxNtracks_

TH1F* PrimaryVertexValidation::h_fitVtxNtracks_
private

Definition at line 677 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxTrackAverageWeight_

TH1F* PrimaryVertexValidation::h_fitVtxTrackAverageWeight_
private

Definition at line 681 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxTrackWeights_

TH1F* PrimaryVertexValidation::h_fitVtxTrackWeights_
private

Definition at line 680 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_lumiFromConfig

TH1F* PrimaryVertexValidation::h_lumiFromConfig
private

Definition at line 603 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ h_nbins

TH1F* PrimaryVertexValidation::h_nbins
private

Definition at line 309 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_nClus

TH1F* PrimaryVertexValidation::h_nClus
private

Definition at line 600 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_nLadders

TH1F* PrimaryVertexValidation::h_nLadders
private

Definition at line 310 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_nOfflineVertices

TH1F* PrimaryVertexValidation::h_nOfflineVertices
private

Definition at line 601 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_norm_dxy_Central_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dxy_Central_pT_
private

Definition at line 699 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dxy_ladder_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dxy_ladder_
private

Definition at line 714 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dxy_modZ_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dxy_modZ_
private

Definition at line 706 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dxy_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dxy_pT_
private

Definition at line 694 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dz_Central_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dz_Central_pT_
private

Definition at line 700 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dz_ladder_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dz_ladder_
private

Definition at line 715 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dz_modZ_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dz_modZ_
private

Definition at line 707 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_norm_dz_pT_

std::vector<TH1F*> PrimaryVertexValidation::h_norm_dz_pT_
private

Definition at line 695 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ h_nTracks

TH1F* PrimaryVertexValidation::h_nTracks
private

Definition at line 599 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeCharge_

TH1F* PrimaryVertexValidation::h_probeCharge_
private

Definition at line 631 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeChi2_

TH1F* PrimaryVertexValidation::h_probeChi2_
private

Definition at line 629 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probed0RefitV_

TH1F* PrimaryVertexValidation::h_probed0RefitV_
private

Definition at line 640 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probed3DRefitV_

TH1F* PrimaryVertexValidation::h_probed3DRefitV_
private

Definition at line 644 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedxyRecoV_

TH1F* PrimaryVertexValidation::h_probedxyRecoV_
private

Definition at line 635 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedxyRefitV_

TH1F* PrimaryVertexValidation::h_probedxyRefitV_
private

Definition at line 638 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedzRecoV_

TH1F* PrimaryVertexValidation::h_probedzRecoV_
private

Definition at line 634 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedzRefitV_

TH1F* PrimaryVertexValidation::h_probedzRefitV_
private

Definition at line 637 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeEta_

TH1F* PrimaryVertexValidation::h_probeEta_
private

Definition at line 627 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHasBPixL1Overlap_

TH1I* PrimaryVertexValidation::h_probeHasBPixL1Overlap_
private

Definition at line 667 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits1D_

TH1F* PrimaryVertexValidation::h_probeHits1D_
private

Definition at line 656 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits2D_

TH1F* PrimaryVertexValidation::h_probeHits2D_
private

Definition at line 657 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits_

TH1F* PrimaryVertexValidation::h_probeHits_
private

Definition at line 655 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInBPIX_

TH1F* PrimaryVertexValidation::h_probeHitsInBPIX_
private

Definition at line 662 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInFPIX_

TH1F* PrimaryVertexValidation::h_probeHitsInFPIX_
private

Definition at line 663 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTEC_

TH1F* PrimaryVertexValidation::h_probeHitsInTEC_
private

Definition at line 661 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTIB_

TH1F* PrimaryVertexValidation::h_probeHitsInTIB_
private

Definition at line 658 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTID_

TH1F* PrimaryVertexValidation::h_probeHitsInTID_
private

Definition at line 660 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTOB_

TH1F* PrimaryVertexValidation::h_probeHitsInTOB_
private

Definition at line 659 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeL1ClusterProb_

TH1F* PrimaryVertexValidation::h_probeL1ClusterProb_
private

Definition at line 669 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeL1Ladder_

TH1F* PrimaryVertexValidation::h_probeL1Ladder_
private

Definition at line 665 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeL1Module_

TH1F* PrimaryVertexValidation::h_probeL1Module_
private

Definition at line 666 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeNormChi2_

TH1F* PrimaryVertexValidation::h_probeNormChi2_
private

Definition at line 630 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeP_

TH1F* PrimaryVertexValidation::h_probeP_
private

Definition at line 624 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePhi_

TH1F* PrimaryVertexValidation::h_probePhi_
private

Definition at line 628 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePt_

TH1F* PrimaryVertexValidation::h_probePt_
private

Definition at line 625 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePtRebin_

TH1F* PrimaryVertexValidation::h_probePtRebin_
private

Definition at line 626 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeQoverP_

TH1F* PrimaryVertexValidation::h_probeQoverP_
private

Definition at line 632 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRecoVSigXY_

TH1F* PrimaryVertexValidation::h_probeRecoVSigXY_
private

Definition at line 648 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRecoVSigZ_

TH1F* PrimaryVertexValidation::h_probeRecoVSigZ_
private

Definition at line 647 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVLogSig3D_

TH1F* PrimaryVertexValidation::h_probeRefitVLogSig3D_
private

Definition at line 652 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSig3D_

TH1F* PrimaryVertexValidation::h_probeRefitVSig3D_
private

Definition at line 651 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigResZ_

TH1F* PrimaryVertexValidation::h_probeRefitVSigResZ_
private

Definition at line 653 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigXY_

TH1F* PrimaryVertexValidation::h_probeRefitVSigXY_
private

Definition at line 650 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigZ_

TH1F* PrimaryVertexValidation::h_probeRefitVSigZ_
private

Definition at line 649 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probereszRefitV_

TH1F* PrimaryVertexValidation::h_probereszRefitV_
private

Definition at line 645 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probesignIP2DRefitV_

TH1F* PrimaryVertexValidation::h_probesignIP2DRefitV_
private

Definition at line 643 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probez0RefitV_

TH1F* PrimaryVertexValidation::h_probez0RefitV_
private

Definition at line 641 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_pTinfo

TH1F* PrimaryVertexValidation::h_pTinfo
private

Definition at line 311 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxChi2ndf_

TH1F* PrimaryVertexValidation::h_recoVtxChi2ndf_
private

Definition at line 684 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxChi2Prob_

TH1F* PrimaryVertexValidation::h_recoVtxChi2Prob_
private

Definition at line 685 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxNtracks_

TH1F* PrimaryVertexValidation::h_recoVtxNtracks_
private

Definition at line 683 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxSumPt_

TH1F* PrimaryVertexValidation::h_recoVtxSumPt_
private

Definition at line 686 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_runEndTimes

TH1I* PrimaryVertexValidation::h_runEndTimes
private

Definition at line 315 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ h_runFromConfig

TH1I* PrimaryVertexValidation::h_runFromConfig
private

Definition at line 604 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ h_runFromEvent

TH1I* PrimaryVertexValidation::h_runFromEvent
private

Definition at line 605 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_runNumber

TH1F* PrimaryVertexValidation::h_runNumber
private

Definition at line 602 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_runStartTimes

TH1I* PrimaryVertexValidation::h_runStartTimes
private

Definition at line 314 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ h_xErrOfflineVertex

TH1F* PrimaryVertexValidation::h_xErrOfflineVertex
private

Definition at line 609 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_xOfflineVertex

TH1F* PrimaryVertexValidation::h_xOfflineVertex
private

Definition at line 606 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_yErrOfflineVertex

TH1F* PrimaryVertexValidation::h_yErrOfflineVertex
private

Definition at line 610 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_yOfflineVertex

TH1F* PrimaryVertexValidation::h_yOfflineVertex
private

Definition at line 607 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_zErrOfflineVertex

TH1F* PrimaryVertexValidation::h_zErrOfflineVertex
private

Definition at line 611 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_zOfflineVertex

TH1F* PrimaryVertexValidation::h_zOfflineVertex
private

Definition at line 608 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ hasRecVertex_

int PrimaryVertexValidation::hasRecVertex_[nMaxtracks_]
private

Definition at line 294 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ hDA

std::map<std::string, TH1*> PrimaryVertexValidation::hDA
private

Definition at line 688 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ intLumi_

double PrimaryVertexValidation::intLumi_
private

Definition at line 169 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ IP3DsigFromMyVertex_

double PrimaryVertexValidation::IP3DsigFromMyVertex_[nMaxtracks_]
private

Definition at line 292 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ IPLsigFromMyVertex_

double PrimaryVertexValidation::IPLsigFromMyVertex_[nMaxtracks_]
private

Definition at line 291 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ IPTsigFromMyVertex_

double PrimaryVertexValidation::IPTsigFromMyVertex_[nMaxtracks_]
private

Definition at line 290 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ isGoodTrack_

int PrimaryVertexValidation::isGoodTrack_[nMaxtracks_]
private

Definition at line 295 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ isHighPurity_

int PrimaryVertexValidation::isHighPurity_[nMaxtracks_]
private

Definition at line 257 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ isPhase1_

bool PrimaryVertexValidation::isPhase1_
private

Definition at line 179 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ lightNtupleSwitch_

bool PrimaryVertexValidation::lightNtupleSwitch_
private

Definition at line 159 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ LuminosityBlockNumber_

unsigned int PrimaryVertexValidation::LuminosityBlockNumber_
private

Definition at line 227 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ MADTrendsDir

TFileDirectory PrimaryVertexValidation::MADTrendsDir
private

Definition at line 302 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ magFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> PrimaryVertexValidation::magFieldToken_
private

Definition at line 150 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ maxPt_

const double PrimaryVertexValidation::maxPt_
private

Definition at line 186 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ Mean2DMapsDir

TFileDirectory PrimaryVertexValidation::Mean2DMapsDir
private

Definition at line 304 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ MeanTrendsDir

TFileDirectory PrimaryVertexValidation::MeanTrendsDir
private

Definition at line 299 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ MedianTrendsDir

TFileDirectory PrimaryVertexValidation::MedianTrendsDir
private

Definition at line 301 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ minPt_

const double PrimaryVertexValidation::minPt_
private

Definition at line 185 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ mypT_bins_

std::array<float, nPtBins_ + 1> PrimaryVertexValidation::mypT_bins_
private

Definition at line 218 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and PrimaryVertexValidation().

◆ n_d3DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_d3DEtaResiduals
private

Definition at line 363 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_d3DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_d3DPhiResiduals
private

Definition at line 362 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_d3DResidualsMap

TH1F* PrimaryVertexValidation::n_d3DResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 373 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyBiasResidualsMap

TH1F* PrimaryVertexValidation::n_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 537 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyEtaBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dxyEtaBiasResiduals
private

Definition at line 527 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyEtaMADBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMADBiasTrend
private

Definition at line 580 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMADTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMADTrend
private

Definition at line 466 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMeanBiasTrend
private

Definition at line 557 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMeanTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMeanTrend
private

Definition at line 399 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMedianBiasTrend
private

Definition at line 579 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMedianTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMedianTrend
private

Definition at line 465 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dxyEtaResiduals
private

Definition at line 348 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaWidthBiasTrend
private

Definition at line 558 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaWidthTrend

TH1F* PrimaryVertexValidation::n_dxyEtaWidthTrend
private

Definition at line 400 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyL1MeanMap

TH2F* PrimaryVertexValidation::n_dxyL1MeanMap
private

Definition at line 503 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyL1ResidualsMap

TH1F* PrimaryVertexValidation::n_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 379 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyL1WidthMap

TH2F* PrimaryVertexValidation::n_dxyL1WidthMap
private

Definition at line 509 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyladderMeanTrend

TH1F* PrimaryVertexValidation::n_dxyladderMeanTrend
private

Definition at line 443 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyladderWidthTrend

TH1F* PrimaryVertexValidation::n_dxyladderWidthTrend
private

Definition at line 444 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyMeanBiasMap

TH2F* PrimaryVertexValidation::n_dxyMeanBiasMap
private

Definition at line 589 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyMeanMap

TH2F* PrimaryVertexValidation::n_dxyMeanMap
private

Definition at line 489 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxymodZMeanTrend

TH1F* PrimaryVertexValidation::n_dxymodZMeanTrend
private

Definition at line 438 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxymodZWidthTrend

TH1F* PrimaryVertexValidation::n_dxymodZWidthTrend
private

Definition at line 439 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyPhiBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dxyPhiBiasResiduals
private

Definition at line 526 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyPhiMADBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMADBiasTrend
private

Definition at line 575 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMADTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMADTrend
private

Definition at line 461 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMeanBiasTrend
private

Definition at line 552 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMeanTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMeanTrend
private

Definition at line 394 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMedianBiasTrend
private

Definition at line 574 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMedianTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMedianTrend
private

Definition at line 460 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dxyPhiResiduals
private

Definition at line 347 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiWidthBiasTrend
private

Definition at line 553 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiWidthTrend

TH1F* PrimaryVertexValidation::n_dxyPhiWidthTrend
private

Definition at line 395 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTCentralMeanTrend

TH1F* PrimaryVertexValidation::n_dxypTCentralMeanTrend
private

Definition at line 421 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTCentralWidthTrend

TH1F* PrimaryVertexValidation::n_dxypTCentralWidthTrend
private

Definition at line 422 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTMeanTrend

TH1F* PrimaryVertexValidation::n_dxypTMeanTrend
private

Definition at line 416 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTWidthTrend

TH1F* PrimaryVertexValidation::n_dxypTWidthTrend
private

Definition at line 417 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyResidualsMap

TH1F* PrimaryVertexValidation::n_dxyResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 371 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dxyVsEta

TH2F* PrimaryVertexValidation::n_dxyVsEta
private

Definition at line 481 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyVsPhi

TH2F* PrimaryVertexValidation::n_dxyVsPhi
private

Definition at line 475 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyWidthBiasMap

TH2F* PrimaryVertexValidation::n_dxyWidthBiasMap
private

Definition at line 595 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyWidthMap

TH2F* PrimaryVertexValidation::n_dxyWidthMap
private

Definition at line 495 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzBiasResidualsMap

TH1F* PrimaryVertexValidation::n_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 538 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzEtaBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dzEtaBiasResiduals
private

Definition at line 530 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzEtaMADBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMADBiasTrend
private

Definition at line 582 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMADTrend

TH1F* PrimaryVertexValidation::n_dzEtaMADTrend
private

Definition at line 468 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMeanBiasTrend
private

Definition at line 559 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMeanTrend

TH1F* PrimaryVertexValidation::n_dzEtaMeanTrend
private

Definition at line 401 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMedianBiasTrend
private

Definition at line 581 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMedianTrend

TH1F* PrimaryVertexValidation::n_dzEtaMedianTrend
private

Definition at line 467 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dzEtaResiduals
private

Definition at line 351 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaWidthBiasTrend
private

Definition at line 560 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaWidthTrend

TH1F* PrimaryVertexValidation::n_dzEtaWidthTrend
private

Definition at line 402 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzL1MeanMap

TH2F* PrimaryVertexValidation::n_dzL1MeanMap
private

Definition at line 504 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzL1ResidualsMap

TH1F* PrimaryVertexValidation::n_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 380 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzL1WidthMap

TH2F* PrimaryVertexValidation::n_dzL1WidthMap
private

Definition at line 510 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzladderMeanTrend

TH1F* PrimaryVertexValidation::n_dzladderMeanTrend
private

Definition at line 445 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzladderWidthTrend

TH1F* PrimaryVertexValidation::n_dzladderWidthTrend
private

Definition at line 446 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzMeanBiasMap

TH2F* PrimaryVertexValidation::n_dzMeanBiasMap
private

Definition at line 590 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzMeanMap

TH2F* PrimaryVertexValidation::n_dzMeanMap
private

Definition at line 490 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzmodZMeanTrend

TH1F* PrimaryVertexValidation::n_dzmodZMeanTrend
private

Definition at line 440 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzmodZWidthTrend

TH1F* PrimaryVertexValidation::n_dzmodZWidthTrend
private

Definition at line 441 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzPhiBiasResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dzPhiBiasResiduals
private

Definition at line 529 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzPhiMADBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMADBiasTrend
private

Definition at line 577 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMADTrend

TH1F* PrimaryVertexValidation::n_dzPhiMADTrend
private

Definition at line 463 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMeanBiasTrend
private

Definition at line 554 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMeanTrend

TH1F* PrimaryVertexValidation::n_dzPhiMeanTrend
private

Definition at line 396 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMedianBiasTrend
private

Definition at line 576 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMedianTrend

TH1F* PrimaryVertexValidation::n_dzPhiMedianTrend
private

Definition at line 462 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_dzPhiResiduals
private

Definition at line 350 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiWidthBiasTrend
private

Definition at line 555 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiWidthTrend

TH1F* PrimaryVertexValidation::n_dzPhiWidthTrend
private

Definition at line 397 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTCentralMeanTrend

TH1F* PrimaryVertexValidation::n_dzpTCentralMeanTrend
private

Definition at line 423 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTCentralWidthTrend

TH1F* PrimaryVertexValidation::n_dzpTCentralWidthTrend
private

Definition at line 424 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTMeanTrend

TH1F* PrimaryVertexValidation::n_dzpTMeanTrend
private

Definition at line 418 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTWidthTrend

TH1F* PrimaryVertexValidation::n_dzpTWidthTrend
private

Definition at line 419 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzResidualsMap

TH1F* PrimaryVertexValidation::n_dzResidualsMap[nMaxBins_][nMaxBins_]
private

Definition at line 372 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ n_dzVsEta

TH2F* PrimaryVertexValidation::n_dzVsEta
private

Definition at line 482 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dzVsPhi

TH2F* PrimaryVertexValidation::n_dzVsPhi
private

Definition at line 476 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dzWidthBiasMap

TH2F* PrimaryVertexValidation::n_dzWidthBiasMap
private

Definition at line 596 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzWidthMap

TH2F* PrimaryVertexValidation::n_dzWidthMap
private

Definition at line 496 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_IP2DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_IP2DEtaResiduals
private

Definition at line 354 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP2DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_IP2DPhiResiduals
private

Definition at line 353 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP3DEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_IP3DEtaResiduals
private

Definition at line 357 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP3DPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_IP3DPhiResiduals
private

Definition at line 356 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_reszEtaResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_reszEtaResiduals
private

Definition at line 360 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_reszPhiResiduals

std::vector<TH1F*> PrimaryVertexValidation::n_reszPhiResiduals
private

Definition at line 359 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ nBins_

int PrimaryVertexValidation::nBins_
private

Definition at line 182 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), endJob(), fillTrendPlot(), and PrimaryVertexValidation().

◆ nClus_

int PrimaryVertexValidation::nClus_
private

Definition at line 223 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ Nevt_

int PrimaryVertexValidation::Nevt_
private

Definition at line 139 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ nhits1D_

int PrimaryVertexValidation::nhits1D_[nMaxtracks_]
private

Definition at line 249 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhits2D_

int PrimaryVertexValidation::nhits2D_[nMaxtracks_]
private

Definition at line 250 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhits_

int PrimaryVertexValidation::nhits_[nMaxtracks_]
private

Definition at line 248 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhitsBPIX_

int PrimaryVertexValidation::nhitsBPIX_[nMaxtracks_]
private

Definition at line 251 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhitsFPIX_

int PrimaryVertexValidation::nhitsFPIX_[nMaxtracks_]
private

Definition at line 252 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nHitsOfProbe_

double PrimaryVertexValidation::nHitsOfProbe_
private

Definition at line 178 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ nhitsTEC_

int PrimaryVertexValidation::nhitsTEC_[nMaxtracks_]
private

Definition at line 256 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhitsTIB_

int PrimaryVertexValidation::nhitsTIB_[nMaxtracks_]
private

Definition at line 253 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhitsTID_

int PrimaryVertexValidation::nhitsTID_[nMaxtracks_]
private

Definition at line 254 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nhitsTOB_

int PrimaryVertexValidation::nhitsTOB_[nMaxtracks_]
private

Definition at line 255 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nLadders_

unsigned int PrimaryVertexValidation::nLadders_ = 20
private

Definition at line 210 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ nMaxBins_

const int PrimaryVertexValidation::nMaxBins_ = 100
staticprivate

Definition at line 145 of file PrimaryVertexValidation.h.

◆ nMaxtracks_

const int PrimaryVertexValidation::nMaxtracks_ = 1000
staticprivate

Definition at line 206 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ nModZ_

unsigned int PrimaryVertexValidation::nModZ_ = 8
private

Definition at line 211 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ nOfflineVertices_

int PrimaryVertexValidation::nOfflineVertices_
private

Definition at line 224 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nPtBins_

const int PrimaryVertexValidation::nPtBins_ = 48
staticprivate

Definition at line 208 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ nTracks_

int PrimaryVertexValidation::nTracks_
private

Definition at line 221 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ nTracksPerClus_

int PrimaryVertexValidation::nTracksPerClus_
private

Definition at line 222 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ p_

double PrimaryVertexValidation::p_[nMaxtracks_]
private

Definition at line 247 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ phi_

double PrimaryVertexValidation::phi_[nMaxtracks_]
private

Definition at line 260 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ pOfProbe_

double PrimaryVertexValidation::pOfProbe_
private

Definition at line 176 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ pt_

double PrimaryVertexValidation::pt_[nMaxtracks_]
private

Definition at line 246 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ ptOfProbe_

double PrimaryVertexValidation::ptOfProbe_
private

Definition at line 175 of file PrimaryVertexValidation.h.

Referenced by analyze(), and isBFieldConsistentWithMode().

◆ qoverp_

double PrimaryVertexValidation::qoverp_[nMaxtracks_]
private

Definition at line 264 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ rootTree_

TTree* PrimaryVertexValidation::rootTree_
private

Definition at line 200 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ runControl_

bool PrimaryVertexValidation::runControl_
private

Definition at line 191 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ runControlNumbers_

std::vector<unsigned int> PrimaryVertexValidation::runControlNumbers_
private

Definition at line 188 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and PrimaryVertexValidation().

◆ runInfoToken_

const edm::ESGetToken<RunInfo, RunInfoRcd> PrimaryVertexValidation::runInfoToken_
private

Definition at line 155 of file PrimaryVertexValidation.h.

Referenced by getRunTime(), and isBFieldConsistentWithMode().

◆ RunNumber_

unsigned int PrimaryVertexValidation::RunNumber_
private

Definition at line 225 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ runNumbersTimesLog_

std::map<unsigned int, std::pair<long long, long long> > PrimaryVertexValidation::runNumbersTimesLog_
private

Definition at line 313 of file PrimaryVertexValidation.h.

Referenced by analyze(), and endJob().

◆ storeNtuple_

bool PrimaryVertexValidation::storeNtuple_
private

Definition at line 158 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ sumOfWeightsUnbiasedVertex_

float PrimaryVertexValidation::sumOfWeightsUnbiasedVertex_[nMaxtracks_]
private

Definition at line 279 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ theBeamspotToken

edm::EDGetTokenT<reco::BeamSpot> PrimaryVertexValidation::theBeamspotToken
private

Definition at line 198 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theDetails_

PVValHelper::histodetails PrimaryVertexValidation::theDetails_
private

Definition at line 163 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), bookResidualsHistogram(), fillMap(), fillTrendPlot(), fillTrendPlotByIndex(), and PrimaryVertexValidation().

◆ theta_

double PrimaryVertexValidation::theta_[nMaxtracks_]
private

Definition at line 259 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ theTrackClusterizer_

std::unique_ptr<TrackClusterizerInZ> PrimaryVertexValidation::theTrackClusterizer_
private

Definition at line 142 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theTrackCollectionToken

edm::EDGetTokenT<reco::TrackCollection> PrimaryVertexValidation::theTrackCollectionToken
private

Definition at line 196 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theTrackFilter_

std::unique_ptr<TrackFilterForPVFindingBase> PrimaryVertexValidation::theTrackFilter_
private

Definition at line 141 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theVertexCollectionToken

edm::EDGetTokenT<reco::VertexCollection> PrimaryVertexValidation::theVertexCollectionToken
private

Definition at line 197 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ topoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> PrimaryVertexValidation::topoToken_
private

Definition at line 154 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ trackingGeomToken_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> PrimaryVertexValidation::trackingGeomToken_
private

Definition at line 151 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ tracksUsedForVertexing_

int PrimaryVertexValidation::tracksUsedForVertexing_[nMaxtracks_]
private

Definition at line 280 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ ttkToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> PrimaryVertexValidation::ttkToken_
private

Definition at line 153 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ useTracksFromRecoVtx_

bool PrimaryVertexValidation::useTracksFromRecoVtx_
private

Definition at line 160 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and endJob().

◆ vertexZMax_

double PrimaryVertexValidation::vertexZMax_
private

Definition at line 166 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ Width2DMapsDir

TFileDirectory PrimaryVertexValidation::Width2DMapsDir
private

Definition at line 305 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ WidthTrendsDir

TFileDirectory PrimaryVertexValidation::WidthTrendsDir
private

Definition at line 300 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ wxy2_

double PrimaryVertexValidation::wxy2_
private

Definition at line 243 of file PrimaryVertexValidation.h.

Referenced by analyze(), fillTrackHistos(), and SetVarToZero().

◆ xErrOfflineVertex_

double PrimaryVertexValidation::xErrOfflineVertex_
private

Definition at line 232 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ xOfflineVertex_

double PrimaryVertexValidation::xOfflineVertex_
private

Definition at line 228 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ xPCA_

double PrimaryVertexValidation::xPCA_[nMaxtracks_]
private

Definition at line 269 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ xUnbiasedVertex_

double PrimaryVertexValidation::xUnbiasedVertex_[nMaxtracks_]
private

Definition at line 272 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ yErrOfflineVertex_

double PrimaryVertexValidation::yErrOfflineVertex_
private

Definition at line 233 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ yOfflineVertex_

double PrimaryVertexValidation::yOfflineVertex_
private

Definition at line 229 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ yPCA_

double PrimaryVertexValidation::yPCA_[nMaxtracks_]
private

Definition at line 270 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ yUnbiasedVertex_

double PrimaryVertexValidation::yUnbiasedVertex_[nMaxtracks_]
private

Definition at line 273 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ zErrOfflineVertex_

double PrimaryVertexValidation::zErrOfflineVertex_
private

Definition at line 234 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ zOfflineVertex_

double PrimaryVertexValidation::zOfflineVertex_
private

Definition at line 230 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ zPCA_

double PrimaryVertexValidation::zPCA_[nMaxtracks_]
private

Definition at line 271 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

◆ zUnbiasedVertex_

double PrimaryVertexValidation::zUnbiasedVertex_[nMaxtracks_]
private

Definition at line 274 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginJob(), and SetVarToZero().

AdaptiveVertexFitter
Definition: AdaptiveVertexFitter.h:29
PrimaryVertexValidation::a_dxyEtaWidthBiasTrend
TH1F * a_dxyEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:548
PrimaryVertexValidation::chi2UnbiasedVertex_
float chi2UnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:276
PVValHelper::getVarString
plotLabels getVarString(plotVariable var)
Definition: PVValidationHelpers.cc:130
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
PrimaryVertexValidation::h_norm_dz_modZ_
std::vector< TH1F * > h_norm_dz_modZ_
Definition: PrimaryVertexValidation.h:707
PrimaryVertexValidation::MADTrendsDir
TFileDirectory MADTrendsDir
Definition: PrimaryVertexValidation.h:302
reco::Vertex::trackRef_iterator
std::vector< TrackBaseRef >::const_iterator trackRef_iterator
The iteratator for the vector<TrackRef>
Definition: Vertex.h:38
PrimaryVertexValidation::n_dzPhiResiduals
std::vector< TH1F * > n_dzPhiResiduals
Definition: PrimaryVertexValidation.h:350
PrimaryVertexValidation::n_dxyEtaMedianTrend
TH1F * n_dxyEtaMedianTrend
Definition: PrimaryVertexValidation.h:465
PVValHelper::resz
Definition: PVValidationHelpers.h:52
PerigeeTrajectoryParameters::longitudinalImpactParameter
double longitudinalImpactParameter() const
Definition: PerigeeTrajectoryParameters.h:74
PrimaryVertexValidation::a_dxyL1MeanMap
TH2F * a_dxyL1MeanMap
Definition: PrimaryVertexValidation.h:500
PrimaryVertexValidation::a_dzpTWidthTrend
TH1F * a_dzpTWidthTrend
Definition: PrimaryVertexValidation.h:409
DDAxes::y
PrimaryVertexValidation::h_probeChi2_
TH1F * h_probeChi2_
Definition: PrimaryVertexValidation.h:629
PrimaryVertexValidation::chi2_
double chi2_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:261
PrimaryVertexValidation::n_dxyPhiBiasResiduals
std::vector< TH1F * > n_dxyPhiBiasResiduals
Definition: PrimaryVertexValidation.h:526
PrimaryVertexValidation::h_runNumber
TH1F * h_runNumber
Definition: PrimaryVertexValidation.h:602
PrimaryVertexValidation::a_dzEtaMADBiasTrend
TH1F * a_dzEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:572
PrimaryVertexValidation::h_probeL1ClusterProb_
TH1F * h_probeL1ClusterProb_
Definition: PrimaryVertexValidation.h:669
PrimaryVertexValidation::n_dzPhiBiasResiduals
std::vector< TH1F * > n_dzPhiBiasResiduals
Definition: PrimaryVertexValidation.h:529
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
PrimaryVertexValidation::n_d3DEtaResiduals
std::vector< TH1F * > n_d3DEtaResiduals
Definition: PrimaryVertexValidation.h:363
PrimaryVertexValidation::h_probeHits_
TH1F * h_probeHits_
Definition: PrimaryVertexValidation.h:655
runGCPTkAlMap.title
string title
Definition: runGCPTkAlMap.py:94
MonitorHOAlCaRecoStream_cfi.highedge
highedge
Definition: MonitorHOAlCaRecoStream_cfi.py:12
PrimaryVertexValidation::IP3DsigFromMyVertex_
double IP3DsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:292
mps_fire.i
i
Definition: mps_fire.py:428
PrimaryVertexValidation::n_dxyWidthMap
TH2F * n_dxyWidthMap
Definition: PrimaryVertexValidation.h:495
PrimaryVertexValidation::trackingGeomToken_
const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > trackingGeomToken_
Definition: PrimaryVertexValidation.h:151
edm::ESInputTag
Definition: ESInputTag.h:87
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
PrimaryVertexValidation::h2_probeLayer1Map_
TH2F * h2_probeLayer1Map_
Definition: PrimaryVertexValidation.h:670
PrimaryVertexValidation::h_norm_dz_Central_pT_
std::vector< TH1F * > h_norm_dz_Central_pT_
Definition: PrimaryVertexValidation.h:700
PrimaryVertexValidation::n_dxyPhiMedianTrend
TH1F * n_dxyPhiMedianTrend
Definition: PrimaryVertexValidation.h:460
PrimaryVertexValidation::h_norm_dxy_modZ_
std::vector< TH1F * > h_norm_dxy_modZ_
Definition: PrimaryVertexValidation.h:706
PVValHelper::max_eta_phase1
const double max_eta_phase1
Definition: PVValidationHelpers.h:24
pwdgSkimBPark_cfi.beamSpot
beamSpot
Definition: pwdgSkimBPark_cfi.py:5
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11713
PrimaryVertexValidation::h_nClus
TH1F * h_nClus
Definition: PrimaryVertexValidation.h:600
PrimaryVertexValidation::n_dzEtaMeanTrend
TH1F * n_dzEtaMeanTrend
Definition: PrimaryVertexValidation.h:401
PrimaryVertexValidation::h_nbins
TH1F * h_nbins
Definition: PrimaryVertexValidation.h:309
Reference_intrackfit_cff.barrel
list barrel
Definition: Reference_intrackfit_cff.py:37
PrimaryVertexValidation::a_dxyEtaMADBiasTrend
TH1F * a_dxyEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:570
PrimaryVertexValidation::WidthTrendsDir
TFileDirectory WidthTrendsDir
Definition: PrimaryVertexValidation.h:300
PrimaryVertexValidation::BSz0_
double BSz0_
Definition: PrimaryVertexValidation.h:238
PrimaryVertexValidation::n_dzEtaMedianTrend
TH1F * n_dzEtaMedianTrend
Definition: PrimaryVertexValidation.h:467
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
PrimaryVertexValidation::h_probePhi_
TH1F * h_probePhi_
Definition: PrimaryVertexValidation.h:628
PrimaryVertexValidation::a_dzBiasResidualsMap
TH1F * a_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:535
PixelSubdetector::PixelEndcap
Definition: PixelSubdetector.h:11
PrimaryVertexValidation::n_dzWidthMap
TH2F * n_dzWidthMap
Definition: PrimaryVertexValidation.h:496
PrimaryVertexValidation::n_dxyEtaMADBiasTrend
TH1F * n_dxyEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:580
PrimaryVertexValidation::h_probePt_
TH1F * h_probePt_
Definition: PrimaryVertexValidation.h:625
PrimaryVertexValidation::n_dzladderMeanTrend
TH1F * n_dzladderMeanTrend
Definition: PrimaryVertexValidation.h:445
PrimaryVertexValidation::nhits1D_
int nhits1D_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:249
PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11
PrimaryVertexValidation::h_probedzRecoV_
TH1F * h_probedzRecoV_
Definition: PrimaryVertexValidation.h:634
PrimaryVertexValidation::n_dzResidualsMap
TH1F * n_dzResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:372
PrimaryVertexValidation::a_dxyEtaMedianTrend
TH1F * a_dxyEtaMedianTrend
Definition: PrimaryVertexValidation.h:455
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
PVValHelper::norm_IP2D
Definition: PVValidationHelpers.h:60
PrimaryVertexValidation::a_d3DEtaResiduals
std::vector< TH1F * > a_d3DEtaResiduals
Definition: PrimaryVertexValidation.h:343
PrimaryVertexValidation::nBins_
int nBins_
Definition: PrimaryVertexValidation.h:182
PrimaryVertexValidation::a_dxyResidualsMap
TH1F * a_dxyResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:367
groupFilesInBlocks.tt
int tt
Definition: groupFilesInBlocks.py:144
PrimaryVertexValidation::a_dxyladderMeanTrend
TH1F * a_dxyladderMeanTrend
Definition: PrimaryVertexValidation.h:433
PrimaryVertexValidation::h_fitVtxNtracks_
TH1F * h_fitVtxNtracks_
Definition: PrimaryVertexValidation.h:677
PrimaryVertexValidation::a_dzResidualsMap
TH1F * a_dzResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:368
VertexException
Common base class.
Definition: VertexException.h:12
PrimaryVertexValidation::xErrOfflineVertex_
double xErrOfflineVertex_
Definition: PrimaryVertexValidation.h:232
PrimaryVertexValidation::h_probedxyRecoV_
TH1F * h_probedxyRecoV_
Definition: PrimaryVertexValidation.h:635
PrimaryVertexValidation::h_probeEta_
TH1F * h_probeEta_
Definition: PrimaryVertexValidation.h:627
funct::D0
Divides< arg, void > D0
Definition: Factorize.h:135
PrimaryVertexValidation::a_dzEtaMeanBiasTrend
TH1F * a_dzEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:549
PrimaryVertexValidation::n_dxyL1MeanMap
TH2F * n_dxyL1MeanMap
Definition: PrimaryVertexValidation.h:503
PrimaryVertexValidation::runControlNumbers_
std::vector< unsigned int > runControlNumbers_
Definition: PrimaryVertexValidation.h:188
PrimaryVertexValidation::a_dxyPhiWidthBiasTrend
TH1F * a_dxyPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:543
PV3DBase::x
T x() const
Definition: PV3DBase.h:59
PVValHelper::WIDTH
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::a_dzpTMeanTrend
TH1F * a_dzpTMeanTrend
Definition: PrimaryVertexValidation.h:408
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::TrackBase::p
double p() const
momentum vector magnitude
Definition: TrackBase.h:631
PrimaryVertexValidation::h_norm_dxy_Central_pT_
std::vector< TH1F * > h_norm_dxy_Central_pT_
Definition: PrimaryVertexValidation.h:699
PrimaryVertexValidation::n_dzmodZWidthTrend
TH1F * n_dzmodZWidthTrend
Definition: PrimaryVertexValidation.h:441
min
T min(T a, T b)
Definition: MathUtil.h:58
cond::hash
Definition: Time.h:19
PrimaryVertexValidation::a_dzEtaBiasResiduals
std::vector< TH1F * > a_dzEtaBiasResiduals
Definition: PrimaryVertexValidation.h:522
PrimaryVertexValidation::h_probeRefitVSig3D_
TH1F * h_probeRefitVSig3D_
Definition: PrimaryVertexValidation.h:651
PrimaryVertexValidation::a_IP3DPhiResiduals
std::vector< TH1F * > a_IP3DPhiResiduals
Definition: PrimaryVertexValidation.h:336
TFileDirectory::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileDirectory.h:53
PrimaryVertexValidation::a_dzWidthMap
TH2F * a_dzWidthMap
Definition: PrimaryVertexValidation.h:493
PrimaryVertexValidation::a_dzL1MeanMap
TH2F * a_dzL1MeanMap
Definition: PrimaryVertexValidation.h:501
Measurement1D::value
double value() const
Definition: Measurement1D.h:25
PrimaryVertexValidation::n_dxyladderWidthTrend
TH1F * n_dxyladderWidthTrend
Definition: PrimaryVertexValidation.h:444
PrimaryVertexValidation::a_dxyL1WidthMap
TH2F * a_dxyL1WidthMap
Definition: PrimaryVertexValidation.h:506
PrimaryVertexValidation::h_nTracks
TH1F * h_nTracks
Definition: PrimaryVertexValidation.h:599
TrackerTopology
Definition: TrackerTopology.h:16
IPTools::absoluteImpactParameter3D
std::pair< bool, Measurement1D > absoluteImpactParameter3D(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:38
PrimaryVertexValidation::h_BSy0
TH1F * h_BSy0
Definition: PrimaryVertexValidation.h:613
PrimaryVertexValidation::a_dzPhiMeanTrend
TH1F * a_dzPhiMeanTrend
Definition: PrimaryVertexValidation.h:386
PrimaryVertexValidation::h_probez0RefitV_
TH1F * h_probez0RefitV_
Definition: PrimaryVertexValidation.h:641
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
TFileService::file
TFile & file() const
return opened TFile
Definition: TFileService.h:37
PrimaryVertexValidation::nMaxtracks_
static const int nMaxtracks_
Definition: PrimaryVertexValidation.h:206
TrackerTopology::pxbLadder
unsigned int pxbLadder(const DetId &id) const
Definition: TrackerTopology.h:155
PrimaryVertexValidation::h_runFromEvent
TH1I * h_runFromEvent
Definition: PrimaryVertexValidation.h:605
PrimaryVertexValidation::RunNumber_
unsigned int RunNumber_
Definition: PrimaryVertexValidation.h:225
PrimaryVertexValidation::h_probereszRefitV_
TH1F * h_probereszRefitV_
Definition: PrimaryVertexValidation.h:645
PVValHelper::fill
void fill(std::map< std::string, TH1 * > &h, const std::string &s, double x)
Definition: PVValidationHelpers.cc:20
PrimaryVertexValidation::h_probesignIP2DRefitV_
TH1F * h_probesignIP2DRefitV_
Definition: PrimaryVertexValidation.h:643
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89287
PrimaryVertexValidation::isHit2D
bool isHit2D(const TrackingRecHit &hit) const
Definition: PrimaryVertexValidation.cc:1100
PrimaryVertexValidation::a_dxypTWidthTrend
TH1F * a_dxypTWidthTrend
Definition: PrimaryVertexValidation.h:407
PVValHelper::getTypeString
plotLabels getTypeString(residualType type)
Definition: PVValidationHelpers.cc:63
PrimaryVertexValidation::nTracks_
int nTracks_
Definition: PrimaryVertexValidation.h:221
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
PrimaryVertexValidation::Nevt_
int Nevt_
Definition: PrimaryVertexValidation.h:139
PrimaryVertexValidation::DOFUnbiasedVertex_
float DOFUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:278
PrimaryVertexValidation::n_dxyPhiMADBiasTrend
TH1F * n_dxyPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:575
PrimaryVertexValidation::n_dxyEtaResiduals
std::vector< TH1F * > n_dxyEtaResiduals
Definition: PrimaryVertexValidation.h:348
PrimaryVertexValidation::h_probeRefitVSigResZ_
TH1F * h_probeRefitVSigResZ_
Definition: PrimaryVertexValidation.h:653
PVValHelper::fillByIndex
void fillByIndex(std::vector< TH1F * > &h, unsigned int index, double x, std::string tag="")
Definition: PVValidationHelpers.cc:42
HLT_FULL_cff.etaBins
etaBins
Definition: HLT_FULL_cff.py:15263
PrimaryVertexValidation::d3DFromMyVertex_
double d3DFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:284
PrimaryVertexValidation::qoverp_
double qoverp_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:264
PrimaryVertexValidation::h_probeL1Module_
TH1F * h_probeL1Module_
Definition: PrimaryVertexValidation.h:666
PrimaryVertexValidation::debug_
bool debug_
Definition: PrimaryVertexValidation.h:190
cms::cuda::assert
assert(be >=bs)
PrimaryVertexValidation::a_reszPhiResiduals
std::vector< TH1F * > a_reszPhiResiduals
Definition: PrimaryVertexValidation.h:339
PrimaryVertexValidation::BSy0_
double BSy0_
Definition: PrimaryVertexValidation.h:237
reco::TrackBase::TrackQuality
TrackQuality
track quality
Definition: TrackBase.h:150
PrimaryVertexValidation::hDA
std::map< std::string, TH1 * > hDA
Definition: PrimaryVertexValidation.h:688
PrimaryVertexValidation::n_dxyMeanBiasMap
TH2F * n_dxyMeanBiasMap
Definition: PrimaryVertexValidation.h:589
PrimaryVertexValidation::h_probeHitsInTID_
TH1F * h_probeHitsInTID_
Definition: PrimaryVertexValidation.h:660
PrimaryVertexValidation::a_dxyWidthMap
TH2F * a_dxyWidthMap
Definition: PrimaryVertexValidation.h:492
PrimaryVertexValidation::h_pTinfo
TH1F * h_pTinfo
Definition: PrimaryVertexValidation.h:311
PrimaryVertexValidation::h_probedzRefitV_
TH1F * h_probedzRefitV_
Definition: PrimaryVertexValidation.h:637
PrimaryVertexValidation::dxyBs_
double dxyBs_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:267
PVValHelper::histodetails::histobins
int histobins
Definition: PVValidationHelpers.h:78
PrimaryVertexValidation::n_reszPhiResiduals
std::vector< TH1F * > n_reszPhiResiduals
Definition: PrimaryVertexValidation.h:359
reco::TrackBase::px
double px() const
x coordinate of momentum vector
Definition: TrackBase.h:640
PrimaryVertexValidation::nOfflineVertices_
int nOfflineVertices_
Definition: PrimaryVertexValidation.h:224
PrimaryVertexValidation::a_dxyPhiMedianTrend
TH1F * a_dxyPhiMedianTrend
Definition: PrimaryVertexValidation.h:450
PrimaryVertexValidation::BeamWidthY_
double BeamWidthY_
Definition: PrimaryVertexValidation.h:242
PrimaryVertexValidation::pOfProbe_
double pOfProbe_
Definition: PrimaryVertexValidation.h:176
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
PrimaryVertexValidation::a_dzPhiWidthBiasTrend
TH1F * a_dzPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:545
PrimaryVertexValidation::h_probePtRebin_
TH1F * h_probePtRebin_
Definition: PrimaryVertexValidation.h:626
PrimaryVertexValidation::dxyFromMyVertex_
double dxyFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:282
PrimaryVertexValidation::a_dzladderWidthTrend
TH1F * a_dzladderWidthTrend
Definition: PrimaryVertexValidation.h:436
PrimaryVertexValidation::n_d3DPhiResiduals
std::vector< TH1F * > n_d3DPhiResiduals
Definition: PrimaryVertexValidation.h:362
PrimaryVertexValidation::a_dzEtaWidthBiasTrend
TH1F * a_dzEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:550
DDAxes::x
TFileDirectory
Definition: TFileDirectory.h:24
SiPixelCluster
Pixel cluster – collection of neighboring pixels above threshold.
Definition: SiPixelCluster.h:27
PrimaryVertexValidation::n_dzL1WidthMap
TH2F * n_dzL1WidthMap
Definition: PrimaryVertexValidation.h:510
PrimaryVertexValidation::h_probeRefitVSigXY_
TH1F * h_probeRefitVSigXY_
Definition: PrimaryVertexValidation.h:650
PrimaryVertexValidation::n_dxyBiasResidualsMap
TH1F * n_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:537
PrimaryVertexValidation::MeanTrendsDir
TFileDirectory MeanTrendsDir
Definition: PrimaryVertexValidation.h:299
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
PrimaryVertexValidation::h_fitVtxNdof_
TH1F * h_fitVtxNdof_
Definition: PrimaryVertexValidation.h:675
FreeTrajectoryState::position
GlobalPoint position() const
Definition: FreeTrajectoryState.h:67
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
vertices_cff.ntracks
ntracks
Definition: vertices_cff.py:34
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
cms::Exception::what
char const * what() const noexcept override
Definition: Exception.cc:103
findQualityFiles.v
v
Definition: findQualityFiles.py:179
IPTools::signedTransverseImpactParameter
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:57
PrimaryVertexValidation::h_etaMax
TH1F * h_etaMax
Definition: PrimaryVertexValidation.h:308
PrimaryVertexValidation::h_probeRefitVSigZ_
TH1F * h_probeRefitVSigZ_
Definition: PrimaryVertexValidation.h:649
PrimaryVertexValidation::h_dz_modZ_
std::vector< TH1F * > h_dz_modZ_
Definition: PrimaryVertexValidation.h:705
PrimaryVertexValidation::h_dxy_modZ_
std::vector< TH1F * > h_dxy_modZ_
Definition: PrimaryVertexValidation.h:704
PrimaryVertexValidation::isGoodTrack_
int isGoodTrack_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:295
PrimaryVertexValidation::pixelHitsCheck
std::pair< bool, bool > pixelHitsCheck(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1132
edm::Handle
Definition: AssociativeIterator.h:50
PrimaryVertexValidation::LuminosityBlockNumber_
unsigned int LuminosityBlockNumber_
Definition: PrimaryVertexValidation.h:227
reco::TrackBase::numberOfValidHits
unsigned short numberOfValidHits() const
number of valid hits found
Definition: TrackBase.h:798
PrimaryVertexValidation::a_dzpTCentralWidthTrend
TH1F * a_dzpTCentralWidthTrend
Definition: PrimaryVertexValidation.h:414
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
PrimaryVertexValidation::n_dxyEtaBiasResiduals
std::vector< TH1F * > n_dxyEtaBiasResiduals
Definition: PrimaryVertexValidation.h:527
PrimaryVertexValidation::h_norm_dxy_ladder_
std::vector< TH1F * > h_norm_dxy_ladder_
Definition: PrimaryVertexValidation.h:714
PrimaryVertexValidation::nhits_
int nhits_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:248
PrimaryVertexValidation::Beamsigmaz_
double Beamsigmaz_
Definition: PrimaryVertexValidation.h:239
PrimaryVertexValidation::nhitsTIB_
int nhitsTIB_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:253
PrimaryVertexValidation::a_dxyVsEta
TH2F * a_dxyVsEta
Definition: PrimaryVertexValidation.h:478
PrimaryVertexValidation::n_dzPhiWidthBiasTrend
TH1F * n_dzPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:555
PrimaryVertexValidation::runInfoToken_
const edm::ESGetToken< RunInfo, RunInfoRcd > runInfoToken_
Definition: PrimaryVertexValidation.h:155
SiPixelRecHit
Our base class.
Definition: SiPixelRecHit.h:23
PrimaryVertexValidation::h_dxy_pT_
std::vector< TH1F * > h_dxy_pT_
Definition: PrimaryVertexValidation.h:692
PrimaryVertexValidation::IPTsigFromMyVertex_
double IPTsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:290
edm::Ref
Definition: AssociativeIterator.h:58
HLT_FULL_cff.zVertex
zVertex
Definition: HLT_FULL_cff.py:113773
PrimaryVertexValidation::a_dzPhiWidthTrend
TH1F * a_dzPhiWidthTrend
Definition: PrimaryVertexValidation.h:387
PrimaryVertexValidation::a_IP3DEtaResiduals
std::vector< TH1F * > a_IP3DEtaResiduals
Definition: PrimaryVertexValidation.h:337
TrackerTopology::pxbLayer
unsigned int pxbLayer(const DetId &id) const
Definition: TrackerTopology.h:144
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
units
TString units(TString variable, Char_t axis)
PrimaryVertexValidation::zPCA_
double zPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:271
PrimaryVertexValidation::SetVarToZero
void SetVarToZero()
Definition: PrimaryVertexValidation.cc:2984
PrimaryVertexValidation::a_dzEtaMeanTrend
TH1F * a_dzEtaMeanTrend
Definition: PrimaryVertexValidation.h:391
PVValHelper::END_OF_TYPES
Definition: PVValidationHelpers.h:64
PrimaryVertexValidation::chi2ProbUnbiasedVertex_
float chi2ProbUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:277
LEDCalibrationChannels.iphi
iphi
Definition: LEDCalibrationChannels.py:64
PrimaryVertexValidation::h_fitVtxTrackWeights_
TH1F * h_fitVtxTrackWeights_
Definition: PrimaryVertexValidation.h:680
PrimaryVertexValidation::h_norm_dxy_pT_
std::vector< TH1F * > h_norm_dxy_pT_
Definition: PrimaryVertexValidation.h:694
reco::TrackBase::pt
double pt() const
track transverse momentum
Definition: TrackBase.h:637
PrimaryVertexValidation::a_d3DPhiResiduals
std::vector< TH1F * > a_d3DPhiResiduals
Definition: PrimaryVertexValidation.h:342
PrimaryVertexValidation::n_reszEtaResiduals
std::vector< TH1F * > n_reszEtaResiduals
Definition: PrimaryVertexValidation.h:360
DetId
Definition: DetId.h:17
PrimaryVertexValidation::h_fitVtxChi2ndf_
TH1F * h_fitVtxChi2ndf_
Definition: PrimaryVertexValidation.h:678
PrimaryVertexValidation::wxy2_
double wxy2_
Definition: PrimaryVertexValidation.h:243
PVValHelper::norm_resz
Definition: PVValidationHelpers.h:61
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33
PVValHelper::histodetails::trendbins
std::map< plotVariable, std::vector< float > > trendbins
Definition: PVValidationHelpers.h:80
reco::HitPattern
Definition: HitPattern.h:147
down
Definition: BitonicSort.h:7
PVValHelper::norm_d3D
Definition: PVValidationHelpers.h:63
testProducerWithPsetDescEmpty_cfi.y1
y1
Definition: testProducerWithPsetDescEmpty_cfi.py:29
PrimaryVertexValidation::h_lumiFromConfig
TH1F * h_lumiFromConfig
Definition: PrimaryVertexValidation.h:603
PrimaryVertexValidation::h_fitVtxChi2Prob_
TH1F * h_fitVtxChi2Prob_
Definition: PrimaryVertexValidation.h:679
PrimaryVertexValidation::a_dzL1ResidualsMap
TH1F * a_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:378
PrimaryVertexValidation::a_dzVsEta
TH2F * a_dzVsEta
Definition: PrimaryVertexValidation.h:479
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
PrimaryVertexValidation::h_probeQoverP_
TH1F * h_probeQoverP_
Definition: PrimaryVertexValidation.h:632
PrimaryVertexValidation::a_dzmodZMeanTrend
TH1F * a_dzmodZMeanTrend
Definition: PrimaryVertexValidation.h:430
h
PrimaryVertexValidation::ptOfProbe_
double ptOfProbe_
Definition: PrimaryVertexValidation.h:175
PrimaryVertexValidation::a_dxyPhiMADBiasTrend
TH1F * a_dxyPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:565
PrimaryVertexValidation::a_dxyPhiWidthTrend
TH1F * a_dxyPhiWidthTrend
Definition: PrimaryVertexValidation.h:385
PrimaryVertexValidation::zErrOfflineVertex_
double zErrOfflineVertex_
Definition: PrimaryVertexValidation.h:234
PrimaryVertexValidation::zOfflineVertex_
double zOfflineVertex_
Definition: PrimaryVertexValidation.h:230
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
PerigeeConversions::trajectoryStateClosestToPoint
TrajectoryStateClosestToPoint trajectoryStateClosestToPoint(const AlgebraicVector3 &momentum, const GlobalPoint &referencePoint, const TrackCharge &charge, const AlgebraicSymMatrix66 &theCovarianceMatrix, const MagneticField *field)
Definition: PerigeeConversions.cc:97
reco::TrackBase::py
double py() const
y coordinate of momentum vector
Definition: TrackBase.h:643
PrimaryVertexValidation::h_xErrOfflineVertex
TH1F * h_xErrOfflineVertex
Definition: PrimaryVertexValidation.h:609
PrimaryVertexValidation::h_dxy_ladder_
std::vector< TH1F * > h_dxy_ladder_
Definition: PrimaryVertexValidation.h:712
PerigeeTrajectoryError::longitudinalImpactParameterError
double longitudinalImpactParameterError() const
Definition: PerigeeTrajectoryError.h:68
PrimaryVertexValidation::fillTrackHistos
void fillTrackHistos(std::map< std::string, TH1 * > &h, const std::string &ttype, const reco::TransientTrack *tt, const reco::Vertex &v, const reco::BeamSpot &beamSpot, double fBfield)
Definition: PrimaryVertexValidation.cc:3477
PVValHelper::max_eta_phase0
const double max_eta_phase0
Definition: PVValidationHelpers.h:23
PrimaryVertexValidation::chi2normUnbiasedVertex_
float chi2normUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:275
GeomDetEnumerators::P1PXEC
Definition: GeomDetEnumerators.h:26
IPTools::signedImpactParameter3D
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:81
PrimaryVertexValidation::a_dxyEtaMeanTrend
TH1F * a_dxyEtaMeanTrend
Definition: PrimaryVertexValidation.h:389
PrimaryVertexValidation::h_BSz0
TH1F * h_BSz0
Definition: PrimaryVertexValidation.h:614
TrajectoryStateClosestToPoint::position
GlobalPoint position() const
Definition: TrajectoryStateClosestToPoint.h:90
PVValHelper::eta
Definition: PVValidationHelpers.h:69
PrimaryVertexValidation::yUnbiasedVertex_
double yUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:273
PrimaryVertexValidation::pt_
double pt_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:246
PVValHelper::pT
Definition: PVValidationHelpers.h:70
PVValHelper::pTCentral
Definition: PVValidationHelpers.h:71
PrimaryVertexValidation::fillTrendPlotByIndex
void fillTrendPlotByIndex(TH1F *trendPlot, std::vector< TH1F * > &h, PVValHelper::estimator fitPar_, PVValHelper::plotVariable plotVar=PVValHelper::END_OF_PLOTS)
Definition: PrimaryVertexValidation.cc:3120
PrimaryVertexValidation::theTrackClusterizer_
std::unique_ptr< TrackClusterizerInZ > theTrackClusterizer_
Definition: PrimaryVertexValidation.h:142
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
PrimaryVertexValidation::theVertexCollectionToken
edm::EDGetTokenT< reco::VertexCollection > theVertexCollectionToken
Definition: PrimaryVertexValidation.h:197
PrimaryVertexValidation::h_BSx0
TH1F * h_BSx0
Definition: PrimaryVertexValidation.h:612
PrimaryVertexValidation::n_dzEtaWidthBiasTrend
TH1F * n_dzEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:560
PrimaryVertexValidation::n_dxyL1WidthMap
TH2F * n_dxyL1WidthMap
Definition: PrimaryVertexValidation.h:509
PrimaryVertexValidation::n_dzEtaMADBiasTrend
TH1F * n_dzEtaMADBiasTrend
Definition: PrimaryVertexValidation.h:582
PrimaryVertexValidation::a_dzPhiBiasResiduals
std::vector< TH1F * > a_dzPhiBiasResiduals
Definition: PrimaryVertexValidation.h:521
reco::BeamSpot
Definition: BeamSpot.h:21
DDAxes::z
PrimaryVertexValidation::a_IP2DPhiResiduals
std::vector< TH1F * > a_IP2DPhiResiduals
Definition: PrimaryVertexValidation.h:333
PrimaryVertexValidation::a_dxyMeanMap
TH2F * a_dxyMeanMap
Definition: PrimaryVertexValidation.h:486
reco::Track
Definition: Track.h:27
edm::ESHandle< MagneticField >
PrimaryVertexValidation::a_dzVsPhi
TH2F * a_dzVsPhi
Definition: PrimaryVertexValidation.h:473
PrimaryVertexValidation::h2_probePassingLayer1Map_
TH2F * h2_probePassingLayer1Map_
Definition: PrimaryVertexValidation.h:671
PVValHelper::histodetails::getHigh
float getHigh(residualType type, plotVariable plot)
Definition: PVValidationHelpers.h:105
PrimaryVertexValidation::a_dzEtaResiduals
std::vector< TH1F * > a_dzEtaResiduals
Definition: PrimaryVertexValidation.h:331
PrimaryVertexValidation::h_zOfflineVertex
TH1F * h_zOfflineVertex
Definition: PrimaryVertexValidation.h:608
PVValHelper::modZ
Definition: PVValidationHelpers.h:73
submitPVResolutionJobs.count
count
Definition: submitPVResolutionJobs.py:352
PrimaryVertexValidation::a_dzPhiMeanBiasTrend
TH1F * a_dzPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:544
reco::Track::recHits
auto recHits() const
Access to reconstructed hits on the track.
Definition: Track.h:85
PVValHelper::norm_dxy
Definition: PVValidationHelpers.h:56
PrimaryVertexValidation::vertexZMax_
double vertexZMax_
Definition: PrimaryVertexValidation.h:166
reco::TrackBase::charge
int charge() const
track electric charge
Definition: TrackBase.h:596
PrimaryVertexValidation::n_dxymodZWidthTrend
TH1F * n_dxymodZWidthTrend
Definition: PrimaryVertexValidation.h:439
PrimaryVertexValidation::EventNumber_
unsigned int EventNumber_
Definition: PrimaryVertexValidation.h:226
TrajectoryStateClosestToPoint::perigeeError
const PerigeeTrajectoryError & perigeeError() const
Definition: TrajectoryStateClosestToPoint.h:84
PrimaryVertexValidation::bookVertexHistograms
std::map< std::string, TH1 * > bookVertexHistograms(const TFileDirectory &dir)
Definition: PrimaryVertexValidation.cc:3290
reco::TrackBase::dz
double dz() const
dz parameter (= dsz/cos(lambda)). This is the track z0 w.r.t (0,0,0) only if the refPoint is close to...
Definition: TrackBase.h:622
PrimaryVertexValidation::theTrackFilter_
std::unique_ptr< TrackFilterForPVFindingBase > theTrackFilter_
Definition: PrimaryVertexValidation.h:141
HLTMuonOfflineAnalyzer_cfi.z0
z0
Definition: HLTMuonOfflineAnalyzer_cfi.py:98
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
PrimaryVertexValidation::a_dxEtaResiduals
std::vector< TH1F * > a_dxEtaResiduals
Definition: PrimaryVertexValidation.h:325
PrimaryVertexValidation::n_dzPhiMeanBiasTrend
TH1F * n_dzPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:554
Point3DBase< float, GlobalTag >
PrimaryVertexValidation::nhitsTID_
int nhitsTID_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:254
TrajectoryStateClosestToPoint::perigeeParameters
const PerigeeTrajectoryParameters & perigeeParameters() const
Definition: TrajectoryStateClosestToPoint.h:73
b
double b
Definition: hdecay.h:118
TrackerGeometry::isThere
bool isThere(GeomDetEnumerators::SubDetector subdet) const
Definition: TrackerGeometry.cc:219
PrimaryVertexValidation::h_probeHits2D_
TH1F * h_probeHits2D_
Definition: PrimaryVertexValidation.h:657
PrimaryVertexValidation::dzErrorFromMyVertex_
double dzErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:287
reco::TrackBase::phi
double phi() const
azimuthal angle of momentum vector
Definition: TrackBase.h:649
dumpRecoGeometry_cfg.varType
varType
Definition: dumpRecoGeometry_cfg.py:8
PrimaryVertexValidation::h_yErrOfflineVertex
TH1F * h_yErrOfflineVertex
Definition: PrimaryVertexValidation.h:610
PrimaryVertexValidation::nhitsFPIX_
int nhitsFPIX_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:252
PrimaryVertexValidation::compressionSettings_
const int compressionSettings_
Definition: PrimaryVertexValidation.h:157
PrimaryVertexValidation::isHighPurity_
int isHighPurity_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:257
PrimaryVertexValidation::nHitsOfProbe_
double nHitsOfProbe_
Definition: PrimaryVertexValidation.h:178
PVValHelper::END_OF_PLOTS
Definition: PVValidationHelpers.h:74
PrimaryVertexValidation::dz_
double dz_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:265
PrimaryVertexValidation::doFPix_
bool doFPix_
Definition: PrimaryVertexValidation.h:174
edm::OwnVector::const_iterator
Definition: OwnVector.h:41
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
Measurement1D::error
double error() const
Definition: Measurement1D.h:27
PrimaryVertexValidation::useTracksFromRecoVtx_
bool useTracksFromRecoVtx_
Definition: PrimaryVertexValidation.h:160
PrimaryVertexValidation::n_dxyPhiMADTrend
TH1F * n_dxyPhiMADTrend
Definition: PrimaryVertexValidation.h:461
PrimaryVertexValidation::n_dzPhiMADBiasTrend
TH1F * n_dzPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:577
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PrimaryVertexValidation::n_dzPhiMedianBiasTrend
TH1F * n_dzPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:576
PrimaryVertexValidation::isBFieldConsistentWithMode
bool isBFieldConsistentWithMode(const edm::EventSetup &iSetup) const
Definition: PrimaryVertexValidation.cc:2972
PrimaryVertexValidation::n_dzMeanBiasMap
TH2F * n_dzMeanBiasMap
Definition: PrimaryVertexValidation.h:590
PrimaryVertexValidation::geomToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > geomToken_
Definition: PrimaryVertexValidation.h:152
PrimaryVertexValidation::n_dzpTWidthTrend
TH1F * n_dzpTWidthTrend
Definition: PrimaryVertexValidation.h:419
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
PrimaryVertexValidation::a_dzPhiMADTrend
TH1F * a_dzPhiMADTrend
Definition: PrimaryVertexValidation.h:453
PrimaryVertexValidation::nTracksPerClus_
int nTracksPerClus_
Definition: PrimaryVertexValidation.h:222
PrimaryVertexValidation::n_dxyVsPhi
TH2F * n_dxyVsPhi
Definition: PrimaryVertexValidation.h:475
PrimaryVertexValidation::h_dz_pT_
std::vector< TH1F * > h_dz_pT_
Definition: PrimaryVertexValidation.h:693
PrimaryVertexValidation::h_probeRecoVSigXY_
TH1F * h_probeRecoVSigXY_
Definition: PrimaryVertexValidation.h:648
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
PrimaryVertexValidation::a_dzEtaMedianTrend
TH1F * a_dzEtaMedianTrend
Definition: PrimaryVertexValidation.h:457
PrimaryVertexValidation::h_probed3DRefitV_
TH1F * h_probed3DRefitV_
Definition: PrimaryVertexValidation.h:644
funct::true
true
Definition: Factorize.h:173
GeomDetEnumerators::P1PXB
Definition: GeomDetEnumerators.h:25
PrimaryVertexValidation::a_dxymodZWidthTrend
TH1F * a_dxymodZWidthTrend
Definition: PrimaryVertexValidation.h:429
PrimaryVertexValidation::theta_
double theta_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:259
PrimaryVertexValidation::fs
edm::Service< TFileService > fs
Definition: PrimaryVertexValidation.h:297
PrimaryVertexValidation::h_dz_Central_pT_
std::vector< TH1F * > h_dz_Central_pT_
Definition: PrimaryVertexValidation.h:698
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
PrimaryVertexValidation::a_dxypTCentralWidthTrend
TH1F * a_dxypTCentralWidthTrend
Definition: PrimaryVertexValidation.h:412
PrimaryVertexValidation::h_fitVtxChi2_
TH1F * h_fitVtxChi2_
Definition: PrimaryVertexValidation.h:676
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
PrimaryVertexValidation::a_dxyPhiMADTrend
TH1F * a_dxyPhiMADTrend
Definition: PrimaryVertexValidation.h:451
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
PrimaryVertexValidation::nhitsTOB_
int nhitsTOB_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:255
PrimaryVertexValidation::h_runFromConfig
TH1I * h_runFromConfig
Definition: PrimaryVertexValidation.h:604
PrimaryVertexValidation::h_probeP_
TH1F * h_probeP_
Definition: PrimaryVertexValidation.h:624
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
PVValHelper::getMedian
Measurement1D getMedian(TH1F *histo)
Definition: PVValidationHelpers.cc:178
edm::ParameterSet
Definition: ParameterSet.h:47
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
PrimaryVertexValidation::a_IP2DEtaResiduals
std::vector< TH1F * > a_IP2DEtaResiduals
Definition: PrimaryVertexValidation.h:334
PrimaryVertexValidation::nPtBins_
static const int nPtBins_
Definition: PrimaryVertexValidation.h:208
PrimaryVertexValidation::a_dxyMeanBiasMap
TH2F * a_dxyMeanBiasMap
Definition: PrimaryVertexValidation.h:586
PrimaryVertexValidation::dzBs_
double dzBs_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:268
PrimaryVertexValidation::yPCA_
double yPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:270
PrimaryVertexValidation::fillMap
void fillMap(TH2F *trendMap, TH1F *residualsMapPlot[100][100], PVValHelper::estimator fitPar_, const int nXBins_, const int nYBins_)
Definition: PrimaryVertexValidation.cc:3182
a
double a
Definition: hdecay.h:119
DetId::Tracker
Definition: DetId.h:25
PrimaryVertexValidation::n_dzEtaResiduals
std::vector< TH1F * > n_dzEtaResiduals
Definition: PrimaryVertexValidation.h:351
PrimaryVertexValidation::topoToken_
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > topoToken_
Definition: PrimaryVertexValidation.h:154
PrimaryVertexValidation::a_dxyEtaWidthTrend
TH1F * a_dxyEtaWidthTrend
Definition: PrimaryVertexValidation.h:390
PVValHelper::IP3D
Definition: PVValidationHelpers.h:53
PrimaryVertexValidation::a_dxypTMeanTrend
TH1F * a_dxypTMeanTrend
Definition: PrimaryVertexValidation.h:406
PrimaryVertexValidation::n_dxyWidthBiasMap
TH2F * n_dxyWidthBiasMap
Definition: PrimaryVertexValidation.h:595
PrimaryVertexValidation::tracksUsedForVertexing_
int tracksUsedForVertexing_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:280
PrimaryVertexValidation::Beamdxdz_
double Beamdxdz_
Definition: PrimaryVertexValidation.h:240
PrimaryVertexValidation::h_fitVtxTrackAverageWeight_
TH1F * h_fitVtxTrackAverageWeight_
Definition: PrimaryVertexValidation.h:681
PVValHelper::phi
Definition: PVValidationHelpers.h:68
PrimaryVertexValidation::Width2DMapsDir
TFileDirectory Width2DMapsDir
Definition: PrimaryVertexValidation.h:305
PrimaryVertexValidation::nhitsTEC_
int nhitsTEC_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:256
PrimaryVertexValidation::n_IP3DEtaResiduals
std::vector< TH1F * > n_IP3DEtaResiduals
Definition: PrimaryVertexValidation.h:357
PrimaryVertexValidation::eta_
double eta_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:258
PrimaryVertexValidation::n_dxyMeanMap
TH2F * n_dxyMeanMap
Definition: PrimaryVertexValidation.h:489
PrimaryVertexValidation::a_dxyEtaBiasResiduals
std::vector< TH1F * > a_dxyEtaBiasResiduals
Definition: PrimaryVertexValidation.h:519
PrimaryVertexValidation::zUnbiasedVertex_
double zUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:274
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
PrimaryVertexValidation::n_dxyVsEta
TH2F * n_dxyVsEta
Definition: PrimaryVertexValidation.h:481
PrimaryVertexValidation::n_dxypTCentralWidthTrend
TH1F * n_dxypTCentralWidthTrend
Definition: PrimaryVertexValidation.h:422
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
gainCalibHelper::gainCalibPI::type
type
Definition: SiPixelGainCalibHelper.h:39
PrimaryVertexValidation::a_dzPhiMedianTrend
TH1F * a_dzPhiMedianTrend
Definition: PrimaryVertexValidation.h:452
PrimaryVertexValidation::a_dzPhiResiduals
std::vector< TH1F * > a_dzPhiResiduals
Definition: PrimaryVertexValidation.h:330
reco::TrackBase::eta
double eta() const
pseudorapidity of momentum vector
Definition: TrackBase.h:652
PrimaryVertexValidation::h_norm_dz_pT_
std::vector< TH1F * > h_norm_dz_pT_
Definition: PrimaryVertexValidation.h:695
PrimaryVertexValidation::nLadders_
unsigned int nLadders_
Definition: PrimaryVertexValidation.h:210
position
static int position[264][3]
Definition: ReadPGInfo.cc:289
PrimaryVertexValidation::h2_probeEtaPt_
TH2F * h2_probeEtaPt_
Definition: PrimaryVertexValidation.h:622
reco::TrackBase::dzError
double dzError() const
error on dz
Definition: TrackBase.h:778
PrimaryVertexValidation::n_dxypTMeanTrend
TH1F * n_dxypTMeanTrend
Definition: PrimaryVertexValidation.h:416
PV3DBase::y
T y() const
Definition: PV3DBase.h:60
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
PrimaryVertexValidation::h_BeamWidthY
TH1F * h_BeamWidthY
Definition: PrimaryVertexValidation.h:617
IPTools
Definition: IPTools.h:16
PrimaryVertexValidation::h_probeHasBPixL1Overlap_
TH1I * h_probeHasBPixL1Overlap_
Definition: PrimaryVertexValidation.h:667
PrimaryVertexValidation::n_dzL1ResidualsMap
TH1F * n_dzL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:380
PrimaryVertexValidation::xOfflineVertex_
double xOfflineVertex_
Definition: PrimaryVertexValidation.h:228
PVValHelper::MAD
Definition: PVValidationHelpers.h:44
createfilelist.int
int
Definition: createfilelist.py:10
PrimaryVertexValidation::BSx0_
double BSx0_
Definition: PrimaryVertexValidation.h:236
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
PrimaryVertexValidation::a_dzladderMeanTrend
TH1F * a_dzladderMeanTrend
Definition: PrimaryVertexValidation.h:435
PrimaryVertexValidation::forceBeamSpotContraint_
bool forceBeamSpotContraint_
Definition: PrimaryVertexValidation.h:194
PrimaryVertexValidation::h_dxy_ladderNoOverlap_
std::vector< TH1F * > h_dxy_ladderNoOverlap_
Definition: PrimaryVertexValidation.h:710
PrimaryVertexValidation::n_dzL1MeanMap
TH2F * n_dzL1MeanMap
Definition: PrimaryVertexValidation.h:504
PrimaryVertexValidation::h_probeRefitVLogSig3D_
TH1F * h_probeRefitVLogSig3D_
Definition: PrimaryVertexValidation.h:652
PVValHelper::norm_IP3D
Definition: PVValidationHelpers.h:62
PrimaryVertexValidation::n_dzEtaBiasResiduals
std::vector< TH1F * > n_dzEtaBiasResiduals
Definition: PrimaryVertexValidation.h:530
PrimaryVertexValidation::n_dzPhiMADTrend
TH1F * n_dzPhiMADTrend
Definition: PrimaryVertexValidation.h:463
PrimaryVertexValidation::a_dzMeanBiasMap
TH2F * a_dzMeanBiasMap
Definition: PrimaryVertexValidation.h:587
PrimaryVertexValidation::h_xOfflineVertex
TH1F * h_xOfflineVertex
Definition: PrimaryVertexValidation.h:606
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
edm::EventSetup::getHandle
ESHandle< T > getHandle(const ESGetToken< T, R > &iToken) const
Definition: EventSetup.h:148
PrimaryVertexValidation::storeNtuple_
bool storeNtuple_
Definition: PrimaryVertexValidation.h:158
PrimaryVertexValidation::n_dxyPhiResiduals
std::vector< TH1F * > n_dxyPhiResiduals
Definition: PrimaryVertexValidation.h:347
PrimaryVertexValidation::dzFromMyVertex_
double dzFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:283
PrimaryVertexValidation::chi2ndof_
double chi2ndof_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:262
PrimaryVertexValidation::n_dxyL1ResidualsMap
TH1F * n_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:379
PrimaryVertexValidation::n_dzPhiWidthTrend
TH1F * n_dzPhiWidthTrend
Definition: PrimaryVertexValidation.h:397
PVValHelper::dy
Definition: PVValidationHelpers.h:49
submitPVResolutionJobs.q
q
Definition: submitPVResolutionJobs.py:84
MonitorHOAlCaRecoStream_cfi.lowedge
lowedge
Definition: MonitorHOAlCaRecoStream_cfi.py:11
TransientVertex
Definition: TransientVertex.h:18
TrackerGeometry::dets
const DetContainer & dets() const override
Returm a vector of all GeomDet (including all GeomDetUnits)
Definition: TrackerGeometry.h:62
PrimaryVertexValidation::h_probeHitsInBPIX_
TH1F * h_probeHitsInBPIX_
Definition: PrimaryVertexValidation.h:662
PVValHelper::histodetails::getLow
float getLow(residualType type, plotVariable plot)
Definition: PVValidationHelpers.h:96
TrajectoryStateClosestToPoint
Definition: TrajectoryStateClosestToPoint.h:18
reco::TrackBase::chi2
double chi2() const
chi-squared of the fit
Definition: TrackBase.h:587
reco::TrackBase::normalizedChi2
double normalizedChi2() const
chi-squared divided by n.d.o.f. (or chi-squared * 1e6 if n.d.o.f. is zero)
Definition: TrackBase.h:593
PVValHelper::generateBins
std::vector< float > generateBins(int n, float start, float range)
Definition: PVValidationHelpers.cc:161
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
PrimaryVertexValidation::n_dxypTWidthTrend
TH1F * n_dxypTWidthTrend
Definition: PrimaryVertexValidation.h:417
PrimaryVertexValidation::h_probeHitsInTIB_
TH1F * h_probeHitsInTIB_
Definition: PrimaryVertexValidation.h:658
PrimaryVertexValidation::nhits2D_
int nhits2D_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:250
PrimaryVertexValidation::a_dxyEtaMedianBiasTrend
TH1F * a_dxyEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:569
PrimaryVertexValidation::n_dzVsEta
TH2F * n_dzVsEta
Definition: PrimaryVertexValidation.h:482
PVValHelper::MEAN
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::n_dxyPhiWidthTrend
TH1F * n_dxyPhiWidthTrend
Definition: PrimaryVertexValidation.h:395
PrimaryVertexValidation::intLumi_
double intLumi_
Definition: PrimaryVertexValidation.h:169
PrimaryVertexValidation::h_runEndTimes
TH1I * h_runEndTimes
Definition: PrimaryVertexValidation.h:315
PrimaryVertexValidation::etaOfProbe_
double etaOfProbe_
Definition: PrimaryVertexValidation.h:177
PrimaryVertexValidation::n_dzVsPhi
TH2F * n_dzVsPhi
Definition: PrimaryVertexValidation.h:476
PrimaryVertexValidation::a_dzpTCentralMeanTrend
TH1F * a_dzpTCentralMeanTrend
Definition: PrimaryVertexValidation.h:413
PVValHelper::d3D
Definition: PVValidationHelpers.h:54
reco::TrackBase::vertex
const Point & vertex() const
reference point on the track. This method is DEPRECATED, please use referencePoint() instead
Definition: TrackBase.h:676
PrimaryVertexValidation::h_recoVtxChi2ndf_
TH1F * h_recoVtxChi2ndf_
Definition: PrimaryVertexValidation.h:684
PrimaryVertexValidation::n_d3DResidualsMap
TH1F * n_d3DResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:373
PrimaryVertexValidation::a_dxypTCentralMeanTrend
TH1F * a_dxypTCentralMeanTrend
Definition: PrimaryVertexValidation.h:411
PrimaryVertexValidation::MedianTrendsDir
TFileDirectory MedianTrendsDir
Definition: PrimaryVertexValidation.h:301
PrimaryVertexValidation::a_dxyPhiResiduals
std::vector< TH1F * > a_dxyPhiResiduals
Definition: PrimaryVertexValidation.h:321
newFWLiteAna.bin
bin
Definition: newFWLiteAna.py:161
PrimaryVertexValidation::a_dxyL1ResidualsMap
TH1F * a_dxyL1ResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:377
PrimaryVertexValidation::phi_
double phi_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:260
PrimaryVertexValidation::n_dzPhiMeanTrend
TH1F * n_dzPhiMeanTrend
Definition: PrimaryVertexValidation.h:396
PrimaryVertexValidation::a_dxyPhiBiasResiduals
std::vector< TH1F * > a_dxyPhiBiasResiduals
Definition: PrimaryVertexValidation.h:518
PrimaryVertexValidation::h_nLadders
TH1F * h_nLadders
Definition: PrimaryVertexValidation.h:310
types
types
Definition: AlignPCLThresholds_PayloadInspector.cc:30
reco::TrackBase::qualityByName
static TrackQuality qualityByName(const std::string &name)
Definition: TrackBase.cc:126
PrimaryVertexValidation::dxyErrorFromMyVertex_
double dxyErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:286
PrimaryVertexValidation::a_dxyEtaMeanBiasTrend
TH1F * a_dxyEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:547
PrimaryVertexValidation::a_d3DResidualsMap
TH1F * a_d3DResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:369
PrimaryVertexValidation::n_dxypTCentralMeanTrend
TH1F * n_dxypTCentralMeanTrend
Definition: PrimaryVertexValidation.h:421
PrimaryVertexValidation::a_dyEtaResiduals
std::vector< TH1F * > a_dyEtaResiduals
Definition: PrimaryVertexValidation.h:328
reco::TrackBase::hitPattern
const HitPattern & hitPattern() const
Access the hit pattern, indicating in which Tracker layers the track has hits.
Definition: TrackBase.h:504
PrimaryVertexValidation::runNumbersTimesLog_
std::map< unsigned int, std::pair< long long, long long > > runNumbersTimesLog_
Definition: PrimaryVertexValidation.h:313
JME::Binning::Rho
PrimaryVertexValidation::a_dzEtaMedianBiasTrend
TH1F * a_dzEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:571
PrimaryVertexValidation::h_norm_dz_ladder_
std::vector< TH1F * > h_norm_dz_ladder_
Definition: PrimaryVertexValidation.h:715
PrimaryVertexValidation::h_recoVtxNtracks_
TH1F * h_recoVtxNtracks_
Definition: PrimaryVertexValidation.h:683
PrimaryVertexValidation::h_probeL1Ladder_
TH1F * h_probeL1Ladder_
Definition: PrimaryVertexValidation.h:665
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
PrimaryVertexValidation::IPLsigFromMyVertex_
double IPLsigFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:291
PrimaryVertexValidation::sumOfWeightsUnbiasedVertex_
float sumOfWeightsUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:279
std
Definition: JetResolutionObject.h:76
writedatasetfile.run
run
Definition: writedatasetfile.py:27
PrimaryVertexValidation::d3DErrorFromMyVertex_
double d3DErrorFromMyVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:288
reco::TrackBase::d0Error
double d0Error() const
error on d0
Definition: TrackBase.h:772
PrimaryVertexValidation::hasFirstLayerPixelHits
bool hasFirstLayerPixelHits(const reco::TransientTrack &track)
Definition: PrimaryVertexValidation.cc:1148
PrimaryVertexValidation::n_dxymodZMeanTrend
TH1F * n_dxymodZMeanTrend
Definition: PrimaryVertexValidation.h:438
PrimaryVertexValidation::h_dxy_ladderOverlap_
std::vector< TH1F * > h_dxy_ladderOverlap_
Definition: PrimaryVertexValidation.h:709
reco::TransientTrack
Definition: TransientTrack.h:19
PrimaryVertexValidation::a_dzEtaWidthTrend
TH1F * a_dzEtaWidthTrend
Definition: PrimaryVertexValidation.h:392
PVValHelper::dxy
Definition: PVValidationHelpers.h:47
PrimaryVertexValidation::bookResidualsHistogram
std::vector< TH1F * > bookResidualsHistogram(const TFileDirectory &dir, unsigned int theNOfBins, PVValHelper::residualType resType, PVValHelper::plotVariable varType, bool isNormalized=false)
Definition: PrimaryVertexValidation.cc:3412
TrackerTopology::pxbModule
unsigned int pxbModule(const DetId &id) const
Definition: TrackerTopology.h:160
PrimaryVertexValidation::p_
double p_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:247
PrimaryVertexValidation::yErrOfflineVertex_
double yErrOfflineVertex_
Definition: PrimaryVertexValidation.h:233
PrimaryVertexValidation::h2_probeEtaPhi_
TH2F * h2_probeEtaPhi_
Definition: PrimaryVertexValidation.h:621
PrimaryVertexValidation::n_IP2DPhiResiduals
std::vector< TH1F * > n_IP2DPhiResiduals
Definition: PrimaryVertexValidation.h:353
PrimaryVertexValidation::theDetails_
PVValHelper::histodetails theDetails_
Definition: PrimaryVertexValidation.h:163
PVValHelper::dz
Definition: PVValidationHelpers.h:50
PrimaryVertexValidation::h_nOfflineVertices
TH1F * h_nOfflineVertices
Definition: PrimaryVertexValidation.h:601
edm::LogVerbatim
Log< level::Info, true > LogVerbatim
Definition: MessageLogger.h:128
PrimaryVertexValidation::h_dxy_Central_pT_
std::vector< TH1F * > h_dxy_Central_pT_
Definition: PrimaryVertexValidation.h:697
PrimaryVertexValidation::xUnbiasedVertex_
double xUnbiasedVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:272
PrimaryVertexValidation::n_dzEtaWidthTrend
TH1F * n_dzEtaWidthTrend
Definition: PrimaryVertexValidation.h:402
PrimaryVertexValidation::mypT_bins_
std::array< float, nPtBins_+1 > mypT_bins_
Definition: PrimaryVertexValidation.h:218
PVValHelper::MEDIAN
Definition: PVValidationHelpers.h:44
PrimaryVertexValidation::h_zErrOfflineVertex
TH1F * h_zErrOfflineVertex
Definition: PrimaryVertexValidation.h:611
PrimaryVertexValidation::a_dzMeanMap
TH2F * a_dzMeanMap
Definition: PrimaryVertexValidation.h:487
PrimaryVertexValidation::h_probeHits1D_
TH1F * h_probeHits1D_
Definition: PrimaryVertexValidation.h:656
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
PVValHelper::getMAD
Measurement1D getMAD(TH1F *histo)
Definition: PVValidationHelpers.cc:194
PrimaryVertexValidation::getRunTime
std::pair< long long, long long > getRunTime(const edm::EventSetup &iSetup) const
Definition: PrimaryVertexValidation.cc:2960
PVValHelper::ladder
Definition: PVValidationHelpers.h:72
PrimaryVertexValidation::n_dxyEtaMeanTrend
TH1F * n_dxyEtaMeanTrend
Definition: PrimaryVertexValidation.h:399
PrimaryVertexValidation::n_dzPhiMedianTrend
TH1F * n_dzPhiMedianTrend
Definition: PrimaryVertexValidation.h:462
PrimaryVertexValidation::a_dzL1WidthMap
TH2F * a_dzL1WidthMap
Definition: PrimaryVertexValidation.h:507
PrimaryVertexValidation::n_dxyPhiMeanBiasTrend
TH1F * n_dxyPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:552
PrimaryVertexValidation::ttkToken_
const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord > ttkToken_
Definition: PrimaryVertexValidation.h:153
PrimaryVertexValidation::askFirstLayerHit_
bool askFirstLayerHit_
Definition: PrimaryVertexValidation.h:172
submitPVValidationJobs.runInfo
dictionary runInfo
Definition: submitPVValidationJobs.py:1013
PrimaryVertexValidation::n_dxyPhiWidthBiasTrend
TH1F * n_dxyPhiWidthBiasTrend
Definition: PrimaryVertexValidation.h:553
PrimaryVertexValidation::charge_
int charge_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:263
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
PrimaryVertexValidation::nhitsBPIX_
int nhitsBPIX_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:251
PrimaryVertexValidation::n_dzEtaMeanBiasTrend
TH1F * n_dzEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:559
PrimaryVertexValidation::n_dzladderWidthTrend
TH1F * n_dzladderWidthTrend
Definition: PrimaryVertexValidation.h:446
PrimaryVertexValidation::isPhase1_
bool isPhase1_
Definition: PrimaryVertexValidation.h:179
PrimaryVertexValidation::runControl_
bool runControl_
Definition: PrimaryVertexValidation.h:191
dqm-mbProfile.log
log
Definition: dqm-mbProfile.py:17
PrimaryVertexValidation::a_dxymodZMeanTrend
TH1F * a_dxymodZMeanTrend
Definition: PrimaryVertexValidation.h:428
PrimaryVertexValidation::a_dxyPhiMeanTrend
TH1F * a_dxyPhiMeanTrend
Definition: PrimaryVertexValidation.h:384
PrimaryVertexValidation::doBPix_
bool doBPix_
Definition: PrimaryVertexValidation.h:173
PrimaryVertexValidation::h_dz_ladder_
std::vector< TH1F * > h_dz_ladder_
Definition: PrimaryVertexValidation.h:713
PrimaryVertexValidation::n_dzEtaMADTrend
TH1F * n_dzEtaMADTrend
Definition: PrimaryVertexValidation.h:468
PrimaryVertexValidation::n_dzmodZMeanTrend
TH1F * n_dzmodZMeanTrend
Definition: PrimaryVertexValidation.h:440
PrimaryVertexValidation::n_dzEtaMedianBiasTrend
TH1F * n_dzEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:581
PrimaryVertexValidation::h_probed0RefitV_
TH1F * h_probed0RefitV_
Definition: PrimaryVertexValidation.h:640
PrimaryVertexValidation::a_dxyWidthBiasMap
TH2F * a_dxyWidthBiasMap
Definition: PrimaryVertexValidation.h:592
TransientTrackBuilder::build
reco::TransientTrack build(const reco::Track *p) const
Definition: TransientTrackBuilder.cc:20
PrimaryVertexValidation::Mean2DMapsDir
TFileDirectory Mean2DMapsDir
Definition: PrimaryVertexValidation.h:304
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
PrimaryVertexValidation::a_dzWidthBiasMap
TH2F * a_dzWidthBiasMap
Definition: PrimaryVertexValidation.h:593
PVValHelper::histodetails::setMap
void setMap(residualType type, plotVariable plot, float low, float high)
Definition: PVValidationHelpers.h:82
PrimaryVertexValidation::h_probeHitsInFPIX_
TH1F * h_probeHitsInFPIX_
Definition: PrimaryVertexValidation.h:663
reco::TrackBase::pz
double pz() const
z coordinate of momentum vector
Definition: TrackBase.h:646
PrimaryVertexValidation::BeamWidthX_
double BeamWidthX_
Definition: PrimaryVertexValidation.h:241
PrimaryVertexValidation::a_dxyPhiMedianBiasTrend
TH1F * a_dxyPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:564
cms::Exception
Definition: Exception.h:70
PrimaryVertexValidation::a_dxyVsPhi
TH2F * a_dxyVsPhi
Definition: PrimaryVertexValidation.h:472
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
PrimaryVertexValidation::a_dxyladderWidthTrend
TH1F * a_dxyladderWidthTrend
Definition: PrimaryVertexValidation.h:434
PrimaryVertexValidation::nModZ_
unsigned int nModZ_
Definition: PrimaryVertexValidation.h:211
PrimaryVertexValidation::nClus_
int nClus_
Definition: PrimaryVertexValidation.h:223
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
kappa
static const G4double kappa
Definition: UrbanMscModel93.cc:35
PrimaryVertexValidation::xPCA_
double xPCA_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:269
PrimaryVertexValidation::h_probeCharge_
TH1F * h_probeCharge_
Definition: PrimaryVertexValidation.h:631
PrimaryVertexValidation::n_dzMeanMap
TH2F * n_dzMeanMap
Definition: PrimaryVertexValidation.h:490
PVValHelper::histodetails::range
std::map< std::pair< residualType, plotVariable >, std::pair< float, float > > range
Definition: PVValidationHelpers.h:79
PrimaryVertexValidation::dxy_
double dxy_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:266
PrimaryVertexValidation::n_dzpTMeanTrend
TH1F * n_dzpTMeanTrend
Definition: PrimaryVertexValidation.h:418
PrimaryVertexValidation::a_dxPhiResiduals
std::vector< TH1F * > a_dxPhiResiduals
Definition: PrimaryVertexValidation.h:324
PerigeeTrajectoryParameters::transverseImpactParameter
double transverseImpactParameter() const
Definition: PerigeeTrajectoryParameters.h:68
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
PrimaryVertexValidation::n_dzpTCentralWidthTrend
TH1F * n_dzpTCentralWidthTrend
Definition: PrimaryVertexValidation.h:424
TrajectoryStateClosestToPoint::theState
const FreeTrajectoryState & theState() const
Definition: TrajectoryStateClosestToPoint.h:96
PrimaryVertexValidation::n_dxyEtaMADTrend
TH1F * n_dxyEtaMADTrend
Definition: PrimaryVertexValidation.h:466
PrimaryVertexValidation::lightNtupleSwitch_
bool lightNtupleSwitch_
Definition: PrimaryVertexValidation.h:159
PrimaryVertexValidation::h_recoVtxSumPt_
TH1F * h_recoVtxSumPt_
Definition: PrimaryVertexValidation.h:686
PrimaryVertexValidation::maxPt_
const double maxPt_
Definition: PrimaryVertexValidation.h:186
PrimaryVertexValidation::n_dxyResidualsMap
TH1F * n_dxyResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:371
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
PrimaryVertexValidation::n_dzpTCentralMeanTrend
TH1F * n_dzpTCentralMeanTrend
Definition: PrimaryVertexValidation.h:423
PrimaryVertexValidation::minPt_
const double minPt_
Definition: PrimaryVertexValidation.h:185
PrimaryVertexValidation::n_dxyPhiMedianBiasTrend
TH1F * n_dxyPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:574
PrimaryVertexValidation::n_dxyEtaMeanBiasTrend
TH1F * n_dxyEtaMeanBiasTrend
Definition: PrimaryVertexValidation.h:557
HLT_FULL_cff.distance
distance
Definition: HLT_FULL_cff.py:7733
PrimaryVertexValidation::h_probeHitsInTOB_
TH1F * h_probeHitsInTOB_
Definition: PrimaryVertexValidation.h:659
d0
static constexpr float d0
Definition: L1EGammaCrystalsEmulatorProducer.cc:84
PrimaryVertexValidation::theTrackCollectionToken
edm::EDGetTokenT< reco::TrackCollection > theTrackCollectionToken
Definition: PrimaryVertexValidation.h:196
reco::TrackBase::theta
double theta() const
polar angle
Definition: TrackBase.h:602
PrimaryVertexValidation::a_dxyEtaMADTrend
TH1F * a_dxyEtaMADTrend
Definition: PrimaryVertexValidation.h:456
PrimaryVertexValidation::theBeamspotToken
edm::EDGetTokenT< reco::BeamSpot > theBeamspotToken
Definition: PrimaryVertexValidation.h:198
PrimaryVertexValidation::a_dzPhiMADBiasTrend
TH1F * a_dzPhiMADBiasTrend
Definition: PrimaryVertexValidation.h:567
PrimaryVertexValidation::h_yOfflineVertex
TH1F * h_yOfflineVertex
Definition: PrimaryVertexValidation.h:607
reco::TrackBase::dxy
double dxy() const
dxy parameter. (This is the transverse impact parameter w.r.t. to (0,0,0) ONLY if refPoint is close t...
Definition: TrackBase.h:608
PrimaryVertexValidation::n_IP2DEtaResiduals
std::vector< TH1F * > n_IP2DEtaResiduals
Definition: PrimaryVertexValidation.h:354
PrimaryVertexValidation::cmToum
static const int cmToum
Definition: PrimaryVertexValidation.h:207
PrimaryVertexValidation::a_dzEtaMADTrend
TH1F * a_dzEtaMADTrend
Definition: PrimaryVertexValidation.h:458
SiPixelRecHit::clusterProbability
float clusterProbability(unsigned int flags=0) const
Definition: SiPixelRecHit.cc:9
reco::TrackBase::quality
bool quality(const TrackQuality) const
Track quality.
Definition: TrackBase.h:552
edm::InputTag
Definition: InputTag.h:15
PVValHelper::dx
Definition: PVValidationHelpers.h:48
PrimaryVertexValidation::vtxSort
static bool vtxSort(const reco::Vertex &a, const reco::Vertex &b)
Definition: PrimaryVertexValidation.cc:3246
PrimaryVertexValidation::h_probeHitsInTEC_
TH1F * h_probeHitsInTEC_
Definition: PrimaryVertexValidation.h:661
PrimaryVertexValidation::n_dxyEtaWidthTrend
TH1F * n_dxyEtaWidthTrend
Definition: PrimaryVertexValidation.h:400
PrimaryVertexValidation::n_dzBiasResidualsMap
TH1F * n_dzBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:538
PrimaryVertexValidation::a_dyPhiResiduals
std::vector< TH1F * > a_dyPhiResiduals
Definition: PrimaryVertexValidation.h:327
PrimaryVertexValidation::n_dxyEtaMedianBiasTrend
TH1F * n_dxyEtaMedianBiasTrend
Definition: PrimaryVertexValidation.h:579
PrimaryVertexValidation::n_dxyPhiMeanTrend
TH1F * n_dxyPhiMeanTrend
Definition: PrimaryVertexValidation.h:394
up
Definition: BitonicSort.h:7
PrimaryVertexValidation::a_dxyPhiMeanBiasTrend
TH1F * a_dxyPhiMeanBiasTrend
Definition: PrimaryVertexValidation.h:542
PrimaryVertexValidation::h_BeamWidthX
TH1F * h_BeamWidthX
Definition: PrimaryVertexValidation.h:616
PrimaryVertexValidation::h_probedxyRefitV_
TH1F * h_probedxyRefitV_
Definition: PrimaryVertexValidation.h:638
PrimaryVertexValidation::yOfflineVertex_
double yOfflineVertex_
Definition: PrimaryVertexValidation.h:229
reco::Vertex
Definition: Vertex.h:35
PrimaryVertexValidation::magFieldToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > magFieldToken_
Definition: PrimaryVertexValidation.h:150
PrimaryVertexValidation::h_probeRecoVSigZ_
TH1F * h_probeRecoVSigZ_
Definition: PrimaryVertexValidation.h:647
hit
Definition: SiStripHitEffFromCalibTree.cc:88
PrimaryVertexValidation::n_dxyEtaWidthBiasTrend
TH1F * n_dxyEtaWidthBiasTrend
Definition: PrimaryVertexValidation.h:558
PrimaryVertexValidation::rootTree_
TTree * rootTree_
Definition: PrimaryVertexValidation.h:200
TFileService::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileService.h:64
PrimaryVertexValidation::h_recoVtxChi2Prob_
TH1F * h_recoVtxChi2Prob_
Definition: PrimaryVertexValidation.h:685
PrimaryVertexValidation::h_probeNormChi2_
TH1F * h_probeNormChi2_
Definition: PrimaryVertexValidation.h:630
PrimaryVertexValidation::a_reszEtaResiduals
std::vector< TH1F * > a_reszEtaResiduals
Definition: PrimaryVertexValidation.h:340
reco::TrackBase::qoverp
double qoverp() const
q / p
Definition: TrackBase.h:599
PVValHelper::IP2D
Definition: PVValidationHelpers.h:51
PrimaryVertexValidation::n_dzWidthBiasMap
TH2F * n_dzWidthBiasMap
Definition: PrimaryVertexValidation.h:596
PrimaryVertexValidation::n_IP3DPhiResiduals
std::vector< TH1F * > n_IP3DPhiResiduals
Definition: PrimaryVertexValidation.h:356
PrimaryVertexValidation::a_dxyEtaResiduals
std::vector< TH1F * > a_dxyEtaResiduals
Definition: PrimaryVertexValidation.h:322
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
PVValHelper::shrinkHistVectorToFit
void shrinkHistVectorToFit(std::vector< TH1F * > &h, unsigned int desired_size)
Definition: PVValidationHelpers.cc:56
PrimaryVertexValidation::a_dzmodZWidthTrend
TH1F * a_dzmodZWidthTrend
Definition: PrimaryVertexValidation.h:431
PrimaryVertexValidation::a_dzPhiMedianBiasTrend
TH1F * a_dzPhiMedianBiasTrend
Definition: PrimaryVertexValidation.h:566
PrimaryVertexValidation::h_Beamsigmaz
TH1F * h_Beamsigmaz
Definition: PrimaryVertexValidation.h:615
PVValHelper::norm_dz
Definition: PVValidationHelpers.h:59
PrimaryVertexValidation::h_runStartTimes
TH1I * h_runStartTimes
Definition: PrimaryVertexValidation.h:314
PrimaryVertexValidation::hasRecVertex_
int hasRecVertex_[nMaxtracks_]
Definition: PrimaryVertexValidation.h:294
PrimaryVertexValidation::a_dxyBiasResidualsMap
TH1F * a_dxyBiasResidualsMap[nMaxBins_][nMaxBins_]
Definition: PrimaryVertexValidation.h:534
PVValHelper::fitResiduals
std::pair< Measurement1D, Measurement1D > fitResiduals(TH1 *hist)
Definition: PVValidationHelpers.cc:223
PrimaryVertexValidation::n_dxyladderMeanTrend
TH1F * n_dxyladderMeanTrend
Definition: PrimaryVertexValidation.h:443
Generated for CMSSW Reference Manual by doxygen 1.8.16