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

Inheritance diagram for PrimaryVertexValidation:

Public Member Functions
	PrimaryVertexValidation (const edm::ParameterSet &)

	~PrimaryVertexValidation () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

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

void	beginRun (edm::Run const &iRun, edm::EventSetup const &iSetup) 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	endRun (edm::Run const &, edm::EventSetup const &) 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 PVValHelper::detectorPhase &thePhase) 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 >	geomTokenBR_

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_nModZ

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	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_ = 9

int	nOfflineVertices_

int	nTracks_

int	nTracksPerClus_

double	p_ [nMaxtracks_]

PVValHelper::detectorPhase	phase_

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 >	runInfoTokenBR_

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< TrackerTopology, TrackerTopologyRcd >	topoTokenBR_

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_ = 10000

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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Validate alignment constants using unbiased vertex residuals

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

Definition at line 73 of file PrimaryVertexValidation.h.

Constructor & Destructor Documentation

◆ PrimaryVertexValidation()

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

explicit

Definition at line 68 of file PrimaryVertexValidation.cc.

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_, cond::impl::to_string(), and PVValHelper::histodetails::trendbins.

     : magFieldToken_(esConsumes<MagneticField, IdealMagneticFieldRecord>()),
       trackingGeomToken_(esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>()),
       ttkToken_(esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"))),
       topoToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>()),
       topoTokenBR_(esConsumes<TrackerTopology, TrackerTopologyRcd, edm::Transition::BeginRun>()),
       geomTokenBR_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord, edm::Transition::BeginRun>()),
       runInfoTokenBR_(esConsumes<RunInfo, RunInfoRcd, edm::Transition::BeginRun>()),
       compressionSettings_(iConfig.getUntrackedParameter<int>("compressionSettings", -1)),
       storeNtuple_(iConfig.getParameter<bool>("storeNtuple")),
       lightNtupleSwitch_(iConfig.getParameter<bool>("isLightNtuple")),
       useTracksFromRecoVtx_(iConfig.getParameter<bool>("useTracksFromRecoVtx")),
       vertexZMax_(iConfig.getUntrackedParameter<double>("vertexZMax", 99.)),
       intLumi_(iConfig.getUntrackedParameter<double>("intLumi", 0.)),
       askFirstLayerHit_(iConfig.getParameter<bool>("askFirstLayerHit")),
       doBPix_(iConfig.getUntrackedParameter<bool>("doBPix", true)),
       doFPix_(iConfig.getUntrackedParameter<bool>("doFPix", true)),
       ptOfProbe_(iConfig.getUntrackedParameter<double>("probePt", 0.)),
       pOfProbe_(iConfig.getUntrackedParameter<double>("probeP", 0.)),
       etaOfProbe_(iConfig.getUntrackedParameter<double>("probeEta", 2.4)),
       nHitsOfProbe_(iConfig.getUntrackedParameter<double>("probeNHits", 0.)),
       nBins_(iConfig.getUntrackedParameter<int>("numberOfBins", 24)),
       minPt_(iConfig.getUntrackedParameter<double>("minPt", 1.)),
       maxPt_(iConfig.getUntrackedParameter<double>("maxPt", 20.)),
       debug_(iConfig.getParameter<bool>("Debug")),
       runControl_(iConfig.getUntrackedParameter<bool>("runControl", false)),
       forceBeamSpotContraint_(iConfig.getUntrackedParameter<bool>("forceBeamSpot", false)) {
   // now do what ever initialization is needed
   // initialize phase space boundaries
 
   usesResource(TFileService::kSharedResource);
 
   std::vector<unsigned int> defaultRuns;
   defaultRuns.push_back(0);
   runControlNumbers_ = iConfig.getUntrackedParameter<std::vector<unsigned int>>("runControlNumber", defaultRuns);
 
   edm::InputTag TrackCollectionTag_ = iConfig.getParameter<edm::InputTag>("TrackCollectionTag");
   theTrackCollectionToken_ = consumes<reco::TrackCollection>(TrackCollectionTag_);
 
   edm::InputTag VertexCollectionTag_ = iConfig.getParameter<edm::InputTag>("VertexCollectionTag");
   theVertexCollectionToken_ = consumes<reco::VertexCollection>(VertexCollectionTag_);
 
   edm::InputTag BeamspotTag_ = iConfig.getParameter<edm::InputTag>("BeamSpotTag");
   theBeamspotToken_ = consumes<reco::BeamSpot>(BeamspotTag_);
 
   // select and configure the track filter
   theTrackFilter_ =
       std::make_unique<TrackFilterForPVFinding>(iConfig.getParameter<edm::ParameterSet>("TkFilterParameters"));
   // select and configure the track clusterizer
   std::string clusteringAlgorithm =
       iConfig.getParameter<edm::ParameterSet>("TkClusParameters").getParameter<std::string>("algorithm");
   if (clusteringAlgorithm == "gap") {
     theTrackClusterizer_ =
         std::make_unique<GapClusterizerInZ>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
                                                 .getParameter<edm::ParameterSet>("TkGapClusParameters"));
   } else if (clusteringAlgorithm == "DA") {
     theTrackClusterizer_ =
         std::make_unique<DAClusterizerInZ>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
                                                .getParameter<edm::ParameterSet>("TkDAClusParameters"));
     // provide the vectorized version of the clusterizer, if supported by the build
   } else if (clusteringAlgorithm == "DA_vect") {
     theTrackClusterizer_ =
         std::make_unique<DAClusterizerInZ_vect>(iConfig.getParameter<edm::ParameterSet>("TkClusParameters")
                                                     .getParameter<edm::ParameterSet>("TkDAClusParameters"));
   } else {
     throw VertexException("PrimaryVertexProducerAlgorithm: unknown clustering algorithm: " + clusteringAlgorithm);
   }
 
   theDetails_.histobins = 500;
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::phi, -2000., 2000.);
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::eta, -3000., 3000.);
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::pT, -1000., 1000.);
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::pTCentral, -1000., 1000.);
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::ladder, -1000., 1000.);
   theDetails_.setMap(PVValHelper::dxy, PVValHelper::modZ, -1000., 1000.);
 
   for (int i = PVValHelper::phi; i < PVValHelper::END_OF_PLOTS; i++) {
     for (int j = PVValHelper::dx; j < PVValHelper::END_OF_TYPES; j++) {
       auto plot_index = static_cast<PVValHelper::plotVariable>(i);
       auto res_index = static_cast<PVValHelper::residualType>(j);
 
       if (debug_) {
         edm::LogInfo("PrimaryVertexValidation")
             << "==> " << std::get<0>(PVValHelper::getTypeString(res_index)) << " " << std::setw(10)
             << std::get<0>(PVValHelper::getVarString(plot_index)) << std::endl;
       }
       if (res_index != PVValHelper::d3D && res_index != PVValHelper::norm_d3D)
         theDetails_.setMap(res_index,
                            plot_index,
                            theDetails_.getLow(PVValHelper::dxy, plot_index),
                            theDetails_.getHigh(PVValHelper::dxy, plot_index));
       else
         theDetails_.setMap(res_index, plot_index, 0., theDetails_.getHigh(PVValHelper::dxy, plot_index));
     }
   }
 
   edm::LogVerbatim("PrimaryVertexValidation") << "######################################";
   for (const auto& it : theDetails_.range) {
     edm::LogVerbatim("PrimaryVertexValidation")
         << "|" << std::setw(10) << std::get<0>(PVValHelper::getTypeString(it.first.first)) << "|" << std::setw(10)
         << std::get<0>(PVValHelper::getVarString(it.first.second)) << "| (" << std::setw(5) << it.second.first << ";"
         << std::setw(5) << it.second.second << ") |" << std::endl;
   }
 
   theDetails_.trendbins[PVValHelper::phi] = PVValHelper::generateBins(nBins_ + 1, -180., 360.);
   theDetails_.trendbins[PVValHelper::eta] = PVValHelper::generateBins(nBins_ + 1, -etaOfProbe_, 2 * etaOfProbe_);
 
   if (debug_) {
     edm::LogVerbatim("PrimaryVertexValidation") << "etaBins: ";
     for (auto ieta : theDetails_.trendbins[PVValHelper::eta]) {
       edm::LogVerbatim("PrimaryVertexValidation") << ieta << " ";
     }
     edm::LogVerbatim("PrimaryVertexValidation") << "\n";
 
     edm::LogVerbatim("PrimaryVertexValidation") << "phiBins: ";
     for (auto iphi : theDetails_.trendbins[PVValHelper::phi]) {
       edm::LogVerbatim("PrimaryVertexValidation") << iphi << " ";
     }
     edm::LogVerbatim("PrimaryVertexValidation") << "\n";
   }
 
   // create the bins of the pT-binned distributions
 
   mypT_bins_ = PVValHelper::makeLogBins<float, nPtBins_>(minPt_, maxPt_);
 
   std::string toOutput = "";
   for (auto ptbin : mypT_bins_) {
     toOutput += " ";
     toOutput += std::to_string(ptbin);
     toOutput += ",";
   }
 
   edm::LogVerbatim("PrimaryVertexValidation") << "######################################\n";
   edm::LogVerbatim("PrimaryVertexValidation") << "The pT binning is: [" << toOutput << "] \n";
 }

◆ ~PrimaryVertexValidation()

PrimaryVertexValidation::~PrimaryVertexValidation ( )

overridedefault

Member Function Documentation

◆ add()

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

private

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

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 211 of file PrimaryVertexValidation.cc.

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_, 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_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), 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_fitVtxChi2_, h_fitVtxChi2ndf_, h_fitVtxChi2Prob_, h_fitVtxNdof_, h_fitVtxNtracks_, h_fitVtxTrackAverageWeight_, h_fitVtxTrackWeights_, h_nClus, 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_recoVtxChi2ndf_, h_recoVtxChi2Prob_, h_recoVtxNtracks_, h_recoVtxSumPt_, 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_, isGoodTrack_, isHighPurity_, isHit2D(), sistrip::SpyUtilities::isValid(), edm::HandleBase::isValid(), dqmiolumiharvest::j, pixelTopology::layer, LogDebug, LogTrace, PerigeeTrajectoryParameters::longitudinalImpactParameter(), PerigeeTrajectoryError::longitudinalImpactParameterError(), LuminosityBlockNumber_, M_PI, magFieldToken_, 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_, nMaxtracks_, nOfflineVertices_, reco::TrackBase::normalizedChi2(), nPtBins_, vertices_cff::ntracks, nTracks_, nTracksPerClus_, reco::TrackBase::numberOfValidHits(), reco::TrackBase::p(), p_, TrajectoryStateClosestToPoint::perigeeError(), TrajectoryStateClosestToPoint::perigeeParameters(), phase_, PVValHelper::phi, reco::TrackBase::phi(), phi_, PixelSubdetector::PixelBarrel, pixelHitsCheck(), pOfProbe_, point, FreeTrajectoryState::position(), TrajectoryStateClosestToPoint::position(), position, funct::pow(), DiDispStaMuonMonitor_cfi::pt, reco::TrackBase::pt(), pt_, ptOfProbe_, reco::TrackBase::px(), TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), reco::TrackBase::py(), reco::TrackBase::pz(), reco::TrackBase::qoverp(), qoverp_, reco::TrackBase::quality(), pixelTrack::qualityByName(), reco::Track::recHits(), rootTree_, runControl_, PV_cfg::runControlNumber, runControlNumbers_, RunNumber_, SetVarToZero(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), jetUpdater_cfi::sort, mathSSE::sqrt(), storeNtuple_, DetId::subdetId(), sumOfWeightsUnbiasedVertex_, funct::tan(), theBeamspotToken_, theDetails_, TrajectoryStateClosestToPoint::theState(), reco::TrackBase::theta(), theta_, theTrackClusterizer_, theTrackCollectionToken_, theTrackFilter_, theVertexCollectionToken_, topoToken_, HLT_2023v12_cff::track, trackingGeomToken_, pwdgSkimBPark_cfi::tracks, tracksUsedForVertexing_, PerigeeConversions::trajectoryStateClosestToPoint(), PerigeeTrajectoryParameters::transverseImpactParameter(), PVValHelper::histodetails::trendbins, ttkToken_, useTracksFromRecoVtx_, bphysicsOniaDQM_cfi::vertex, reco::TrackBase::vertex(), vertexZMax_, AlignmentTracksFromVertexSelector_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_, globals_cff::zError, zOfflineVertex_, zPCA_, zUnbiasedVertex_, and HLT_FULL_cff::zVertex.

                                                                                          {
   using namespace std;
   using namespace reco;
   using namespace IPTools;
 
   if (nBins_ != 24 && debug_) {
     edm::LogInfo("PrimaryVertexValidation") << "Using: " << nBins_ << " bins plots";
   }
 
   bool passesRunControl = false;
 
   if (runControl_) {
     for (const auto& runControlNumber : runControlNumbers_) {
       if (iEvent.eventAuxiliary().run() == runControlNumber) {
         if (debug_) {
           edm::LogInfo("PrimaryVertexValidation")
               << " run number: " << iEvent.eventAuxiliary().run() << " keeping run:" << runControlNumber;
         }
         passesRunControl = true;
         break;
       }
     }
     if (!passesRunControl)
       return;
   }
 
   Nevt_++;
 
   //=======================================================
   // Initialize Root-tuple variables
   //=======================================================
 
   SetVarToZero();
 
   //=======================================================
   // Retrieve tracker topology from geometry
   //=======================================================
 
   const TrackerTopology* const tTopo = &iSetup.getData(topoToken_);
 
   //=======================================================
   // Retrieve the Magnetic Field information
   //=======================================================
 
   edm::ESHandle<MagneticField> theMGField = iSetup.getHandle(magFieldToken_);
 
   //=======================================================
   // Retrieve the Tracking Geometry information
   //=======================================================
 
   edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry = iSetup.getHandle(trackingGeomToken_);
 
   //=======================================================
   // Retrieve the Transient Track Builder information
   //=======================================================
 
   edm::ESHandle<TransientTrackBuilder> theB_ = iSetup.getHandle(ttkToken_);
   double fBfield_ = ((*theB_).field()->inTesla(GlobalPoint(0., 0., 0.))).z();
 
   //=======================================================
   // Retrieve the Track information
   //=======================================================
 
   edm::Handle<TrackCollection> trackCollectionHandle = iEvent.getHandle(theTrackCollectionToken_);
   if (!trackCollectionHandle.isValid())
     return;
   auto const& tracks = *trackCollectionHandle;
 
   //=======================================================
   // Retrieve offline vartex information (only for reco)
   //=======================================================
 
   //edm::Handle<VertexCollection> vertices;
   edm::Handle<std::vector<Vertex>> vertices;
 
   try {
     vertices = iEvent.getHandle(theVertexCollectionToken_);
   } catch (cms::Exception& er) {
     LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
   }
 
   std::vector<Vertex> vsorted = *(vertices);
   // sort the vertices by number of tracks in descending order
   // use chi2 as tiebreaker
   std::sort(vsorted.begin(), vsorted.end(), PrimaryVertexValidation::vtxSort);
 
   // skip events with no PV, this should not happen
 
   if (vsorted.empty())
     return;
 
   // skip events failing vertex cut
   if (std::abs(vsorted[0].z()) > vertexZMax_)
     return;
 
   if (vsorted[0].isValid()) {
     xOfflineVertex_ = (vsorted)[0].x();
     yOfflineVertex_ = (vsorted)[0].y();
     zOfflineVertex_ = (vsorted)[0].z();
 
     xErrOfflineVertex_ = (vsorted)[0].xError();
     yErrOfflineVertex_ = (vsorted)[0].yError();
     zErrOfflineVertex_ = (vsorted)[0].zError();
   }
 
   h_xOfflineVertex->Fill(xOfflineVertex_);
   h_yOfflineVertex->Fill(yOfflineVertex_);
   h_zOfflineVertex->Fill(zOfflineVertex_);
   h_xErrOfflineVertex->Fill(xErrOfflineVertex_);
   h_yErrOfflineVertex->Fill(yErrOfflineVertex_);
   h_zErrOfflineVertex->Fill(zErrOfflineVertex_);
 
   unsigned int vertexCollectionSize = vsorted.size();
   int nvvertex = 0;
 
   for (unsigned int i = 0; i < vertexCollectionSize; i++) {
     const Vertex& vertex = vsorted.at(i);
     if (vertex.isValid())
       nvvertex++;
   }
 
   nOfflineVertices_ = nvvertex;
   h_nOfflineVertices->Fill(nvvertex);
 
   if (!vsorted.empty() && useTracksFromRecoVtx_) {
     double sumpt = 0;
     size_t ntracks = 0;
     double chi2ndf = 0.;
     double chi2prob = 0.;
 
     if (!vsorted.at(0).isFake()) {
       Vertex pv = vsorted.at(0);
 
       ntracks = pv.tracksSize();
       chi2ndf = pv.normalizedChi2();
       chi2prob = TMath::Prob(pv.chi2(), (int)pv.ndof());
 
       h_recoVtxNtracks_->Fill(ntracks);
       h_recoVtxChi2ndf_->Fill(chi2ndf);
       h_recoVtxChi2Prob_->Fill(chi2prob);
 
       for (Vertex::trackRef_iterator itrk = pv.tracks_begin(); itrk != pv.tracks_end(); ++itrk) {
         double pt = (**itrk).pt();
         sumpt += pt * pt;
 
         const math::XYZPoint myVertex(pv.position().x(), pv.position().y(), pv.position().z());
 
         double dxyRes = (**itrk).dxy(myVertex);
         double dzRes = (**itrk).dz(myVertex);
 
         double dxy_err = (**itrk).dxyError();
         double dz_err = (**itrk).dzError();
 
         float trackphi = ((**itrk).phi()) * (180 / M_PI);
         float tracketa = (**itrk).eta();
 
         for (int i = 0; i < nBins_; i++) {
           float phiF = theDetails_.trendbins[PVValHelper::phi][i];
           float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
 
           float etaF = theDetails_.trendbins[PVValHelper::eta][i];
           float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
 
           if (tracketa >= etaF && tracketa < etaL) {
             PVValHelper::fillByIndex(a_dxyEtaBiasResiduals, i, dxyRes * cmToum, "1");
             PVValHelper::fillByIndex(a_dzEtaBiasResiduals, i, dzRes * cmToum, "2");
             PVValHelper::fillByIndex(n_dxyEtaBiasResiduals, i, (dxyRes) / dxy_err, "3");
             PVValHelper::fillByIndex(n_dzEtaBiasResiduals, i, (dzRes) / dz_err, "4");
           }
 
           if (trackphi >= phiF && trackphi < phiL) {
             PVValHelper::fillByIndex(a_dxyPhiBiasResiduals, i, dxyRes * cmToum, "5");
             PVValHelper::fillByIndex(a_dzPhiBiasResiduals, i, dzRes * cmToum, "6");
             PVValHelper::fillByIndex(n_dxyPhiBiasResiduals, i, (dxyRes) / dxy_err, "7");
             PVValHelper::fillByIndex(n_dzPhiBiasResiduals, i, (dzRes) / dz_err, "8");
 
             for (int j = 0; j < nBins_; j++) {
               float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
               float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
 
               if (tracketa >= etaJ && tracketa < etaK) {
                 a_dxyBiasResidualsMap[i][j]->Fill(dxyRes * cmToum);
                 a_dzBiasResidualsMap[i][j]->Fill(dzRes * cmToum);
 
                 n_dxyBiasResidualsMap[i][j]->Fill((dxyRes) / dxy_err);
                 n_dzBiasResidualsMap[i][j]->Fill((dzRes) / dz_err);
               }
             }
           }
         }
       }
 
       h_recoVtxSumPt_->Fill(sumpt);
     }
   }
 
   //=======================================================
   // Retrieve Beamspot information
   //=======================================================
 
   BeamSpot beamSpot;
   edm::Handle<BeamSpot> beamSpotHandle = iEvent.getHandle(theBeamspotToken_);
 
   if (beamSpotHandle.isValid()) {
     beamSpot = *beamSpotHandle;
     BSx0_ = beamSpot.x0();
     BSy0_ = beamSpot.y0();
     BSz0_ = beamSpot.z0();
     Beamsigmaz_ = beamSpot.sigmaZ();
     Beamdxdz_ = beamSpot.dxdz();
     BeamWidthX_ = beamSpot.BeamWidthX();
     BeamWidthY_ = beamSpot.BeamWidthY();
 
     wxy2_ = TMath::Power(BeamWidthX_, 2) + TMath::Power(BeamWidthY_, 2);
 
   } else {
     edm::LogWarning("PrimaryVertexValidation") << "No BeamSpot found!";
   }
 
   h_BSx0->Fill(BSx0_);
   h_BSy0->Fill(BSy0_);
   h_BSz0->Fill(BSz0_);
   h_Beamsigmaz->Fill(Beamsigmaz_);
   h_BeamWidthX->Fill(BeamWidthX_);
   h_BeamWidthY->Fill(BeamWidthY_);
 
   if (debug_)
     edm::LogInfo("PrimaryVertexValidation") << "Beamspot x:" << BSx0_ << " y:" << BSy0_ << " z:" << BSz0_;
 
   //=======================================================
   // Starts here ananlysis
   //=======================================================
 
   RunNumber_ = iEvent.eventAuxiliary().run();
   LuminosityBlockNumber_ = iEvent.eventAuxiliary().luminosityBlock();
   EventNumber_ = iEvent.eventAuxiliary().id().event();
 
   if (debug_)
     edm::LogInfo("PrimaryVertexValidation") << " looping over " << trackCollectionHandle->size() << "tracks";
 
   h_nTracks->Fill(trackCollectionHandle->size());
 
   //======================================================
   // Interface RECO tracks to vertex reconstruction
   //======================================================
 
   std::vector<TransientTrack> t_tks;
   for (const auto& track : tracks) {
     TransientTrack tt = theB_->build(&(track));
     tt.setBeamSpot(beamSpot);
     t_tks.push_back(tt);
   }
 
   if (debug_) {
     edm::LogInfo("PrimaryVertexValidation") << "Found: " << t_tks.size() << " reconstructed tracks";
   }
 
   //======================================================
   // select the tracks
   //======================================================
 
   std::vector<TransientTrack> seltks = theTrackFilter_->select(t_tks);
 
   //======================================================
   // clusterize tracks in Z
   //======================================================
 
   vector<vector<TransientTrack>> clusters = theTrackClusterizer_->clusterize(seltks);
 
   if (debug_) {
     edm::LogInfo("PrimaryVertexValidation")
         << " looping over: " << clusters.size() << " clusters  from " << t_tks.size() << " selected tracks";
   }
 
   nClus_ = clusters.size();
   h_nClus->Fill(nClus_);
 
   //======================================================
   // Starts loop on clusters
   //======================================================
   for (const auto& iclus : clusters) {
     nTracksPerClus_ = 0;
 
     unsigned int i = 0;
     for (const auto& theTTrack : iclus) {
       i++;
 
       if (nTracks_ >= nMaxtracks_) {
         edm::LogError("PrimaryVertexValidation")
             << " Warning - Number of tracks: " << nTracks_ << " , greater than " << nMaxtracks_;
         continue;
       }
 
       const Track& theTrack = theTTrack.track();
 
       pt_[nTracks_] = theTrack.pt();
       p_[nTracks_] = theTrack.p();
       nhits_[nTracks_] = theTrack.numberOfValidHits();
       eta_[nTracks_] = theTrack.eta();
       theta_[nTracks_] = theTrack.theta();
       phi_[nTracks_] = theTrack.phi();
       chi2_[nTracks_] = theTrack.chi2();
       chi2ndof_[nTracks_] = theTrack.normalizedChi2();
       charge_[nTracks_] = theTrack.charge();
       qoverp_[nTracks_] = theTrack.qoverp();
       dz_[nTracks_] = theTrack.dz();
       dxy_[nTracks_] = theTrack.dxy();
 
       TrackBase::TrackQuality _trackQuality = TrackBase::qualityByName("highPurity");
       isHighPurity_[nTracks_] = theTrack.quality(_trackQuality);
 
       math::XYZPoint point(BSx0_, BSy0_, BSz0_);
       dxyBs_[nTracks_] = theTrack.dxy(point);
       dzBs_[nTracks_] = theTrack.dz(point);
 
       xPCA_[nTracks_] = theTrack.vertex().x();
       yPCA_[nTracks_] = theTrack.vertex().y();
       zPCA_[nTracks_] = theTrack.vertex().z();
 
       //=======================================================
       // Retrieve rechit information
       //=======================================================
 
       const reco::HitPattern& hits = theTrack.hitPattern();
 
       int nRecHit1D = 0;
       int nRecHit2D = 0;
       int nhitinTIB = hits.numberOfValidStripTIBHits();
       int nhitinTOB = hits.numberOfValidStripTOBHits();
       int nhitinTID = hits.numberOfValidStripTIDHits();
       int nhitinTEC = hits.numberOfValidStripTECHits();
       int nhitinBPIX = hits.numberOfValidPixelBarrelHits();
       int nhitinFPIX = hits.numberOfValidPixelEndcapHits();
       for (trackingRecHit_iterator iHit = theTTrack.recHitsBegin(); iHit != theTTrack.recHitsEnd(); ++iHit) {
         if ((*iHit)->isValid()) {
           if (this->isHit2D(**iHit, phase_)) {
             ++nRecHit2D;
           } else {
             ++nRecHit1D;
           }
         }
       }
 
       nhits1D_[nTracks_] = nRecHit1D;
       nhits2D_[nTracks_] = nRecHit2D;
       nhitsBPIX_[nTracks_] = nhitinBPIX;
       nhitsFPIX_[nTracks_] = nhitinFPIX;
       nhitsTIB_[nTracks_] = nhitinTIB;
       nhitsTID_[nTracks_] = nhitinTID;
       nhitsTOB_[nTracks_] = nhitinTOB;
       nhitsTEC_[nTracks_] = nhitinTEC;
 
       //=======================================================
       // Good tracks for vertexing selection
       //=======================================================
 
       bool pass = true;
       if (askFirstLayerHit_)
         pass = this->hasFirstLayerPixelHits(theTTrack);
       if (pass && (theTrack.pt() >= ptOfProbe_) && std::abs(theTrack.eta()) <= etaOfProbe_ &&
           (theTrack.numberOfValidHits()) >= nHitsOfProbe_ && (theTrack.p()) >= pOfProbe_) {
         isGoodTrack_[nTracks_] = 1;
       }
 
       //=======================================================
       // Fit unbiased vertex
       //=======================================================
 
       vector<TransientTrack> theFinalTracks;
       theFinalTracks.clear();
 
       for (const auto& tk : iclus) {
         pass = this->hasFirstLayerPixelHits(tk);
         if (pass) {
           if (tk == theTTrack)
             continue;
           else {
             theFinalTracks.push_back(tk);
           }
         }
       }
 
       if (theFinalTracks.size() > 1) {
         if (debug_)
           edm::LogInfo("PrimaryVertexValidation") << "Transient Track Collection size: " << theFinalTracks.size();
         try {
           //AdaptiveVertexFitter* theFitter = new AdaptiveVertexFitter;
           auto theFitter = std::unique_ptr<VertexFitter<5>>(new AdaptiveVertexFitter());
           TransientVertex theFittedVertex;
 
           if (forceBeamSpotContraint_) {
             theFittedVertex = theFitter->vertex(theFinalTracks, beamSpot);  // if you want the beam constraint
           } else {
             theFittedVertex = theFitter->vertex(theFinalTracks);
           }
 
           double totalTrackWeights = 0;
           if (theFittedVertex.isValid()) {
             if (theFittedVertex.hasTrackWeight()) {
               for (const auto& theFinalTrack : theFinalTracks) {
                 sumOfWeightsUnbiasedVertex_[nTracks_] += theFittedVertex.trackWeight(theFinalTrack);
                 totalTrackWeights += theFittedVertex.trackWeight(theFinalTrack);
                 h_fitVtxTrackWeights_->Fill(theFittedVertex.trackWeight(theFinalTrack));
               }
             }
 
             h_fitVtxTrackAverageWeight_->Fill(totalTrackWeights / theFinalTracks.size());
 
             const math::XYZPoint theRecoVertex(xOfflineVertex_, yOfflineVertex_, zOfflineVertex_);
             const math::XYZPoint myVertex(
                 theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
 
             const Vertex vertex = theFittedVertex;
             fillTrackHistos(hDA, "all", &theTTrack, vertex, beamSpot, fBfield_);
 
             hasRecVertex_[nTracks_] = 1;
             xUnbiasedVertex_[nTracks_] = theFittedVertex.position().x();
             yUnbiasedVertex_[nTracks_] = theFittedVertex.position().y();
             zUnbiasedVertex_[nTracks_] = theFittedVertex.position().z();
 
             chi2normUnbiasedVertex_[nTracks_] = theFittedVertex.normalisedChiSquared();
             chi2UnbiasedVertex_[nTracks_] = theFittedVertex.totalChiSquared();
             DOFUnbiasedVertex_[nTracks_] = theFittedVertex.degreesOfFreedom();
             chi2ProbUnbiasedVertex_[nTracks_] =
                 TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom());
             tracksUsedForVertexing_[nTracks_] = theFinalTracks.size();
 
             h_fitVtxNtracks_->Fill(theFinalTracks.size());
             h_fitVtxChi2_->Fill(theFittedVertex.totalChiSquared());
             h_fitVtxNdof_->Fill(theFittedVertex.degreesOfFreedom());
             h_fitVtxChi2ndf_->Fill(theFittedVertex.normalisedChiSquared());
             h_fitVtxChi2Prob_->Fill(
                 TMath::Prob(theFittedVertex.totalChiSquared(), (int)theFittedVertex.degreesOfFreedom()));
 
             // from my Vertex
             double dxyFromMyVertex = theTrack.dxy(myVertex);
             double dzFromMyVertex = theTrack.dz(myVertex);
 
             GlobalPoint vert(
                 theFittedVertex.position().x(), theFittedVertex.position().y(), theFittedVertex.position().z());
 
             //FreeTrajectoryState theTrackNearVertex = theTTrack.trajectoryStateClosestToPoint(vert).theState();
             //double dz_err = sqrt(theFittedVertex.positionError().czz() + theTrackNearVertex.cartesianError().position().czz());
             //double dz_err = hypot(theTrack.dzError(),theFittedVertex.positionError().czz());
 
             double dz_err = sqrt(std::pow(theTrack.dzError(), 2) + theFittedVertex.positionError().czz());
 
             // PV2D
             std::pair<bool, Measurement1D> s_ip2dpv = signedTransverseImpactParameter(
                 theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
 
             double s_ip2dpv_corr = s_ip2dpv.second.value();
             double s_ip2dpv_err = s_ip2dpv.second.error();
 
             // PV3D
             std::pair<bool, Measurement1D> s_ip3dpv = signedImpactParameter3D(
                 theTTrack, GlobalVector(theTrack.px(), theTrack.py(), theTrack.pz()), theFittedVertex);
 
             double s_ip3dpv_corr = s_ip3dpv.second.value();
             double s_ip3dpv_err = s_ip3dpv.second.error();
 
             // PV3D absolute
             std::pair<bool, Measurement1D> ip3dpv = absoluteImpactParameter3D(theTTrack, theFittedVertex);
             double ip3d_corr = ip3dpv.second.value();
             double ip3d_err = ip3dpv.second.error();
 
             // with respect to any specified vertex, such as primary vertex
             TrajectoryStateClosestToPoint traj = (theTTrack).trajectoryStateClosestToPoint(vert);
 
             GlobalPoint refPoint = traj.position();
             GlobalPoint cPToVtx = traj.theState().position();
 
             float my_dx = refPoint.x() - myVertex.x();
             float my_dy = refPoint.y() - myVertex.y();
 
             float my_dx2 = cPToVtx.x() - myVertex.x();
             float my_dy2 = cPToVtx.y() - myVertex.y();
 
             float my_dxy = std::sqrt(my_dx * my_dx + my_dy * my_dy);
 
             double d0 = traj.perigeeParameters().transverseImpactParameter();
             //double d0_error = traj.perigeeError().transverseImpactParameterError();
             double z0 = traj.perigeeParameters().longitudinalImpactParameter();
             double z0_error = traj.perigeeError().longitudinalImpactParameterError();
 
             if (debug_) {
               edm::LogInfo("PrimaryVertexValidation")
                   << "my_dx:" << my_dx << " my_dy:" << my_dy << " my_dxy:" << my_dxy << " my_dx2:" << my_dx2
                   << " my_dy2:" << my_dy2 << " d0: " << d0 << " dxyFromVtx:" << dxyFromMyVertex << "\n"
                   << " ============================== "
                   << "\n"
                   << "diff1:" << std::abs(d0) - std::abs(my_dxy) << "\n"
                   << "diff2:" << std::abs(d0) - std::abs(dxyFromMyVertex) << "\n"
                   << "diff3:" << (my_dx - my_dx2) << " " << (my_dy - my_dy2) << "\n"
                   << std::endl;
             }
 
             // define IPs
 
             dxyFromMyVertex_[nTracks_] = dxyFromMyVertex;
             dxyErrorFromMyVertex_[nTracks_] = s_ip2dpv_err;
             IPTsigFromMyVertex_[nTracks_] = dxyFromMyVertex / s_ip2dpv_err;
 
             dzFromMyVertex_[nTracks_] = dzFromMyVertex;
             dzErrorFromMyVertex_[nTracks_] = dz_err;
             IPLsigFromMyVertex_[nTracks_] = dzFromMyVertex / dz_err;
 
             d3DFromMyVertex_[nTracks_] = ip3d_corr;
             d3DErrorFromMyVertex_[nTracks_] = ip3d_err;
             IP3DsigFromMyVertex_[nTracks_] = (ip3d_corr / ip3d_err);
 
             // fill directly the histograms of residuals
 
             float trackphi = (theTrack.phi()) * (180. / M_PI);
             float tracketa = theTrack.eta();
             float trackpt = theTrack.pt();
             float trackp = theTrack.p();
             float tracknhits = theTrack.numberOfValidHits();
 
             // determine the module number and ladder
 
             int ladder_num = -1.;
             int module_num = -1.;
             int L1BPixHitCount = 0;
 
             for (auto const& hit : theTrack.recHits()) {
               const DetId& detId = hit->geographicalId();
               unsigned int subid = detId.subdetId();
 
               if (hit->isValid() && (subid == PixelSubdetector::PixelBarrel)) {
                 int layer = tTopo->pxbLayer(detId);
                 if (layer == 1) {
                   const SiPixelRecHit* prechit = dynamic_cast<const SiPixelRecHit*>(
                       hit);  //to be used to get the associated cluster and the cluster probability
                   double clusterProbability = prechit->clusterProbability(0);
                   if (clusterProbability > 0) {
                     h_probeL1ClusterProb_->Fill(log10(clusterProbability));
                   }
 
                   L1BPixHitCount += 1;
                   ladder_num = tTopo->pxbLadder(detId);
                   module_num = tTopo->pxbModule(detId);
                 }
               }
             }
 
             h_probeL1Ladder_->Fill(ladder_num);
             h_probeL1Module_->Fill(module_num);
             h2_probeLayer1Map_->Fill(module_num, ladder_num);
             h_probeHasBPixL1Overlap_->Fill(L1BPixHitCount);
 
             // residuals vs ladder and module number for map
             if (module_num > 0 && ladder_num > 0) {  // only if we are on BPix Layer 1
               a_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex * cmToum);
               a_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex * cmToum);
               n_dxyL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dxyFromMyVertex / s_ip2dpv_err);
               n_dzL1ResidualsMap[ladder_num - 1][module_num - 1]->Fill(dzFromMyVertex / dz_err);
             }
 
             // filling the pT-binned distributions
 
             for (int ipTBin = 0; ipTBin < nPtBins_; ipTBin++) {
               float pTF = mypT_bins_[ipTBin];
               float pTL = mypT_bins_[ipTBin + 1];
 
               if (debug_)
                 edm::LogInfo("PrimaryVertexValidation") << "ipTBin:" << ipTBin << " " << mypT_bins_[ipTBin]
                                                         << " < pT < " << mypT_bins_[ipTBin + 1] << std::endl;
 
               if (std::abs(tracketa) < 1.5 && (trackpt >= pTF && trackpt < pTL)) {
                 if (debug_)
                   edm::LogInfo("PrimaryVertexValidation") << "passes this cut: " << mypT_bins_[ipTBin] << std::endl;
                 PVValHelper::fillByIndex(h_dxy_pT_, ipTBin, dxyFromMyVertex * cmToum, "9");
                 PVValHelper::fillByIndex(h_dz_pT_, ipTBin, dzFromMyVertex * cmToum, "10");
                 PVValHelper::fillByIndex(h_norm_dxy_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err, "11");
                 PVValHelper::fillByIndex(h_norm_dz_pT_, ipTBin, dzFromMyVertex / dz_err, "12");
 
                 if (std::abs(tracketa) < 1.) {
                   if (debug_)
                     edm::LogInfo("PrimaryVertexValidation")
                         << "passes tight eta cut: " << mypT_bins_[ipTBin] << std::endl;
                   PVValHelper::fillByIndex(h_dxy_Central_pT_, ipTBin, dxyFromMyVertex * cmToum, "13");
                   PVValHelper::fillByIndex(h_dz_Central_pT_, ipTBin, dzFromMyVertex * cmToum, "14");
                   PVValHelper::fillByIndex(h_norm_dxy_Central_pT_, ipTBin, dxyFromMyVertex / s_ip2dpv_err, "15");
                   PVValHelper::fillByIndex(h_norm_dz_Central_pT_, ipTBin, dzFromMyVertex / dz_err, "16");
                 }
               }
             }
 
             // checks on the probe track quality
             if (trackpt >= ptOfProbe_ && std::abs(tracketa) <= etaOfProbe_ && tracknhits >= nHitsOfProbe_ &&
                 trackp >= pOfProbe_) {
               std::pair<bool, bool> pixelOcc = pixelHitsCheck((theTTrack));
 
               if (debug_) {
                 if (pixelOcc.first == true)
                   edm::LogInfo("PrimaryVertexValidation") << "has BPIx hits" << std::endl;
                 if (pixelOcc.second == true)
                   edm::LogInfo("PrimaryVertexValidation") << "has FPix hits" << std::endl;
               }
 
               if (!doBPix_ && (pixelOcc.first == true))
                 continue;
               if (!doFPix_ && (pixelOcc.second == true))
                 continue;
 
               fillTrackHistos(hDA, "sel", &(theTTrack), vertex, beamSpot, fBfield_);
 
               // probe checks
               h_probePt_->Fill(theTrack.pt());
               h_probePtRebin_->Fill(theTrack.pt());
               h_probeP_->Fill(theTrack.p());
               h_probeEta_->Fill(theTrack.eta());
               h_probePhi_->Fill(theTrack.phi());
               h2_probeEtaPhi_->Fill(theTrack.eta(), theTrack.phi());
               h2_probeEtaPt_->Fill(theTrack.eta(), theTrack.pt());
 
               h_probeChi2_->Fill(theTrack.chi2());
               h_probeNormChi2_->Fill(theTrack.normalizedChi2());
               h_probeCharge_->Fill(theTrack.charge());
               h_probeQoverP_->Fill(theTrack.qoverp());
               h_probeHits_->Fill(theTrack.numberOfValidHits());
               h_probeHits1D_->Fill(nRecHit1D);
               h_probeHits2D_->Fill(nRecHit2D);
               h_probeHitsInTIB_->Fill(nhitinTIB);
               h_probeHitsInTOB_->Fill(nhitinTOB);
               h_probeHitsInTID_->Fill(nhitinTID);
               h_probeHitsInTEC_->Fill(nhitinTEC);
               h_probeHitsInBPIX_->Fill(nhitinBPIX);
               h_probeHitsInFPIX_->Fill(nhitinFPIX);
 
               float dxyRecoV = theTrack.dz(theRecoVertex);
               float dzRecoV = theTrack.dxy(theRecoVertex);
               float dxysigmaRecoV =
                   TMath::Sqrt(theTrack.d0Error() * theTrack.d0Error() + xErrOfflineVertex_ * yErrOfflineVertex_);
               float dzsigmaRecoV =
                   TMath::Sqrt(theTrack.dzError() * theTrack.dzError() + zErrOfflineVertex_ * zErrOfflineVertex_);
 
               double zTrack = (theTTrack.stateAtBeamLine().trackStateAtPCA()).position().z();
               double zVertex = theFittedVertex.position().z();
               double tantheta = tan((theTTrack.stateAtBeamLine().trackStateAtPCA()).momentum().theta());
 
               double dz2 = pow(theTrack.dzError(), 2) + wxy2_ / pow(tantheta, 2);
               double restrkz = zTrack - zVertex;
               double pulltrkz = (zTrack - zVertex) / TMath::Sqrt(dz2);
 
               h_probedxyRecoV_->Fill(dxyRecoV);
               h_probedzRecoV_->Fill(dzRecoV);
 
               h_probedzRefitV_->Fill(dxyFromMyVertex);
               h_probedxyRefitV_->Fill(dzFromMyVertex);
 
               h_probed0RefitV_->Fill(d0);
               h_probez0RefitV_->Fill(z0);
 
               h_probesignIP2DRefitV_->Fill(s_ip2dpv_corr);
               h_probed3DRefitV_->Fill(ip3d_corr);
               h_probereszRefitV_->Fill(restrkz);
 
               h_probeRecoVSigZ_->Fill(dzRecoV / dzsigmaRecoV);
               h_probeRecoVSigXY_->Fill(dxyRecoV / dxysigmaRecoV);
               h_probeRefitVSigZ_->Fill(dzFromMyVertex / dz_err);
               h_probeRefitVSigXY_->Fill(dxyFromMyVertex / s_ip2dpv_err);
               h_probeRefitVSig3D_->Fill(ip3d_corr / ip3d_err);
               h_probeRefitVLogSig3D_->Fill(log10(ip3d_corr / ip3d_err));
               h_probeRefitVSigResZ_->Fill(pulltrkz);
 
               a_dxyVsPhi->Fill(trackphi, dxyFromMyVertex * cmToum);
               a_dzVsPhi->Fill(trackphi, z0 * cmToum);
               n_dxyVsPhi->Fill(trackphi, dxyFromMyVertex / s_ip2dpv_err);
               n_dzVsPhi->Fill(trackphi, z0 / z0_error);
 
               a_dxyVsEta->Fill(tracketa, dxyFromMyVertex * cmToum);
               a_dzVsEta->Fill(tracketa, z0 * cmToum);
               n_dxyVsEta->Fill(tracketa, dxyFromMyVertex / s_ip2dpv_err);
               n_dzVsEta->Fill(tracketa, z0 / z0_error);
 
               if (ladder_num > 0 && module_num > 0) {
                 LogDebug("PrimaryVertexValidation")
                     << " ladder_num: " << ladder_num << " module_num: " << module_num << std::endl;
 
                 PVValHelper::fillByIndex(h_dxy_modZ_, module_num - 1, dxyFromMyVertex * cmToum, "17");
                 PVValHelper::fillByIndex(h_dz_modZ_, module_num - 1, dzFromMyVertex * cmToum, "18");
                 PVValHelper::fillByIndex(h_norm_dxy_modZ_, module_num - 1, dxyFromMyVertex / s_ip2dpv_err, "19");
                 PVValHelper::fillByIndex(h_norm_dz_modZ_, module_num - 1, dzFromMyVertex / dz_err, "20");
 
                 PVValHelper::fillByIndex(h_dxy_ladder_, ladder_num - 1, dxyFromMyVertex * cmToum, "21");
 
                 LogDebug("PrimaryVertexValidation") << "h_dxy_ladder size:" << h_dxy_ladder_.size() << std::endl;
 
                 if (L1BPixHitCount == 1) {
                   PVValHelper::fillByIndex(h_dxy_ladderNoOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
                 } else {
                   PVValHelper::fillByIndex(h_dxy_ladderOverlap_, ladder_num - 1, dxyFromMyVertex * cmToum);
                 }
 
                 h2_probePassingLayer1Map_->Fill(module_num, ladder_num);
 
                 PVValHelper::fillByIndex(h_dz_ladder_, ladder_num - 1, dzFromMyVertex * cmToum, "22");
                 PVValHelper::fillByIndex(h_norm_dxy_ladder_, ladder_num - 1, dxyFromMyVertex / s_ip2dpv_err, "23");
                 PVValHelper::fillByIndex(h_norm_dz_ladder_, ladder_num - 1, dzFromMyVertex / dz_err, "24");
               }
 
               // filling the binned distributions
               for (int i = 0; i < nBins_; i++) {
                 float phiF = theDetails_.trendbins[PVValHelper::phi][i];
                 float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
 
                 float etaF = theDetails_.trendbins[PVValHelper::eta][i];
                 float etaL = theDetails_.trendbins[PVValHelper::eta][i + 1];
 
                 if (tracketa >= etaF && tracketa < etaL) {
                   PVValHelper::fillByIndex(a_dxyEtaResiduals, i, dxyFromMyVertex * cmToum, "25");
                   PVValHelper::fillByIndex(a_dxEtaResiduals, i, my_dx * cmToum, "26");
                   PVValHelper::fillByIndex(a_dyEtaResiduals, i, my_dy * cmToum, "27");
                   PVValHelper::fillByIndex(a_dzEtaResiduals, i, dzFromMyVertex * cmToum, "28");
                   PVValHelper::fillByIndex(n_dxyEtaResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "29");
                   PVValHelper::fillByIndex(n_dzEtaResiduals, i, dzFromMyVertex / dz_err, "30");
                   PVValHelper::fillByIndex(a_IP2DEtaResiduals, i, s_ip2dpv_corr * cmToum, "31");
                   PVValHelper::fillByIndex(n_IP2DEtaResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "32");
                   PVValHelper::fillByIndex(a_reszEtaResiduals, i, restrkz * cmToum, "33");
                   PVValHelper::fillByIndex(n_reszEtaResiduals, i, pulltrkz, "34");
                   PVValHelper::fillByIndex(a_d3DEtaResiduals, i, ip3d_corr * cmToum, "35");
                   PVValHelper::fillByIndex(n_d3DEtaResiduals, i, ip3d_corr / ip3d_err, "36");
                   PVValHelper::fillByIndex(a_IP3DEtaResiduals, i, s_ip3dpv_corr * cmToum, "37");
                   PVValHelper::fillByIndex(n_IP3DEtaResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "38");
                 }
 
                 if (trackphi >= phiF && trackphi < phiL) {
                   PVValHelper::fillByIndex(a_dxyPhiResiduals, i, dxyFromMyVertex * cmToum, "39");
                   PVValHelper::fillByIndex(a_dxPhiResiduals, i, my_dx * cmToum, "40");
                   PVValHelper::fillByIndex(a_dyPhiResiduals, i, my_dy * cmToum, "41");
                   PVValHelper::fillByIndex(a_dzPhiResiduals, i, dzFromMyVertex * cmToum, "42");
                   PVValHelper::fillByIndex(n_dxyPhiResiduals, i, dxyFromMyVertex / s_ip2dpv_err, "43");
                   PVValHelper::fillByIndex(n_dzPhiResiduals, i, dzFromMyVertex / dz_err, "44");
                   PVValHelper::fillByIndex(a_IP2DPhiResiduals, i, s_ip2dpv_corr * cmToum, "45");
                   PVValHelper::fillByIndex(n_IP2DPhiResiduals, i, s_ip2dpv_corr / s_ip2dpv_err, "46");
                   PVValHelper::fillByIndex(a_reszPhiResiduals, i, restrkz * cmToum, "47");
                   PVValHelper::fillByIndex(n_reszPhiResiduals, i, pulltrkz, "48");
                   PVValHelper::fillByIndex(a_d3DPhiResiduals, i, ip3d_corr * cmToum, "49");
                   PVValHelper::fillByIndex(n_d3DPhiResiduals, i, ip3d_corr / ip3d_err, "50");
                   PVValHelper::fillByIndex(a_IP3DPhiResiduals, i, s_ip3dpv_corr * cmToum, "51");
                   PVValHelper::fillByIndex(n_IP3DPhiResiduals, i, s_ip3dpv_corr / s_ip3dpv_err, "52");
 
                   for (int j = 0; j < nBins_; j++) {
                     float etaJ = theDetails_.trendbins[PVValHelper::eta][j];
                     float etaK = theDetails_.trendbins[PVValHelper::eta][j + 1];
 
                     if (tracketa >= etaJ && tracketa < etaK) {
                       a_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex * cmToum);
                       a_dzResidualsMap[i][j]->Fill(dzFromMyVertex * cmToum);
                       n_dxyResidualsMap[i][j]->Fill(dxyFromMyVertex / s_ip2dpv_err);
                       n_dzResidualsMap[i][j]->Fill(dzFromMyVertex / dz_err);
                       a_d3DResidualsMap[i][j]->Fill(ip3d_corr * cmToum);
                       n_d3DResidualsMap[i][j]->Fill(ip3d_corr / ip3d_err);
                     }
                   }
                 }
               }
             }
 
             if (debug_) {
               edm::LogInfo("PrimaryVertexValidation")
                   << " myVertex.x()= " << myVertex.x() << "\n"
                   << " myVertex.y()= " << myVertex.y() << " \n"
                   << " myVertex.z()= " << myVertex.z() << " \n"
                   << " theTrack.dz(myVertex)= " << theTrack.dz(myVertex) << " \n"
                   << " zPCA -myVertex.z() = " << (theTrack.vertex().z() - myVertex.z());
 
             }  // ends if debug_
           }    // ends if the fitted vertex is Valid
 
           //delete theFitter;
 
         } catch (cms::Exception& er) {
           LogTrace("PrimaryVertexValidation") << "caught std::exception " << er.what() << std::endl;
         }
 
       }  //ends if theFinalTracks.size() > 2
 
       else {
         if (debug_)
           edm::LogInfo("PrimaryVertexValidation") << "Not enough tracks to make a vertex.  Returns no vertex info";
       }
 
       ++nTracks_;
       ++nTracksPerClus_;
 
       if (debug_)
         edm::LogInfo("PrimaryVertexValidation") << "Track " << i << " : pT = " << theTrack.pt();
 
     }  // for loop on tracks
   }    // for loop on track clusters
 
   // Fill the TTree if needed
 
   if (storeNtuple_) {
     rootTree_->Fill();
   }
 }

◆ beginJob()

void PrimaryVertexValidation::beginJob ( )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1080 of file PrimaryVertexValidation.cc.

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_nModZ, 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_, nModZ_, 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_.

                                        {
   edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
                                           << "Begin Job \n"
                                           << "######################################";
 
   // Define TTree for output
   Nevt_ = 0;
   if (compressionSettings_ > 0) {
     fs->file().SetCompressionSettings(compressionSettings_);
   }
 
   //  rootFile_ = new TFile(filename_.c_str(),"recreate");
   rootTree_ = fs->make<TTree>("tree", "PV Validation tree");
 
   // Track Paramters
 
   if (lightNtupleSwitch_) {
     rootTree_->Branch("EventNumber", &EventNumber_, "EventNumber/i");
     rootTree_->Branch("RunNumber", &RunNumber_, "RunNumber/i");
     rootTree_->Branch("LuminosityBlockNumber", &LuminosityBlockNumber_, "LuminosityBlockNumber/i");
     rootTree_->Branch("nOfflineVertices", &nOfflineVertices_, "nOfflineVertices/I");
     rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
     rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
     rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
     rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
     rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
     rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
     rootTree_->Branch("d3DFromMyVertex", &d3DFromMyVertex_, "d3DFromMyVertex[nTracks]/D");
     rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
     rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
     rootTree_->Branch("IP3DsigFromMyVertex", &IP3DsigFromMyVertex_, "IP3DsigFromMyVertex_[nTracks]/D");
     rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
     rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
     rootTree_->Branch("isHighPurity", &isHighPurity_, "isHighPurity_[nTracks]/I");
 
   } else {
     rootTree_->Branch("nTracks", &nTracks_, "nTracks/I");
     rootTree_->Branch("nTracksPerClus", &nTracksPerClus_, "nTracksPerClus/I");
     rootTree_->Branch("nClus", &nClus_, "nClus/I");
     rootTree_->Branch("xOfflineVertex", &xOfflineVertex_, "xOfflineVertex/D");
     rootTree_->Branch("yOfflineVertex", &yOfflineVertex_, "yOfflineVertex/D");
     rootTree_->Branch("zOfflineVertex", &zOfflineVertex_, "zOfflineVertex/D");
     rootTree_->Branch("BSx0", &BSx0_, "BSx0/D");
     rootTree_->Branch("BSy0", &BSy0_, "BSy0/D");
     rootTree_->Branch("BSz0", &BSz0_, "BSz0/D");
     rootTree_->Branch("Beamsigmaz", &Beamsigmaz_, "Beamsigmaz/D");
     rootTree_->Branch("Beamdxdz", &Beamdxdz_, "Beamdxdz/D");
     rootTree_->Branch("BeamWidthX", &BeamWidthX_, "BeamWidthX/D");
     rootTree_->Branch("BeamWidthY", &BeamWidthY_, "BeamWidthY/D");
     rootTree_->Branch("pt", &pt_, "pt[nTracks]/D");
     rootTree_->Branch("p", &p_, "p[nTracks]/D");
     rootTree_->Branch("nhits", &nhits_, "nhits[nTracks]/I");
     rootTree_->Branch("nhits1D", &nhits1D_, "nhits1D[nTracks]/I");
     rootTree_->Branch("nhits2D", &nhits2D_, "nhits2D[nTracks]/I");
     rootTree_->Branch("nhitsBPIX", &nhitsBPIX_, "nhitsBPIX[nTracks]/I");
     rootTree_->Branch("nhitsFPIX", &nhitsFPIX_, "nhitsFPIX[nTracks]/I");
     rootTree_->Branch("nhitsTIB", &nhitsTIB_, "nhitsTIB[nTracks]/I");
     rootTree_->Branch("nhitsTID", &nhitsTID_, "nhitsTID[nTracks]/I");
     rootTree_->Branch("nhitsTOB", &nhitsTOB_, "nhitsTOB[nTracks]/I");
     rootTree_->Branch("nhitsTEC", &nhitsTEC_, "nhitsTEC[nTracks]/I");
     rootTree_->Branch("eta", &eta_, "eta[nTracks]/D");
     rootTree_->Branch("theta", &theta_, "theta[nTracks]/D");
     rootTree_->Branch("phi", &phi_, "phi[nTracks]/D");
     rootTree_->Branch("chi2", &chi2_, "chi2[nTracks]/D");
     rootTree_->Branch("chi2ndof", &chi2ndof_, "chi2ndof[nTracks]/D");
     rootTree_->Branch("charge", &charge_, "charge[nTracks]/I");
     rootTree_->Branch("qoverp", &qoverp_, "qoverp[nTracks]/D");
     rootTree_->Branch("dz", &dz_, "dz[nTracks]/D");
     rootTree_->Branch("dxy", &dxy_, "dxy[nTracks]/D");
     rootTree_->Branch("dzBs", &dzBs_, "dzBs[nTracks]/D");
     rootTree_->Branch("dxyBs", &dxyBs_, "dxyBs[nTracks]/D");
     rootTree_->Branch("xPCA", &xPCA_, "xPCA[nTracks]/D");
     rootTree_->Branch("yPCA", &yPCA_, "yPCA[nTracks]/D");
     rootTree_->Branch("zPCA", &zPCA_, "zPCA[nTracks]/D");
     rootTree_->Branch("xUnbiasedVertex", &xUnbiasedVertex_, "xUnbiasedVertex[nTracks]/D");
     rootTree_->Branch("yUnbiasedVertex", &yUnbiasedVertex_, "yUnbiasedVertex[nTracks]/D");
     rootTree_->Branch("zUnbiasedVertex", &zUnbiasedVertex_, "zUnbiasedVertex[nTracks]/D");
     rootTree_->Branch("chi2normUnbiasedVertex", &chi2normUnbiasedVertex_, "chi2normUnbiasedVertex[nTracks]/F");
     rootTree_->Branch("chi2UnbiasedVertex", &chi2UnbiasedVertex_, "chi2UnbiasedVertex[nTracks]/F");
     rootTree_->Branch("DOFUnbiasedVertex", &DOFUnbiasedVertex_, " DOFUnbiasedVertex[nTracks]/F");
     rootTree_->Branch("chi2ProbUnbiasedVertex", &chi2ProbUnbiasedVertex_, "chi2ProbUnbiasedVertex[nTracks]/F");
     rootTree_->Branch(
         "sumOfWeightsUnbiasedVertex", &sumOfWeightsUnbiasedVertex_, "sumOfWeightsUnbiasedVertex[nTracks]/F");
     rootTree_->Branch("tracksUsedForVertexing", &tracksUsedForVertexing_, "tracksUsedForVertexing[nTracks]/I");
     rootTree_->Branch("dxyFromMyVertex", &dxyFromMyVertex_, "dxyFromMyVertex[nTracks]/D");
     rootTree_->Branch("dzFromMyVertex", &dzFromMyVertex_, "dzFromMyVertex[nTracks]/D");
     rootTree_->Branch("dxyErrorFromMyVertex", &dxyErrorFromMyVertex_, "dxyErrorFromMyVertex_[nTracks]/D");
     rootTree_->Branch("dzErrorFromMyVertex", &dzErrorFromMyVertex_, "dzErrorFromMyVertex_[nTracks]/D");
     rootTree_->Branch("IPTsigFromMyVertex", &IPTsigFromMyVertex_, "IPTsigFromMyVertex_[nTracks]/D");
     rootTree_->Branch("IPLsigFromMyVertex", &IPLsigFromMyVertex_, "IPLsigFromMyVertex_[nTracks]/D");
     rootTree_->Branch("hasRecVertex", &hasRecVertex_, "hasRecVertex[nTracks]/I");
     rootTree_->Branch("isGoodTrack", &isGoodTrack_, "isGoodTrack[nTracks]/I");
   }
 
   // event histograms
   TFileDirectory EventFeatures = fs->mkdir("EventFeatures");
 
   TH1F::SetDefaultSumw2(kTRUE);
 
   h_lumiFromConfig =
       EventFeatures.make<TH1F>("h_lumiFromConfig", "luminosity from config;;luminosity of present run", 1, -0.5, 0.5);
   h_lumiFromConfig->SetBinContent(1, intLumi_);
 
   h_runFromConfig = EventFeatures.make<TH1I>("h_runFromConfig",
                                              "run number from config;;run number (from configuration)",
                                              runControlNumbers_.size(),
                                              0.,
                                              runControlNumbers_.size());
 
   for (const auto& run : runControlNumbers_ | boost::adaptors::indexed(1)) {
     h_runFromConfig->SetBinContent(run.index(), run.value());
   }
 
   h_runFromEvent =
       EventFeatures.make<TH1I>("h_runFromEvent", "run number from event;;run number (from event)", 1, -0.5, 0.5);
   h_nTracks =
       EventFeatures.make<TH1F>("h_nTracks", "number of tracks per event;n_{tracks}/event;n_{events}", 300, -0.5, 299.5);
   h_nClus =
       EventFeatures.make<TH1F>("h_nClus", "number of track clusters;n_{clusters}/event;n_{events}", 50, -0.5, 49.5);
   h_nOfflineVertices = EventFeatures.make<TH1F>(
       "h_nOfflineVertices", "number of offline reconstructed vertices;n_{vertices}/event;n_{events}", 50, -0.5, 49.5);
   h_runNumber = EventFeatures.make<TH1F>("h_runNumber", "run number;run number;n_{events}", 100000, 250000., 350000.);
   h_xOfflineVertex = EventFeatures.make<TH1F>(
       "h_xOfflineVertex", "x-coordinate of offline vertex;x_{vertex};n_{events}", 100, -0.1, 0.1);
   h_yOfflineVertex = EventFeatures.make<TH1F>(
       "h_yOfflineVertex", "y-coordinate of offline vertex;y_{vertex};n_{events}", 100, -0.1, 0.1);
   h_zOfflineVertex = EventFeatures.make<TH1F>(
       "h_zOfflineVertex", "z-coordinate of offline vertex;z_{vertex};n_{events}", 100, -30., 30.);
   h_xErrOfflineVertex = EventFeatures.make<TH1F>(
       "h_xErrOfflineVertex", "x-coordinate error of offline vertex;err_{x}^{vtx};n_{events}", 100, 0., 0.01);
   h_yErrOfflineVertex = EventFeatures.make<TH1F>(
       "h_yErrOfflineVertex", "y-coordinate error of offline vertex;err_{y}^{vtx};n_{events}", 100, 0., 0.01);
   h_zErrOfflineVertex = EventFeatures.make<TH1F>(
       "h_zErrOfflineVertex", "z-coordinate error of offline vertex;err_{z}^{vtx};n_{events}", 100, 0., 10.);
   h_BSx0 = EventFeatures.make<TH1F>("h_BSx0", "x-coordinate of reco beamspot;x^{BS}_{0};n_{events}", 100, -0.1, 0.1);
   h_BSy0 = EventFeatures.make<TH1F>("h_BSy0", "y-coordinate of reco beamspot;y^{BS}_{0};n_{events}", 100, -0.1, 0.1);
   h_BSz0 = EventFeatures.make<TH1F>("h_BSz0", "z-coordinate of reco beamspot;z^{BS}_{0};n_{events}", 100, -1., 1.);
   h_Beamsigmaz =
       EventFeatures.make<TH1F>("h_Beamsigmaz", "z-coordinate beam width;#sigma_{Z}^{beam};n_{events}", 100, 0., 1.);
   h_BeamWidthX =
       EventFeatures.make<TH1F>("h_BeamWidthX", "x-coordinate beam width;#sigma_{X}^{beam};n_{events}", 100, 0., 0.01);
   h_BeamWidthY =
       EventFeatures.make<TH1F>("h_BeamWidthY", "y-coordinate beam width;#sigma_{Y}^{beam};n_{events}", 100, 0., 0.01);
 
   h_etaMax = EventFeatures.make<TH1F>("etaMax", "etaMax", 1, -0.5, 0.5);
   h_pTinfo = EventFeatures.make<TH1F>("pTinfo", "pTinfo", 3, -1.5, 1.5);
   h_pTinfo->GetXaxis()->SetBinLabel(1, "n. bins");
   h_pTinfo->GetXaxis()->SetBinLabel(2, "pT min");
   h_pTinfo->GetXaxis()->SetBinLabel(3, "pT max");
 
   h_nbins = EventFeatures.make<TH1F>("nbins", "nbins", 1, -0.5, 0.5);
   h_nLadders = EventFeatures.make<TH1F>("nladders", "n. ladders", 1, -0.5, 0.5);
   h_nModZ = EventFeatures.make<TH1F>("nModZ", "n. modules along z", 1, -0.5, 0.5);
 
   // probe track histograms
   TFileDirectory ProbeFeatures = fs->mkdir("ProbeTrackFeatures");
 
   h_probePt_ = ProbeFeatures.make<TH1F>("h_probePt", "p_{T} of probe track;track p_{T} (GeV); tracks", 100, 0., 50.);
   h_probePtRebin_ = ProbeFeatures.make<TH1F>(
       "h_probePtRebin", "p_{T} of probe track;track p_{T} (GeV); tracks", mypT_bins_.size() - 1, mypT_bins_.data());
   h_probeP_ = ProbeFeatures.make<TH1F>("h_probeP", "momentum of probe track;track p (GeV); tracks", 100, 0., 100.);
   h_probeEta_ = ProbeFeatures.make<TH1F>(
       "h_probeEta", "#eta of the probe track;track #eta;tracks", 54, -etaOfProbe_, etaOfProbe_);
   h_probePhi_ = ProbeFeatures.make<TH1F>("h_probePhi", "#phi of probe track;track #phi (rad);tracks", 100, -3.15, 3.15);
 
   h2_probeEtaPhi_ =
       ProbeFeatures.make<TH2F>("h2_probeEtaPhi",
                                "probe track #phi vs #eta;#eta of probe track;track #phi of probe track (rad); tracks",
                                54,
                                -etaOfProbe_,
                                etaOfProbe_,
                                100,
                                -M_PI,
                                M_PI);
   h2_probeEtaPt_ = ProbeFeatures.make<TH2F>("h2_probeEtaPt",
                                             "probe track p_{T} vs #eta;#eta of probe track;track p_{T} (GeV); tracks",
                                             54,
                                             -etaOfProbe_,
                                             etaOfProbe_,
                                             100,
                                             0.,
                                             50.);
 
   h_probeChi2_ =
       ProbeFeatures.make<TH1F>("h_probeChi2", "#chi^{2} of probe track;track #chi^{2}; tracks", 100, 0., 100.);
   h_probeNormChi2_ = ProbeFeatures.make<TH1F>(
       "h_probeNormChi2", " normalized #chi^{2} of probe track;track #chi^{2}/ndof; tracks", 100, 0., 10.);
   h_probeCharge_ =
       ProbeFeatures.make<TH1F>("h_probeCharge", "charge of probe track;track charge Q;tracks", 3, -1.5, 1.5);
   h_probeQoverP_ =
       ProbeFeatures.make<TH1F>("h_probeQoverP", "q/p of probe track; track Q/p (GeV^{-1});tracks", 200, -1., 1.);
   h_probedzRecoV_ = ProbeFeatures.make<TH1F>(
       "h_probedzRecoV", "d_{z}(V_{offline}) of probe track;track d_{z}(V_{off}) (cm);tracks", 200, -1., 1.);
   h_probedxyRecoV_ = ProbeFeatures.make<TH1F>(
       "h_probedxyRecoV", "d_{xy}(V_{offline}) of probe track;track d_{xy}(V_{off}) (cm);tracks", 200, -1., 1.);
   h_probedzRefitV_ = ProbeFeatures.make<TH1F>(
       "h_probedzRefitV", "d_{z}(V_{refit}) of probe track;track d_{z}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
   h_probesignIP2DRefitV_ = ProbeFeatures.make<TH1F>(
       "h_probesignIPRefitV", "ip_{2D}(V_{refit}) of probe track;track ip_{2D}(V_{fit}) (cm);tracks", 200, -1., 1.);
   h_probedxyRefitV_ = ProbeFeatures.make<TH1F>(
       "h_probedxyRefitV", "d_{xy}(V_{refit}) of probe track;track d_{xy}(V_{fit}) (cm);tracks", 200, -0.5, 0.5);
 
   h_probez0RefitV_ = ProbeFeatures.make<TH1F>(
       "h_probez0RefitV", "z_{0}(V_{refit}) of probe track;track z_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
   h_probed0RefitV_ = ProbeFeatures.make<TH1F>(
       "h_probed0RefitV", "d_{0}(V_{refit}) of probe track;track d_{0}(V_{fit}) (cm);tracks", 200, -1., 1.);
 
   h_probed3DRefitV_ = ProbeFeatures.make<TH1F>(
       "h_probed3DRefitV", "d_{3D}(V_{refit}) of probe track;track d_{3D}(V_{fit}) (cm);tracks", 200, 0., 1.);
   h_probereszRefitV_ = ProbeFeatures.make<TH1F>(
       "h_probeReszRefitV", "z_{track} -z_{V_{refit}};track res_{z}(V_{refit}) (cm);tracks", 200, -1., 1.);
 
   h_probeRecoVSigZ_ = ProbeFeatures.make<TH1F>(
       "h_probeRecoVSigZ", "Longitudinal DCA Significance (reco);d_{z}(V_{off})/#sigma_{dz};tracks", 100, -8, 8);
   h_probeRecoVSigXY_ = ProbeFeatures.make<TH1F>(
       "h_probeRecoVSigXY", "Transverse DCA Significance (reco);d_{xy}(V_{off})/#sigma_{dxy};tracks", 100, -8, 8);
   h_probeRefitVSigZ_ = ProbeFeatures.make<TH1F>(
       "h_probeRefitVSigZ", "Longitudinal DCA Significance (refit);d_{z}(V_{fit})/#sigma_{dz};tracks", 100, -8, 8);
   h_probeRefitVSigXY_ = ProbeFeatures.make<TH1F>(
       "h_probeRefitVSigXY", "Transverse DCA Significance (refit);d_{xy}(V_{fit})/#sigma_{dxy};tracks", 100, -8, 8);
   h_probeRefitVSig3D_ = ProbeFeatures.make<TH1F>(
       "h_probeRefitVSig3D", "3D DCA Significance (refit);d_{3D}/#sigma_{3D};tracks", 100, 0., 20.);
   h_probeRefitVLogSig3D_ =
       ProbeFeatures.make<TH1F>("h_probeRefitVLogSig3D",
                                "log_{10}(3D DCA-Significance) (refit);log_{10}(d_{3D}/#sigma_{3D});tracks",
                                100,
                                -5.,
                                4.);
   h_probeRefitVSigResZ_ = ProbeFeatures.make<TH1F>(
       "h_probeRefitVSigResZ",
       "Longitudinal residual significance (refit);(z_{track} -z_{V_{fit}})/#sigma_{res_{z}};tracks",
       100,
       -8,
       8);
 
   h_probeHits_ = ProbeFeatures.make<TH1F>("h_probeNRechits", "N_{hits}     ;N_{hits}    ;tracks", 40, -0.5, 39.5);
   h_probeHits1D_ = ProbeFeatures.make<TH1F>("h_probeNRechits1D", "N_{hits} 1D  ;N_{hits} 1D ;tracks", 40, -0.5, 39.5);
   h_probeHits2D_ = ProbeFeatures.make<TH1F>("h_probeNRechits2D", "N_{hits} 2D  ;N_{hits} 2D ;tracks", 40, -0.5, 39.5);
   h_probeHitsInTIB_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsTIB", "N_{hits} TIB ;N_{hits} TIB;tracks", 40, -0.5, 39.5);
   h_probeHitsInTOB_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsTOB", "N_{hits} TOB ;N_{hits} TOB;tracks", 40, -0.5, 39.5);
   h_probeHitsInTID_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsTID", "N_{hits} TID ;N_{hits} TID;tracks", 40, -0.5, 39.5);
   h_probeHitsInTEC_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsTEC", "N_{hits} TEC ;N_{hits} TEC;tracks", 40, -0.5, 39.5);
   h_probeHitsInBPIX_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsBPIX", "N_{hits} BPIX;N_{hits} BPIX;tracks", 40, -0.5, 39.5);
   h_probeHitsInFPIX_ =
       ProbeFeatures.make<TH1F>("h_probeNRechitsFPIX", "N_{hits} FPIX;N_{hits} FPIX;tracks", 40, -0.5, 39.5);
 
   h_probeL1Ladder_ = ProbeFeatures.make<TH1F>(
       "h_probeL1Ladder", "Ladder number (L1 hit); ladder number", nLadders_ + 2, -1.5, nLadders_ + 0.5);
   h_probeL1Module_ = ProbeFeatures.make<TH1F>(
       "h_probeL1Module", "Module number (L1 hit); module number", nModZ_ + 2, -1.5, nModZ_ + 0.5);
 
   h2_probeLayer1Map_ = ProbeFeatures.make<TH2F>("h2_probeLayer1Map",
                                                 "Position in Layer 1 of first hit;module number;ladder number",
                                                 nModZ_,
                                                 0.5,
                                                 nModZ_ + 0.5,
                                                 nLadders_,
                                                 0.5,
                                                 nLadders_ + 0.5);
 
   h2_probePassingLayer1Map_ = ProbeFeatures.make<TH2F>("h2_probePassingLayer1Map",
                                                        "Position in Layer 1 of first hit;module number;ladder number",
                                                        nModZ_,
                                                        0.5,
                                                        nModZ_ + 0.5,
                                                        nLadders_,
                                                        0.5,
                                                        nLadders_ + 0.5);
   h_probeHasBPixL1Overlap_ =
       ProbeFeatures.make<TH1I>("h_probeHasBPixL1Overlap", "n. hits in L1;n. L1-BPix hits;tracks", 5, -0.5, 4.5);
   h_probeL1ClusterProb_ = ProbeFeatures.make<TH1F>(
       "h_probeL1ClusterProb",
       "log_{10}(Cluster Probability) for Layer1 hits;log_{10}(cluster probability); n. Layer1 hits",
       100,
       -10.,
       0.);
 
   // refit vertex features
   TFileDirectory RefitVertexFeatures = fs->mkdir("RefitVertexFeatures");
   h_fitVtxNtracks_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxNtracks", "N_{trks} used in vertex fit;N^{fit}_{tracks};vertices", 100, -0.5, 99.5);
   h_fitVtxNdof_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxNdof", "N_{DOF} of vertex fit;N_{DOF} of refit vertex;vertices", 100, -0.5, 99.5);
   h_fitVtxChi2_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxChi2", "#chi^{2} of vertex fit;vertex #chi^{2};vertices", 100, -0.5, 99.5);
   h_fitVtxChi2ndf_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxChi2ndf", "#chi^{2}/ndf of vertex fit;vertex #chi^{2}/ndf;vertices", 100, -0.5, 9.5);
   h_fitVtxChi2Prob_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxChi2Prob", "Prob(#chi^{2},ndf) of vertex fit;Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
   h_fitVtxTrackWeights_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxTrackWeights", "track weights associated to track;track weights;tracks", 40, 0., 1.);
   h_fitVtxTrackAverageWeight_ = RefitVertexFeatures.make<TH1F>(
       "h_fitVtxTrackAverageWeight_", "average track weight per vertex;#LT track weight #GT;vertices", 40, 0., 1.);
 
   if (useTracksFromRecoVtx_) {
     TFileDirectory RecoVertexFeatures = fs->mkdir("RecoVertexFeatures");
     h_recoVtxNtracks_ =
         RecoVertexFeatures.make<TH1F>("h_recoVtxNtracks", "N^{vtx}_{trks};N^{vtx}_{trks};vertices", 100, -0.5, 99.5);
     h_recoVtxChi2ndf_ =
         RecoVertexFeatures.make<TH1F>("h_recoVtxChi2ndf", "#chi^{2}/ndf vtx;#chi^{2}/ndf vtx;vertices", 10, -0.5, 9.5);
     h_recoVtxChi2Prob_ = RecoVertexFeatures.make<TH1F>(
         "h_recoVtxChi2Prob", "Prob(#chi^{2},ndf);Prob(#chi^{2},ndf);vertices", 40, 0., 1.);
     h_recoVtxSumPt_ =
         RecoVertexFeatures.make<TH1F>("h_recoVtxSumPt", "Sum(p^{trks}_{T});Sum(p^{trks}_{T});vertices", 100, 0., 200.);
   }
 
   TFileDirectory DA = fs->mkdir("DA");
   //DA.cd();
   hDA = bookVertexHistograms(DA);
   //for(std::map<std::string,TH1*>::const_iterator hist=hDA.begin(); hist!=hDA.end(); hist++){
   //hist->second->SetDirectory(DA);
   // DA.make<TH1F>(hist->second);
   // }
 
   // initialize the residuals histograms
 
   const float dxymax_phi = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
   const float dzmax_phi = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
   const float dxymax_eta = theDetails_.getHigh(PVValHelper::dxy, PVValHelper::phi);
   const float dzmax_eta = theDetails_.getHigh(PVValHelper::dz, PVValHelper::eta);
   //const float d3Dmax_phi = theDetails_.getHigh(PVValHelper::d3D,PVValHelper::phi);
   const float d3Dmax_eta = theDetails_.getHigh(PVValHelper::d3D, PVValHelper::eta);
 
   //
   // Unbiased track-to-vertex residuals
   // The vertex is refit without the probe track
   //
 
   //    _   _            _      _         ___        _    _           _
   //   /_\ | |__ ___ ___| |_  _| |_ ___  | _ \___ __(_)__| |_  _ __ _| |___
   //  / _ \| '_ (_-</ _ \ | || |  _/ -_) |   / -_|_-< / _` | || / _` | (_-<
   // /_/ \_\_.__/__/\___/_|\_,_|\__\___| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
   //
 
   TFileDirectory AbsTransPhiRes = fs->mkdir("Abs_Transv_Phi_Residuals");
   a_dxyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
   a_dxPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dx, PVValHelper::phi);
   a_dyPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::dy, PVValHelper::phi);
   a_IP2DPhiResiduals = bookResidualsHistogram(AbsTransPhiRes, nBins_, PVValHelper::IP2D, PVValHelper::phi);
 
   TFileDirectory AbsTransEtaRes = fs->mkdir("Abs_Transv_Eta_Residuals");
   a_dxyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
   a_dxEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dx, PVValHelper::eta);
   a_dyEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::dy, PVValHelper::eta);
   a_IP2DEtaResiduals = bookResidualsHistogram(AbsTransEtaRes, nBins_, PVValHelper::IP2D, PVValHelper::eta);
 
   TFileDirectory AbsLongPhiRes = fs->mkdir("Abs_Long_Phi_Residuals");
   a_dzPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::dz, PVValHelper::phi);
   a_reszPhiResiduals = bookResidualsHistogram(AbsLongPhiRes, nBins_, PVValHelper::resz, PVValHelper::phi);
 
   TFileDirectory AbsLongEtaRes = fs->mkdir("Abs_Long_Eta_Residuals");
   a_dzEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::dz, PVValHelper::eta);
   a_reszEtaResiduals = bookResidualsHistogram(AbsLongEtaRes, nBins_, PVValHelper::resz, PVValHelper::eta);
 
   TFileDirectory Abs3DPhiRes = fs->mkdir("Abs_3D_Phi_Residuals");
   a_d3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::d3D, PVValHelper::phi);
   a_IP3DPhiResiduals = bookResidualsHistogram(Abs3DPhiRes, nBins_, PVValHelper::IP3D, PVValHelper::phi);
 
   TFileDirectory Abs3DEtaRes = fs->mkdir("Abs_3D_Eta_Residuals");
   a_d3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::d3D, PVValHelper::eta);
   a_IP3DEtaResiduals = bookResidualsHistogram(Abs3DEtaRes, nBins_, PVValHelper::IP3D, PVValHelper::eta);
 
   TFileDirectory NormTransPhiRes = fs->mkdir("Norm_Transv_Phi_Residuals");
   n_dxyPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_dxy, PVValHelper::phi, true);
   n_IP2DPhiResiduals = bookResidualsHistogram(NormTransPhiRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::phi, true);
 
   TFileDirectory NormTransEtaRes = fs->mkdir("Norm_Transv_Eta_Residuals");
   n_dxyEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_dxy, PVValHelper::eta, true);
   n_IP2DEtaResiduals = bookResidualsHistogram(NormTransEtaRes, nBins_, PVValHelper::norm_IP2D, PVValHelper::eta, true);
 
   TFileDirectory NormLongPhiRes = fs->mkdir("Norm_Long_Phi_Residuals");
   n_dzPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_dz, PVValHelper::phi, true);
   n_reszPhiResiduals = bookResidualsHistogram(NormLongPhiRes, nBins_, PVValHelper::norm_resz, PVValHelper::phi, true);
 
   TFileDirectory NormLongEtaRes = fs->mkdir("Norm_Long_Eta_Residuals");
   n_dzEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_dz, PVValHelper::eta, true);
   n_reszEtaResiduals = bookResidualsHistogram(NormLongEtaRes, nBins_, PVValHelper::norm_resz, PVValHelper::eta, true);
 
   TFileDirectory Norm3DPhiRes = fs->mkdir("Norm_3D_Phi_Residuals");
   n_d3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_d3D, PVValHelper::phi, true);
   n_IP3DPhiResiduals = bookResidualsHistogram(Norm3DPhiRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::phi, true);
 
   TFileDirectory Norm3DEtaRes = fs->mkdir("Norm_3D_Eta_Residuals");
   n_d3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_d3D, PVValHelper::eta, true);
   n_IP3DEtaResiduals = bookResidualsHistogram(Norm3DEtaRes, nBins_, PVValHelper::norm_IP3D, PVValHelper::eta, true);
 
   TFileDirectory AbsDoubleDiffRes = fs->mkdir("Abs_DoubleDiffResiduals");
   TFileDirectory NormDoubleDiffRes = fs->mkdir("Norm_DoubleDiffResiduals");
 
   TFileDirectory AbsL1Map = fs->mkdir("Abs_L1Residuals");
   TFileDirectory NormL1Map = fs->mkdir("Norm_L1Residuals");
 
   // book residuals vs pT histograms
 
   TFileDirectory AbsTranspTRes = fs->mkdir("Abs_Transv_pT_Residuals");
   h_dxy_pT_ = bookResidualsHistogram(AbsTranspTRes, nPtBins_, PVValHelper::dxy, PVValHelper::pT);
 
   TFileDirectory AbsLongpTRes = fs->mkdir("Abs_Long_pT_Residuals");
   h_dz_pT_ = bookResidualsHistogram(AbsLongpTRes, nPtBins_, PVValHelper::dz, PVValHelper::pT);
 
   TFileDirectory NormTranspTRes = fs->mkdir("Norm_Transv_pT_Residuals");
   h_norm_dxy_pT_ = bookResidualsHistogram(NormTranspTRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pT, true);
 
   TFileDirectory NormLongpTRes = fs->mkdir("Norm_Long_pT_Residuals");
   h_norm_dz_pT_ = bookResidualsHistogram(NormLongpTRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pT, true);
 
   // book residuals vs pT histograms in central region (|eta|<1.0)
 
   TFileDirectory AbsTranspTCentralRes = fs->mkdir("Abs_Transv_pTCentral_Residuals");
   h_dxy_Central_pT_ = bookResidualsHistogram(AbsTranspTCentralRes, nPtBins_, PVValHelper::dxy, PVValHelper::pTCentral);
 
   TFileDirectory AbsLongpTCentralRes = fs->mkdir("Abs_Long_pTCentral_Residuals");
   h_dz_Central_pT_ = bookResidualsHistogram(AbsLongpTCentralRes, nPtBins_, PVValHelper::dz, PVValHelper::pTCentral);
 
   TFileDirectory NormTranspTCentralRes = fs->mkdir("Norm_Transv_pTCentral_Residuals");
   h_norm_dxy_Central_pT_ =
       bookResidualsHistogram(NormTranspTCentralRes, nPtBins_, PVValHelper::norm_dxy, PVValHelper::pTCentral, true);
 
   TFileDirectory NormLongpTCentralRes = fs->mkdir("Norm_Long_pTCentral_Residuals");
   h_norm_dz_Central_pT_ =
       bookResidualsHistogram(NormLongpTCentralRes, nPtBins_, PVValHelper::norm_dz, PVValHelper::pTCentral, true);
 
   // book residuals vs module number
 
   TFileDirectory AbsTransModZRes = fs->mkdir("Abs_Transv_modZ_Residuals");
   h_dxy_modZ_ = bookResidualsHistogram(AbsTransModZRes, nModZ_, PVValHelper::dxy, PVValHelper::modZ);
 
   TFileDirectory AbsLongModZRes = fs->mkdir("Abs_Long_modZ_Residuals");
   h_dz_modZ_ = bookResidualsHistogram(AbsLongModZRes, nModZ_, PVValHelper::dz, PVValHelper::modZ);
 
   //  _  _                    _ _           _   ___        _    _           _
   // | \| |___ _ _ _ __  __ _| (_)______ __| | | _ \___ __(_)__| |_  _ __ _| |___
   // | .` / _ \ '_| '  \/ _` | | |_ / -_) _` | |   / -_|_-< / _` | || / _` | (_-<
   // |_|\_\___/_| |_|_|_\__,_|_|_/__\___\__,_| |_|_\___/__/_\__,_|\_,_\__,_|_/__/
   //
 
   TFileDirectory NormTransModZRes = fs->mkdir("Norm_Transv_modZ_Residuals");
   h_norm_dxy_modZ_ = bookResidualsHistogram(NormTransModZRes, nModZ_, PVValHelper::norm_dxy, PVValHelper::modZ, true);
 
   TFileDirectory NormLongModZRes = fs->mkdir("Norm_Long_modZ_Residuals");
   h_norm_dz_modZ_ = bookResidualsHistogram(NormLongModZRes, nModZ_, PVValHelper::norm_dz, PVValHelper::modZ, true);
 
   TFileDirectory AbsTransLadderRes = fs->mkdir("Abs_Transv_ladder_Residuals");
   h_dxy_ladder_ = bookResidualsHistogram(AbsTransLadderRes, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
 
   TFileDirectory AbsTransLadderResOverlap = fs->mkdir("Abs_Transv_ladderOverlap_Residuals");
   h_dxy_ladderOverlap_ =
       bookResidualsHistogram(AbsTransLadderResOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
 
   TFileDirectory AbsTransLadderResNoOverlap = fs->mkdir("Abs_Transv_ladderNoOverlap_Residuals");
   h_dxy_ladderNoOverlap_ =
       bookResidualsHistogram(AbsTransLadderResNoOverlap, nLadders_, PVValHelper::dxy, PVValHelper::ladder);
 
   TFileDirectory AbsLongLadderRes = fs->mkdir("Abs_Long_ladder_Residuals");
   h_dz_ladder_ = bookResidualsHistogram(AbsLongLadderRes, nLadders_, PVValHelper::dz, PVValHelper::ladder);
 
   TFileDirectory NormTransLadderRes = fs->mkdir("Norm_Transv_ladder_Residuals");
   h_norm_dxy_ladder_ =
       bookResidualsHistogram(NormTransLadderRes, nLadders_, PVValHelper::norm_dxy, PVValHelper::ladder, true);
 
   TFileDirectory NormLongLadderRes = fs->mkdir("Norm_Long_ladder_Residuals");
   h_norm_dz_ladder_ =
       bookResidualsHistogram(NormLongLadderRes, nLadders_, PVValHelper::norm_dz, PVValHelper::ladder, true);
 
   // book residuals as function of nLadders and nModules
 
   for (unsigned int iLadder = 0; iLadder < nLadders_; iLadder++) {
     for (unsigned int iModule = 0; iModule < nModZ_; iModule++) {
       a_dxyL1ResidualsMap[iLadder][iModule] =
           AbsL1Map.make<TH1F>(Form("histo_dxy_ladder%i_module%i", iLadder, iModule),
                               Form("d_{xy} ladder=%i module=%i;d_{xy} [#mum];tracks", iLadder, iModule),
                               theDetails_.histobins,
                               -dzmax_eta,
                               dzmax_eta);
 
       a_dzL1ResidualsMap[iLadder][iModule] =
           AbsL1Map.make<TH1F>(Form("histo_dz_ladder%i_module%i", iLadder, iModule),
                               Form("d_{z} ladder=%i module=%i;d_{z} [#mum];tracks", iLadder, iModule),
                               theDetails_.histobins,
                               -dzmax_eta,
                               dzmax_eta);
 
       n_dxyL1ResidualsMap[iLadder][iModule] =
           NormL1Map.make<TH1F>(Form("histo_norm_dxy_ladder%i_module%i", iLadder, iModule),
                                Form("d_{xy} ladder=%i module=%i;d_{xy}/#sigma_{d_{xy}};tracks", iLadder, iModule),
                                theDetails_.histobins,
                                -dzmax_eta / 100,
                                dzmax_eta / 100);
 
       n_dzL1ResidualsMap[iLadder][iModule] =
           NormL1Map.make<TH1F>(Form("histo_norm_dz_ladder%i_module%i", iLadder, iModule),
                                Form("d_{z} ladder=%i module=%i;d_{z}/#sigma_{d_{z}};tracks", iLadder, iModule),
                                theDetails_.histobins,
                                -dzmax_eta / 100,
                                dzmax_eta / 100);
     }
   }
 
   // book residuals as function of phi and eta
 
   for (int i = 0; i < nBins_; ++i) {
     float phiF = theDetails_.trendbins[PVValHelper::phi][i];
     float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
 
     //  ___           _    _     ___  _  __  __   ___        _    _           _
     // |   \ ___ _  _| |__| |___|   \(_)/ _|/ _| | _ \___ __(_)__| |_  _ __ _| |___
     // | |) / _ \ || | '_ \ / -_) |) | |  _|  _| |   / -_|_-< / _` | || / _` | (_-<
     // |___/\___/\_,_|_.__/_\___|___/|_|_| |_|   |_|_\___/__/_\__,_|\_,_\__,_|_/__/
 
     for (int j = 0; j < nBins_; ++j) {
       float etaF = theDetails_.trendbins[PVValHelper::eta][j];
       float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
 
       a_dxyResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
           Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy};tracks", etaF, etaL, phiF, phiL),
           theDetails_.histobins,
           -dzmax_eta,
           dzmax_eta);
 
       a_dzResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
           Form("histo_dz_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z};tracks", etaF, etaL, phiF, phiL),
           theDetails_.histobins,
           -dzmax_eta,
           dzmax_eta);
 
       a_d3DResidualsMap[i][j] = AbsDoubleDiffRes.make<TH1F>(
           Form("histo_d3D_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D};tracks", etaF, etaL, phiF, phiL),
           theDetails_.histobins,
           0.,
           d3Dmax_eta);
 
       n_dxyResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
           Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
                etaF,
                etaL,
                phiF,
                phiL),
           theDetails_.histobins,
           -dzmax_eta / 100,
           dzmax_eta / 100);
 
       n_dzResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
           Form("histo_norm_dz_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
                etaF,
                etaL,
                phiF,
                phiL),
           theDetails_.histobins,
           -dzmax_eta / 100,
           dzmax_eta / 100);
 
       n_d3DResidualsMap[i][j] = NormDoubleDiffRes.make<TH1F>(
           Form("histo_norm_d3D_eta_plot%i_phi_plot%i", i, j),
           Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{3D}/#sigma_{d_{3D}};tracks",
                etaF,
                etaL,
                phiF,
                phiL),
           theDetails_.histobins,
           0.,
           d3Dmax_eta);
     }
   }
 
   // declaration of the directories
 
   TFileDirectory BiasVsParameter = fs->mkdir("BiasVsParameter");
 
   a_dxyVsPhi = BiasVsParameter.make<TH2F>("h2_dxy_vs_phi",
                                           "d_{xy} vs track #phi;track #phi [rad];track d_{xy}(PV) [#mum]",
                                           nBins_,
                                           -M_PI,
                                           M_PI,
                                           theDetails_.histobins,
                                           -dxymax_phi,
                                           dxymax_phi);
 
   a_dzVsPhi = BiasVsParameter.make<TH2F>("h2_dz_vs_phi",
                                          "d_{z} vs track #phi;track #phi [rad];track d_{z}(PV) [#mum]",
                                          nBins_,
                                          -M_PI,
                                          M_PI,
                                          theDetails_.histobins,
                                          -dzmax_phi,
                                          dzmax_phi);
 
   n_dxyVsPhi = BiasVsParameter.make<TH2F>(
       "h2_n_dxy_vs_phi",
       "d_{xy}/#sigma_{d_{xy}} vs track #phi;track #phi [rad];track d_{xy}(PV)/#sigma_{d_{xy}}",
       nBins_,
       -M_PI,
       M_PI,
       theDetails_.histobins,
       -dxymax_phi / 100.,
       dxymax_phi / 100.);
 
   n_dzVsPhi =
       BiasVsParameter.make<TH2F>("h2_n_dz_vs_phi",
                                  "d_{z}/#sigma_{d_{z}} vs track #phi;track #phi [rad];track d_{z}(PV)/#sigma_{d_{z}}",
                                  nBins_,
                                  -M_PI,
                                  M_PI,
                                  theDetails_.histobins,
                                  -dzmax_phi / 100.,
                                  dzmax_phi / 100.);
 
   a_dxyVsEta = BiasVsParameter.make<TH2F>("h2_dxy_vs_eta",
                                           "d_{xy} vs track #eta;track #eta;track d_{xy}(PV) [#mum]",
                                           nBins_,
                                           -etaOfProbe_,
                                           etaOfProbe_,
                                           theDetails_.histobins,
                                           -dxymax_eta,
                                           dzmax_eta);
 
   a_dzVsEta = BiasVsParameter.make<TH2F>("h2_dz_vs_eta",
                                          "d_{z} vs track #eta;track #eta;track d_{z}(PV) [#mum]",
                                          nBins_,
                                          -etaOfProbe_,
                                          etaOfProbe_,
                                          theDetails_.histobins,
                                          -dzmax_eta,
                                          dzmax_eta);
 
   n_dxyVsEta =
       BiasVsParameter.make<TH2F>("h2_n_dxy_vs_eta",
                                  "d_{xy}/#sigma_{d_{xy}} vs track #eta;track #eta;track d_{xy}(PV)/#sigma_{d_{xy}}",
                                  nBins_,
                                  -etaOfProbe_,
                                  etaOfProbe_,
                                  theDetails_.histobins,
                                  -dxymax_eta / 100.,
                                  dxymax_eta / 100.);
 
   n_dzVsEta = BiasVsParameter.make<TH2F>("h2_n_dz_vs_eta",
                                          "d_{z}/#sigma_{d_{z}} vs track #eta;track #eta;track d_{z}(PV)/#sigma_{d_{z}}",
                                          nBins_,
                                          -etaOfProbe_,
                                          etaOfProbe_,
                                          theDetails_.histobins,
                                          -dzmax_eta / 100.,
                                          dzmax_eta / 100.);
 
   MeanTrendsDir = fs->mkdir("MeanTrends");
   WidthTrendsDir = fs->mkdir("WidthTrends");
   MedianTrendsDir = fs->mkdir("MedianTrends");
   MADTrendsDir = fs->mkdir("MADTrends");
 
   Mean2DMapsDir = fs->mkdir("MeanMaps");
   Width2DMapsDir = fs->mkdir("WidthMaps");
 
   double highedge = nBins_ - 0.5;
   double lowedge = -0.5;
 
   // means and widths from the fit
 
   a_dxyPhiMeanTrend =
       MeanTrendsDir.make<TH1F>("means_dxy_phi",
                                "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
                                nBins_,
                                lowedge,
                                highedge);
 
   a_dxyPhiWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dxy_phi",
                                 "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
                                 nBins_,
                                 lowedge,
                                 highedge);
 
   a_dzPhiMeanTrend =
       MeanTrendsDir.make<TH1F>("means_dz_phi",
                                "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
                                nBins_,
                                lowedge,
                                highedge);
 
   a_dzPhiWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dz_phi",
                                 "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
                                 nBins_,
                                 lowedge,
                                 highedge);
 
   a_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
 
   a_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_eta",
                                                  "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
                                                  nBins_,
                                                  lowedge,
                                                  highedge);
 
   a_dzEtaMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
 
   a_dzEtaWidthTrend = WidthTrendsDir.make<TH1F>(
       "widths_dz_eta", "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]", nBins_, lowedge, highedge);
 
   n_dxyPhiMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dxy_phi",
       "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
       nBins_,
       lowedge,
       highedge);
 
   n_dxyPhiWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dxy_phi",
       "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dzPhiMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dz_phi",
       "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
       nBins_,
       lowedge,
       highedge);
 
   n_dzPhiWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dz_phi",
       "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dxyEtaMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dxy_eta",
       "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
       nBins_,
       lowedge,
       highedge);
 
   n_dxyEtaWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dxy_eta",
       "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dzEtaMeanTrend =
       MeanTrendsDir.make<TH1F>("norm_means_dz_eta",
                                "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
                                nBins_,
                                lowedge,
                                highedge);
 
   n_dzEtaWidthTrend =
       WidthTrendsDir.make<TH1F>("norm_widths_dz_eta",
                                 "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
                                 nBins_,
                                 lowedge,
                                 highedge);
 
   // means and widhts vs pT and pTCentral
 
   a_dxypTMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_pT",
                                               "#LT d_{xy} #GT vs pT;p_{T} [GeV];#LT d_{xy} #GT [#mum]",
                                               mypT_bins_.size() - 1,
                                               mypT_bins_.data());
 
   a_dxypTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dxy_pT",
                                                 "#sigma_{d_{xy}} vs pT;p_{T} [GeV];#sigma_{d_{xy}} [#mum]",
                                                 mypT_bins_.size() - 1,
                                                 mypT_bins_.data());
 
   a_dzpTMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dz_pT", "#LT d_{z} #GT vs pT;p_{T} [GeV];#LT d_{z} #GT [#mum]", mypT_bins_.size() - 1, mypT_bins_.data());
 
   a_dzpTWidthTrend = WidthTrendsDir.make<TH1F>("widths_dz_pT",
                                                "#sigma_{d_{z}} vs pT;p_{T} [GeV];#sigma_{d_{z}} [#mum]",
                                                mypT_bins_.size() - 1,
                                                mypT_bins_.data());
 
   n_dxypTMeanTrend =
       MeanTrendsDir.make<TH1F>("norm_means_dxy_pT",
                                "#LT d_{xy}/#sigma_{d_{xy}} #GT vs pT;p_{T} [GeV];#LT d_{xy}/#sigma_{d_{xy}} #GT",
                                mypT_bins_.size() - 1,
                                mypT_bins_.data());
 
   n_dxypTWidthTrend =
       WidthTrendsDir.make<TH1F>("norm_widths_dxy_pT",
                                 "width(d_{xy}/#sigma_{d_{xy}}) vs pT;p_{T} [GeV]; width(d_{xy}/#sigma_{d_{xy}})",
                                 mypT_bins_.size() - 1,
                                 mypT_bins_.data());
 
   n_dzpTMeanTrend =
       MeanTrendsDir.make<TH1F>("norm_means_dz_pT",
                                "#LT d_{z}/#sigma_{d_{z}} #GT vs pT;p_{T} [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
                                mypT_bins_.size() - 1,
                                mypT_bins_.data());
 
   n_dzpTWidthTrend =
       WidthTrendsDir.make<TH1F>("norm_widths_dz_pT",
                                 "width(d_{z}/#sigma_{d_{z}}) vs pT;p_{T} [GeV];width(d_{z}/#sigma_{d_{z}})",
                                 mypT_bins_.size() - 1,
                                 mypT_bins_.data());
 
   a_dxypTCentralMeanTrend =
       MeanTrendsDir.make<TH1F>("means_dxy_pTCentral",
                                "#LT d_{xy} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy} #GT [#mum]",
                                mypT_bins_.size() - 1,
                                mypT_bins_.data());
 
   a_dxypTCentralWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dxy_pTCentral",
                                 "#sigma_{d_{xy}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{xy}} [#mum]",
                                 mypT_bins_.size() - 1,
                                 mypT_bins_.data());
 
   a_dzpTCentralMeanTrend =
       MeanTrendsDir.make<TH1F>("means_dz_pTCentral",
                                "#LT d_{z} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z} #GT [#mum]",
                                mypT_bins_.size() - 1,
                                mypT_bins_.data());
 
   a_dzpTCentralWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dz_pTCentral",
                                 "#sigma_{d_{z}} vs p_{T};p_{T}(|#eta|<1.) [GeV];#sigma_{d_{z}} [#mum]",
                                 mypT_bins_.size() - 1,
                                 mypT_bins_.data());
 
   n_dxypTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dxy_pTCentral",
       "#LT d_{xy}/#sigma_{d_{xy}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{xy}/#sigma_{d_{z}} #GT",
       mypT_bins_.size() - 1,
       mypT_bins_.data());
 
   n_dxypTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dxy_pTCentral",
       "width(d_{xy}/#sigma_{d_{xy}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{xy}/#sigma_{d_{z}})",
       mypT_bins_.size() - 1,
       mypT_bins_.data());
 
   n_dzpTCentralMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dz_pTCentral",
       "#LT d_{z}/#sigma_{d_{z}} #GT vs p_{T};p_{T}(|#eta|<1.) [GeV];#LT d_{z}/#sigma_{d_{z}} #GT",
       mypT_bins_.size() - 1,
       mypT_bins_.data());
 
   n_dzpTCentralWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dz_pTCentral",
       "width(d_{z}/#sigma_{d_{z}}) vs p_{T};p_{T}(|#eta|<1.) [GeV];width(d_{z}/#sigma_{d_{z}})",
       mypT_bins_.size() - 1,
       mypT_bins_.data());
 
   // 2D maps
 
   a_dxyMeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_map",
                                           "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                           nBins_,
                                           lowedge,
                                           highedge,
                                           nBins_,
                                           lowedge,
                                           highedge);
 
   a_dzMeanMap = Mean2DMapsDir.make<TH2F>("means_dz_map",
                                          "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                          nBins_,
                                          lowedge,
                                          highedge,
                                          nBins_,
                                          lowedge,
                                          highedge);
 
   n_dxyMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dxy_map",
                                           "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                           nBins_,
                                           lowedge,
                                           highedge,
                                           nBins_,
                                           lowedge,
                                           highedge);
 
   n_dzMeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_map",
                                          "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                          nBins_,
                                          lowedge,
                                          highedge,
                                          nBins_,
                                          lowedge,
                                          highedge);
 
   a_dxyWidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_map",
                                             "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
                                             nBins_,
                                             lowedge,
                                             highedge,
                                             nBins_,
                                             lowedge,
                                             highedge);
 
   a_dzWidthMap = Width2DMapsDir.make<TH2F>("widths_dz_map",
                                            "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
                                            nBins_,
                                            lowedge,
                                            highedge,
                                            nBins_,
                                            lowedge,
                                            highedge);
 
   n_dxyWidthMap =
       Width2DMapsDir.make<TH2F>("norm_widths_dxy_map",
                                 "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
                                 nBins_,
                                 lowedge,
                                 highedge,
                                 nBins_,
                                 lowedge,
                                 highedge);
 
   n_dzWidthMap = Width2DMapsDir.make<TH2F>("norm_widths_dz_map",
                                            "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
                                            nBins_,
                                            lowedge,
                                            highedge,
                                            nBins_,
                                            lowedge,
                                            highedge);
 
   // medians and MADs
 
   a_dxyPhiMedianTrend =
       MedianTrendsDir.make<TH1F>("medians_dxy_phi",
                                  "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
                                  nBins_,
                                  lowedge,
                                  highedge);
 
   a_dxyPhiMADTrend = MADTrendsDir.make<TH1F>(
       "MADs_dxy_phi",
       "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
       nBins_,
       lowedge,
       highedge);
 
   a_dzPhiMedianTrend =
       MedianTrendsDir.make<TH1F>("medians_dz_phi",
                                  "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
                                  nBins_,
                                  lowedge,
                                  highedge);
 
   a_dzPhiMADTrend = MADTrendsDir.make<TH1F>(
       "MADs_dz_phi",
       "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
       nBins_,
       lowedge,
       highedge);
 
   a_dxyEtaMedianTrend =
       MedianTrendsDir.make<TH1F>("medians_dxy_eta",
                                  "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
                                  nBins_,
                                  lowedge,
                                  highedge);
 
   a_dxyEtaMADTrend =
       MADTrendsDir.make<TH1F>("MADs_dxy_eta",
                               "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
                               nBins_,
                               lowedge,
                               highedge);
 
   a_dzEtaMedianTrend =
       MedianTrendsDir.make<TH1F>("medians_dz_eta",
                                  "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
                                  nBins_,
                                  lowedge,
                                  highedge);
 
   a_dzEtaMADTrend =
       MADTrendsDir.make<TH1F>("MADs_dz_eta",
                               "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
                               nBins_,
                               lowedge,
                               highedge);
 
   n_dxyPhiMedianTrend = MedianTrendsDir.make<TH1F>(
       "norm_medians_dxy_phi",
       "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dxyPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
                                              "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
                                              "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
                                              nBins_,
                                              lowedge,
                                              highedge);
 
   n_dzPhiMedianTrend = MedianTrendsDir.make<TH1F>(
       "norm_medians_dz_phi",
       "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dzPhiMADTrend = MADTrendsDir.make<TH1F>("norm_MADs_dz_phi",
                                             "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi "
                                             "(sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
                                             nBins_,
                                             lowedge,
                                             highedge);
 
   n_dxyEtaMedianTrend = MedianTrendsDir.make<TH1F>(
       "norm_medians_dxy_eta",
       "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dxyEtaMADTrend = MADTrendsDir.make<TH1F>(
       "norm_MADs_dxy_eta",
       "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dzEtaMedianTrend = MedianTrendsDir.make<TH1F>(
       "norm_medians_dz_eta",
       "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   n_dzEtaMADTrend = MADTrendsDir.make<TH1F>(
       "norm_MADs_dz_eta",
       "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
       nBins_,
       lowedge,
       highedge);
 
   //
   // plots of biased residuals
   // The vertex includes the probe track
   //
 
   if (useTracksFromRecoVtx_) {
     TFileDirectory AbsTransPhiBiasRes = fs->mkdir("Abs_Transv_Phi_BiasResiduals");
     a_dxyPhiBiasResiduals = bookResidualsHistogram(AbsTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
 
     TFileDirectory AbsTransEtaBiasRes = fs->mkdir("Abs_Transv_Eta_BiasResiduals");
     a_dxyEtaBiasResiduals = bookResidualsHistogram(AbsTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
 
     TFileDirectory AbsLongPhiBiasRes = fs->mkdir("Abs_Long_Phi_BiasResiduals");
     a_dzPhiBiasResiduals = bookResidualsHistogram(AbsLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
 
     TFileDirectory AbsLongEtaBiasRes = fs->mkdir("Abs_Long_Eta_BiasResiduals");
     a_dzEtaBiasResiduals = bookResidualsHistogram(AbsLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
 
     TFileDirectory NormTransPhiBiasRes = fs->mkdir("Norm_Transv_Phi_BiasResiduals");
     n_dxyPhiBiasResiduals = bookResidualsHistogram(NormTransPhiBiasRes, nBins_, PVValHelper::dxy, PVValHelper::phi);
 
     TFileDirectory NormTransEtaBiasRes = fs->mkdir("Norm_Transv_Eta_BiasResiduals");
     n_dxyEtaBiasResiduals = bookResidualsHistogram(NormTransEtaBiasRes, nBins_, PVValHelper::dxy, PVValHelper::eta);
 
     TFileDirectory NormLongPhiBiasRes = fs->mkdir("Norm_Long_Phi_BiasResiduals");
     n_dzPhiBiasResiduals = bookResidualsHistogram(NormLongPhiBiasRes, nBins_, PVValHelper::dz, PVValHelper::phi);
 
     TFileDirectory NormLongEtaBiasRes = fs->mkdir("Norm_Long_Eta_BiasResiduals");
     n_dzEtaBiasResiduals = bookResidualsHistogram(NormLongEtaBiasRes, nBins_, PVValHelper::dz, PVValHelper::eta);
 
     TFileDirectory AbsDoubleDiffBiasRes = fs->mkdir("Abs_DoubleDiffBiasResiduals");
     TFileDirectory NormDoubleDiffBiasRes = fs->mkdir("Norm_DoubleDiffBiasResiduals");
 
     for (int i = 0; i < nBins_; ++i) {
       float phiF = theDetails_.trendbins[PVValHelper::phi][i];
       float phiL = theDetails_.trendbins[PVValHelper::phi][i + 1];
 
       for (int j = 0; j < nBins_; ++j) {
         float etaF = theDetails_.trendbins[PVValHelper::eta][j];
         float etaL = theDetails_.trendbins[PVValHelper::eta][j + 1];
 
         a_dxyBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
             Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
             Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy} [#mum];tracks", etaF, etaL, phiF, phiL),
             theDetails_.histobins,
             -dzmax_eta,
             dzmax_eta);
 
         a_dzBiasResidualsMap[i][j] = AbsDoubleDiffBiasRes.make<TH1F>(
             Form("histo_dxy_eta_plot%i_phi_plot%i", i, j),
             Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z} [#mum];tracks", etaF, etaL, phiF, phiL),
             theDetails_.histobins,
             -dzmax_eta,
             dzmax_eta);
 
         n_dxyBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
             Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
             Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{xy}/#sigma_{d_{xy}};tracks",
                  etaF,
                  etaL,
                  phiF,
                  phiL),
             theDetails_.histobins,
             -dzmax_eta / 100,
             dzmax_eta / 100);
 
         n_dzBiasResidualsMap[i][j] = NormDoubleDiffBiasRes.make<TH1F>(
             Form("histo_norm_dxy_eta_plot%i_phi_plot%i", i, j),
             Form("%.2f<#eta_{tk}<%.2f %.2f#circ<#varphi_{tk}<%.2f#circ;d_{z}/#sigma_{d_{z}};tracks",
                  etaF,
                  etaL,
                  phiF,
                  phiL),
             theDetails_.histobins,
             -dzmax_eta / 100,
             dzmax_eta / 100);
       }
     }
 
     // declaration of the directories
 
     TFileDirectory MeanBiasTrendsDir = fs->mkdir("MeanBiasTrends");
     TFileDirectory WidthBiasTrendsDir = fs->mkdir("WidthBiasTrends");
     TFileDirectory MedianBiasTrendsDir = fs->mkdir("MedianBiasTrends");
     TFileDirectory MADBiasTrendsDir = fs->mkdir("MADBiasTrends");
 
     TFileDirectory Mean2DBiasMapsDir = fs->mkdir("MeanBiasMaps");
     TFileDirectory Width2DBiasMapsDir = fs->mkdir("WidthBiasMaps");
 
     // means and widths from the fit
 
     a_dxyPhiMeanBiasTrend =
         MeanBiasTrendsDir.make<TH1F>("means_dxy_phi",
                                      "#LT d_{xy} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy} #GT [#mum]",
                                      nBins_,
                                      lowedge,
                                      highedge);
 
     a_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
         "widths_dxy_phi",
         "#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{xy}} [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dzPhiMeanBiasTrend =
         MeanBiasTrendsDir.make<TH1F>("means_dz_phi",
                                      "#LT d_{z} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z} #GT [#mum]",
                                      nBins_,
                                      lowedge,
                                      highedge);
 
     a_dzPhiWidthBiasTrend =
         WidthBiasTrendsDir.make<TH1F>("widths_dz_phi",
                                       "#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#sigma_{d_{z}} [#mum]",
                                       nBins_,
                                       lowedge,
                                       highedge);
 
     a_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "means_dxy_eta", "#LT d_{xy} #GT vs #eta sector;#eta (sector);#LT d_{xy} #GT [#mum]", nBins_, lowedge, highedge);
 
     a_dxyEtaWidthBiasTrend =
         WidthBiasTrendsDir.make<TH1F>("widths_dxy_eta",
                                       "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{xy}} [#mum]",
                                       nBins_,
                                       lowedge,
                                       highedge);
 
     a_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "means_dz_eta", "#LT d_{z} #GT vs #eta sector;#eta (sector);#LT d_{z} #GT [#mum]", nBins_, lowedge, highedge);
 
     a_dzEtaWidthBiasTrend =
         WidthBiasTrendsDir.make<TH1F>("widths_dz_eta",
                                       "#sigma_{d_{xy}} vs #eta sector;#eta (sector);#sigma_{d_{z}} [#mum]",
                                       nBins_,
                                       lowedge,
                                       highedge);
 
     n_dxyPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "norm_means_dxy_phi",
         "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{xy}/#sigma_{d_{xy}} #GT",
         nBins_,
         lowedge,
         highedge);
 
     n_dxyPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
         "norm_widths_dxy_phi",
         "width(d_{xy}/#sigma_{d_{xy}}) vs #phi sector;#varphi (sector) [degrees]; width(d_{xy}/#sigma_{d_{xy}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dzPhiMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "norm_means_dz_phi",
         "#LT d_{z}/#sigma_{d_{z}} #GT vs #phi sector;#varphi (sector) [degrees];#LT d_{z}/#sigma_{d_{z}} #GT",
         nBins_,
         lowedge,
         highedge);
 
     n_dzPhiWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
         "norm_widths_dz_phi",
         "width(d_{z}/#sigma_{d_{z}}) vs #phi sector;#varphi (sector) [degrees];width(d_{z}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dxyEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "norm_means_dxy_eta",
         "#LT d_{xy}/#sigma_{d_{xy}} #GT vs #eta sector;#eta (sector);#LT d_{xy}/#sigma_{d_{z}} #GT",
         nBins_,
         lowedge,
         highedge);
 
     n_dxyEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
         "norm_widths_dxy_eta",
         "width(d_{xy}/#sigma_{d_{xy}}) vs #eta sector;#eta (sector);width(d_{xy}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dzEtaMeanBiasTrend = MeanBiasTrendsDir.make<TH1F>(
         "norm_means_dz_eta",
         "#LT d_{z}/#sigma_{d_{z}} #GT vs #eta sector;#eta (sector);#LT d_{z}/#sigma_{d_{z}} #GT",
         nBins_,
         lowedge,
         highedge);
 
     n_dzEtaWidthBiasTrend = WidthBiasTrendsDir.make<TH1F>(
         "norm_widths_dz_eta",
         "width(d_{z}/#sigma_{d_{z}}) vs #eta sector;#eta (sector);width(d_{z}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     // 2D maps
 
     a_dxyMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dxy_map",
                                                     "#LT d_{xy} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                                     nBins_,
                                                     lowedge,
                                                     highedge,
                                                     nBins_,
                                                     lowedge,
                                                     highedge);
 
     a_dzMeanBiasMap = Mean2DBiasMapsDir.make<TH2F>("means_dz_map",
                                                    "#LT d_{z} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                                    nBins_,
                                                    lowedge,
                                                    highedge,
                                                    nBins_,
                                                    lowedge,
                                                    highedge);
 
     n_dxyMeanBiasMap =
         Mean2DBiasMapsDir.make<TH2F>("norm_means_dxy_map",
                                      "#LT d_{xy}/#sigma_{d_{xy}} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                      nBins_,
                                      lowedge,
                                      highedge,
                                      nBins_,
                                      lowedge,
                                      highedge);
 
     n_dzMeanBiasMap =
         Mean2DBiasMapsDir.make<TH2F>("norm_means_dz_map",
                                      "#LT d_{z}/#sigma_{d_{z}} #GT map;#eta (sector);#varphi (sector) [degrees]",
                                      nBins_,
                                      lowedge,
                                      highedge,
                                      nBins_,
                                      lowedge,
                                      highedge);
 
     a_dxyWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dxy_map",
                                                       "#sigma_{d_{xy}} map;#eta (sector);#varphi (sector) [degrees]",
                                                       nBins_,
                                                       lowedge,
                                                       highedge,
                                                       nBins_,
                                                       lowedge,
                                                       highedge);
 
     a_dzWidthBiasMap = Width2DBiasMapsDir.make<TH2F>("widths_dz_map",
                                                      "#sigma_{d_{z}} map;#eta (sector);#varphi (sector) [degrees]",
                                                      nBins_,
                                                      lowedge,
                                                      highedge,
                                                      nBins_,
                                                      lowedge,
                                                      highedge);
 
     n_dxyWidthBiasMap =
         Width2DBiasMapsDir.make<TH2F>("norm_widths_dxy_map",
                                       "width(d_{xy}/#sigma_{d_{xy}}) map;#eta (sector);#varphi (sector) [degrees]",
                                       nBins_,
                                       lowedge,
                                       highedge,
                                       nBins_,
                                       lowedge,
                                       highedge);
 
     n_dzWidthBiasMap =
         Width2DBiasMapsDir.make<TH2F>("norm_widths_dz_map",
                                       "width(d_{z}/#sigma_{d_{z}}) map;#eta (sector);#varphi (sector) [degrees]",
                                       nBins_,
                                       lowedge,
                                       highedge,
                                       nBins_,
                                       lowedge,
                                       highedge);
 
     // medians and MADs
 
     a_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "medians_dxy_phi",
         "Median of d_{xy} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}) [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
         "MADs_dxy_phi",
         "Median absolute deviation of d_{xy} vs #phi sector;#varphi (sector) [degrees];MAD(d_{xy}) [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "medians_dz_phi",
         "Median of d_{z} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}) [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
         "MADs_dz_phi",
         "Median absolute deviation of d_{z} vs #phi sector;#varphi (sector) [degrees];MAD(d_{z}) [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dxyEtaMedianBiasTrend =
         MedianBiasTrendsDir.make<TH1F>("medians_dxy_eta",
                                        "Median of d_{xy} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}) [#mum]",
                                        nBins_,
                                        lowedge,
                                        highedge);
 
     a_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
         "MADs_dxy_eta",
         "Median absolute deviation of d_{xy} vs #eta sector;#eta (sector);MAD(d_{xy}) [#mum]",
         nBins_,
         lowedge,
         highedge);
 
     a_dzEtaMedianBiasTrend =
         MedianBiasTrendsDir.make<TH1F>("medians_dz_eta",
                                        "Median of d_{z} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}) [#mum]",
                                        nBins_,
                                        lowedge,
                                        highedge);
 
     a_dzEtaMADBiasTrend =
         MADBiasTrendsDir.make<TH1F>("MADs_dz_eta",
                                     "Median absolute deviation of d_{z} vs #eta sector;#eta (sector);MAD(d_{z}) [#mum]",
                                     nBins_,
                                     lowedge,
                                     highedge);
 
     n_dxyPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "norm_medians_dxy_phi",
         "Median of d_{xy}/#sigma_{d_{xy}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{xy}/#sigma_{d_{xy}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dxyPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dxy_phi",
                                                        "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #phi "
                                                        "sector;#varphi (sector) [degrees]; MAD(d_{xy}/#sigma_{d_{xy}})",
                                                        nBins_,
                                                        lowedge,
                                                        highedge);
 
     n_dzPhiMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "norm_medians_dz_phi",
         "Median of d_{z}/#sigma_{d_{z}} vs #phi sector;#varphi (sector) [degrees];#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dzPhiMADBiasTrend = MADBiasTrendsDir.make<TH1F>("norm_MADs_dz_phi",
                                                       "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #phi "
                                                       "sector;#varphi (sector) [degrees];MAD(d_{z}/#sigma_{d_{z}})",
                                                       nBins_,
                                                       lowedge,
                                                       highedge);
 
     n_dxyEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "norm_medians_dxy_eta",
         "Median of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{xy}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dxyEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
         "norm_MADs_dxy_eta",
         "Median absolute deviation of d_{xy}/#sigma_{d_{xy}} vs #eta sector;#eta (sector);MAD(d_{xy}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dzEtaMedianBiasTrend = MedianBiasTrendsDir.make<TH1F>(
         "norm_medians_dz_eta",
         "Median of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);#mu_{1/2}(d_{z}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
 
     n_dzEtaMADBiasTrend = MADBiasTrendsDir.make<TH1F>(
         "norm_MADs_dz_eta",
         "Median absolute deviation of d_{z}/#sigma_{d_{z}} vs #eta sector;#eta (sector);MAD(d_{z}/#sigma_{d_{z}})",
         nBins_,
         lowedge,
         highedge);
   }
 }

◆ beginRun()

void PrimaryVertexValidation::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 2520 of file PrimaryVertexValidation.cc.

References debug_, TrackerGeometry::dets(), etaOfProbe_, geomTokenBR_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), PixelTopologyMap::getPXBLadders(), PixelTopologyMap::getPXBModules(), getRunTime(), h_dxy_ladder_, h_dxy_ladderNoOverlap_, h_dxy_ladderOverlap_, h_dxy_modZ_, h_dz_ladder_, h_dz_modZ_, h_etaMax, h_nbins, h_nLadders, h_nModZ, h_norm_dxy_ladder_, h_norm_dxy_modZ_, h_norm_dz_ladder_, h_pTinfo, h_runFromEvent, h_runNumber, isBFieldConsistentWithMode(), TrackerGeometry::isThere(), PVValHelper::max_eta_phase0, PVValHelper::max_eta_phase1, PVValHelper::max_eta_phase2, maxPt_, SiStripPI::min, minPt_, mypT_bins_, nBins_, nLadders_, nModZ_, GeomDetEnumerators::P1PXB, GeomDetEnumerators::P1PXEC, GeomDetEnumerators::P2PXB, GeomDetEnumerators::P2PXEC, PVValHelper::phase0, PVValHelper::phase1, PVValHelper::phase2, phase_, edm::ESHandle< T >::product(), ptOfProbe_, edm::RunBase::run(), sistrip::runNumber_, RunNumber_, runNumbersTimesLog_, PVValHelper::shrinkHistVectorToFit(), and topoTokenBR_.

                                                                                       {
   //=======================================================
   // check on the b-field consistency
   //=======================================================
 
   if (!isBFieldConsistentWithMode(iSetup)) {
     edm::LogWarning("PrimaryVertexValidation")
         << "*********************************************************************************\n"
         << "* The configuration (ptOfProbe > " << ptOfProbe_
         << "GeV) is not correctly set for current value of magnetic field \n"
         << "* Switching it to 0. !!! \n"
         << "*********************************************************************************" << std::endl;
     ptOfProbe_ = 0.;
   }
 
   //=======================================================
   // Run numbers analysis
   //=======================================================
 
   const auto runNumber_ = iRun.run();
   h_runNumber->Fill(runNumber_);
 
   if (!runNumbersTimesLog_.count(runNumber_)) {
     auto times = getRunTime(iSetup);
 
     if (debug_) {
       const time_t start_time = times.first / 1000000;
       edm::LogInfo("PrimaryVertexValidation")
           << runNumber_ << " has start time: " << times.first << " - " << times.second << std::endl;
       edm::LogInfo("PrimaryVertexValidation")
           << "human readable time: " << std::asctime(std::gmtime(&start_time)) << std::endl;
     }
 
     runNumbersTimesLog_[runNumber_] = times;
   }
 
   if (h_runFromEvent->GetEntries() == 0) {
     h_runFromEvent->SetBinContent(1, RunNumber_);
   }
 
   //=======================================================
   // Retrieve tracker topology from geometry
   //=======================================================
 
   const TrackerTopology* const tTopo = &iSetup.getData(topoTokenBR_);
 
   //=======================================================
   // Retrieve geometry information
   //=======================================================
 
   edm::LogInfo("read tracker geometry...");
   edm::ESHandle<TrackerGeometry> pDD = iSetup.getHandle(geomTokenBR_);
   edm::LogInfo("tracker geometry read") << "There are: " << pDD->dets().size() << " detectors";
 
   PixelTopologyMap PTMap = PixelTopologyMap(pDD.product(), tTopo);
   nLadders_ = PTMap.getPXBLadders(1);
   nModZ_ = PTMap.getPXBModules(1);
 
   //=======================================================
   // shrink to fit
   //=======================================================
 
   if (h_dxy_ladderOverlap_.size() != nLadders_) {
     PVValHelper::shrinkHistVectorToFit(h_dxy_ladderOverlap_, nLadders_);
     PVValHelper::shrinkHistVectorToFit(h_dxy_ladderNoOverlap_, nLadders_);
     PVValHelper::shrinkHistVectorToFit(h_dxy_ladder_, nLadders_);
     PVValHelper::shrinkHistVectorToFit(h_dz_ladder_, nLadders_);
     PVValHelper::shrinkHistVectorToFit(h_norm_dxy_ladder_, nLadders_);
     PVValHelper::shrinkHistVectorToFit(h_norm_dz_ladder_, nLadders_);
 
     if (debug_) {
       edm::LogInfo("PrimaryVertexValidation") << "checking size:" << h_dxy_ladder_.size() << std::endl;
     }
   }
 
   if (h_dxy_modZ_.size() != nModZ_) {
     PVValHelper::shrinkHistVectorToFit(h_dxy_modZ_, nModZ_);
     PVValHelper::shrinkHistVectorToFit(h_dz_modZ_, nModZ_);
     PVValHelper::shrinkHistVectorToFit(h_norm_dxy_modZ_, nModZ_);
     PVValHelper::shrinkHistVectorToFit(h_norm_dxy_modZ_, nModZ_);
 
     if (debug_) {
       edm::LogInfo("PrimaryVertexValidation") << "checking size:" << h_dxy_modZ_.size() << std::endl;
     }
   }
 
   if ((pDD->isThere(GeomDetEnumerators::P2PXB)) || (pDD->isThere(GeomDetEnumerators::P2PXEC))) {
     // switch on the phase-2
     phase_ = PVValHelper::phase2;
     if (debug_) {
       edm::LogInfo("PrimaryVertexValidation")
           << " pixel phase2 setup, nLadders: " << nLadders_ << " nModules:" << nModZ_;
     }
 
   } else if ((pDD->isThere(GeomDetEnumerators::P1PXB)) || (pDD->isThere(GeomDetEnumerators::P1PXEC))) {
     // switch on the phase-1
     if (debug_) {
       edm::LogInfo("PrimaryVertexValidation")
           << " pixel phase1 setup, nLadders: " << nLadders_ << " nModules:" << nModZ_;
     }
   } else {
     // switch on the phase-0
     phase_ = PVValHelper::phase0;
     if (debug_) {
       edm::LogInfo("PrimaryVertexValidation")
           << " pixel phase0 setup, nLadders: " << nLadders_ << " nModules:" << nModZ_;
     }
   }
 
   switch (phase_) {
     case PVValHelper::phase0:
       etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase0);
       break;
     case PVValHelper::phase1:
       etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase1);
       break;
     case PVValHelper::phase2:
       etaOfProbe_ = std::min(etaOfProbe_, PVValHelper::max_eta_phase2);
       break;
     default:
       edm::LogWarning("LogicError") << "Unknown detector phase: " << phase_;
   }
 
   if (h_etaMax->GetEntries() == 0.) {
     h_etaMax->SetBinContent(1., etaOfProbe_);
     h_nbins->SetBinContent(1., nBins_);
     h_nLadders->SetBinContent(1., nLadders_);
     h_nModZ->SetBinContent(1., nModZ_);
     h_pTinfo->SetBinContent(1., mypT_bins_.size());
     h_pTinfo->SetBinContent(2., minPt_);
     h_pTinfo->SetBinContent(3., maxPt_);
   }
 }

◆ 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 3480 of file PrimaryVertexValidation.cc.

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().

                                                                                       {
   TH1F::SetDefaultSumw2(kTRUE);
 
   auto hash = std::make_pair(resType, varType);
 
   double down = theDetails_.range[hash].first;
   double up = theDetails_.range[hash].second;
 
   if (isNormalized) {
     up = up / 100.;
     down = down / 100.;
   }
 
   std::vector<TH1F*> h;
   h.reserve(theNOfBins);
 
   if (theNOfBins == 0) {
     edm::LogError("PrimaryVertexValidation")
         << "bookResidualsHistogram() The number of bins cannot be identically 0" << std::endl;
     assert(false);
   }
 
   std::string s_resType = std::get<0>(PVValHelper::getTypeString(resType));
   std::string s_varType = std::get<0>(PVValHelper::getVarString(varType));
 
   std::string t_resType = std::get<1>(PVValHelper::getTypeString(resType));
   std::string t_varType = std::get<1>(PVValHelper::getVarString(varType));
   std::string units = std::get<2>(PVValHelper::getTypeString(resType));
 
   for (unsigned int i = 0; i < theNOfBins; i++) {
     TString title = (varType == PVValHelper::phi || varType == PVValHelper::eta)
                         ? Form("%s vs %s - bin %i (%f < %s < %f);%s %s;tracks",
                                t_resType.c_str(),
                                t_varType.c_str(),
                                i,
                                theDetails_.trendbins[varType][i],
                                t_varType.c_str(),
                                theDetails_.trendbins[varType][i + 1],
                                t_resType.c_str(),
                                units.c_str())
                         : Form("%s vs %s - bin %i;%s %s;tracks",
                                t_resType.c_str(),
                                t_varType.c_str(),
                                i,
                                t_resType.c_str(),
                                units.c_str());
 
     TH1F* htemp = dir.make<TH1F>(
         Form("histo_%s_%s_plot%i", s_resType.c_str(), s_varType.c_str(), i),
         //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()),
         title.Data(),
         theDetails_.histobins,
         down,
         up);
     h.push_back(htemp);
   }
 
   return h;
 }

◆ bookVertexHistograms()

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

private

Definition at line 3358 of file PrimaryVertexValidation.cc.

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

Referenced by beginJob().

 {
   TH1F::SetDefaultSumw2(kTRUE);
 
   std::map<std::string, TH1*> h;
 
   // histograms of track quality (Data and MC)
   std::string types[] = {"all", "sel"};
   for (const auto& type : types) {
     h["pseudorapidity_" + type] =
         dir.make<TH1F>(("rapidity_" + type).c_str(), "track pseudorapidity; track #eta; tracks", 100, -3., 3.);
     h["z0_" + type] = dir.make<TH1F>(("z0_" + type).c_str(), "track z_{0};track z_{0} (cm);tracks", 80, -40., 40.);
     h["phi_" + type] = dir.make<TH1F>(("phi_" + type).c_str(), "track #phi; track #phi;tracks", 80, -M_PI, M_PI);
     h["eta_" + type] = dir.make<TH1F>(("eta_" + type).c_str(), "track #eta; track #eta;tracks", 80, -4., 4.);
     h["pt_" + type] = dir.make<TH1F>(("pt_" + type).c_str(), "track p_{T}; track p_{T} [GeV];tracks", 100, 0., 20.);
     h["p_" + type] = dir.make<TH1F>(("p_" + type).c_str(), "track p; track p [GeV];tracks", 100, 0., 20.);
     h["found_" + type] =
         dir.make<TH1F>(("found_" + type).c_str(), "n. found hits;n^{found}_{hits};tracks", 30, 0., 30.);
     h["lost_" + type] = dir.make<TH1F>(("lost_" + type).c_str(), "n. lost hits;n^{lost}_{hits};tracks", 20, 0., 20.);
     h["nchi2_" + type] =
         dir.make<TH1F>(("nchi2_" + type).c_str(), "normalized track #chi^{2};track #chi^{2}/ndf;tracks", 100, 0., 20.);
     h["rstart_" + type] = dir.make<TH1F>(
         ("rstart_" + type).c_str(), "track start radius; track innermost radius r (cm);tracks", 100, 0., 20.);
     h["expectedInner_" + type] = dir.make<TH1F>(
         ("expectedInner_" + type).c_str(), "n. expected inner hits;n^{expected}_{inner};tracks", 10, 0., 10.);
     h["expectedOuter_" + type] = dir.make<TH1F>(
         ("expectedOuter_" + type).c_str(), "n. expected outer hits;n^{expected}_{outer};tracks ", 10, 0., 10.);
     h["logtresxy_" + type] =
         dir.make<TH1F>(("logtresxy_" + type).c_str(),
                        "log10(track r-#phi resolution/#mum);log10(track r-#phi resolution/#mum);tracks",
                        100,
                        0.,
                        5.);
     h["logtresz_" + type] = dir.make<TH1F>(("logtresz_" + type).c_str(),
                                            "log10(track z resolution/#mum);log10(track z resolution/#mum);tracks",
                                            100,
                                            0.,
                                            5.);
     h["tpullxy_" + type] =
         dir.make<TH1F>(("tpullxy_" + type).c_str(), "track r-#phi pull;pull_{r-#phi};tracks", 100, -10., 10.);
     h["tpullz_" + type] =
         dir.make<TH1F>(("tpullz_" + type).c_str(), "track r-z pull;pull_{r-z};tracks", 100, -50., 50.);
     h["tlogDCAxy_" + type] = dir.make<TH1F>(
         ("tlogDCAxy_" + type).c_str(), "track log_{10}(DCA_{r-#phi});track log_{10}(DCA_{r-#phi});tracks", 200, -5., 3.);
     h["tlogDCAz_" + type] = dir.make<TH1F>(
         ("tlogDCAz_" + type).c_str(), "track log_{10}(DCA_{r-z});track log_{10}(DCA_{r-z});tracks", 200, -5., 5.);
     h["lvseta_" + type] = dir.make<TH2F>(
         ("lvseta_" + type).c_str(), "cluster length vs #eta;track #eta;cluster length", 60, -3., 3., 20, 0., 20);
     h["lvstanlambda_" + type] = dir.make<TH2F>(("lvstanlambda_" + type).c_str(),
                                                "cluster length vs tan #lambda; tan#lambda;cluster length",
                                                60,
                                                -6.,
                                                6.,
                                                20,
                                                0.,
                                                20);
     h["restrkz_" + type] =
         dir.make<TH1F>(("restrkz_" + type).c_str(), "z-residuals (track vs vertex);res_{z} (cm);tracks", 200, -5., 5.);
     h["restrkzvsphi_" + type] = dir.make<TH2F>(("restrkzvsphi_" + type).c_str(),
                                                "z-residuals (track - vertex) vs track #phi;track #phi;res_{z} (cm)",
                                                12,
                                                -M_PI,
                                                M_PI,
                                                100,
                                                -0.5,
                                                0.5);
     h["restrkzvseta_" + type] = dir.make<TH2F>(("restrkzvseta_" + type).c_str(),
                                                "z-residuals (track - vertex) vs track #eta;track #eta;res_{z} (cm)",
                                                12,
                                                -3.,
                                                3.,
                                                200,
                                                -0.5,
                                                0.5);
     h["pulltrkzvsphi_" + type] =
         dir.make<TH2F>(("pulltrkzvsphi_" + type).c_str(),
                        "normalized z-residuals (track - vertex) vs track #phi;track #phi;res_{z}/#sigma_{res_{z}}",
                        12,
                        -M_PI,
                        M_PI,
                        100,
                        -5.,
                        5.);
     h["pulltrkzvseta_" + type] =
         dir.make<TH2F>(("pulltrkzvseta_" + type).c_str(),
                        "normalized z-residuals (track - vertex) vs track #eta;track #eta;res_{z}/#sigma_{res_{z}}",
                        12,
                        -3.,
                        3.,
                        100,
                        -5.,
                        5.);
     h["pulltrkz_" + type] = dir.make<TH1F>(("pulltrkz_" + type).c_str(),
                                            "normalized z-residuals (track vs vertex);res_{z}/#sigma_{res_{z}};tracks",
                                            100,
                                            -5.,
                                            5.);
     h["sigmatrkz0_" + type] = dir.make<TH1F>(
         ("sigmatrkz0_" + type).c_str(), "z-resolution (excluding beam);#sigma^{trk}_{z_{0}} (cm);tracks", 100, 0., 5.);
     h["sigmatrkz_" + type] = dir.make<TH1F>(
         ("sigmatrkz_" + type).c_str(), "z-resolution (including beam);#sigma^{trk}_{z} (cm);tracks", 100, 0., 5.);
     h["nbarrelhits_" + type] = dir.make<TH1F>(
         ("nbarrelhits_" + type).c_str(), "number of pixel barrel hits;n. hits Barrel Pixel;tracks", 10, 0., 10.);
     h["nbarrelLayers_" + type] = dir.make<TH1F>(
         ("nbarrelLayers_" + type).c_str(), "number of pixel barrel layers;n. layers Barrel Pixel;tracks", 10, 0., 10.);
     h["nPxLayers_" + type] = dir.make<TH1F>(
         ("nPxLayers_" + type).c_str(), "number of pixel layers (barrel+endcap);n. Pixel layers;tracks", 10, 0., 10.);
     h["nSiLayers_" + type] =
         dir.make<TH1F>(("nSiLayers_" + type).c_str(), "number of Tracker layers;n. Tracker layers;tracks", 20, 0., 20.);
     h["trackAlgo_" + type] =
         dir.make<TH1F>(("trackAlgo_" + type).c_str(), "track algorithm;track algo;tracks", 30, 0., 30.);
     h["trackQuality_" + type] =
         dir.make<TH1F>(("trackQuality_" + type).c_str(), "track quality;track quality;tracks", 7, -1., 6.);
   }
 
   return h;
 }

◆ endJob()

void PrimaryVertexValidation::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 2655 of file PrimaryVertexValidation.cc.

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, h2_probeLayer1Map_, h2_probePassingLayer1Map_, 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_probeL1Ladder_, h_probeL1Module_, 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_, cond::impl::to_string(), useTracksFromRecoVtx_, PVValHelper::WIDTH, Width2DMapsDir, and WidthTrendsDir.

Referenced by o2olib.O2ORunMgr::executeJob().

                                      {
   // shring the histograms to fit
   h_probeL1Ladder_->GetXaxis()->SetRangeUser(-1.5, nLadders_ + 0.5);
   h_probeL1Module_->GetXaxis()->SetRangeUser(-1.5, nModZ_ + 0.5);
   h2_probeLayer1Map_->GetXaxis()->SetRangeUser(0.5, nModZ_ + 0.5);
   h2_probeLayer1Map_->GetYaxis()->SetRangeUser(0.5, nLadders_ + 0.5);
   h2_probePassingLayer1Map_->GetXaxis()->SetRangeUser(0.5, nModZ_ + 0.5);
   h2_probePassingLayer1Map_->GetYaxis()->SetRangeUser(0.5, nLadders_ + 0.5);
 
   TFileDirectory RunFeatures = fs->mkdir("RunFeatures");
   h_runStartTimes = RunFeatures.make<TH1I>(
       "runStartTimes", "run start times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
   h_runEndTimes =
       RunFeatures.make<TH1I>("runEndTimes", "run end times", runNumbersTimesLog_.size(), 0, runNumbersTimesLog_.size());
 
   unsigned int count = 1;
   for (const auto& run : runNumbersTimesLog_) {
     // strip down the microseconds
     h_runStartTimes->SetBinContent(count, run.second.first / 10e6);
     h_runStartTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
 
     h_runEndTimes->SetBinContent(count, run.second.second / 10e6);
     h_runEndTimes->GetXaxis()->SetBinLabel(count, (std::to_string(run.first)).c_str());
 
     count++;
   }
 
   edm::LogInfo("PrimaryVertexValidation") << "######################################\n"
                                           << "# PrimaryVertexValidation::endJob()\n"
                                           << "# Number of analyzed events: " << Nevt_ << "\n"
                                           << "######################################";
 
   // means and widhts vs ladder and module number
 
   a_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dxy_modZ", "#LT d_{xy} #GT vs modZ;module number (Z);#LT d_{xy} #GT [#mum]", nModZ_, 0., nModZ_);
 
   a_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
       "widths_dxy_modZ", "#sigma_{d_{xy}} vs modZ;module number (Z);#sigma_{d_{xy}} [#mum]", nModZ_, 0., nModZ_);
 
   a_dzmodZMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dz_modZ", "#LT d_{z} #GT vs modZ;module number (Z);#LT d_{z} #GT [#mum]", nModZ_, 0., nModZ_);
 
   a_dzmodZWidthTrend = WidthTrendsDir.make<TH1F>(
       "widths_dz_modZ", "#sigma_{d_{z}} vs modZ;module number (Z);#sigma_{d_{z}} [#mum]", nModZ_, 0., nModZ_);
 
   a_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>("means_dxy_ladder",
                                                   "#LT d_{xy} #GT vs ladder;ladder number (#phi);#LT d_{xy} #GT [#mum]",
                                                   nLadders_,
                                                   0.,
                                                   nLadders_);
 
   a_dxyladderWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dxy_ladder",
                                 "#sigma_{d_{xy}} vs ladder;ladder number (#phi);#sigma_{d_{xy}} [#mum]",
                                 nLadders_,
                                 0.,
                                 nLadders_);
 
   a_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
       "means_dz_ladder", "#LT d_{z} #GT vs ladder;ladder number (#phi);#LT d_{z} #GT [#mum]", nLadders_, 0., nLadders_);
 
   a_dzladderWidthTrend =
       WidthTrendsDir.make<TH1F>("widths_dz_ladder",
                                 "#sigma_{d_{z}} vs ladder;ladder number (#phi);#sigma_{d_{z}} [#mum]",
                                 nLadders_,
                                 0.,
                                 nLadders_);
 
   n_dxymodZMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dxy_modZ",
       "#LT d_{xy}/#sigma_{d_{xy}} #GT vs modZ;module number (Z);#LT d_{xy}/#sigma_{d_{xy}} #GT",
       nModZ_,
       0.,
       nModZ_);
 
   n_dxymodZWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dxy_modZ",
       "width(d_{xy}/#sigma_{d_{xy}}) vs modZ;module number (Z); width(d_{xy}/#sigma_{d_{xy}})",
       nModZ_,
       0.,
       nModZ_);
 
   n_dzmodZMeanTrend =
       MeanTrendsDir.make<TH1F>("norm_means_dz_modZ",
                                "#LT d_{z}/#sigma_{d_{z}} #GT vs modZ;module number (Z);#LT d_{z}/#sigma_{d_{z}} #GT",
                                nModZ_,
                                0.,
                                nModZ_);
 
   n_dzmodZWidthTrend =
       WidthTrendsDir.make<TH1F>("norm_widths_dz_modZ",
                                 "width(d_{z}/#sigma_{d_{z}}) vs pT;module number (Z);width(d_{z}/#sigma_{d_{z}})",
                                 nModZ_,
                                 0.,
                                 nModZ_);
 
   n_dxyladderMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dxy_ladder",
       "#LT d_{xy}/#sigma_{d_{xy}} #GT vs ladder;ladder number (#phi);#LT d_{xy}/#sigma_{d_{z}} #GT",
       nLadders_,
       0.,
       nLadders_);
 
   n_dxyladderWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dxy_ladder",
       "width(d_{xy}/#sigma_{d_{xy}}) vs ladder;ladder number (#phi);width(d_{xy}/#sigma_{d_{z}})",
       nLadders_,
       0.,
       nLadders_);
 
   n_dzladderMeanTrend = MeanTrendsDir.make<TH1F>(
       "norm_means_dz_ladder",
       "#LT d_{z}/#sigma_{d_{z}} #GT vs ladder;ladder number (#phi);#LT d_{z}/#sigma_{d_{z}} #GT",
       nLadders_,
       0.,
       nLadders_);
 
   n_dzladderWidthTrend = WidthTrendsDir.make<TH1F>(
       "norm_widths_dz_ladder",
       "width(d_{z}/#sigma_{d_{z}}) vs ladder;ladder number (#phi);width(d_{z}/#sigma_{d_{z}})",
       nLadders_,
       0.,
       nLadders_);
 
   // 2D maps of residuals in bins of L1 modules
 
   a_dxyL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dxy_l1map",
                                             "#LT d_{xy} #GT map;module number [z];ladder number [#varphi]",
                                             nModZ_,
                                             0.,
                                             nModZ_,
                                             nLadders_,
                                             0.,
                                             nLadders_);
 
   a_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("means_dz_l1map",
                                            "#LT d_{z} #GT map;module number [z];ladder number [#varphi]",
                                            nModZ_,
                                            0.,
                                            nModZ_,
                                            nLadders_,
                                            0.,
                                            nLadders_);
 
   n_dxyL1MeanMap =
       Mean2DMapsDir.make<TH2F>("norm_means_dxy_l1map",
                                "#LT d_{xy}/#sigma_{d_{xy}} #GT map;module number [z];ladder number [#varphi]",
                                nModZ_,
                                0.,
                                nModZ_,
                                nLadders_,
                                0.,
                                nLadders_);
 
   n_dzL1MeanMap = Mean2DMapsDir.make<TH2F>("norm_means_dz_l1map",
                                            "#LT d_{z}/#sigma_{d_{z}} #GT map;module number [z];ladder number [#varphi]",
                                            nModZ_,
                                            0.,
                                            nModZ_,
                                            nLadders_,
                                            0.,
                                            nLadders_);
 
   a_dxyL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dxy_l1map",
                                               "#sigma_{d_{xy}} map;module number [z];ladder number [#varphi]",
                                               nModZ_,
                                               0.,
                                               nModZ_,
                                               nLadders_,
                                               0.,
                                               nLadders_);
 
   a_dzL1WidthMap = Width2DMapsDir.make<TH2F>("widths_dz_l1map",
                                              "#sigma_{d_{z}} map;module number [z];ladder number [#varphi]",
                                              nModZ_,
                                              0.,
                                              nModZ_,
                                              nLadders_,
                                              0.,
                                              nLadders_);
 
   n_dxyL1WidthMap =
       Width2DMapsDir.make<TH2F>("norm_widths_dxy_l1map",
                                 "width(d_{xy}/#sigma_{d_{xy}}) map;module number [z];ladder number [#varphi]",
                                 nModZ_,
                                 0.,
                                 nModZ_,
                                 nLadders_,
                                 0.,
                                 nLadders_);
 
   n_dzL1WidthMap =
       Width2DMapsDir.make<TH2F>("norm_widths_dz_l1map",
                                 "width(d_{z}/#sigma_{d_{z}}) map;module number [z];ladder number [#varphi]",
                                 nModZ_,
                                 0.,
                                 nModZ_,
                                 nLadders_,
                                 0.,
                                 nLadders_);
 
   if (useTracksFromRecoVtx_) {
     fillTrendPlotByIndex(a_dxyPhiMeanBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
     fillTrendPlotByIndex(a_dxyPhiWidthBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
     fillTrendPlotByIndex(a_dzPhiMeanBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
     fillTrendPlotByIndex(a_dzPhiWidthBiasTrend, a_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
 
     fillTrendPlotByIndex(a_dxyEtaMeanBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
     fillTrendPlotByIndex(a_dxyEtaWidthBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
     fillTrendPlotByIndex(a_dzEtaMeanBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
     fillTrendPlotByIndex(a_dzEtaWidthBiasTrend, a_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
 
     fillTrendPlotByIndex(n_dxyPhiMeanBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
     fillTrendPlotByIndex(n_dxyPhiWidthBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
     fillTrendPlotByIndex(n_dzPhiMeanBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEAN, PVValHelper::phi);
     fillTrendPlotByIndex(n_dzPhiWidthBiasTrend, n_dzPhiBiasResiduals, PVValHelper::WIDTH, PVValHelper::phi);
 
     fillTrendPlotByIndex(n_dxyEtaMeanBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
     fillTrendPlotByIndex(n_dxyEtaWidthBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
     fillTrendPlotByIndex(n_dzEtaMeanBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEAN, PVValHelper::eta);
     fillTrendPlotByIndex(n_dzEtaWidthBiasTrend, n_dzEtaBiasResiduals, PVValHelper::WIDTH, PVValHelper::eta);
 
     // medians and MADs
 
     fillTrendPlotByIndex(a_dxyPhiMedianBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
     fillTrendPlotByIndex(a_dxyPhiMADBiasTrend, a_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
     fillTrendPlotByIndex(a_dzPhiMedianBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
     fillTrendPlotByIndex(a_dzPhiMADBiasTrend, a_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
 
     fillTrendPlotByIndex(a_dxyEtaMedianBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
     fillTrendPlotByIndex(a_dxyEtaMADBiasTrend, a_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
     fillTrendPlotByIndex(a_dzEtaMedianBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
     fillTrendPlotByIndex(a_dzEtaMADBiasTrend, a_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
 
     fillTrendPlotByIndex(n_dxyPhiMedianBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
     fillTrendPlotByIndex(n_dxyPhiMADBiasTrend, n_dxyPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
     fillTrendPlotByIndex(n_dzPhiMedianBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
     fillTrendPlotByIndex(n_dzPhiMADBiasTrend, n_dzPhiBiasResiduals, PVValHelper::MAD, PVValHelper::phi);
 
     fillTrendPlotByIndex(n_dxyEtaMedianBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
     fillTrendPlotByIndex(n_dxyEtaMADBiasTrend, n_dxyEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
     fillTrendPlotByIndex(n_dzEtaMedianBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
     fillTrendPlotByIndex(n_dzEtaMADBiasTrend, n_dzEtaBiasResiduals, PVValHelper::MAD, PVValHelper::eta);
 
     // 2d Maps
 
     fillMap(a_dxyMeanBiasMap, a_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
     fillMap(a_dxyWidthBiasMap, a_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
     fillMap(a_dzMeanBiasMap, a_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
     fillMap(a_dzWidthBiasMap, a_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
 
     fillMap(n_dxyMeanBiasMap, n_dxyBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
     fillMap(n_dxyWidthBiasMap, n_dxyBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
     fillMap(n_dzMeanBiasMap, n_dzBiasResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
     fillMap(n_dzWidthBiasMap, n_dzBiasResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
   }
 
   // do profiles
 
   fillTrendPlotByIndex(a_dxyPhiMeanTrend, a_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
   fillTrendPlotByIndex(a_dxyPhiWidthTrend, a_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
   fillTrendPlotByIndex(a_dzPhiMeanTrend, a_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
   fillTrendPlotByIndex(a_dzPhiWidthTrend, a_dzPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
 
   fillTrendPlotByIndex(a_dxyEtaMeanTrend, a_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
   fillTrendPlotByIndex(a_dxyEtaWidthTrend, a_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
   fillTrendPlotByIndex(a_dzEtaMeanTrend, a_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
   fillTrendPlotByIndex(a_dzEtaWidthTrend, a_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
 
   fillTrendPlotByIndex(n_dxyPhiMeanTrend, n_dxyPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
   fillTrendPlotByIndex(n_dxyPhiWidthTrend, n_dxyPhiResiduals, PVValHelper::WIDTH, PVValHelper::phi);
   fillTrendPlotByIndex(n_dzPhiMeanTrend, n_dzPhiResiduals, PVValHelper::MEAN, PVValHelper::phi);
   fillTrendPlotByIndex(n_dzPhiWidthTrend, n_dzPhiResiduals, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(n_dxyEtaMeanTrend, n_dxyEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
   fillTrendPlotByIndex(n_dxyEtaWidthTrend, n_dxyEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
   fillTrendPlotByIndex(n_dzEtaMeanTrend, n_dzEtaResiduals, PVValHelper::MEAN, PVValHelper::eta);
   fillTrendPlotByIndex(n_dzEtaWidthTrend, n_dzEtaResiduals, PVValHelper::WIDTH, PVValHelper::eta);
 
   // vs transverse momentum
 
   fillTrendPlotByIndex(a_dxypTMeanTrend, h_dxy_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dxypTWidthTrend, h_dxy_pT_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(a_dzpTMeanTrend, h_dz_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dzpTWidthTrend, h_dz_pT_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(a_dxypTCentralMeanTrend, h_dxy_Central_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dxypTCentralWidthTrend, h_dxy_Central_pT_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(a_dzpTCentralMeanTrend, h_dz_Central_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dzpTCentralWidthTrend, h_dz_Central_pT_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(n_dxypTMeanTrend, h_norm_dxy_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dxypTWidthTrend, h_norm_dxy_pT_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(n_dzpTMeanTrend, h_norm_dz_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dzpTWidthTrend, h_norm_dz_pT_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(n_dxypTCentralMeanTrend, h_norm_dxy_Central_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dxypTCentralWidthTrend, h_norm_dxy_Central_pT_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(n_dzpTCentralMeanTrend, h_norm_dz_Central_pT_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dzpTCentralWidthTrend, h_norm_dz_Central_pT_, PVValHelper::WIDTH);
 
   // vs ladder and module number
 
   fillTrendPlotByIndex(a_dxymodZMeanTrend, h_dxy_modZ_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dxymodZWidthTrend, h_dxy_modZ_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(a_dzmodZMeanTrend, h_dz_modZ_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dzmodZWidthTrend, h_dz_modZ_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(a_dxyladderMeanTrend, h_dxy_ladder_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dxyladderWidthTrend, h_dxy_ladder_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(a_dzladderMeanTrend, h_dz_ladder_, PVValHelper::MEAN);
   fillTrendPlotByIndex(a_dzladderWidthTrend, h_dz_ladder_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(n_dxymodZMeanTrend, h_norm_dxy_modZ_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dxymodZWidthTrend, h_norm_dxy_modZ_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(n_dzmodZMeanTrend, h_norm_dz_modZ_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dzmodZWidthTrend, h_norm_dz_modZ_, PVValHelper::WIDTH);
 
   fillTrendPlotByIndex(n_dxyladderMeanTrend, h_norm_dxy_ladder_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dxyladderWidthTrend, h_norm_dxy_ladder_, PVValHelper::WIDTH);
   fillTrendPlotByIndex(n_dzladderMeanTrend, h_norm_dz_ladder_, PVValHelper::MEAN);
   fillTrendPlotByIndex(n_dzladderWidthTrend, h_norm_dz_ladder_, PVValHelper::WIDTH);
 
   // medians and MADs
 
   fillTrendPlotByIndex(a_dxyPhiMedianTrend, a_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
   fillTrendPlotByIndex(a_dxyPhiMADTrend, a_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
 
   fillTrendPlotByIndex(a_dzPhiMedianTrend, a_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
   fillTrendPlotByIndex(a_dzPhiMADTrend, a_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
 
   fillTrendPlotByIndex(a_dxyEtaMedianTrend, a_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
   fillTrendPlotByIndex(a_dxyEtaMADTrend, a_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
   fillTrendPlotByIndex(a_dzEtaMedianTrend, a_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
   fillTrendPlotByIndex(a_dzEtaMADTrend, a_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
 
   fillTrendPlotByIndex(n_dxyPhiMedianTrend, n_dxyPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
   fillTrendPlotByIndex(n_dxyPhiMADTrend, n_dxyPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
   fillTrendPlotByIndex(n_dzPhiMedianTrend, n_dzPhiResiduals, PVValHelper::MEDIAN, PVValHelper::phi);
   fillTrendPlotByIndex(n_dzPhiMADTrend, n_dzPhiResiduals, PVValHelper::MAD, PVValHelper::phi);
 
   fillTrendPlotByIndex(n_dxyEtaMedianTrend, n_dxyEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
   fillTrendPlotByIndex(n_dxyEtaMADTrend, n_dxyEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
   fillTrendPlotByIndex(n_dzEtaMedianTrend, n_dzEtaResiduals, PVValHelper::MEDIAN, PVValHelper::eta);
   fillTrendPlotByIndex(n_dzEtaMADTrend, n_dzEtaResiduals, PVValHelper::MAD, PVValHelper::eta);
 
   // 2D Maps
 
   fillMap(a_dxyMeanMap, a_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
   fillMap(a_dxyWidthMap, a_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
   fillMap(a_dzMeanMap, a_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
   fillMap(a_dzWidthMap, a_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
 
   fillMap(n_dxyMeanMap, n_dxyResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
   fillMap(n_dxyWidthMap, n_dxyResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
   fillMap(n_dzMeanMap, n_dzResidualsMap, PVValHelper::MEAN, nBins_, nBins_);
   fillMap(n_dzWidthMap, n_dzResidualsMap, PVValHelper::WIDTH, nBins_, nBins_);
 
   // 2D Maps of residuals in bins of L1 modules
 
   fillMap(a_dxyL1MeanMap, a_dxyL1ResidualsMap, PVValHelper::MEAN, nModZ_, nLadders_);
   fillMap(a_dxyL1WidthMap, a_dxyL1ResidualsMap, PVValHelper::WIDTH, nModZ_, nLadders_);
   fillMap(a_dzL1MeanMap, a_dzL1ResidualsMap, PVValHelper::MEAN, nModZ_, nLadders_);
   fillMap(a_dzL1WidthMap, a_dzL1ResidualsMap, PVValHelper::WIDTH, nModZ_, nLadders_);
 
   fillMap(n_dxyL1MeanMap, n_dxyL1ResidualsMap, PVValHelper::MEAN, nModZ_, nLadders_);
   fillMap(n_dxyL1WidthMap, n_dxyL1ResidualsMap, PVValHelper::WIDTH, nModZ_, nLadders_);
   fillMap(n_dzL1MeanMap, n_dzL1ResidualsMap, PVValHelper::MEAN, nModZ_, nLadders_);
   fillMap(n_dzL1WidthMap, n_dzL1ResidualsMap, PVValHelper::WIDTH, nModZ_, nLadders_);
 }

◆ endRun()

void PrimaryVertexValidation::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

inlineoverrideprivate

Definition at line 84 of file PrimaryVertexValidation.h.

84 {};

◆ 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 3665 of file PrimaryVertexValidation.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, GapClusterizerInZ::fillPSetDescription(), TrackFilterForPVFinding::fillPSetDescription(), DAClusterizerInZ_vect::fillPSetDescription(), ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.setComment("Validates alignment payloads by evaluating unbiased track paramter resisuals to vertices");
 
   // PV Validation specific
 
   desc.addUntracked<int>("compressionSettings", -1);
   desc.add<bool>("storeNtuple", false);
   desc.add<bool>("isLightNtuple", true);
   desc.add<bool>("useTracksFromRecoVtx", false);
   desc.addUntracked<double>("vertexZMax", 99);
   desc.addUntracked<double>("intLumi", 0.);
   desc.add<bool>("askFirstLayerHit", false);
   desc.addUntracked<bool>("doBPix", true);
   desc.addUntracked<bool>("doFPix", true);
   desc.addUntracked<double>("probePt", 0.);
   desc.addUntracked<double>("probeP", 0.);
   desc.addUntracked<double>("probeEta", 2.4);
   desc.addUntracked<double>("probeNHits", 0.);
   desc.addUntracked<int>("numberOfBins", 24);
   desc.addUntracked<double>("minPt", 1.);
   desc.addUntracked<double>("maxPt", 20.);
   desc.add<bool>("Debug", false);
   desc.addUntracked<bool>("runControl", false);
   desc.addUntracked<bool>("forceBeamSpot", false);
 
   std::vector<unsigned int> defaultRuns;
   defaultRuns.push_back(0);
   desc.addUntracked<std::vector<unsigned int>>("runControlNumber", defaultRuns);
 
   // event sources
 
   desc.add<edm::InputTag>("TrackCollectionTag", edm::InputTag("ALCARECOTkAlMinBias"));
   desc.add<edm::InputTag>("VertexCollectionTag", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("BeamSpotTag", edm::InputTag("offlineBeamSpot"));
 
   // track filtering
   edm::ParameterSetDescription psd0;
   TrackFilterForPVFinding::fillPSetDescription(psd0);
   psd0.add<int>("numTracksThreshold", 0);  // HI only
   desc.add<edm::ParameterSetDescription>("TkFilterParameters", psd0);
 
   // PV Clusterization
   {
     edm::ParameterSetDescription psd0;
     {
       edm::ParameterSetDescription psd1;
       DAClusterizerInZ_vect::fillPSetDescription(psd1);
       psd0.add<edm::ParameterSetDescription>("TkDAClusParameters", psd1);
 
       edm::ParameterSetDescription psd2;
       GapClusterizerInZ::fillPSetDescription(psd2);
       psd0.add<edm::ParameterSetDescription>("TkGapClusParameters", psd2);
     }
     psd0.add<std::string>("algorithm", "DA_vect");
     desc.add<edm::ParameterSetDescription>("TkClusParameters", psd0);
   }
 
   descriptions.add("primaryVertexValidation", desc);
 }

◆ fillMap()

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

private

Definition at line 3250 of file PrimaryVertexValidation.cc.

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

Referenced by endJob().

 {
   for (int i = 0; i < nYBins_; ++i) {
     char phibincenter[129];
     auto phiBins = theDetails_.trendbins[PVValHelper::phi];
     sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
 
     if (nXBins_ == nYBins_) {
       trendMap->GetYaxis()->SetBinLabel(i + 1, phibincenter);
     }
 
     for (int j = 0; j < nXBins_; ++j) {
       char etabincenter[129];
       auto etaBins = theDetails_.trendbins[PVValHelper::eta];
       sprintf(etabincenter, "%.1f", (etaBins[j] + etaBins[j + 1]) / 2.);
 
       if (i == 0) {
         if (nXBins_ == nYBins_) {
           trendMap->GetXaxis()->SetBinLabel(j + 1, etabincenter);
         }
       }
 
       switch (fitPar_) {
         case PVValHelper::MEAN: {
           float mean_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.value();
           float meanErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).first.error();
           trendMap->SetBinContent(j + 1, i + 1, mean_);
           trendMap->SetBinError(j + 1, i + 1, meanErr_);
           break;
         }
         case PVValHelper::WIDTH: {
           float width_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.value();
           float widthErr_ = PVValHelper::fitResiduals(residualsMapPlot[i][j]).second.error();
           trendMap->SetBinContent(j + 1, i + 1, width_);
           trendMap->SetBinError(j + 1, i + 1, widthErr_);
           break;
         }
         case PVValHelper::MEDIAN: {
           float median_ = PVValHelper::getMedian(residualsMapPlot[i][j]).value();
           float medianErr_ = PVValHelper::getMedian(residualsMapPlot[i][j]).error();
           trendMap->SetBinContent(j + 1, i + 1, median_);
           trendMap->SetBinError(j + 1, i + 1, medianErr_);
           break;
         }
         case PVValHelper::MAD: {
           float mad_ = PVValHelper::getMAD(residualsMapPlot[i][j]).value();
           float madErr_ = PVValHelper::getMAD(residualsMapPlot[i][j]).error();
           trendMap->SetBinContent(j + 1, i + 1, mad_);
           trendMap->SetBinError(j + 1, i + 1, madErr_);
           break;
         }
         default:
           edm::LogWarning("PrimaryVertexValidation:") << " fillMap() " << fitPar_ << " unknown estimator!" << std::endl;
       }
     }  // closes loop on eta bins
   }    // cloeses loop on phi bins
 }

◆ 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 3545 of file PrimaryVertexValidation.cc.

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

Referenced by analyze().

 {
   using namespace reco;
 
   PVValHelper::fill(h, "pseudorapidity_" + ttype, tt->track().eta());
   PVValHelper::fill(h, "z0_" + ttype, tt->track().vz());
   PVValHelper::fill(h, "phi_" + ttype, tt->track().phi());
   PVValHelper::fill(h, "eta_" + ttype, tt->track().eta());
   PVValHelper::fill(h, "pt_" + ttype, tt->track().pt());
   PVValHelper::fill(h, "p_" + ttype, tt->track().p());
   PVValHelper::fill(h, "found_" + ttype, tt->track().found());
   PVValHelper::fill(h, "lost_" + ttype, tt->track().lost());
   PVValHelper::fill(h, "nchi2_" + ttype, tt->track().normalizedChi2());
   PVValHelper::fill(h, "rstart_" + ttype, (tt->track().innerPosition()).Rho());
 
   double d0Error = tt->track().d0Error();
   double d0 = tt->track().dxy(beamSpot.position());
   double dz = tt->track().dz(beamSpot.position());
   if (d0Error > 0) {
     PVValHelper::fill(h, "logtresxy_" + ttype, log(d0Error / 0.0001) / log(10.));
     PVValHelper::fill(h, "tpullxy_" + ttype, d0 / d0Error);
     PVValHelper::fill(h, "tlogDCAxy_" + ttype, log(std::abs(d0 / d0Error)));
   }
   //double z0=tt->track().vz();
   double dzError = tt->track().dzError();
   if (dzError > 0) {
     PVValHelper::fill(h, "logtresz_" + ttype, log(dzError / 0.0001) / log(10.));
     PVValHelper::fill(h, "tpullz_" + ttype, dz / dzError);
     PVValHelper::fill(h, "tlogDCAz_" + ttype, log(std::abs(dz / dzError)));
   }
 
   //
   double wxy2_ = pow(beamSpot.BeamWidthX(), 2) + pow(beamSpot.BeamWidthY(), 2);
 
   PVValHelper::fill(
       h, "sigmatrkz_" + ttype, sqrt(pow(tt->track().dzError(), 2) + wxy2_ / pow(tan(tt->track().theta()), 2)));
   PVValHelper::fill(h, "sigmatrkz0_" + ttype, tt->track().dzError());
 
   // track vs vertex
   if (v.isValid()) {  // && (v.ndof()<10.)) {
     // emulate clusterizer input
     //const TransientTrack & tt = theB_->build(&t); wrong !!!!
     //reco::TransientTrack tt = theB_->build(&t);
     //ttt->track().setBeamSpot(beamSpot); // need the setBeamSpot !
     double z = (tt->stateAtBeamLine().trackStateAtPCA()).position().z();
     double tantheta = tan((tt->stateAtBeamLine().trackStateAtPCA()).momentum().theta());
     double dz2 = pow(tt->track().dzError(), 2) + wxy2_ / pow(tantheta, 2);
 
     PVValHelper::fill(h, "restrkz_" + ttype, z - v.position().z());
     PVValHelper::fill(h, "restrkzvsphi_" + ttype, tt->track().phi(), z - v.position().z());
     PVValHelper::fill(h, "restrkzvseta_" + ttype, tt->track().eta(), z - v.position().z());
     PVValHelper::fill(h, "pulltrkzvsphi_" + ttype, tt->track().phi(), (z - v.position().z()) / sqrt(dz2));
     PVValHelper::fill(h, "pulltrkzvseta_" + ttype, tt->track().eta(), (z - v.position().z()) / sqrt(dz2));
 
     PVValHelper::fill(h, "pulltrkz_" + ttype, (z - v.position().z()) / sqrt(dz2));
 
     double x1 = tt->track().vx() - beamSpot.x0();
     double y1 = tt->track().vy() - beamSpot.y0();
 
     double kappa = -0.002998 * fBfield_ * tt->track().qoverp() / cos(tt->track().theta());
     double D0 = x1 * sin(tt->track().phi()) - y1 * cos(tt->track().phi()) - 0.5 * kappa * (x1 * x1 + y1 * y1);
     double q = sqrt(1. - 2. * kappa * D0);
     double s0 = (x1 * cos(tt->track().phi()) + y1 * sin(tt->track().phi())) / q;
     // double s1;
     if (std::abs(kappa * s0) > 0.001) {
       //s1=asin(kappa*s0)/kappa;
     } else {
       //double ks02=(kappa*s0)*(kappa*s0);
       //s1=s0*(1.+ks02/6.+3./40.*ks02*ks02+5./112.*pow(ks02,3));
     }
     // sp.ddcap=-2.*D0/(1.+q);
     //double zdcap=tt->track().vz()-s1/tan(tt->track().theta());
   }
   //
 
   // collect some info on hits and clusters
   PVValHelper::fill(h, "nbarrelLayers_" + ttype, tt->track().hitPattern().pixelBarrelLayersWithMeasurement());
   PVValHelper::fill(h, "nPxLayers_" + ttype, tt->track().hitPattern().pixelLayersWithMeasurement());
   PVValHelper::fill(h, "nSiLayers_" + ttype, tt->track().hitPattern().trackerLayersWithMeasurement());
   PVValHelper::fill(
       h, "expectedInner_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS));
   PVValHelper::fill(
       h, "expectedOuter_" + ttype, tt->track().hitPattern().numberOfLostHits(HitPattern::MISSING_OUTER_HITS));
   PVValHelper::fill(h, "trackAlgo_" + ttype, tt->track().algo());
   PVValHelper::fill(h, "trackQuality_" + ttype, tt->track().qualityMask());
 
   //
   int longesthit = 0, nbarrel = 0;
   for (auto const& hit : tt->track().recHits()) {
     if (hit->isValid() && hit->geographicalId().det() == DetId::Tracker) {
       bool barrel = DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelBarrel);
       //bool endcap = DetId::DetId(hit->geographicalId()).subdetId() == static_cast<int>(PixelSubdetector::PixelEndcap);
       if (barrel) {
         const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>(&(*hit));
         edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const& clust = (*pixhit).cluster();
         if (clust.isNonnull()) {
           nbarrel++;
           if (clust->sizeY() - longesthit > 0)
             longesthit = clust->sizeY();
           if (clust->sizeY() > 20.) {
             PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), 19.9);
             PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), 19.9);
           } else {
             PVValHelper::fill(h, "lvseta_" + ttype, tt->track().eta(), float(clust->sizeY()));
             PVValHelper::fill(h, "lvstanlambda_" + ttype, tan(tt->track().lambda()), float(clust->sizeY()));
           }
         }
       }
     }
   }
   PVValHelper::fill(h, "nbarrelhits_" + ttype, float(nbarrel));
   //-------------------------------------------------------------------
 }

◆ fillTrendPlot()

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

private

Definition at line 3126 of file PrimaryVertexValidation.cc.

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

 {
   for (int i = 0; i < nBins_; ++i) {
     char phibincenter[129];
     auto phiBins = theDetails_.trendbins[PVValHelper::phi];
     sprintf(phibincenter, "%.f", (phiBins[i] + phiBins[i + 1]) / 2.);
 
     char etabincenter[129];
     auto etaBins = theDetails_.trendbins[PVValHelper::eta];
     sprintf(etabincenter, "%.1f", (etaBins[i] + etaBins[i + 1]) / 2.);
 
     switch (fitPar_) {
       case PVValHelper::MEAN: {
         float mean_ = PVValHelper::fitResiduals(residualsPlot[i]).first.value();
         float meanErr_ = PVValHelper::fitResiduals(residualsPlot[i]).first.error();
         trendPlot->SetBinContent(i + 1, mean_);
         trendPlot->SetBinError(i + 1, meanErr_);
         break;
       }
       case PVValHelper::WIDTH: {
         float width_ = PVValHelper::fitResiduals(residualsPlot[i]).second.value();
         float widthErr_ = PVValHelper::fitResiduals(residualsPlot[i]).second.error();
         trendPlot->SetBinContent(i + 1, width_);
         trendPlot->SetBinError(i + 1, widthErr_);
         break;
       }
       case PVValHelper::MEDIAN: {
         float median_ = PVValHelper::getMedian(residualsPlot[i]).value();
         float medianErr_ = PVValHelper::getMedian(residualsPlot[i]).error();
         trendPlot->SetBinContent(i + 1, median_);
         trendPlot->SetBinError(i + 1, medianErr_);
         break;
       }
       case PVValHelper::MAD: {
         float mad_ = PVValHelper::getMAD(residualsPlot[i]).value();
         float madErr_ = PVValHelper::getMAD(residualsPlot[i]).error();
         trendPlot->SetBinContent(i + 1, mad_);
         trendPlot->SetBinError(i + 1, madErr_);
         break;
       }
       default:
         edm::LogWarning("PrimaryVertexValidation")
             << "fillTrendPlot() " << fitPar_ << " unknown estimator!" << std::endl;
         break;
     }
 
     if (var_.find("eta") != std::string::npos) {
       trendPlot->GetXaxis()->SetBinLabel(i + 1, etabincenter);
     } else if (var_.find("phi") != std::string::npos) {
       trendPlot->GetXaxis()->SetBinLabel(i + 1, phibincenter);
     } else {
       edm::LogWarning("PrimaryVertexValidation")
           << "fillTrendPlot() " << var_ << " unknown track parameter!" << std::endl;
     }
   }
 }

◆ 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 3188 of file PrimaryVertexValidation.cc.

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

Referenced by endJob().

 {
   for (auto iterator = h.begin(); iterator != h.end(); iterator++) {
     unsigned int bin = std::distance(h.begin(), iterator) + 1;
     std::pair<Measurement1D, Measurement1D> myFit = PVValHelper::fitResiduals((*iterator));
 
     switch (fitPar_) {
       case PVValHelper::MEAN: {
         float mean_ = myFit.first.value();
         float meanErr_ = myFit.first.error();
         trendPlot->SetBinContent(bin, mean_);
         trendPlot->SetBinError(bin, meanErr_);
         break;
       }
       case PVValHelper::WIDTH: {
         float width_ = myFit.second.value();
         float widthErr_ = myFit.second.error();
         trendPlot->SetBinContent(bin, width_);
         trendPlot->SetBinError(bin, widthErr_);
         break;
       }
       case PVValHelper::MEDIAN: {
         float median_ = PVValHelper::getMedian(*iterator).value();
         float medianErr_ = PVValHelper::getMedian(*iterator).error();
         trendPlot->SetBinContent(bin, median_);
         trendPlot->SetBinError(bin, medianErr_);
         break;
       }
       case PVValHelper::MAD: {
         float mad_ = PVValHelper::getMAD(*iterator).value();
         float madErr_ = PVValHelper::getMAD(*iterator).error();
         trendPlot->SetBinContent(bin, mad_);
         trendPlot->SetBinError(bin, madErr_);
         break;
       }
       default:
         edm::LogWarning("PrimaryVertexValidation")
             << "fillTrendPlotByIndex() " << fitPar_ << " unknown estimator!" << std::endl;
         break;
     }
 
     char bincenter[129];
     if (plotVar == PVValHelper::eta) {
       auto etaBins = theDetails_.trendbins[PVValHelper::eta];
       sprintf(bincenter, "%.1f", (etaBins[bin - 1] + etaBins[bin]) / 2.);
       trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
     } else if (plotVar == PVValHelper::phi) {
       auto phiBins = theDetails_.trendbins[PVValHelper::phi];
       sprintf(bincenter, "%.f", (phiBins[bin - 1] + phiBins[bin]) / 2.);
       trendPlot->GetXaxis()->SetBinLabel(bin, bincenter);
     } else {
       //edm::LogWarning("PrimaryVertexValidation")<<"fillTrendPlotByIndex() "<< plotVar <<" unknown track parameter!"<<std::endl;
     }
   }
 }

◆ 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 3028 of file PrimaryVertexValidation.cc.

References debug_, submitPVValidationJobs::runInfo, and runInfoTokenBR_.

Referenced by beginRun().

 {
   edm::ESHandle<RunInfo> runInfo = iSetup.getHandle(runInfoTokenBR_);
   if (debug_) {
     edm::LogInfo("PrimaryVertexValidation")
         << runInfo.product()->m_start_time_str << " " << runInfo.product()->m_stop_time_str << std::endl;
   }
   return std::make_pair(runInfo.product()->m_start_time_ll, runInfo.product()->m_stop_time_ll);
 }

◆ 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 1063 of file PrimaryVertexValidation.cc.

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

Referenced by analyze().

                                                                                     {
   using namespace reco;
   const HitPattern& p = track.hitPattern();
   for (int i = 0; i < p.numberOfAllHits(HitPattern::TRACK_HITS); i++) {
     uint32_t pattern = p.getHitPattern(HitPattern::TRACK_HITS, i);
     if (p.pixelBarrelHitFilter(pattern) || p.pixelEndcapHitFilter(pattern)) {
       if (p.getLayer(pattern) == 1) {
         if (p.validHitFilter(pattern)) {
           return true;
         }
       }
     }
   }
   return false;
 }

◆ isBFieldConsistentWithMode()

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

private

Definition at line 3040 of file PrimaryVertexValidation.cc.

References ptOfProbe_, submitPVValidationJobs::runInfo, and runInfoTokenBR_.

Referenced by beginRun().

 {
   edm::ESHandle<RunInfo> runInfo = iSetup.getHandle(runInfoTokenBR_);
   double average_current = runInfo.product()->m_avg_current;
   bool isOn = (average_current > 2000.);
   bool is0T = (ptOfProbe_ == 0.);
 
   return ((isOn && !is0T) || (!isOn && is0T));
 }

◆ isHit2D()

bool PrimaryVertexValidation::isHit2D	(	const TrackingRecHit &	hit,
		const PVValHelper::detectorPhase &	thePhase
	)		const

private

Definition at line 1013 of file PrimaryVertexValidation.cc.

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

Referenced by analyze().

                                                                                                                {
   if (hit.dimension() < 2) {
     return false;  // some (muon...) stuff really has RecHit1D
   } else {
     const DetId detId(hit.geographicalId());
     if (detId.det() == DetId::Tracker) {
       if (detId.subdetId() == PixelSubdetector::PixelBarrel || detId.subdetId() == PixelSubdetector::PixelEndcap) {
         return true;                                 // pixel is always 2D
       } else if (thePhase != PVValHelper::phase2) {  // should be SiStrip now
         if (dynamic_cast<const SiStripRecHit2D*>(&hit))
           return false;  // normal hit
         else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit))
           return true;  // matched is 2D
         else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit))
           return false;  // crazy hit...
         else {
           edm::LogError("UnknownType") << "@SUB=PrimaryVertexValidation::isHit2D"
                                        << "Tracker hit not in pixel and neither SiStripRecHit2D nor "
                                        << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
           return false;
         }
       } else {
         return false;
       }
     } else {  // not tracker??
       edm::LogWarning("DetectorMismatch") << "@SUB=PrimaryVertexValidation::isHit2D"
                                           << "Hit not in tracker with 'official' dimension >=2.";
       return true;  // dimension() >= 2 so accept that...
     }
   }
   // never reached...
 }

◆ 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 3324 of file PrimaryVertexValidation.cc.

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

 {
   math::XYZPoint vtxPoint(0.0, 0.0, 0.0);
   double vzErr = 0.0, vxErr = 0.0, vyErr = 0.0;
   vtxPoint = vertex.position();
   vzErr = vertex.zError();
   vxErr = vertex.xError();
   vyErr = vertex.yError();
 
   double dxy = 0.0, dz = 0.0, dxysigma = 0.0, dzsigma = 0.0;
   dxy = track.dxy(vtxPoint);
   dz = track.dz(vtxPoint);
   dxysigma = sqrt(track.d0Error() * track.d0Error() + vxErr * vyErr);
   dzsigma = sqrt(track.dzError() * track.dzError() + vzErr * vzErr);
 
   if (track.quality(reco::TrackBase::qualityByName(qualityString_)) != 1)
     return false;
   if (std::abs(dxy / dxysigma) > dxyErrMax_)
     return false;
   if (std::abs(dz / dzsigma) > dzErrMax_)
     return false;
   if (track.ptError() / track.pt() > ptErrMax_)
     return false;
 
   return true;
 }

◆ pixelHitsCheck()

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

private

Definition at line 1047 of file PrimaryVertexValidation.cc.

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

Referenced by analyze().

                                                                                            {
   bool hasBPixHits = false;
   bool hasFPixHits = false;
 
   const reco::HitPattern& p = track.hitPattern();
   if (p.numberOfValidPixelEndcapHits() != 0) {
     hasFPixHits = true;
   }
   if (p.numberOfValidPixelBarrelHits() != 0) {
     hasBPixHits = true;
   }
 
   return std::make_pair(hasBPixHits, hasFPixHits);
 }

◆ SetVarToZero()

void PrimaryVertexValidation::SetVarToZero ( )

private

Definition at line 3052 of file PrimaryVertexValidation.cc.

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().

 {
   nTracks_ = 0;
   nClus_ = 0;
   nOfflineVertices_ = 0;
   RunNumber_ = 0;
   LuminosityBlockNumber_ = 0;
   xOfflineVertex_ = -999.;
   yOfflineVertex_ = -999.;
   zOfflineVertex_ = -999.;
   xErrOfflineVertex_ = 0.;
   yErrOfflineVertex_ = 0.;
   zErrOfflineVertex_ = 0.;
   BSx0_ = -999.;
   BSy0_ = -999.;
   BSz0_ = -999.;
   Beamsigmaz_ = -999.;
   Beamdxdz_ = -999.;
   BeamWidthX_ = -999.;
   BeamWidthY_ = -999.;
   wxy2_ = -999.;
 
   for (int i = 0; i < nMaxtracks_; ++i) {
     pt_[i] = 0;
     p_[i] = 0;
     nhits_[i] = 0;
     nhits1D_[i] = 0;
     nhits2D_[i] = 0;
     nhitsBPIX_[i] = 0;
     nhitsFPIX_[i] = 0;
     nhitsTIB_[i] = 0;
     nhitsTID_[i] = 0;
     nhitsTOB_[i] = 0;
     nhitsTEC_[i] = 0;
     isHighPurity_[i] = 0;
     eta_[i] = 0;
     theta_[i] = 0;
     phi_[i] = 0;
     chi2_[i] = 0;
     chi2ndof_[i] = 0;
     charge_[i] = 0;
     qoverp_[i] = 0;
     dz_[i] = 0;
     dxy_[i] = 0;
     dzBs_[i] = 0;
     dxyBs_[i] = 0;
     xPCA_[i] = 0;
     yPCA_[i] = 0;
     zPCA_[i] = 0;
     xUnbiasedVertex_[i] = 0;
     yUnbiasedVertex_[i] = 0;
     zUnbiasedVertex_[i] = 0;
     chi2normUnbiasedVertex_[i] = 0;
     chi2UnbiasedVertex_[i] = 0;
     chi2ProbUnbiasedVertex_[i] = 0;
     DOFUnbiasedVertex_[i] = 0;
     sumOfWeightsUnbiasedVertex_[i] = 0;
     tracksUsedForVertexing_[i] = 0;
     dxyFromMyVertex_[i] = 0;
     dzFromMyVertex_[i] = 0;
     d3DFromMyVertex_[i] = 0;
     dxyErrorFromMyVertex_[i] = 0;
     dzErrorFromMyVertex_[i] = 0;
     d3DErrorFromMyVertex_[i] = 0;
     IPTsigFromMyVertex_[i] = 0;
     IPLsigFromMyVertex_[i] = 0;
     IP3DsigFromMyVertex_[i] = 0;
     hasRecVertex_[i] = 0;
     isGoodTrack_[i] = 0;
   }
 }

◆ shrinkHistVectorToFit()

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

private

◆ square()

double PrimaryVertexValidation::square ( double x )

inlineprivate

Definition at line 140 of file PrimaryVertexValidation.h.

References x.

140 { return x * x; }

DDAxes::x

◆ vtxSort()

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

staticprivate

Definition at line 3314 of file PrimaryVertexValidation.cc.

References a, b, and funct::true.

Referenced by analyze().

 {
   if (a.tracksSize() != b.tracksSize())
     return a.tracksSize() > b.tracksSize() ? true : false;
   else
     return a.chi2() < b.chi2() ? true : false;
 }

Member Data Documentation

◆ a_d3DEtaResiduals

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

private

Definition at line 350 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_d3DPhiResiduals

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

private

Definition at line 349 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_d3DResidualsMap

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

private

Definition at line 376 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxEtaResiduals

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

private

Definition at line 332 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxPhiResiduals

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

private

Definition at line 331 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyBiasResidualsMap

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

private

Definition at line 541 of file PrimaryVertexValidation.h.

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

◆ a_dxyEtaBiasResiduals

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

private

Definition at line 526 of file PrimaryVertexValidation.h.

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

◆ a_dxyEtaMADBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMADBiasTrend

private

Definition at line 577 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMADTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMADTrend

private

Definition at line 463 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMeanBiasTrend

private

Definition at line 554 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMeanTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMeanTrend

private

Definition at line 396 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMedianBiasTrend

private

Definition at line 576 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaMedianTrend

TH1F* PrimaryVertexValidation::a_dxyEtaMedianTrend

private

Definition at line 462 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaResiduals

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

private

Definition at line 329 of file PrimaryVertexValidation.h.

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

◆ a_dxyEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dxyEtaWidthBiasTrend

private

Definition at line 555 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyEtaWidthTrend

TH1F* PrimaryVertexValidation::a_dxyEtaWidthTrend

private

Definition at line 397 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyL1MeanMap

TH2F* PrimaryVertexValidation::a_dxyL1MeanMap

private

Definition at line 507 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyL1ResidualsMap

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

private

Definition at line 384 of file PrimaryVertexValidation.h.

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

◆ a_dxyL1WidthMap

TH2F* PrimaryVertexValidation::a_dxyL1WidthMap

private

Definition at line 513 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyladderMeanTrend

TH1F* PrimaryVertexValidation::a_dxyladderMeanTrend

private

Definition at line 440 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyladderWidthTrend

TH1F* PrimaryVertexValidation::a_dxyladderWidthTrend

private

Definition at line 441 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyMeanBiasMap

TH2F* PrimaryVertexValidation::a_dxyMeanBiasMap

private

Definition at line 593 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyMeanMap

TH2F* PrimaryVertexValidation::a_dxyMeanMap

private

Definition at line 493 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxymodZMeanTrend

TH1F* PrimaryVertexValidation::a_dxymodZMeanTrend

private

Definition at line 435 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxymodZWidthTrend

TH1F* PrimaryVertexValidation::a_dxymodZWidthTrend

private

Definition at line 436 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dxyPhiBiasResiduals

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

private

Definition at line 525 of file PrimaryVertexValidation.h.

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

◆ a_dxyPhiMADBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMADBiasTrend

private

Definition at line 572 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMADTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMADTrend

private

Definition at line 458 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMeanBiasTrend

private

Definition at line 549 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMeanTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMeanTrend

private

Definition at line 391 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMedianBiasTrend

private

Definition at line 571 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiMedianTrend

TH1F* PrimaryVertexValidation::a_dxyPhiMedianTrend

private

Definition at line 457 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiResiduals

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

private

Definition at line 328 of file PrimaryVertexValidation.h.

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

◆ a_dxyPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dxyPhiWidthBiasTrend

private

Definition at line 550 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyPhiWidthTrend

TH1F* PrimaryVertexValidation::a_dxyPhiWidthTrend

private

Definition at line 392 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTCentralMeanTrend

TH1F* PrimaryVertexValidation::a_dxypTCentralMeanTrend

private

Definition at line 418 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTCentralWidthTrend

TH1F* PrimaryVertexValidation::a_dxypTCentralWidthTrend

private

Definition at line 419 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTMeanTrend

TH1F* PrimaryVertexValidation::a_dxypTMeanTrend

private

Definition at line 413 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxypTWidthTrend

TH1F* PrimaryVertexValidation::a_dxypTWidthTrend

private

Definition at line 414 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyResidualsMap

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

private

Definition at line 374 of file PrimaryVertexValidation.h.

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

◆ a_dxyVsEta

TH2F* PrimaryVertexValidation::a_dxyVsEta

private

Definition at line 485 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyVsPhi

TH2F* PrimaryVertexValidation::a_dxyVsPhi

private

Definition at line 479 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dxyWidthBiasMap

TH2F* PrimaryVertexValidation::a_dxyWidthBiasMap

private

Definition at line 599 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dxyWidthMap

TH2F* PrimaryVertexValidation::a_dxyWidthMap

private

Definition at line 499 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dyEtaResiduals

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

private

Definition at line 335 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dyPhiResiduals

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

private

Definition at line 334 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzBiasResidualsMap

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

private

Definition at line 542 of file PrimaryVertexValidation.h.

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

◆ a_dzEtaBiasResiduals

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

private

Definition at line 529 of file PrimaryVertexValidation.h.

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

◆ a_dzEtaMADBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMADBiasTrend

private

Definition at line 579 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMADTrend

TH1F* PrimaryVertexValidation::a_dzEtaMADTrend

private

Definition at line 465 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMeanBiasTrend

private

Definition at line 556 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMeanTrend

TH1F* PrimaryVertexValidation::a_dzEtaMeanTrend

private

Definition at line 398 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaMedianBiasTrend

private

Definition at line 578 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaMedianTrend

TH1F* PrimaryVertexValidation::a_dzEtaMedianTrend

private

Definition at line 464 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaResiduals

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

private

Definition at line 338 of file PrimaryVertexValidation.h.

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

◆ a_dzEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dzEtaWidthBiasTrend

private

Definition at line 557 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzEtaWidthTrend

TH1F* PrimaryVertexValidation::a_dzEtaWidthTrend

private

Definition at line 399 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzL1MeanMap

TH2F* PrimaryVertexValidation::a_dzL1MeanMap

private

Definition at line 508 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzL1ResidualsMap

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

private

Definition at line 385 of file PrimaryVertexValidation.h.

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

◆ a_dzL1WidthMap

TH2F* PrimaryVertexValidation::a_dzL1WidthMap

private

Definition at line 514 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzladderMeanTrend

TH1F* PrimaryVertexValidation::a_dzladderMeanTrend

private

Definition at line 442 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzladderWidthTrend

TH1F* PrimaryVertexValidation::a_dzladderWidthTrend

private

Definition at line 443 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzMeanBiasMap

TH2F* PrimaryVertexValidation::a_dzMeanBiasMap

private

Definition at line 594 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzMeanMap

TH2F* PrimaryVertexValidation::a_dzMeanMap

private

Definition at line 494 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzmodZMeanTrend

TH1F* PrimaryVertexValidation::a_dzmodZMeanTrend

private

Definition at line 437 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzmodZWidthTrend

TH1F* PrimaryVertexValidation::a_dzmodZWidthTrend

private

Definition at line 438 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ a_dzPhiBiasResiduals

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

private

Definition at line 528 of file PrimaryVertexValidation.h.

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

◆ a_dzPhiMADBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMADBiasTrend

private

Definition at line 574 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMADTrend

TH1F* PrimaryVertexValidation::a_dzPhiMADTrend

private

Definition at line 460 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMeanBiasTrend

private

Definition at line 551 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMeanTrend

TH1F* PrimaryVertexValidation::a_dzPhiMeanTrend

private

Definition at line 393 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiMedianBiasTrend

private

Definition at line 573 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiMedianTrend

TH1F* PrimaryVertexValidation::a_dzPhiMedianTrend

private

Definition at line 459 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiResiduals

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

private

Definition at line 337 of file PrimaryVertexValidation.h.

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

◆ a_dzPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::a_dzPhiWidthBiasTrend

private

Definition at line 552 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzPhiWidthTrend

TH1F* PrimaryVertexValidation::a_dzPhiWidthTrend

private

Definition at line 394 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTCentralMeanTrend

TH1F* PrimaryVertexValidation::a_dzpTCentralMeanTrend

private

Definition at line 420 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTCentralWidthTrend

TH1F* PrimaryVertexValidation::a_dzpTCentralWidthTrend

private

Definition at line 421 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTMeanTrend

TH1F* PrimaryVertexValidation::a_dzpTMeanTrend

private

Definition at line 415 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzpTWidthTrend

TH1F* PrimaryVertexValidation::a_dzpTWidthTrend

private

Definition at line 416 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzResidualsMap

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

private

Definition at line 375 of file PrimaryVertexValidation.h.

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

◆ a_dzVsEta

TH2F* PrimaryVertexValidation::a_dzVsEta

private

Definition at line 486 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzVsPhi

TH2F* PrimaryVertexValidation::a_dzVsPhi

private

Definition at line 480 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_dzWidthBiasMap

TH2F* PrimaryVertexValidation::a_dzWidthBiasMap

private

Definition at line 600 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_dzWidthMap

TH2F* PrimaryVertexValidation::a_dzWidthMap

private

Definition at line 500 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ a_IP2DEtaResiduals

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

private

Definition at line 341 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP2DPhiResiduals

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

private

Definition at line 340 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP3DEtaResiduals

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

private

Definition at line 344 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_IP3DPhiResiduals

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

private

Definition at line 343 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_reszEtaResiduals

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

private

Definition at line 347 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ a_reszPhiResiduals

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

private

Definition at line 346 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ askFirstLayerHit_

bool PrimaryVertexValidation::askFirstLayerHit_

private

Definition at line 177 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ Beamdxdz_

double PrimaryVertexValidation::Beamdxdz_

private

Definition at line 246 of file PrimaryVertexValidation.h.

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

◆ Beamsigmaz_

double PrimaryVertexValidation::Beamsigmaz_

private

Definition at line 245 of file PrimaryVertexValidation.h.

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

◆ BeamWidthX_

double PrimaryVertexValidation::BeamWidthX_

private

Definition at line 247 of file PrimaryVertexValidation.h.

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

◆ BeamWidthY_

double PrimaryVertexValidation::BeamWidthY_

private

Definition at line 248 of file PrimaryVertexValidation.h.

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

◆ BSx0_

double PrimaryVertexValidation::BSx0_

private

Definition at line 242 of file PrimaryVertexValidation.h.

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

◆ BSy0_

double PrimaryVertexValidation::BSy0_

private

Definition at line 243 of file PrimaryVertexValidation.h.

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

◆ BSz0_

double PrimaryVertexValidation::BSz0_

private

Definition at line 244 of file PrimaryVertexValidation.h.

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

◆ charge_

int PrimaryVertexValidation::charge_[nMaxtracks_]

private

Definition at line 269 of file PrimaryVertexValidation.h.

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

◆ chi2_

double PrimaryVertexValidation::chi2_[nMaxtracks_]

private

Definition at line 267 of file PrimaryVertexValidation.h.

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

◆ chi2ndof_

double PrimaryVertexValidation::chi2ndof_[nMaxtracks_]

private

Definition at line 268 of file PrimaryVertexValidation.h.

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

◆ chi2normUnbiasedVertex_

float PrimaryVertexValidation::chi2normUnbiasedVertex_[nMaxtracks_]

private

Definition at line 281 of file PrimaryVertexValidation.h.

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

◆ chi2ProbUnbiasedVertex_

float PrimaryVertexValidation::chi2ProbUnbiasedVertex_[nMaxtracks_]

private

Definition at line 283 of file PrimaryVertexValidation.h.

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

◆ chi2UnbiasedVertex_

float PrimaryVertexValidation::chi2UnbiasedVertex_[nMaxtracks_]

private

Definition at line 282 of file PrimaryVertexValidation.h.

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

◆ cmToum

const int PrimaryVertexValidation::cmToum = 10000

staticprivate

Definition at line 212 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ compressionSettings_

const int PrimaryVertexValidation::compressionSettings_

private

Definition at line 162 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ d3DErrorFromMyVertex_

double PrimaryVertexValidation::d3DErrorFromMyVertex_[nMaxtracks_]

private

Definition at line 294 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ d3DFromMyVertex_

double PrimaryVertexValidation::d3DFromMyVertex_[nMaxtracks_]

private

Definition at line 290 of file PrimaryVertexValidation.h.

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

◆ debug_

bool PrimaryVertexValidation::debug_

private

Definition at line 195 of file PrimaryVertexValidation.h.

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

◆ doBPix_

bool PrimaryVertexValidation::doBPix_

private

Definition at line 178 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ doFPix_

bool PrimaryVertexValidation::doFPix_

private

Definition at line 179 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ DOFUnbiasedVertex_

float PrimaryVertexValidation::DOFUnbiasedVertex_[nMaxtracks_]

private

Definition at line 284 of file PrimaryVertexValidation.h.

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

◆ dxy_

double PrimaryVertexValidation::dxy_[nMaxtracks_]

private

Definition at line 272 of file PrimaryVertexValidation.h.

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

◆ dxyBs_

double PrimaryVertexValidation::dxyBs_[nMaxtracks_]

private

Definition at line 273 of file PrimaryVertexValidation.h.

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

◆ dxyErrorFromMyVertex_

double PrimaryVertexValidation::dxyErrorFromMyVertex_[nMaxtracks_]

private

Definition at line 292 of file PrimaryVertexValidation.h.

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

◆ dxyFromMyVertex_

double PrimaryVertexValidation::dxyFromMyVertex_[nMaxtracks_]

private

Definition at line 288 of file PrimaryVertexValidation.h.

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

◆ dz_

double PrimaryVertexValidation::dz_[nMaxtracks_]

private

Definition at line 271 of file PrimaryVertexValidation.h.

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

◆ dzBs_

double PrimaryVertexValidation::dzBs_[nMaxtracks_]

private

Definition at line 274 of file PrimaryVertexValidation.h.

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

◆ dzErrorFromMyVertex_

double PrimaryVertexValidation::dzErrorFromMyVertex_[nMaxtracks_]

private

Definition at line 293 of file PrimaryVertexValidation.h.

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

◆ dzFromMyVertex_

double PrimaryVertexValidation::dzFromMyVertex_[nMaxtracks_]

private

Definition at line 289 of file PrimaryVertexValidation.h.

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

◆ eta_

double PrimaryVertexValidation::eta_[nMaxtracks_]

private

Definition at line 264 of file PrimaryVertexValidation.h.

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

◆ etaOfProbe_

double PrimaryVertexValidation::etaOfProbe_

private

Definition at line 182 of file PrimaryVertexValidation.h.

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

◆ EventNumber_

unsigned int PrimaryVertexValidation::EventNumber_

private

Definition at line 232 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ forceBeamSpotContraint_

bool PrimaryVertexValidation::forceBeamSpotContraint_

private

Definition at line 199 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ fs

edm::Service<TFileService> PrimaryVertexValidation::fs

private

Definition at line 303 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ geomTokenBR_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> PrimaryVertexValidation::geomTokenBR_

private

Definition at line 159 of file PrimaryVertexValidation.h.

Referenced by beginRun().

◆ h2_probeEtaPhi_

TH2F* PrimaryVertexValidation::h2_probeEtaPhi_

private

Definition at line 628 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h2_probeEtaPt_

TH2F* PrimaryVertexValidation::h2_probeEtaPt_

private

Definition at line 629 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h2_probeLayer1Map_

TH2F* PrimaryVertexValidation::h2_probeLayer1Map_

private

Definition at line 677 of file PrimaryVertexValidation.h.

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

◆ h2_probePassingLayer1Map_

TH2F* PrimaryVertexValidation::h2_probePassingLayer1Map_

private

Definition at line 678 of file PrimaryVertexValidation.h.

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

◆ h_Beamsigmaz

TH1F* PrimaryVertexValidation::h_Beamsigmaz

private

Definition at line 622 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BeamWidthX

TH1F* PrimaryVertexValidation::h_BeamWidthX

private

Definition at line 623 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BeamWidthY

TH1F* PrimaryVertexValidation::h_BeamWidthY

private

Definition at line 624 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSx0

TH1F* PrimaryVertexValidation::h_BSx0

private

Definition at line 619 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSy0

TH1F* PrimaryVertexValidation::h_BSy0

private

Definition at line 620 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_BSz0

TH1F* PrimaryVertexValidation::h_BSz0

private

Definition at line 621 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 704 of file PrimaryVertexValidation.h.

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

◆ h_dxy_ladder_

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

private

Definition at line 719 of file PrimaryVertexValidation.h.

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

◆ h_dxy_ladderNoOverlap_

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

private

Definition at line 717 of file PrimaryVertexValidation.h.

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

◆ h_dxy_ladderOverlap_

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

private

Definition at line 716 of file PrimaryVertexValidation.h.

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

◆ h_dxy_modZ_

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

private

Definition at line 711 of file PrimaryVertexValidation.h.

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

◆ h_dxy_pT_

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

private

Definition at line 699 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 705 of file PrimaryVertexValidation.h.

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

◆ h_dz_ladder_

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

private

Definition at line 720 of file PrimaryVertexValidation.h.

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

◆ h_dz_modZ_

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

private

Definition at line 712 of file PrimaryVertexValidation.h.

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

◆ h_dz_pT_

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

private

Definition at line 700 of file PrimaryVertexValidation.h.

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

◆ h_etaMax

TH1F* PrimaryVertexValidation::h_etaMax

private

Definition at line 314 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_fitVtxChi2_

TH1F* PrimaryVertexValidation::h_fitVtxChi2_

private

Definition at line 683 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxChi2ndf_

TH1F* PrimaryVertexValidation::h_fitVtxChi2ndf_

private

Definition at line 685 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxChi2Prob_

TH1F* PrimaryVertexValidation::h_fitVtxChi2Prob_

private

Definition at line 686 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxNdof_

TH1F* PrimaryVertexValidation::h_fitVtxNdof_

private

Definition at line 682 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxNtracks_

TH1F* PrimaryVertexValidation::h_fitVtxNtracks_

private

Definition at line 684 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxTrackAverageWeight_

TH1F* PrimaryVertexValidation::h_fitVtxTrackAverageWeight_

private

Definition at line 688 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_fitVtxTrackWeights_

TH1F* PrimaryVertexValidation::h_fitVtxTrackWeights_

private

Definition at line 687 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_lumiFromConfig

TH1F* PrimaryVertexValidation::h_lumiFromConfig

private

Definition at line 610 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ h_nbins

TH1F* PrimaryVertexValidation::h_nbins

private

Definition at line 315 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_nClus

TH1F* PrimaryVertexValidation::h_nClus

private

Definition at line 607 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_nLadders

TH1F* PrimaryVertexValidation::h_nLadders

private

Definition at line 316 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_nModZ

TH1F* PrimaryVertexValidation::h_nModZ

private

Definition at line 317 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_nOfflineVertices

TH1F* PrimaryVertexValidation::h_nOfflineVertices

private

Definition at line 608 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 706 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 721 of file PrimaryVertexValidation.h.

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

◆ h_norm_dxy_modZ_

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

private

Definition at line 713 of file PrimaryVertexValidation.h.

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

◆ h_norm_dxy_pT_

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

private

Definition at line 701 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 707 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 722 of file PrimaryVertexValidation.h.

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

◆ h_norm_dz_modZ_

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

private

Definition at line 714 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 702 of file PrimaryVertexValidation.h.

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

◆ h_nTracks

TH1F* PrimaryVertexValidation::h_nTracks

private

Definition at line 606 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeCharge_

TH1F* PrimaryVertexValidation::h_probeCharge_

private

Definition at line 638 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeChi2_

TH1F* PrimaryVertexValidation::h_probeChi2_

private

Definition at line 636 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probed0RefitV_

TH1F* PrimaryVertexValidation::h_probed0RefitV_

private

Definition at line 647 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probed3DRefitV_

TH1F* PrimaryVertexValidation::h_probed3DRefitV_

private

Definition at line 651 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedxyRecoV_

TH1F* PrimaryVertexValidation::h_probedxyRecoV_

private

Definition at line 642 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedxyRefitV_

TH1F* PrimaryVertexValidation::h_probedxyRefitV_

private

Definition at line 645 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedzRecoV_

TH1F* PrimaryVertexValidation::h_probedzRecoV_

private

Definition at line 641 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probedzRefitV_

TH1F* PrimaryVertexValidation::h_probedzRefitV_

private

Definition at line 644 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeEta_

TH1F* PrimaryVertexValidation::h_probeEta_

private

Definition at line 634 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHasBPixL1Overlap_

TH1I* PrimaryVertexValidation::h_probeHasBPixL1Overlap_

private

Definition at line 674 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits1D_

TH1F* PrimaryVertexValidation::h_probeHits1D_

private

Definition at line 663 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits2D_

TH1F* PrimaryVertexValidation::h_probeHits2D_

private

Definition at line 664 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHits_

TH1F* PrimaryVertexValidation::h_probeHits_

private

Definition at line 662 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInBPIX_

TH1F* PrimaryVertexValidation::h_probeHitsInBPIX_

private

Definition at line 669 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInFPIX_

TH1F* PrimaryVertexValidation::h_probeHitsInFPIX_

private

Definition at line 670 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTEC_

TH1F* PrimaryVertexValidation::h_probeHitsInTEC_

private

Definition at line 668 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTIB_

TH1F* PrimaryVertexValidation::h_probeHitsInTIB_

private

Definition at line 665 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTID_

TH1F* PrimaryVertexValidation::h_probeHitsInTID_

private

Definition at line 667 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeHitsInTOB_

TH1F* PrimaryVertexValidation::h_probeHitsInTOB_

private

Definition at line 666 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeL1ClusterProb_

TH1F* PrimaryVertexValidation::h_probeL1ClusterProb_

private

Definition at line 676 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeL1Ladder_

TH1F* PrimaryVertexValidation::h_probeL1Ladder_

private

Definition at line 672 of file PrimaryVertexValidation.h.

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

◆ h_probeL1Module_

TH1F* PrimaryVertexValidation::h_probeL1Module_

private

Definition at line 673 of file PrimaryVertexValidation.h.

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

◆ h_probeNormChi2_

TH1F* PrimaryVertexValidation::h_probeNormChi2_

private

Definition at line 637 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeP_

TH1F* PrimaryVertexValidation::h_probeP_

private

Definition at line 631 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePhi_

TH1F* PrimaryVertexValidation::h_probePhi_

private

Definition at line 635 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePt_

TH1F* PrimaryVertexValidation::h_probePt_

private

Definition at line 632 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probePtRebin_

TH1F* PrimaryVertexValidation::h_probePtRebin_

private

Definition at line 633 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeQoverP_

TH1F* PrimaryVertexValidation::h_probeQoverP_

private

Definition at line 639 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRecoVSigXY_

TH1F* PrimaryVertexValidation::h_probeRecoVSigXY_

private

Definition at line 655 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRecoVSigZ_

TH1F* PrimaryVertexValidation::h_probeRecoVSigZ_

private

Definition at line 654 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVLogSig3D_

TH1F* PrimaryVertexValidation::h_probeRefitVLogSig3D_

private

Definition at line 659 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSig3D_

TH1F* PrimaryVertexValidation::h_probeRefitVSig3D_

private

Definition at line 658 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigResZ_

TH1F* PrimaryVertexValidation::h_probeRefitVSigResZ_

private

Definition at line 660 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigXY_

TH1F* PrimaryVertexValidation::h_probeRefitVSigXY_

private

Definition at line 657 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probeRefitVSigZ_

TH1F* PrimaryVertexValidation::h_probeRefitVSigZ_

private

Definition at line 656 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probereszRefitV_

TH1F* PrimaryVertexValidation::h_probereszRefitV_

private

Definition at line 652 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probesignIP2DRefitV_

TH1F* PrimaryVertexValidation::h_probesignIP2DRefitV_

private

Definition at line 650 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_probez0RefitV_

TH1F* PrimaryVertexValidation::h_probez0RefitV_

private

Definition at line 648 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_pTinfo

TH1F* PrimaryVertexValidation::h_pTinfo

private

Definition at line 318 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_recoVtxChi2ndf_

TH1F* PrimaryVertexValidation::h_recoVtxChi2ndf_

private

Definition at line 691 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxChi2Prob_

TH1F* PrimaryVertexValidation::h_recoVtxChi2Prob_

private

Definition at line 692 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxNtracks_

TH1F* PrimaryVertexValidation::h_recoVtxNtracks_

private

Definition at line 690 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_recoVtxSumPt_

TH1F* PrimaryVertexValidation::h_recoVtxSumPt_

private

Definition at line 693 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_runEndTimes

TH1I* PrimaryVertexValidation::h_runEndTimes

private

Definition at line 322 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ h_runFromConfig

TH1I* PrimaryVertexValidation::h_runFromConfig

private

Definition at line 611 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ h_runFromEvent

TH1I* PrimaryVertexValidation::h_runFromEvent

private

Definition at line 612 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_runNumber

TH1F* PrimaryVertexValidation::h_runNumber

private

Definition at line 609 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and beginRun().

◆ h_runStartTimes

TH1I* PrimaryVertexValidation::h_runStartTimes

private

Definition at line 321 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ h_xErrOfflineVertex

TH1F* PrimaryVertexValidation::h_xErrOfflineVertex

private

Definition at line 616 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_xOfflineVertex

TH1F* PrimaryVertexValidation::h_xOfflineVertex

private

Definition at line 613 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_yErrOfflineVertex

TH1F* PrimaryVertexValidation::h_yErrOfflineVertex

private

Definition at line 617 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_yOfflineVertex

TH1F* PrimaryVertexValidation::h_yOfflineVertex

private

Definition at line 614 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_zErrOfflineVertex

TH1F* PrimaryVertexValidation::h_zErrOfflineVertex

private

Definition at line 618 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ h_zOfflineVertex

TH1F* PrimaryVertexValidation::h_zOfflineVertex

private

Definition at line 615 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ hasRecVertex_

int PrimaryVertexValidation::hasRecVertex_[nMaxtracks_]

private

Definition at line 300 of file PrimaryVertexValidation.h.

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

◆ hDA

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

private

Definition at line 695 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ intLumi_

double PrimaryVertexValidation::intLumi_

private

Definition at line 174 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ IP3DsigFromMyVertex_

double PrimaryVertexValidation::IP3DsigFromMyVertex_[nMaxtracks_]

private

Definition at line 298 of file PrimaryVertexValidation.h.

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

◆ IPLsigFromMyVertex_

double PrimaryVertexValidation::IPLsigFromMyVertex_[nMaxtracks_]

private

Definition at line 297 of file PrimaryVertexValidation.h.

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

◆ IPTsigFromMyVertex_

double PrimaryVertexValidation::IPTsigFromMyVertex_[nMaxtracks_]

private

Definition at line 296 of file PrimaryVertexValidation.h.

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

◆ isGoodTrack_

int PrimaryVertexValidation::isGoodTrack_[nMaxtracks_]

private

Definition at line 301 of file PrimaryVertexValidation.h.

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

◆ isHighPurity_

int PrimaryVertexValidation::isHighPurity_[nMaxtracks_]

private

Definition at line 263 of file PrimaryVertexValidation.h.

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

◆ lightNtupleSwitch_

bool PrimaryVertexValidation::lightNtupleSwitch_

private

Definition at line 164 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ LuminosityBlockNumber_

unsigned int PrimaryVertexValidation::LuminosityBlockNumber_

private

Definition at line 233 of file PrimaryVertexValidation.h.

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

◆ MADTrendsDir

TFileDirectory PrimaryVertexValidation::MADTrendsDir

private

Definition at line 308 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ magFieldToken_

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

private

Definition at line 154 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ maxPt_

const double PrimaryVertexValidation::maxPt_

private

Definition at line 191 of file PrimaryVertexValidation.h.

Referenced by beginRun(), and PrimaryVertexValidation().

◆ Mean2DMapsDir

TFileDirectory PrimaryVertexValidation::Mean2DMapsDir

private

Definition at line 310 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ MeanTrendsDir

TFileDirectory PrimaryVertexValidation::MeanTrendsDir

private

Definition at line 305 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ MedianTrendsDir

TFileDirectory PrimaryVertexValidation::MedianTrendsDir

private

Definition at line 307 of file PrimaryVertexValidation.h.

Referenced by beginJob().

◆ minPt_

const double PrimaryVertexValidation::minPt_

private

Definition at line 190 of file PrimaryVertexValidation.h.

Referenced by beginRun(), and PrimaryVertexValidation().

◆ mypT_bins_

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

private

Definition at line 224 of file PrimaryVertexValidation.h.

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

◆ n_d3DEtaResiduals

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

private

Definition at line 370 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_d3DPhiResiduals

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

private

Definition at line 369 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_d3DResidualsMap

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

private

Definition at line 380 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyBiasResidualsMap

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

private

Definition at line 544 of file PrimaryVertexValidation.h.

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

◆ n_dxyEtaBiasResiduals

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

private

Definition at line 534 of file PrimaryVertexValidation.h.

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

◆ n_dxyEtaMADBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMADBiasTrend

private

Definition at line 587 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMADTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMADTrend

private

Definition at line 473 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMeanBiasTrend

private

Definition at line 564 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMeanTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMeanTrend

private

Definition at line 406 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMedianBiasTrend

private

Definition at line 586 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaMedianTrend

TH1F* PrimaryVertexValidation::n_dxyEtaMedianTrend

private

Definition at line 472 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaResiduals

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

private

Definition at line 355 of file PrimaryVertexValidation.h.

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

◆ n_dxyEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dxyEtaWidthBiasTrend

private

Definition at line 565 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyEtaWidthTrend

TH1F* PrimaryVertexValidation::n_dxyEtaWidthTrend

private

Definition at line 407 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyL1MeanMap

TH2F* PrimaryVertexValidation::n_dxyL1MeanMap

private

Definition at line 510 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyL1ResidualsMap

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

private

Definition at line 386 of file PrimaryVertexValidation.h.

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

◆ n_dxyL1WidthMap

TH2F* PrimaryVertexValidation::n_dxyL1WidthMap

private

Definition at line 516 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyladderMeanTrend

TH1F* PrimaryVertexValidation::n_dxyladderMeanTrend

private

Definition at line 450 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyladderWidthTrend

TH1F* PrimaryVertexValidation::n_dxyladderWidthTrend

private

Definition at line 451 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyMeanBiasMap

TH2F* PrimaryVertexValidation::n_dxyMeanBiasMap

private

Definition at line 596 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyMeanMap

TH2F* PrimaryVertexValidation::n_dxyMeanMap

private

Definition at line 496 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxymodZMeanTrend

TH1F* PrimaryVertexValidation::n_dxymodZMeanTrend

private

Definition at line 445 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxymodZWidthTrend

TH1F* PrimaryVertexValidation::n_dxymodZWidthTrend

private

Definition at line 446 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dxyPhiBiasResiduals

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

private

Definition at line 533 of file PrimaryVertexValidation.h.

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

◆ n_dxyPhiMADBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMADBiasTrend

private

Definition at line 582 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMADTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMADTrend

private

Definition at line 468 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMeanBiasTrend

private

Definition at line 559 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMeanTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMeanTrend

private

Definition at line 401 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMedianBiasTrend

private

Definition at line 581 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiMedianTrend

TH1F* PrimaryVertexValidation::n_dxyPhiMedianTrend

private

Definition at line 467 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiResiduals

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

private

Definition at line 354 of file PrimaryVertexValidation.h.

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

◆ n_dxyPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dxyPhiWidthBiasTrend

private

Definition at line 560 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyPhiWidthTrend

TH1F* PrimaryVertexValidation::n_dxyPhiWidthTrend

private

Definition at line 402 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTCentralMeanTrend

TH1F* PrimaryVertexValidation::n_dxypTCentralMeanTrend

private

Definition at line 428 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTCentralWidthTrend

TH1F* PrimaryVertexValidation::n_dxypTCentralWidthTrend

private

Definition at line 429 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTMeanTrend

TH1F* PrimaryVertexValidation::n_dxypTMeanTrend

private

Definition at line 423 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxypTWidthTrend

TH1F* PrimaryVertexValidation::n_dxypTWidthTrend

private

Definition at line 424 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyResidualsMap

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

private

Definition at line 378 of file PrimaryVertexValidation.h.

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

◆ n_dxyVsEta

TH2F* PrimaryVertexValidation::n_dxyVsEta

private

Definition at line 488 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyVsPhi

TH2F* PrimaryVertexValidation::n_dxyVsPhi

private

Definition at line 482 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dxyWidthBiasMap

TH2F* PrimaryVertexValidation::n_dxyWidthBiasMap

private

Definition at line 602 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dxyWidthMap

TH2F* PrimaryVertexValidation::n_dxyWidthMap

private

Definition at line 502 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzBiasResidualsMap

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

private

Definition at line 545 of file PrimaryVertexValidation.h.

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

◆ n_dzEtaBiasResiduals

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

private

Definition at line 537 of file PrimaryVertexValidation.h.

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

◆ n_dzEtaMADBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMADBiasTrend

private

Definition at line 589 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMADTrend

TH1F* PrimaryVertexValidation::n_dzEtaMADTrend

private

Definition at line 475 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMeanBiasTrend

private

Definition at line 566 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMeanTrend

TH1F* PrimaryVertexValidation::n_dzEtaMeanTrend

private

Definition at line 408 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaMedianBiasTrend

private

Definition at line 588 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaMedianTrend

TH1F* PrimaryVertexValidation::n_dzEtaMedianTrend

private

Definition at line 474 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaResiduals

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

private

Definition at line 358 of file PrimaryVertexValidation.h.

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

◆ n_dzEtaWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dzEtaWidthBiasTrend

private

Definition at line 567 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzEtaWidthTrend

TH1F* PrimaryVertexValidation::n_dzEtaWidthTrend

private

Definition at line 409 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzL1MeanMap

TH2F* PrimaryVertexValidation::n_dzL1MeanMap

private

Definition at line 511 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzL1ResidualsMap

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

private

Definition at line 387 of file PrimaryVertexValidation.h.

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

◆ n_dzL1WidthMap

TH2F* PrimaryVertexValidation::n_dzL1WidthMap

private

Definition at line 517 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzladderMeanTrend

TH1F* PrimaryVertexValidation::n_dzladderMeanTrend

private

Definition at line 452 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzladderWidthTrend

TH1F* PrimaryVertexValidation::n_dzladderWidthTrend

private

Definition at line 453 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzMeanBiasMap

TH2F* PrimaryVertexValidation::n_dzMeanBiasMap

private

Definition at line 597 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzMeanMap

TH2F* PrimaryVertexValidation::n_dzMeanMap

private

Definition at line 497 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzmodZMeanTrend

TH1F* PrimaryVertexValidation::n_dzmodZMeanTrend

private

Definition at line 447 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzmodZWidthTrend

TH1F* PrimaryVertexValidation::n_dzmodZWidthTrend

private

Definition at line 448 of file PrimaryVertexValidation.h.

Referenced by endJob().

◆ n_dzPhiBiasResiduals

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

private

Definition at line 536 of file PrimaryVertexValidation.h.

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

◆ n_dzPhiMADBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMADBiasTrend

private

Definition at line 584 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMADTrend

TH1F* PrimaryVertexValidation::n_dzPhiMADTrend

private

Definition at line 470 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMeanBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMeanBiasTrend

private

Definition at line 561 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMeanTrend

TH1F* PrimaryVertexValidation::n_dzPhiMeanTrend

private

Definition at line 403 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMedianBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiMedianBiasTrend

private

Definition at line 583 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiMedianTrend

TH1F* PrimaryVertexValidation::n_dzPhiMedianTrend

private

Definition at line 469 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiResiduals

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

private

Definition at line 357 of file PrimaryVertexValidation.h.

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

◆ n_dzPhiWidthBiasTrend

TH1F* PrimaryVertexValidation::n_dzPhiWidthBiasTrend

private

Definition at line 562 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzPhiWidthTrend

TH1F* PrimaryVertexValidation::n_dzPhiWidthTrend

private

Definition at line 404 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTCentralMeanTrend

TH1F* PrimaryVertexValidation::n_dzpTCentralMeanTrend

private

Definition at line 430 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTCentralWidthTrend

TH1F* PrimaryVertexValidation::n_dzpTCentralWidthTrend

private

Definition at line 431 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTMeanTrend

TH1F* PrimaryVertexValidation::n_dzpTMeanTrend

private

Definition at line 425 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzpTWidthTrend

TH1F* PrimaryVertexValidation::n_dzpTWidthTrend

private

Definition at line 426 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzResidualsMap

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

private

Definition at line 379 of file PrimaryVertexValidation.h.

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

◆ n_dzVsEta

TH2F* PrimaryVertexValidation::n_dzVsEta

private

Definition at line 489 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dzVsPhi

TH2F* PrimaryVertexValidation::n_dzVsPhi

private

Definition at line 483 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_dzWidthBiasMap

TH2F* PrimaryVertexValidation::n_dzWidthBiasMap

private

Definition at line 603 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_dzWidthMap

TH2F* PrimaryVertexValidation::n_dzWidthMap

private

Definition at line 503 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ n_IP2DEtaResiduals

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

private

Definition at line 361 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP2DPhiResiduals

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

private

Definition at line 360 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP3DEtaResiduals

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

private

Definition at line 364 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_IP3DPhiResiduals

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

private

Definition at line 363 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_reszEtaResiduals

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

private

Definition at line 367 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ n_reszPhiResiduals

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

private

Definition at line 366 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ nBins_

int PrimaryVertexValidation::nBins_

private

Definition at line 187 of file PrimaryVertexValidation.h.

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

◆ nClus_

int PrimaryVertexValidation::nClus_

private

Definition at line 229 of file PrimaryVertexValidation.h.

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

◆ Nevt_

int PrimaryVertexValidation::Nevt_

private

Definition at line 143 of file PrimaryVertexValidation.h.

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

◆ nhits1D_

int PrimaryVertexValidation::nhits1D_[nMaxtracks_]

private

Definition at line 255 of file PrimaryVertexValidation.h.

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

◆ nhits2D_

int PrimaryVertexValidation::nhits2D_[nMaxtracks_]

private

Definition at line 256 of file PrimaryVertexValidation.h.

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

◆ nhits_

int PrimaryVertexValidation::nhits_[nMaxtracks_]

private

Definition at line 254 of file PrimaryVertexValidation.h.

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

◆ nhitsBPIX_

int PrimaryVertexValidation::nhitsBPIX_[nMaxtracks_]

private

Definition at line 257 of file PrimaryVertexValidation.h.

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

◆ nhitsFPIX_

int PrimaryVertexValidation::nhitsFPIX_[nMaxtracks_]

private

Definition at line 258 of file PrimaryVertexValidation.h.

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

◆ nHitsOfProbe_

double PrimaryVertexValidation::nHitsOfProbe_

private

Definition at line 183 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ nhitsTEC_

int PrimaryVertexValidation::nhitsTEC_[nMaxtracks_]

private

Definition at line 262 of file PrimaryVertexValidation.h.

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

◆ nhitsTIB_

int PrimaryVertexValidation::nhitsTIB_[nMaxtracks_]

private

Definition at line 259 of file PrimaryVertexValidation.h.

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

◆ nhitsTID_

int PrimaryVertexValidation::nhitsTID_[nMaxtracks_]

private

Definition at line 260 of file PrimaryVertexValidation.h.

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

◆ nhitsTOB_

int PrimaryVertexValidation::nhitsTOB_[nMaxtracks_]

private

Definition at line 261 of file PrimaryVertexValidation.h.

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

◆ nLadders_

unsigned int PrimaryVertexValidation::nLadders_ = 20

private

Definition at line 216 of file PrimaryVertexValidation.h.

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

◆ nMaxBins_

const int PrimaryVertexValidation::nMaxBins_ = 100

staticprivate

Definition at line 149 of file PrimaryVertexValidation.h.

◆ nMaxtracks_

const int PrimaryVertexValidation::nMaxtracks_ = 10000

staticprivate

Definition at line 211 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ nModZ_

unsigned int PrimaryVertexValidation::nModZ_ = 9

private

Definition at line 217 of file PrimaryVertexValidation.h.

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

◆ nOfflineVertices_

int PrimaryVertexValidation::nOfflineVertices_

private

Definition at line 230 of file PrimaryVertexValidation.h.

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

◆ nPtBins_

const int PrimaryVertexValidation::nPtBins_ = 48

staticprivate

Definition at line 213 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ nTracks_

int PrimaryVertexValidation::nTracks_

private

Definition at line 227 of file PrimaryVertexValidation.h.

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

◆ nTracksPerClus_

int PrimaryVertexValidation::nTracksPerClus_

private

Definition at line 228 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ p_

double PrimaryVertexValidation::p_[nMaxtracks_]

private

Definition at line 253 of file PrimaryVertexValidation.h.

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

◆ phase_

PVValHelper::detectorPhase PrimaryVertexValidation::phase_

private

Definition at line 184 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginRun().

◆ phi_

double PrimaryVertexValidation::phi_[nMaxtracks_]

private

Definition at line 266 of file PrimaryVertexValidation.h.

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

◆ pOfProbe_

double PrimaryVertexValidation::pOfProbe_

private

Definition at line 181 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ pt_

double PrimaryVertexValidation::pt_[nMaxtracks_]

private

Definition at line 252 of file PrimaryVertexValidation.h.

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

◆ ptOfProbe_

double PrimaryVertexValidation::ptOfProbe_

private

Definition at line 180 of file PrimaryVertexValidation.h.

Referenced by analyze(), beginRun(), and isBFieldConsistentWithMode().

◆ qoverp_

double PrimaryVertexValidation::qoverp_[nMaxtracks_]

private

Definition at line 270 of file PrimaryVertexValidation.h.

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

◆ rootTree_

TTree* PrimaryVertexValidation::rootTree_

private

Definition at line 205 of file PrimaryVertexValidation.h.

Referenced by analyze(), and beginJob().

◆ runControl_

bool PrimaryVertexValidation::runControl_

private

Definition at line 196 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ runControlNumbers_

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

private

Definition at line 193 of file PrimaryVertexValidation.h.

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

◆ runInfoTokenBR_

const edm::ESGetToken<RunInfo, RunInfoRcd> PrimaryVertexValidation::runInfoTokenBR_

private

Definition at line 160 of file PrimaryVertexValidation.h.

Referenced by getRunTime(), and isBFieldConsistentWithMode().

◆ RunNumber_

unsigned int PrimaryVertexValidation::RunNumber_

private

Definition at line 231 of file PrimaryVertexValidation.h.

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

◆ runNumbersTimesLog_

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

private

Definition at line 320 of file PrimaryVertexValidation.h.

Referenced by beginRun(), and endJob().

◆ storeNtuple_

bool PrimaryVertexValidation::storeNtuple_

private

Definition at line 163 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ sumOfWeightsUnbiasedVertex_

float PrimaryVertexValidation::sumOfWeightsUnbiasedVertex_[nMaxtracks_]

private

Definition at line 285 of file PrimaryVertexValidation.h.

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

◆ theBeamspotToken_

edm::EDGetTokenT<reco::BeamSpot> PrimaryVertexValidation::theBeamspotToken_

private

Definition at line 203 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theDetails_

PVValHelper::histodetails PrimaryVertexValidation::theDetails_

private

Definition at line 168 of file PrimaryVertexValidation.h.

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

◆ theta_

double PrimaryVertexValidation::theta_[nMaxtracks_]

private

Definition at line 265 of file PrimaryVertexValidation.h.

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

◆ theTrackClusterizer_

std::unique_ptr<TrackClusterizerInZ> PrimaryVertexValidation::theTrackClusterizer_

private

Definition at line 146 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theTrackCollectionToken_

edm::EDGetTokenT<reco::TrackCollection> PrimaryVertexValidation::theTrackCollectionToken_

private

Definition at line 201 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theTrackFilter_

std::unique_ptr<TrackFilterForPVFindingBase> PrimaryVertexValidation::theTrackFilter_

private

Definition at line 145 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ theVertexCollectionToken_

edm::EDGetTokenT<reco::VertexCollection> PrimaryVertexValidation::theVertexCollectionToken_

private

Definition at line 202 of file PrimaryVertexValidation.h.

Referenced by analyze(), and PrimaryVertexValidation().

◆ topoToken_

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

private

Definition at line 157 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ topoTokenBR_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> PrimaryVertexValidation::topoTokenBR_

private

Definition at line 158 of file PrimaryVertexValidation.h.

Referenced by beginRun().

◆ trackingGeomToken_

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

private

Definition at line 155 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ tracksUsedForVertexing_

int PrimaryVertexValidation::tracksUsedForVertexing_[nMaxtracks_]

private

Definition at line 286 of file PrimaryVertexValidation.h.

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

◆ ttkToken_

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

private

Definition at line 156 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ useTracksFromRecoVtx_

bool PrimaryVertexValidation::useTracksFromRecoVtx_

private

Definition at line 165 of file PrimaryVertexValidation.h.

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

◆ vertexZMax_

double PrimaryVertexValidation::vertexZMax_

private

Definition at line 171 of file PrimaryVertexValidation.h.

Referenced by analyze().

◆ Width2DMapsDir

TFileDirectory PrimaryVertexValidation::Width2DMapsDir

private

Definition at line 311 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ WidthTrendsDir

TFileDirectory PrimaryVertexValidation::WidthTrendsDir

private

Definition at line 306 of file PrimaryVertexValidation.h.

Referenced by beginJob(), and endJob().

◆ wxy2_

double PrimaryVertexValidation::wxy2_

private

Definition at line 249 of file PrimaryVertexValidation.h.

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

◆ xErrOfflineVertex_

double PrimaryVertexValidation::xErrOfflineVertex_

private

Definition at line 238 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ xOfflineVertex_

double PrimaryVertexValidation::xOfflineVertex_

private

Definition at line 234 of file PrimaryVertexValidation.h.

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

◆ xPCA_

double PrimaryVertexValidation::xPCA_[nMaxtracks_]

private

Definition at line 275 of file PrimaryVertexValidation.h.

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

◆ xUnbiasedVertex_

double PrimaryVertexValidation::xUnbiasedVertex_[nMaxtracks_]

private

Definition at line 278 of file PrimaryVertexValidation.h.

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

◆ yErrOfflineVertex_

double PrimaryVertexValidation::yErrOfflineVertex_

private

Definition at line 239 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ yOfflineVertex_

double PrimaryVertexValidation::yOfflineVertex_

private

Definition at line 235 of file PrimaryVertexValidation.h.

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

◆ yPCA_

double PrimaryVertexValidation::yPCA_[nMaxtracks_]

private

Definition at line 276 of file PrimaryVertexValidation.h.

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

◆ yUnbiasedVertex_

double PrimaryVertexValidation::yUnbiasedVertex_[nMaxtracks_]

private

Definition at line 279 of file PrimaryVertexValidation.h.

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

◆ zErrOfflineVertex_

double PrimaryVertexValidation::zErrOfflineVertex_

private

Definition at line 240 of file PrimaryVertexValidation.h.

Referenced by analyze(), and SetVarToZero().

◆ zOfflineVertex_

double PrimaryVertexValidation::zOfflineVertex_

private

Definition at line 236 of file PrimaryVertexValidation.h.

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

◆ zPCA_

double PrimaryVertexValidation::zPCA_[nMaxtracks_]

private

Definition at line 277 of file PrimaryVertexValidation.h.

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

◆ zUnbiasedVertex_

double PrimaryVertexValidation::zUnbiasedVertex_[nMaxtracks_]

private

Definition at line 280 of file PrimaryVertexValidation.h.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PrimaryVertexValidation()

◆ ~PrimaryVertexValidation()

Member Function Documentation

◆ add()

◆ analyze()

◆ beginJob()

◆ beginRun()

◆ bookResidualsHistogram()

◆ bookVertexHistograms()

◆ endJob()

◆ endRun()

◆ fill() [1/2]

◆ fill() [2/2]

◆ fillByIndex()

◆ fillDescriptions()

◆ fillMap()

◆ fillTrackHistos()

◆ fillTrendPlot()

◆ fillTrendPlotByIndex()

◆ fitResiduals()

◆ getMAD()

◆ getMedian()

◆ getRunTime()

◆ getTypeString()

◆ getVarString()

◆ hasFirstLayerPixelHits()

◆ isBFieldConsistentWithMode()

◆ isHit2D()

◆ passesTrackCuts()

◆ pixelHitsCheck()

◆ SetVarToZero()

◆ shrinkHistVectorToFit()

◆ square()

◆ vtxSort()

Member Data Documentation

◆ 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_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