InDetPerfPlot_VertexTruthMatching Class Reference

class holding plots for truth matched vertices More...

#include <InDetPerfPlot_VertexTruthMatching.h>

Inheritance diagram for InDetPerfPlot_VertexTruthMatching:

Collaboration diagram for InDetPerfPlot_VertexTruthMatching:

Public Member Functions
	InDetPerfPlot_VertexTruthMatching (InDetPlotBase *pParent, const std::string &dirName, const int detailLevel=10, bool isITk=false)
void	fill (const xAOD::Vertex &vertex, const xAOD::TruthVertex *tvrt=0, float weight=1.0)
void	fill (const xAOD::Vertex *recoHardScatter, const xAOD::VertexContainer &vertexContainer, const std::vector< const xAOD::TruthVertex * > &truthHSVertices, const std::vector< const xAOD::TruthVertex * > &truthPUVertices, float actualMu, float weight=1.0)
SingleHistogramDefinition	retrieveDefinition (std::string_view histoIdentifier, std::string_view folder="default", std::string_view nameOverride="")
	Retrieve a single histogram definition, given the unique string identifier.
template<class Htype>
void	book (Htype *&pHisto, std::string_view histoIdentifier, std::string_view nameOverride="", std::string_view folder="default")
	Helper method to book histograms using an identifier string.
void	book (TH1 *&pHisto, const SingleHistogramDefinition &hd)
	Book a TH1 histogram.
void	book (TProfile *&pHisto, const SingleHistogramDefinition &hd)
	Book a TProfile histogram.
void	book (TProfile2D *&pHisto, const SingleHistogramDefinition &hd)
	Book a TProfile2D histogram.
void	book (TH2 *&pHisto, const SingleHistogramDefinition &hd)
	Book a 2D histogram (TH2).
void	book (TEfficiency *&pHisto, const SingleHistogramDefinition &hd)
	Book a (1-D) TEfficiency.
void	initialize ()
void	finalize ()
void	setDetailLevel (int iDetailLevel)
void	RegisterSubPlot (PlotBase *pPlotBase)
std::vector< HistData >	retrieveBookedHistograms ()
	Retrieve all booked histograms.
std::vector< TreeData >	retrieveBookedTrees ()
	Retrieve all booked trees.
std::vector< EfficiencyData >	retrieveBookedEfficiencies ()
	Retrieve all booked efficiency objects.
TTree *	BookTree (std::string_view name, bool prependDir=true)
	Book a TTree.
const std::string &	getDirectory ()
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Methods to book monitoring histograms
Note: methods starting with capitals should be deprecated in favour of camel-cased methods
TH1D *	Book1D (std::string_view name, std::string_view labels, int nBins, float start, float end, bool prependDir=true)
	Book a TH1D histogram.
TH1D *	Book1D (std::string_view name, TH1 *refHist, std::string_view labels, bool prependDir=true)
	Book a TH1D histogram using refHist as reference for number of bins and axis range.
TH2F *	Book2D (std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, int nBinsY, float startY, float endY, bool prependDir=true)
	Book a TH2F histogram.
TH2F *	Book2D (std::string_view name, TH2 *refHist, std::string_view labels, bool prependDir=true)
	Book a TH2D histogram using refHist as reference for number of bins and axis range.
TH2F *	Book2D (std::string_view name, std::string_view labels, int nBinsX, Double_t *binsX, int nBinsY, Double_t startY, Double_t endY, bool prependDir=true)
	Book a TH2F histogram with variable x axis binning.
TH3F *	Book3D (std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, int nBinsY, float startY, float endY, int nBinsZ, float startZ, float endZ, bool prependDir=true)
	Book a TH3F histogram.
TH3F *	Book3D (std::string_view name, TH3 *refHist, std::string_view labels, bool prependDir=true)
	Book a TH3F histogram using refHist as reference for number of bins and axis range.
TProfile *	BookTProfile (std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, float startY=-1, float endY=-1, bool prependDir=true, bool useRMS=false)
	Book a TProfile histogram.
TProfile *	BookTProfile (std::string_view name, std::string_view labels, int nBinsX, float *binsX, bool prependDir=true)
	Book a TProfile histogram with variable binning in x-axis.
TProfile *	BookTProfileRangeY (std::string_view name, std::string_view labels, int nBinsX, double *binsX, double startY, double endY, bool prependDir=true)
	Book a TProfile histogram with variable binning in x-axis and limits in y-values.
TProfile2D *	BookTProfile2D (std::string_view name, std::string_view labels, const int nBinsX, const double xlo, const double xhi, const int nBinsY, const double ylo, const double yhi, bool prependDir=true, bool useRMS=false)
	Book a TProfile 2D histogram with variable binning in x-axis and limits in y-values.
TProfile2D *	BookTProfile2D (std::string_view name, std::string_view labels, const int nBinsX, double *binsX, const int nBinsY, double *binsY, bool prependDir=true, bool useRMS=false)
	Book a TProfile 2D histogram with variable binning in x-axis and limits in y-values.
TEfficiency *	BookTEfficiency (std::string_view name, std::string_view labels, const int nBinsX, const float xlo, const float xhi, const bool prependDir=true)
	Book a (1-D) TEfficiency histogram.
TEfficiency *	BookTEfficiency (std::string_view name, std::string_view labels, const int nBinsX, const float xlo, const float xhi, const int nBinsy, const float ylo, const float yhi, const bool prependDir=true)
	Book a (2-D) TEfficiency histogram.

Static Public Member Functions
static void	fillHisto (TProfile *pTprofile, const float bin, const float weight, const float weight2=1.0)
static void	fillHisto (TProfile2D *pTprofile, const float xval, const float yval, const float weight, const float weight2=1.0)
static void	fillHisto (TH1 *pTh1, const float value)
static void	fillHisto (TH1 *pTh1, const float value, const float weight)
static void	fillHisto (TH2 *pTh2, const float xval, const float yval)
static void	fillHisto (TH2 *pTh2, const float xval, const float yval, const float weight)
static void	fillHisto (TH3 *pTh3, const float xval, const float yval, const float zval)
static void	fillHisto (TEfficiency *pTeff, const float value, const bool accepted, float weight)
static void	fillHisto (TEfficiency *eff2d, const float xvalue, const float yvalue, const bool accepted, const float weight)

Protected Member Functions
template<class T>
void	mBook (T &pHisto, const std::string &histoIdentifier)
	book, for use by macro

Protected Attributes
std::vector< PlotBase * >	m_vSubNodes
std::vector< HistData >	m_vBookedHistograms
std::vector< TreeData >	m_vBookedTrees
std::vector< EfficiencyData >	m_vBookedEfficiencies
std::string	m_sDirectory
int	m_iDetailLevel

Private Member Functions
void	initializePlots ()
template<typename U, typename V>
float	getRadialDiff2 (const U *vtx1, const V *vtx2) const
float	getLocalPUDensity (const xAOD::TruthVertex *vtxOfInterest, const std::vector< const xAOD::TruthVertex * > &truthHSVertices, const std::vector< const xAOD::TruthVertex * > &truthPUVertices, const float radialWindow=2.0) const
const xAOD::TruthVertex *	getTruthVertex (const xAOD::Vertex *recoVtx) const
void	finalizePlots ()
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static const xAOD::Vertex *	getHSRecoVertexSumPt2 (const xAOD::VertexContainer &recoVertices)
static float	getRecoLongitudinalReso (const xAOD::Vertex *recoVtx)
static float	getRecoTransverseReso (const xAOD::Vertex *recoVtx)
static void	fillResoHist (TH1 *resoHist, const TH2 *resoHist2D)
static std::string	constructPrefix (std::string dir, bool prependDir)

Private Attributes
bool	m_isITk {false}
int	m_detailLevel {10}
float	m_cutMinTruthRecoRadialDiff = 0.1
TH1 *	m_vx_type_truth {}
	truth type
TH1 *	m_vx_x_diff {}
TH1 *	m_vx_x_diff_pull {}
TH1 *	m_vx_y_diff {}
TH1 *	m_vx_y_diff_pull {}
TH1 *	m_vx_z_diff {}
TH1 *	m_vx_z_diff_pull {}
TH1 *	m_vx_time_diff {}
	vertex time
TH1 *	m_vx_time_diff_pull {}
TH1 *	m_vx_hs_classification {}
	hardscatter classification
TProfile *	m_vx_nReco_vs_nTruth_inclusive
	vertex reco efficiency
TProfile *	m_vx_nReco_vs_nTruth_matched
TProfile *	m_vx_nReco_vs_nTruth_merged
TProfile *	m_vx_nReco_vs_nTruth_split
TProfile *	m_vx_nReco_vs_nTruth_fake
TProfile *	m_vx_nReco_vs_nTruth_dummy
TProfile *	m_vx_nReco_vs_nTruth_clean
TProfile *	m_vx_nReco_vs_nTruth_lowpu
TProfile *	m_vx_nReco_vs_nTruth_highpu
TProfile *	m_vx_nReco_vs_nTruth_hssplit
TProfile *	m_vx_nReco_vs_nTruth_none
TEfficiency *	m_vx_hs_reco_eff
TEfficiency *	m_vx_hs_sel_eff
TEfficiency *	m_vx_hs_sel_eff_vs_nReco
TEfficiency *	m_vx_hs_reco_sel_eff
TEfficiency *	m_vx_hs_sel_eff_dist
TEfficiency *	m_vx_hs_sel_eff_mu
TEfficiency *	m_vx_hs_sel_eff_dist_vs_nReco
TEfficiency *	m_vx_hs_reco_eff_vs_ntruth
TEfficiency *	m_vx_hs_sel_eff_vs_ntruth
TEfficiency *	m_vx_hs_reco_sel_eff_vs_ntruth
TProfile *	m_vx_hs_reco_long_reso
TProfile *	m_vx_hs_reco_trans_reso
TH2 *	m_resHelper_PUdensity_hsVxTruthLong
TH1 *	m_resolution_vs_PUdensity_hsVxTruthLong
TH1 *	m_resmean_vs_PUdensity_hsVxTruthLong
TH2 *	m_resHelper_PUdensity_hsVxTruthTransv
TH1 *	m_resolution_vs_PUdensity_hsVxTruthTransv
TH1 *	m_resmean_vs_PUdensity_hsVxTruthTransv
TH1 *	m_vx_hs_z_pull
TH1 *	m_vx_hs_y_pull
TH1 *	m_vx_hs_x_pull
TH1 *	m_vx_all_z_pull
TH1 *	m_vx_all_y_pull
TH1 *	m_vx_all_x_pull
TH1 *	m_vx_hs_z_res
TH1 *	m_vx_hs_y_res
TH1 *	m_vx_hs_x_res
TH1 *	m_vx_all_z_res
TH1 *	m_vx_all_y_res
TH1 *	m_vx_all_x_res
TH2 *	m_vx_all_truth_z_res_vs_PU
TH2 *	m_vx_all_truth_x_res_vs_PU
TH2 *	m_vx_all_truth_y_res_vs_PU
TH2 *	m_vx_all_truth_z_pull_vs_PU
TH2 *	m_vx_all_truth_x_pull_vs_PU
TH2 *	m_vx_all_truth_y_pull_vs_PU
TH2 *	m_vx_all_truth_z_res_vs_nTrk
TH2 *	m_vx_all_truth_x_res_vs_nTrk
TH2 *	m_vx_all_truth_y_res_vs_nTrk
TH2 *	m_vx_all_truth_z_pull_vs_nTrk
TH2 *	m_vx_all_truth_x_pull_vs_nTrk
TH2 *	m_vx_all_truth_y_pull_vs_nTrk
TH2 *	m_vx_hs_truth_z_res_vs_PU
TH2 *	m_vx_hs_truth_x_res_vs_PU
TH2 *	m_vx_hs_truth_y_res_vs_PU
TH2 *	m_vx_hs_truth_z_pull_vs_PU
TH2 *	m_vx_hs_truth_x_pull_vs_PU
TH2 *	m_vx_hs_truth_y_pull_vs_PU
TH2 *	m_vx_hs_truth_z_res_vs_nTrk
TH2 *	m_vx_hs_truth_x_res_vs_nTrk
TH2 *	m_vx_hs_truth_y_res_vs_nTrk
TH2 *	m_vx_hs_truth_z_pull_vs_nTrk
TH2 *	m_vx_hs_truth_x_pull_vs_nTrk
TH2 *	m_vx_hs_truth_y_pull_vs_nTrk
TH1 *	m_vx_ntracks_matched
TH1 *	m_vx_ntracks_merged
TH1 *	m_vx_ntracks_split
TH1 *	m_vx_ntracks_HS_matched
TH1 *	m_vx_ntracks_HS_merged
TH1 *	m_vx_ntracks_HS_split
TH1 *	m_vx_ntracks_ALL_matched
TH1 *	m_vx_ntracks_ALL_merged
TH1 *	m_vx_ntracks_ALL_split
TH1 *	m_vx_sumpT_matched
TH1 *	m_vx_sumpT_merged
TH1 *	m_vx_sumpT_split
TH1 *	m_vx_sumpT_HS_matched
TH1 *	m_vx_sumpT_HS_merged
TH1 *	m_vx_sumpT_HS_split
TH1 *	m_vx_z_asym_matched
TH1 *	m_vx_z_asym_merged
TH1 *	m_vx_z_asym_split
TH1 *	m_vx_z_asym_HS_matched
TH1 *	m_vx_z_asym_HS_merged
TH1 *	m_vx_z_asym_HS_split
TH1 *	m_vx_z_asym_weighted_matched
TH1 *	m_vx_z_asym_weighted_merged
TH1 *	m_vx_z_asym_weighted_split
TH1 *	m_vx_z_asym_weighted_HS_matched
TH1 *	m_vx_z_asym_weighted_HS_merged
TH1 *	m_vx_z_asym_weighted_HS_split
TH1 *	m_vx_track_weight_matched
TH1 *	m_vx_track_weight_merged
TH1 *	m_vx_track_weight_split
TH1 *	m_vx_track_weight_HS_matched
TH1 *	m_vx_track_weight_HS_merged
TH1 *	m_vx_track_weight_HS_split
TH1 *	m_vx_normalised_track_weight_matched
TH1 *	m_vx_normalised_track_weight_merged
TH1 *	m_vx_normalised_track_weight_split
TH1 *	m_vx_normalised_track_weight_HS_matched
TH1 *	m_vx_normalised_track_weight_HS_merged
TH1 *	m_vx_normalised_track_weight_HS_split
TH1 *	m_vx_chi2Over_ndf_matched
TH1 *	m_vx_chi2Over_ndf_merged
TH1 *	m_vx_chi2Over_ndf_split
TH1 *	m_vx_chi2Over_ndf_HS_matched
TH1 *	m_vx_chi2Over_ndf_HS_merged
TH1 *	m_vx_chi2Over_ndf_HS_split
TH1 *	m_vx_z0_skewness_matched
TH1 *	m_vx_z0_skewness_merged
TH1 *	m_vx_z0_skewness_split
TH1 *	m_vx_z0_skewness_HS_matched
TH1 *	m_vx_z0_skewness_HS_merged
TH1 *	m_vx_z0_skewness_HS_split
TH1 *	m_vx_z0_kurtosis_matched
TH1 *	m_vx_z0_kurtosis_merged
TH1 *	m_vx_z0_kurtosis_split
TH1 *	m_vx_z0_kurtosis_HS_matched
TH1 *	m_vx_z0_kurtosis_HS_merged
TH1 *	m_vx_z0_kurtosis_HS_split
TH1 *	m_vx_sumpT_ALL_matched
TH1 *	m_vx_sumpT_ALL_merged
TH1 *	m_vx_sumpT_ALL_split
TH1 *	m_vx_z_asym_ALL_matched
TH1 *	m_vx_z_asym_ALL_merged
TH1 *	m_vx_z_asym_ALL_split
TH1 *	m_vx_z_asym_weighted_ALL_matched
TH1 *	m_vx_z_asym_weighted_ALL_merged
TH1 *	m_vx_z_asym_weighted_ALL_split
TH1 *	m_vx_track_weight_ALL_matched
TH1 *	m_vx_track_weight_ALL_merged
TH1 *	m_vx_track_weight_ALL_split
TH1 *	m_vx_normalised_track_weight_ALL_matched
TH1 *	m_vx_normalised_track_weight_ALL_merged
TH1 *	m_vx_normalised_track_weight_ALL_split
TH1 *	m_vx_chi2Over_ndf_ALL_matched
TH1 *	m_vx_chi2Over_ndf_ALL_merged
TH1 *	m_vx_chi2Over_ndf_ALL_split
TH1 *	m_vx_z0_skewness_ALL_matched
TH1 *	m_vx_z0_skewness_ALL_merged
TH1 *	m_vx_z0_skewness_ALL_split
TH1 *	m_vx_z0_kurtosis_ALL_matched
TH1 *	m_vx_z0_kurtosis_ALL_merged
TH1 *	m_vx_z0_kurtosis_ALL_split
TH1 *	m_vx_nVertices_ALL_matched
TH1 *	m_vx_nVertices_ALL_merged
TH1 *	m_vx_nVertices_ALL_split
TH1 *	m_vx_nVertices_ALL_fake
TH1 *	m_vx_nVertices_HS_matched
TH1 *	m_vx_nVertices_HS_merged
TH1 *	m_vx_nVertices_HS_split
TH1 *	m_vx_nVertices_HS_fake
TH1 *	m_vx_nVertices_matched
TH1 *	m_vx_nVertices_merged
TH1 *	m_vx_nVertices_split
TH1 *	m_vx_nVertices_fake
TH1 *	m_vx_all_dz
TH1 *	m_vx_hs_mindz
TH1 *	m_vx_PUdensity
TH1 *	m_vx_nTruth
TH2 *	m_vx_nTruth_vs_PUdensity
ServiceHandle< IHistogramDefinitionSvc >	m_histoDefSvc
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

class holding plots for truth matched vertices

Definition at line 41 of file InDetPerfPlot_VertexTruthMatching.h.

Constructor & Destructor Documentation

InDetPerfPlot_VertexTruthMatching()

InDetPerfPlot_VertexTruthMatching::InDetPerfPlot_VertexTruthMatching	(	InDetPlotBase *	pParent,
		const std::string &	dirName,
		const int	detailLevel = 10,
		bool	isITk = false )

Definition at line 21 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                                                                     :
    InDetPlotBase(pParent, sDir),
    m_isITk(isITk),
    m_detailLevel(detailLevel),
    m_vx_type_truth(nullptr),
    m_vx_hs_classification(nullptr),
    m_vx_nReco_vs_nTruth_inclusive(nullptr),
    m_vx_nReco_vs_nTruth_matched(nullptr),
    m_vx_nReco_vs_nTruth_merged(nullptr),
    m_vx_nReco_vs_nTruth_split(nullptr),
    m_vx_nReco_vs_nTruth_fake(nullptr),
    m_vx_nReco_vs_nTruth_dummy(nullptr),
    m_vx_nReco_vs_nTruth_clean(nullptr),
    m_vx_nReco_vs_nTruth_lowpu(nullptr),
    m_vx_nReco_vs_nTruth_highpu(nullptr),
    m_vx_nReco_vs_nTruth_hssplit(nullptr),
    m_vx_nReco_vs_nTruth_none(nullptr),
    m_vx_hs_reco_eff(nullptr),
    m_vx_hs_sel_eff(nullptr),
    m_vx_hs_sel_eff_vs_nReco(nullptr),
    m_vx_hs_reco_sel_eff(nullptr),
    m_vx_hs_sel_eff_dist(nullptr),
    m_vx_hs_sel_eff_mu(nullptr),
    m_vx_hs_sel_eff_dist_vs_nReco(nullptr),
    m_vx_hs_reco_eff_vs_ntruth(nullptr),
    m_vx_hs_sel_eff_vs_ntruth(nullptr),
    m_vx_hs_reco_sel_eff_vs_ntruth(nullptr),
    m_vx_hs_reco_long_reso(nullptr),
    m_vx_hs_reco_trans_reso(nullptr),
 
    //Longitudinal and transverse resolution plots for hs vertices
    m_resHelper_PUdensity_hsVxTruthLong(nullptr),
    m_resolution_vs_PUdensity_hsVxTruthLong(nullptr),
    m_resmean_vs_PUdensity_hsVxTruthLong(nullptr),
    m_resHelper_PUdensity_hsVxTruthTransv(nullptr),
    m_resolution_vs_PUdensity_hsVxTruthTransv(nullptr),
    m_resmean_vs_PUdensity_hsVxTruthTransv(nullptr),
 
    m_vx_hs_z_pull(nullptr),
    m_vx_hs_y_pull(nullptr),
    m_vx_hs_x_pull(nullptr),
    m_vx_all_z_pull(nullptr),
    m_vx_all_y_pull(nullptr),
    m_vx_all_x_pull(nullptr),
    m_vx_hs_z_res(nullptr),
    m_vx_hs_y_res(nullptr),
    m_vx_hs_x_res(nullptr),
    m_vx_all_z_res(nullptr),
    m_vx_all_y_res(nullptr),
    m_vx_all_x_res(nullptr),
    m_vx_all_truth_z_res_vs_PU(nullptr),
    m_vx_all_truth_x_res_vs_PU(nullptr),
    m_vx_all_truth_y_res_vs_PU(nullptr),
    m_vx_all_truth_z_pull_vs_PU(nullptr),
    m_vx_all_truth_x_pull_vs_PU(nullptr),
    m_vx_all_truth_y_pull_vs_PU(nullptr),
    m_vx_all_truth_z_res_vs_nTrk(nullptr),
    m_vx_all_truth_x_res_vs_nTrk(nullptr),
    m_vx_all_truth_y_res_vs_nTrk(nullptr),
    m_vx_all_truth_z_pull_vs_nTrk(nullptr),
    m_vx_all_truth_x_pull_vs_nTrk(nullptr),
    m_vx_all_truth_y_pull_vs_nTrk(nullptr),
    m_vx_hs_truth_z_res_vs_PU(nullptr),
    m_vx_hs_truth_x_res_vs_PU(nullptr),
    m_vx_hs_truth_y_res_vs_PU(nullptr),
    m_vx_hs_truth_z_pull_vs_PU(nullptr),
    m_vx_hs_truth_x_pull_vs_PU(nullptr),
    m_vx_hs_truth_y_pull_vs_PU(nullptr),
    m_vx_hs_truth_z_res_vs_nTrk(nullptr),
    m_vx_hs_truth_x_res_vs_nTrk(nullptr),
    m_vx_hs_truth_y_res_vs_nTrk(nullptr),
    m_vx_hs_truth_z_pull_vs_nTrk(nullptr),
    m_vx_hs_truth_x_pull_vs_nTrk(nullptr),
    m_vx_hs_truth_y_pull_vs_nTrk(nullptr),
 
   // New Expert Histograms for vertex classifiations
    m_vx_ntracks_matched(nullptr),
    m_vx_ntracks_merged(nullptr),
    m_vx_ntracks_split(nullptr),
    m_vx_ntracks_HS_matched(nullptr),
    m_vx_ntracks_HS_merged(nullptr),
    m_vx_ntracks_HS_split(nullptr),
    m_vx_ntracks_ALL_matched(nullptr),
    m_vx_ntracks_ALL_merged(nullptr),
    m_vx_ntracks_ALL_split(nullptr),
    m_vx_sumpT_matched(nullptr),
    m_vx_sumpT_merged(nullptr),
    m_vx_sumpT_split(nullptr),
    m_vx_sumpT_HS_matched(nullptr),
    m_vx_sumpT_HS_merged(nullptr),
    m_vx_sumpT_HS_split(nullptr),
    
    m_vx_z_asym_matched(nullptr),
    m_vx_z_asym_merged(nullptr),
    m_vx_z_asym_split(nullptr),
    m_vx_z_asym_HS_matched(nullptr),
    m_vx_z_asym_HS_merged(nullptr),
    m_vx_z_asym_HS_split(nullptr),
    m_vx_z_asym_weighted_matched(nullptr),
    m_vx_z_asym_weighted_merged(nullptr),
    m_vx_z_asym_weighted_split(nullptr),
    m_vx_z_asym_weighted_HS_matched(nullptr),
    m_vx_z_asym_weighted_HS_merged(nullptr),
    m_vx_z_asym_weighted_HS_split(nullptr),
 
    m_vx_track_weight_matched(nullptr),
    m_vx_track_weight_merged(nullptr),
    m_vx_track_weight_split(nullptr),
    m_vx_track_weight_HS_matched(nullptr),
    m_vx_track_weight_HS_merged(nullptr),
    m_vx_track_weight_HS_split(nullptr),
    
    m_vx_normalised_track_weight_matched(nullptr),
    m_vx_normalised_track_weight_merged(nullptr),
    m_vx_normalised_track_weight_split(nullptr),
    m_vx_normalised_track_weight_HS_matched(nullptr),
    m_vx_normalised_track_weight_HS_merged(nullptr),
    m_vx_normalised_track_weight_HS_split(nullptr),
 
    m_vx_chi2Over_ndf_matched(nullptr),
    m_vx_chi2Over_ndf_merged(nullptr),
    m_vx_chi2Over_ndf_split(nullptr),
    m_vx_chi2Over_ndf_HS_matched(nullptr),
    m_vx_chi2Over_ndf_HS_merged(nullptr),
    m_vx_chi2Over_ndf_HS_split(nullptr),
 
    m_vx_z0_skewness_matched(nullptr),
    m_vx_z0_skewness_merged(nullptr),
    m_vx_z0_skewness_split(nullptr),
    m_vx_z0_skewness_HS_matched(nullptr),
    m_vx_z0_skewness_HS_merged(nullptr),
    m_vx_z0_skewness_HS_split(nullptr),
 
    m_vx_z0_kurtosis_matched(nullptr),
    m_vx_z0_kurtosis_merged(nullptr),
    m_vx_z0_kurtosis_split(nullptr),
    m_vx_z0_kurtosis_HS_matched(nullptr),
    m_vx_z0_kurtosis_HS_merged(nullptr),
    m_vx_z0_kurtosis_HS_split(nullptr),
 
    m_vx_sumpT_ALL_matched(nullptr),
    m_vx_sumpT_ALL_merged(nullptr),
    m_vx_sumpT_ALL_split(nullptr),
    m_vx_z_asym_ALL_matched(nullptr),
    m_vx_z_asym_ALL_merged(nullptr),
    m_vx_z_asym_ALL_split(nullptr),
    m_vx_z_asym_weighted_ALL_matched(nullptr),
    m_vx_z_asym_weighted_ALL_merged(nullptr),
    m_vx_z_asym_weighted_ALL_split(nullptr),
    
    m_vx_track_weight_ALL_matched(nullptr),
    m_vx_track_weight_ALL_merged(nullptr),
    m_vx_track_weight_ALL_split(nullptr),
 
    m_vx_normalised_track_weight_ALL_matched(nullptr),
    m_vx_normalised_track_weight_ALL_merged(nullptr),
    m_vx_normalised_track_weight_ALL_split(nullptr),
 
    m_vx_chi2Over_ndf_ALL_matched(nullptr),
    m_vx_chi2Over_ndf_ALL_merged(nullptr),
    m_vx_chi2Over_ndf_ALL_split(nullptr),
 
    m_vx_z0_skewness_ALL_matched(nullptr),
    m_vx_z0_skewness_ALL_merged(nullptr),
    m_vx_z0_skewness_ALL_split(nullptr),
 
    m_vx_z0_kurtosis_ALL_matched(nullptr),
    m_vx_z0_kurtosis_ALL_merged(nullptr),
    m_vx_z0_kurtosis_ALL_split(nullptr),
 
    m_vx_nVertices_ALL_matched(nullptr),
    m_vx_nVertices_ALL_merged(nullptr),
    m_vx_nVertices_ALL_split(nullptr),
    m_vx_nVertices_ALL_fake(nullptr),
    m_vx_nVertices_HS_matched(nullptr),
    m_vx_nVertices_HS_merged(nullptr),
    m_vx_nVertices_HS_split(nullptr),
    m_vx_nVertices_HS_fake(nullptr),
    m_vx_nVertices_matched(nullptr),
    m_vx_nVertices_merged(nullptr),
    m_vx_nVertices_split(nullptr),
    m_vx_nVertices_fake(nullptr),
 
    m_vx_all_dz(nullptr),
    m_vx_hs_mindz(nullptr),
 
    m_vx_PUdensity(nullptr),
    m_vx_nTruth(nullptr),
    m_vx_nTruth_vs_PUdensity(nullptr)
 
 
{
  // nop
}

Member Function Documentation

book() [1/6]

template<class Htype>

void InDetPlotBase::book ( Htype *& pHisto, std::string_view histoIdentifier, std::string_view nameOverride = "", std::string_view folder = "default" )

inherited

Helper method to book histograms using an identifier string.

Parameters

pHisto	Pointer to the histogram to be booked (assumed to be initialized to nullptr)
histoIdentifier	Identifier (looked up in the XML file)
nameOverride	Allows to override the histo name w.r.t the identifier. Leave empty for no override. This can be used to instantiate multiple, identically binned plots from a single entry in the XML.
folder	Folder to place the plot (if any)

book() [2/6]

void InDetPlotBase::book ( TEfficiency *& pHisto, const SingleHistogramDefinition & hd )

inherited

Book a (1-D) TEfficiency.

Definition at line 71 of file InDetPlotBase.cxx.

                                                                             {
  if (hd.isValid()) {
    if(hd.nBinsY==0) {
      pHisto = BookTEfficiency(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, false);
    } else {
      pHisto = BookTEfficiency(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first, hd.yAxis.second, false);
    }
  }
  }

book() [3/6]

void InDetPlotBase::book ( TH1 *& pHisto, const SingleHistogramDefinition & hd )

inherited

Book a TH1 histogram.

Definition at line 43 of file InDetPlotBase.cxx.

                                                                     {
  if (hd.isValid()) {
    pHisto = Book1D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, false);
  }
  }

book() [4/6]

void InDetPlotBase::book ( TH2 *& pHisto, const SingleHistogramDefinition & hd )

inherited

Book a 2D histogram (TH2).

Definition at line 63 of file InDetPlotBase.cxx.

                                                                     {
  if (hd.isValid()) {
    pHisto = Book2D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first,
                    hd.yAxis.second, false);
  }
  }

book() [5/6]

void InDetPlotBase::book ( TProfile *& pHisto, const SingleHistogramDefinition & hd )

inherited

Book a TProfile histogram.

Definition at line 49 of file InDetPlotBase.cxx.

                                                                          {
  if (hd.isValid()) {
    pHisto = BookTProfile(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.yAxis.first,
                          hd.yAxis.second, false);
  }
  }

book() [6/6]

void InDetPlotBase::book ( TProfile2D *& pHisto, const SingleHistogramDefinition & hd )

inherited

Book a TProfile2D histogram.

Definition at line 56 of file InDetPlotBase.cxx.

                                                                            {
  if (hd.isValid()) {
    pHisto = BookTProfile2D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first,
                          hd.yAxis.second, false);
  }
  }

Book1D() [1/2]

TH1D * PlotBase::Book1D ( std::string_view name, std::string_view labels, int nBins, float start, float end, bool prependDir = true )

inherited

Book a TH1D histogram.

Definition at line 94 of file PlotBase.cxx.

                                  {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  TH1D *hist = new TH1D(prefix.append(name).c_str(), labels.data(), nBins, start, end);
  TH1::AddDirectory(oldstat);
 
  hist->Sumw2();
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book1D() [2/2]

TH1D * PlotBase::Book1D ( std::string_view name, TH1 * refHist, std::string_view labels, bool prependDir = true )

inherited

Book a TH1D histogram using refHist as reference for number of bins and axis range.

Definition at line 108 of file PlotBase.cxx.

                                                                                          {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  TH1D *hist = new TH1D(prefix.append(name).c_str(), labels.data(), refHist->GetNbinsX(),
                        refHist->GetXaxis()->GetXbins()->GetArray());
  hist->Sumw2();
  TH1::AddDirectory(oldstat);
 
 
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book2D() [1/3]

TH2F * PlotBase::Book2D ( std::string_view name, std::string_view labels, int nBinsX, Double_t * binsX, int nBinsY, Double_t startY, Double_t endY, bool prependDir = true )

inherited

Book a TH2F histogram with variable x axis binning.

Definition at line 144 of file PlotBase.cxx.

                                                                  {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH2::AddDirectoryStatus();
  TH2::AddDirectory(false);
  TH2F *hist = new TH2F(prefix.append(name).c_str(), labels.data(), nBinsX, binsX, nBinsY, startY, endY);
  hist->Sumw2();
  TH2::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book2D() [2/3]

TH2F * PlotBase::Book2D ( std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, int nBinsY, float startY, float endY, bool prependDir = true )

inherited

Book a TH2F histogram.

Definition at line 123 of file PlotBase.cxx.

                                                            {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH2::AddDirectoryStatus();
  TH2::AddDirectory(false);
  TH2F *hist = new TH2F(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, nBinsY, startY, endY);
  hist->Sumw2();
  TH2::AddDirectory(oldstat);
 
 
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book2D() [3/3]

TH2F * PlotBase::Book2D ( std::string_view name, TH2 * refHist, std::string_view labels, bool prependDir = true )

inherited

Book a TH2D histogram using refHist as reference for number of bins and axis range.

Definition at line 138 of file PlotBase.cxx.

                                                                                          {
  return Book2D(name, labels, refHist->GetNbinsX(), refHist->GetXaxis()->GetXmin(), refHist->GetXaxis()->GetXmax(),
                refHist->GetNbinsY(), refHist->GetYaxis()->GetXmin(), refHist->GetYaxis()->GetXmax(), prependDir);
}

Book3D() [1/2]

TH3F * PlotBase::Book3D ( std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, int nBinsY, float startY, float endY, int nBinsZ, float startZ, float endZ, bool prependDir = true )

inherited

Book a TH3F histogram.

Definition at line 157 of file PlotBase.cxx.

                                                                                                  {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH3::AddDirectoryStatus();
  TH3::AddDirectory(false);
  TH3F *hist = new TH3F(prefix.append(name).c_str(),
                        labels.data(), nBinsX, startX, endX, nBinsY, startY, endY, nBinsZ, startZ, endZ);
  hist->Sumw2();
  TH3::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book3D() [2/2]

TH3F * PlotBase::Book3D ( std::string_view name, TH3 * refHist, std::string_view labels, bool prependDir = true )

inherited

Book a TH3F histogram using refHist as reference for number of bins and axis range.

Definition at line 171 of file PlotBase.cxx.

                                                                                          {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TH3::AddDirectoryStatus();
  TH3::AddDirectory(false);
  TH3F *hist = new TH3F(prefix.append(name).c_str(), labels.data(), refHist->GetNbinsX(),
                        refHist->GetXaxis()->GetXbins()->GetArray(), refHist->GetNbinsY(),
                        refHist->GetYaxis()->GetXbins()->GetArray(), refHist->GetNbinsZ(),
                        refHist->GetZaxis()->GetXbins()->GetArray());
  TH3::AddDirectory(oldstat);
 
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTEfficiency() [1/2]

TEfficiency * PlotBase::BookTEfficiency ( std::string_view name, std::string_view labels, const int nBinsX, const float xlo, const float xhi, const bool prependDir = true )

inherited

Book a (1-D) TEfficiency histogram.

Definition at line 257 of file PlotBase.cxx.

                                                                                                                                               {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TEfficiency *hist = new TEfficiency(prefix.append(name).c_str(), labels.data(), nBinsX, xlo, xhi);
  hist->SetDirectory(nullptr);
  m_vBookedEfficiencies.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTEfficiency() [2/2]

TEfficiency * PlotBase::BookTEfficiency ( std::string_view name, std::string_view labels, const int nBinsX, const float xlo, const float xhi, const int nBinsy, const float ylo, const float yhi, const bool prependDir = true )

inherited

Book a (2-D) TEfficiency histogram.

Definition at line 266 of file PlotBase.cxx.

                                                                                                                                                                                                   {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
 
  TEfficiency *hist = new TEfficiency(prefix.append(name).c_str(), labels.data(), nBinsX, xlo, xhi, nBinsY, ylo, yhi);
  hist->SetDirectory(nullptr);
  m_vBookedEfficiencies.emplace_back(hist, m_sDirectory);
 
  return hist;
}

BookTProfile() [1/2]

TProfile * PlotBase::BookTProfile ( std::string_view name, std::string_view labels, int nBinsX, float * binsX, bool prependDir = true )

inherited

Book a TProfile histogram with variable binning in x-axis.

Definition at line 204 of file PlotBase.cxx.

                                                                                                            {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TProfile *hist(nullptr);
  Bool_t oldstat = TProfile::AddDirectoryStatus();
  TProfile::AddDirectory(false);
 
  hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, binsX);
  TProfile::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfile() [2/2]

TProfile * PlotBase::BookTProfile ( std::string_view name, std::string_view labels, int nBinsX, float startX, float endX, float startY = -1, float endY = -1, bool prependDir = true, bool useRMS = false )

inherited

Book a TProfile histogram.

Definition at line 186 of file PlotBase.cxx.

                                                                               {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TProfile *hist(nullptr);
  Bool_t oldstat = TProfile::AddDirectoryStatus();
  TProfile::AddDirectory(false);
  std::string opt = useRMS ? "S" : "";
  if ((startY == -1) and (endY == -1)) {
    hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, opt.c_str());
  } else {
    hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, startY, endY, opt.c_str());
  }
  TProfile::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfile2D() [1/2]

TProfile2D * PlotBase::BookTProfile2D ( std::string_view name, std::string_view labels, const int nBinsX, const double xlo, const double xhi, const int nBinsY, const double ylo, const double yhi, bool prependDir = true, bool useRMS = false )

inherited

Book a TProfile 2D histogram with variable binning in x-axis and limits in y-values.

Definition at line 231 of file PlotBase.cxx.

                                                       {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TProfile2D::AddDirectoryStatus();
  TProfile2D::AddDirectory(false);
  std::string opt = useRMS ? "S" : "";
  TProfile2D *hist = new TProfile2D(prefix.append(name).c_str(), labels.data(), nBinsX, xlo, xhi, nBinsY, ylo, yhi, opt.c_str());
  TProfile2D::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfile2D() [2/2]

TProfile2D * PlotBase::BookTProfile2D ( std::string_view name, std::string_view labels, const int nBinsX, double * binsX, const int nBinsY, double * binsY, bool prependDir = true, bool useRMS = false )

inherited

Book a TProfile 2D histogram with variable binning in x-axis and limits in y-values.

Definition at line 245 of file PlotBase.cxx.

                                                                                                                                                                   {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  Bool_t oldstat = TProfile2D::AddDirectoryStatus();
  TProfile2D::AddDirectory(false);
  std::string opt = useRMS ? "S" : "";
  TProfile2D *hist = new TProfile2D(prefix.append(name).c_str(), labels.data(), nBinsX, binsX, nBinsY, binsY, opt.c_str());
  TProfile2D::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfileRangeY()

TProfile * PlotBase::BookTProfileRangeY ( std::string_view name, std::string_view labels, int nBinsX, double * binsX, double startY, double endY, bool prependDir = true )

inherited

Book a TProfile histogram with variable binning in x-axis and limits in y-values.

Definition at line 217 of file PlotBase.cxx.

                                                                          {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TProfile *hist(nullptr);
  Bool_t oldstat = TProfile::AddDirectoryStatus();
  TProfile::AddDirectory(false);
 
  hist = new TProfile(prefix.append(name).c_str(), labels.data(), (Int_t) nBinsX, binsX, startY, endY);
  TProfile::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTree()

TTree * PlotBase::BookTree ( std::string_view name, bool prependDir = true )

inherited

Book a TTree.

Definition at line 277 of file PlotBase.cxx.

                                                       {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TTree *tree = new TTree(prefix.append(name).c_str(), "");
 
  tree->SetAutoSave(0);
  tree->SetAutoFlush(0);
  tree->SetDirectory(nullptr);
  m_vBookedTrees.emplace_back(tree, m_sDirectory);
  return tree;
}

constructPrefix()

std::string PlotBase::constructPrefix ( std::string dir, bool prependDir )

staticprivateinherited

Definition at line 289 of file PlotBase.cxx.

                                                        {
  if (!prependDir) {
    return "";
  }
  std::replace(dir.begin(), dir.end(), '/', '_');
  return dir;
}

fill() [1/2]

void InDetPerfPlot_VertexTruthMatching::fill	(	const xAOD::Vertex &	vertex,
		const xAOD::TruthVertex *	tvrt = 0,
		float	weight = 1.0 )

Definition at line 586 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                                 {
  // not sure how to deal with this type of histogram
    if (tvrt) {
        const float diff_x = vertex.x() - tvrt->x();
        const float diff_y = vertex.y() - tvrt->y();
        const float diff_z = vertex.z() - tvrt->z();
        const AmgSymMatrix(3)& covariance = vertex.covariancePosition();
        const float err_x = std::abs(Amg::error(covariance, 0)) > 1e-7 ? Amg::error(covariance, 0) : 1000.;
        const float err_y = std::abs(Amg::error(covariance, 1)) > 1e-7 ? Amg::error(covariance, 1) : 1000.;
        const float err_z = std::abs(Amg::error(covariance, 2)) > 1e-7 ? Amg::error(covariance, 2) : 1000.;
        fillHisto(m_vx_x_diff, diff_x, weight);
        fillHisto(m_vx_x_diff_pull, diff_x / err_x, weight);
        fillHisto(m_vx_y_diff, diff_y, weight);
        fillHisto(m_vx_y_diff_pull, diff_y / err_y, weight);
        fillHisto(m_vx_z_diff, diff_z, weight);
        fillHisto(m_vx_z_diff_pull, diff_z / err_z, weight);
 
        if (m_isITk) {
            static const SG::AuxElement::Accessor<uint8_t> accHasValidTime("hasValidTime");
            static const SG::AuxElement::Accessor<float> accTime("time");
            static const SG::AuxElement::Accessor<float> accTimeResolution("timeResolution");
            if (accHasValidTime.isAvailable(vertex) && accTime.isAvailable(vertex) &&
                accTimeResolution.isAvailable(vertex)) {
 
                if (vertex.hasValidTime()) {
                    float diff_time = vertex.time() - tvrt->t() / Gaudi::Units::c_light;
                    float err_time = vertex.timeResolution();
                    fillHisto(m_vx_time_diff, diff_time, weight);
                    fillHisto(m_vx_time_diff_pull, diff_time / err_time, weight);
                }
            }
        }
    }
 
    // Get the match type info for each vertex:
    const static xAOD::Vertex::Decorator<InDetVertexTruthMatchUtils::VertexMatchType> recoVtxMatchTypeInfo("VertexMatchType");
    InDetVertexTruthMatchUtils::VertexMatchType matchType;
    if (recoVtxMatchTypeInfo.isAvailable(vertex)) {
        try {
            matchType = recoVtxMatchTypeInfo(vertex);
            ATH_MSG_DEBUG("VERTEX DECORATOR ======= " << matchType << ", with nTRACKS === " << vertex.nTrackParticles() << ", vertex index = " << vertex.index() << " AT (x, y, z) = (" << vertex.x() << ", " << vertex.y() << ", " << vertex.z() << ")");
            fillHisto(m_vx_type_truth, matchType, weight);
        }
        catch (SG::ExcBadAuxVar &) {
            ATH_MSG_WARNING("VertexMatchType DECORATOR seems to be available, but may be broken  ===========");
        } 
    }
    else {
        ATH_MSG_WARNING("VertexMatchType DECORATOR is NOT available  ===========");
    }
 
} // void InDetPerfPlot_VertexTruthMatching::fill(const xAOD::Vertex& vertex) {

fill() [2/2]

void InDetPerfPlot_VertexTruthMatching::fill	(	const xAOD::Vertex *	recoHardScatter,
		const xAOD::VertexContainer &	vertexContainer,
		const std::vector< const xAOD::TruthVertex * > &	truthHSVertices,
		const std::vector< const xAOD::TruthVertex * > &	truthPUVertices,
		float	actualMu,
		float	weight = 1.0 )

Definition at line 639 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                                                                                                                                                                                           {
 
    if (m_detailLevel >= 200) {
        // Fill our histograms
        // Inclusive:
        int nTruthVertices = (int)(truthHSVertices.size() + truthPUVertices.size());
        int nRecoVertices = (int)vertexContainer.size()-1; //Not counting the dummy vertex of type 0
        fillHisto(m_vx_nReco_vs_nTruth_inclusive, nTruthVertices, nRecoVertices, weight);
        fillHisto(m_vx_nTruth, nTruthVertices, weight);
        
        // Let's also plot the vertices by vertex match type:
        const static xAOD::Vertex::Decorator<InDetVertexTruthMatchUtils::VertexMatchType> recoVtxMatchTypeInfo("VertexMatchType");
        std::map<InDetVertexTruthMatchUtils::VertexMatchType, int> breakdown = {};
        breakdown[InDetVertexTruthMatchUtils::VertexMatchType::MATCHED] = 0;
        breakdown[InDetVertexTruthMatchUtils::VertexMatchType::MERGED]  = 0;
        breakdown[InDetVertexTruthMatchUtils::VertexMatchType::SPLIT]   = 0;
        breakdown[InDetVertexTruthMatchUtils::VertexMatchType::FAKE]    = 0;
        breakdown[InDetVertexTruthMatchUtils::VertexMatchType::DUMMY]   = 0;
 
       if (!recoHardScatter){
            ATH_MSG_INFO("No recoHardScatter vertex - not filling vertex truth matching.");
            return;
        }
 
 
        // Get the truth HS vertex
        const xAOD::TruthVertex* truthHSVtx = nullptr;
 
        // Check that we have *exactly* 1 truth HS vertex
        if (!truthHSVertices.empty()) {
            if (truthHSVertices.size() != 1) {
                ATH_MSG_WARNING("Size of truth HS vertex vector is >1 -- only using the first one in the vector.");
            }
            truthHSVtx = truthHSVertices.at(0);
            fillHisto(m_vx_hs_sel_eff_dist, nTruthVertices, getRadialDiff2(recoHardScatter, truthHSVtx) < std::pow(m_cutMinTruthRecoRadialDiff, 2), weight);
            fillHisto(m_vx_hs_sel_eff_dist_vs_nReco, nRecoVertices, getRadialDiff2(recoHardScatter, truthHSVtx) < std::pow(m_cutMinTruthRecoRadialDiff, 2), weight);
        }
        else {
            ATH_MSG_WARNING("Size of truth HS vertex vector is 0 -- assuming truth HS vertex to NOT be reconstructed.");
        }
 
        //Calculating the local PU density around the true HS vertex
        if (!truthHSVtx){
          ATH_MSG_INFO("No truthHSVtx vertex - not filling vertex truth matching.");
          return;
        }
        float localPUDensity = getLocalPUDensity(truthHSVtx, truthHSVertices, truthPUVertices);
        fillHisto(m_vx_PUdensity, localPUDensity, weight);
        fillHisto(m_vx_nTruth_vs_PUdensity, nTruthVertices, localPUDensity, weight);
 
        // Best reco HS vertex identified via truth HS weights
        const xAOD::Vertex* bestRecoHSVtx_truth = InDetVertexTruthMatchUtils::bestHardScatterMatch(vertexContainer);
        if (!bestRecoHSVtx_truth){
            ATH_MSG_INFO("No bestRecoHS vertex - not filling vertex truth matching.");
            return;
        }
 
        fillHisto(m_vx_hs_sel_eff_mu, actualMu, (recoHardScatter == bestRecoHSVtx_truth), weight);
        fillHisto(m_vx_hs_sel_eff, localPUDensity, (recoHardScatter == bestRecoHSVtx_truth), weight);
        fillHisto(m_vx_hs_sel_eff_vs_nReco, nRecoVertices, (recoHardScatter == bestRecoHSVtx_truth), weight);
        fillHisto(m_vx_hs_sel_eff_vs_ntruth, nTruthVertices, (recoHardScatter == bestRecoHSVtx_truth), weight);
 
        // Did we successfully reconstruct our truth HS vertex?
        bool truthHSVtxRecoed = false;
        float minTruthRecoRadialDiff2 = std::pow(m_cutMinTruthRecoRadialDiff, 2);
        float truthRecoRadialDiff2 = -1.;
        if (truthHSVtx) {
            // If the radial difference between the truth-pkg-selected best reco HS vertex and the truth HS vertex is
            // less than some cut (e.g., 0.1 mm), then we say the truth HS vertex is reconstructed
            truthRecoRadialDiff2 = getRadialDiff2(bestRecoHSVtx_truth, truthHSVtx);
            if (truthRecoRadialDiff2 < minTruthRecoRadialDiff2) {
                truthHSVtxRecoed = true;
                minTruthRecoRadialDiff2 = truthRecoRadialDiff2;
            }
        }
 
        // add variables here so that they are in correct scope (outside loop over vertices)
        float number_matched = 0;
        float number_merged = 0;
        float number_split = 0;
        float number_fake = 0;
        float number_matched_HS = 0;
        float number_merged_HS = 0;
        float number_split_HS = 0;
        float number_fake_HS = 0;
        float number_matched_PU = 0;
        float number_merged_PU = 0;
        float number_split_PU = 0;
        float number_fake_PU = 0;
        
        // variables for delta z between the HS and the closest one
        float vx_hs_mindz=9999.; 
        float min_fabs_dz = 9999.;
 
        // Iterate over vertices:
        InDetVertexTruthMatchUtils::VertexMatchType matchType;
        for (const auto& vertex : vertexContainer.stdcont()) {
 
            // Skip dummy vertex (last one in the container)
            if (vertex->vertexType() == xAOD::VxType::NoVtx) {
                continue;
            }
 
            fill(*vertex);
 
            matchType = recoVtxMatchTypeInfo(*vertex);
            breakdown[matchType] += 1;
 
          
            const xAOD::TruthVertex *matchVertex = getTruthVertex(vertex);
            if(!matchVertex) continue;
            float residual_z = matchVertex->z() - vertex->z();
            float residual_x = matchVertex->x() - vertex->x();
            float residual_y = matchVertex->y() - vertex->y();
            const AmgSymMatrix(3)& covariance = vertex->covariancePosition();
            float vtxerr_x = fabs(Amg::error(covariance, 0)) > 1e-7 ? Amg::error(covariance, 0) : 1000.;
            float vtxerr_y = fabs(Amg::error(covariance, 1)) > 1e-7 ? Amg::error(covariance, 1) : 1000.;
            float vtxerr_z = fabs(Amg::error(covariance, 2)) > 1e-7 ? Amg::error(covariance, 2) : 1000.;
            localPUDensity = getLocalPUDensity(matchVertex, truthHSVertices, truthPUVertices);
    
            fillHisto(m_vx_all_z_pull, residual_z/vtxerr_z, weight);
            fillHisto(m_vx_all_y_pull, residual_y/vtxerr_y, weight);
            fillHisto(m_vx_all_x_pull, residual_x/vtxerr_x, weight);
 
            fillHisto(m_vx_all_truth_z_res_vs_PU, localPUDensity, residual_z, weight);
            fillHisto(m_vx_all_truth_x_res_vs_PU, localPUDensity, residual_x, weight);
            fillHisto(m_vx_all_truth_y_res_vs_PU, localPUDensity, residual_y, weight);
 
            fillHisto(m_vx_all_z_res, residual_z, weight);
            fillHisto(m_vx_all_y_res, residual_y, weight);
            fillHisto(m_vx_all_x_res, residual_x, weight);
            
            fillHisto(m_vx_all_truth_z_pull_vs_PU, localPUDensity, residual_z/vtxerr_z, weight);
            fillHisto(m_vx_all_truth_x_pull_vs_PU, localPUDensity, residual_x/vtxerr_x, weight);
            fillHisto(m_vx_all_truth_y_pull_vs_PU, localPUDensity, residual_y/vtxerr_y, weight);
 
            fillHisto(m_vx_all_truth_z_res_vs_nTrk, vertex->nTrackParticles(), residual_z, weight);
            fillHisto(m_vx_all_truth_x_res_vs_nTrk, vertex->nTrackParticles(), residual_x, weight);
            fillHisto(m_vx_all_truth_y_res_vs_nTrk, vertex->nTrackParticles(), residual_y, weight);
            
            fillHisto(m_vx_all_truth_z_pull_vs_nTrk, vertex->nTrackParticles(), residual_z/vtxerr_z, weight);
            fillHisto(m_vx_all_truth_x_pull_vs_nTrk, vertex->nTrackParticles(), residual_x/vtxerr_x, weight);
            fillHisto(m_vx_all_truth_y_pull_vs_nTrk, vertex->nTrackParticles(), residual_y/vtxerr_y, weight);
 
 
 
 
       // New Expert histograms for observables for vertex classifications for HS and PU 
       // For each vertex, loop over all tracks and get sumpt and sum of charges
       // also use this to get the z asymmetry around the vertex.
   
         // Declaring variables for the observables        
         const xAOD::TrackParticle* trackTmp = nullptr;
         float sumPt =0;
         float minpt = 20000 ; // minimum sum pt required for the 'All' vertices plots - 20 GeV
         float trackPt = 0;
 
         // variables for calculation of delta Z asymmetry and delta d asymmetry
         float z_asym = 0;
         float sumDZ = 0;
         float deltaZ =0;
         float modsumDZ =0;
         float weighted_sumDZ = 0;
         float weighted_deltaZ = 0;
         float weighted_modsumDZ = 0;
         float weighted_z_asym =0;
 
         // make vector
         std::vector<float> track_deltaZ;
         std::vector<float> track_deltaPt;
         std::vector<float> track_deltaZ_weighted;
         // loop over tracks 
         for (size_t i = 0; i < vertex->nTrackParticles(); i++) {
            trackTmp = vertex->trackParticle(i);
            
        
            if (trackTmp) {
                 trackPt = trackTmp->pt();  //  MeV 
                 sumPt = sumPt + trackPt;  // in MeV
                 deltaZ = trackTmp->z0() - vertex->z();
                 track_deltaZ.push_back(deltaZ);
                 // get the track weight for each track to get the deltaZ/trk_weight
                 float trk_weight = vertex->trackWeight(i);
                 weighted_deltaZ = deltaZ*trk_weight;
                 // sum of delta z
                 sumDZ = sumDZ + deltaZ; 
                 modsumDZ = modsumDZ + std::abs(deltaZ);
                 weighted_sumDZ =  weighted_sumDZ + weighted_deltaZ;
                 weighted_modsumDZ = weighted_modsumDZ + std::abs(weighted_deltaZ);
               
            }
           } // end loop over tracks
            if  (modsumDZ >0) {
                z_asym = sumDZ/modsumDZ;
            }
            if  (weighted_modsumDZ >0) {
                weighted_z_asym = weighted_sumDZ/weighted_modsumDZ;
            }
 
 
          
            double mean_Dz =0;
            mean_Dz=sumDZ/track_deltaZ.size(); //calculate average
            double number_tracks =0;
            number_tracks = track_deltaZ.size(); // get number of tracks 
 
            double z_sd = 0; //  standard deviation
            double z_skew = 0;  // skewness of DeltaZ asymmetry
            double z_kurt = 0;  // Kurtosis of DeltaZ asymmetry 
            double z_var=0;     // variance of DeltaZ
            double z_zbar=0;    // for use in calculation below
 
            for ( auto i : track_deltaZ) {
      
               z_zbar = (i - mean_Dz);
               z_var =(z_var + z_zbar*z_zbar);
               z_skew =(z_skew + z_zbar*z_zbar*z_zbar);
               z_kurt =(z_kurt + z_zbar*z_zbar*z_zbar*z_zbar);
 
            } 
               z_var = z_var/(number_tracks -1);
               z_sd = std::sqrt(z_var);
               z_skew = z_skew/((number_tracks -1)*z_sd*z_sd*z_sd);
               z_kurt = z_kurt/((number_tracks -1)*z_sd*z_sd*z_sd*z_sd);
 
            float ndf = vertex->numberDoF();
            if (ndf != 0) {
 
              if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MATCHED) {
               if (vertex == bestRecoHSVtx_truth) {
    
         fillHisto(m_vx_sumpT_HS_matched,sumPt ,weight);
                 fillHisto(m_vx_z_asym_HS_matched, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_HS_matched, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_HS_matched, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_HS_matched, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_HS_matched, z_kurt,weight);
       
 
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_HS_matched, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_HS_matched, trkWeight/number_tracks,weight);
                 }
 
               }    
           else { 
        
                 fillHisto(m_vx_sumpT_matched,sumPt ,weight);
                 fillHisto(m_vx_z_asym_matched, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_matched, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_matched, vertex->chiSquared()/ndf,weight);
              
                 fillHisto(m_vx_z0_skewness_matched, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_matched, z_kurt,weight);
 
 
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_matched, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_matched, trkWeight/number_tracks,weight);
                 }
               }
// fill some histograms that contain both HS and PU above a min pt - say 20GeV
              if (sumPt > minpt) {
                 fillHisto(m_vx_sumpT_ALL_matched,sumPt ,weight);
                 fillHisto(m_vx_z_asym_ALL_matched, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_ALL_matched, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_ALL_matched, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_ALL_matched, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_ALL_matched, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_ALL_matched, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_ALL_matched, trkWeight/number_tracks,weight);
                 }
 
              }
             }  // end of if matched vertices
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MERGED) {
              if (vertex == bestRecoHSVtx_truth) {
              
                 fillHisto(m_vx_sumpT_HS_merged, sumPt ,weight);
                 fillHisto(m_vx_z_asym_HS_merged, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_HS_merged, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_HS_merged, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_HS_merged, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_HS_merged, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_HS_merged, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_HS_merged, trkWeight/number_tracks,weight);
                 }
 
 
 
              }
              else {
                 fillHisto(m_vx_sumpT_merged, sumPt ,weight);
                 fillHisto(m_vx_z_asym_merged, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_merged, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_merged, vertex->chiSquared()/ndf,weight);
             
                 fillHisto(m_vx_z0_skewness_merged, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_merged, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_merged, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_merged, trkWeight/number_tracks,weight);
                 }
 
              }
              if (sumPt > minpt) {
                 fillHisto(m_vx_sumpT_ALL_merged,sumPt ,weight);
                 fillHisto(m_vx_z_asym_ALL_merged, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_ALL_merged, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_ALL_merged, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_ALL_merged, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_ALL_merged, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_ALL_merged, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_ALL_merged, trkWeight/number_tracks,weight);
                 }
 
              }
             }   //end of if merged vertices
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::SPLIT) {
              if (vertex == bestRecoHSVtx_truth) {
                 fillHisto(m_vx_sumpT_HS_split, sumPt ,weight);
                 fillHisto(m_vx_z_asym_HS_split, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_HS_split, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_HS_split, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_HS_split, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_HS_split, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_HS_split, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_HS_split, trkWeight/number_tracks,weight);
                 }
 
 
              }
              else {
                 fillHisto(m_vx_sumpT_split, sumPt ,weight);
                 fillHisto(m_vx_z_asym_split, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_split, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_split, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_split, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_split, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_split, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_split, trkWeight/number_tracks,weight);
                 }
 
 
              }
 
              if (sumPt > minpt) {
                 fillHisto(m_vx_sumpT_ALL_split,sumPt ,weight);
                 fillHisto(m_vx_z_asym_ALL_split, z_asym,weight);
                 fillHisto(m_vx_z_asym_weighted_ALL_split, weighted_z_asym,weight);
                 fillHisto(m_vx_chi2Over_ndf_ALL_split, vertex->chiSquared()/ndf,weight);
 
                 fillHisto(m_vx_z0_skewness_ALL_split, z_skew,weight);
                 fillHisto(m_vx_z0_kurtosis_ALL_split, z_kurt,weight);
                 for (const float& trkWeight : vertex->trackWeights()) {
                     fillHisto(m_vx_track_weight_ALL_split, trkWeight,weight);
                     fillHisto(m_vx_normalised_track_weight_ALL_split, trkWeight/number_tracks,weight);
                 }
              }
 
         }   // end of if split vertices
 
// Count the number of vertices for each type per event
         
 
         if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MATCHED) {
              if (vertex == bestRecoHSVtx_truth) {
                 number_matched_HS++;
              }
              else {
                 number_matched_PU++;         
              }
              if (sumPt > minpt) {
                  number_matched++;
             }
         }
 
         else if (matchType  == InDetVertexTruthMatchUtils::VertexMatchType::MERGED) {
              if (vertex == bestRecoHSVtx_truth) {
                 number_merged_HS++;
              }
              else {
                 number_merged_PU++;         
              }
              if (sumPt > minpt) {
                  number_merged++;
             }
         }
 
         else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::SPLIT) {
              if (vertex == bestRecoHSVtx_truth) {
                 number_split_HS++;
              }
              else {
                 number_split_PU++;         
              }
              if (sumPt > minpt) {
                  number_split++;    
             }
         }
 
         else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::FAKE) {
              if (vertex == bestRecoHSVtx_truth) {
                 number_fake_HS++;
              }
              else {
                 number_fake_PU++;         
              }
              if (sumPt > minpt) {
                  number_fake++;    
             }
         }
        } // end of if (ndf != 0)
 
 
 
// New histos to check for number of tracks for each vertex type   
        for (const auto& vertex : vertexContainer.stdcont()) {
           if (vertex == bestRecoHSVtx_truth) {
 
         
             if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MATCHED) {
 
                fillHisto(m_vx_ntracks_HS_matched, vertex->nTrackParticles(),weight);
             } 
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MERGED) {
                 fillHisto(m_vx_ntracks_HS_merged,  vertex->nTrackParticles(),weight);
 
             }
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::SPLIT) {
                 fillHisto(m_vx_ntracks_HS_split,   vertex->nTrackParticles(),weight);
             }
           }
           else {
 
 
             if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MATCHED) {
              
                fillHisto(m_vx_ntracks_matched, vertex->nTrackParticles(),weight);
             }
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MERGED) {
                fillHisto(m_vx_ntracks_merged,  vertex->nTrackParticles(),weight);
 
             }
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::SPLIT) {
                 fillHisto(m_vx_ntracks_split,   vertex->nTrackParticles(),weight);
             }  
 
           }
           if (sumPt > minpt) {
             if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MATCHED) {
              
                fillHisto(m_vx_ntracks_ALL_matched, vertex->nTrackParticles(),weight);
             }
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::MERGED) {
                fillHisto(m_vx_ntracks_ALL_merged,  vertex->nTrackParticles(),weight);
 
             }
 
             else if (matchType == InDetVertexTruthMatchUtils::VertexMatchType::SPLIT) {
                 fillHisto(m_vx_ntracks_ALL_split,   vertex->nTrackParticles(),weight);
             }  
 
           }
   
        } 
 
// delta z  between HS and nearby vertices
      float absd_hs_dz = std::abs(bestRecoHSVtx_truth->z() - vertex->z());
      if(bestRecoHSVtx_truth != vertex && absd_hs_dz < min_fabs_dz) {
         min_fabs_dz = absd_hs_dz;
         vx_hs_mindz = bestRecoHSVtx_truth->z() - vertex->z();
      }
// loop over vertices again for dz of every vertices pair
      for (const auto& vertex2 : vertexContainer.stdcont()) {
         if (vertex2->vertexType() == xAOD::VxType::NoVtx) continue;
         if(vertex2 == vertex) continue;
         fillHisto(m_vx_all_dz, vertex->z() - vertex2->z(), 0.5*weight);
      }
 
       } // end loop over vertices
 
// new histos to count number of vertices per event
        fillHisto(m_vx_nVertices_ALL_matched, number_matched,weight);
        fillHisto(m_vx_nVertices_ALL_merged, number_merged,weight);
        fillHisto(m_vx_nVertices_ALL_split, number_split,weight);
        fillHisto(m_vx_nVertices_ALL_fake, number_fake,weight);
        fillHisto(m_vx_nVertices_HS_matched, number_matched_HS,weight);
        fillHisto(m_vx_nVertices_HS_merged, number_merged_HS,weight);
        fillHisto(m_vx_nVertices_HS_split, number_split_HS,weight);
        fillHisto(m_vx_nVertices_HS_fake, number_fake_HS,weight);
        fillHisto(m_vx_nVertices_matched, number_matched_PU,weight);
        fillHisto(m_vx_nVertices_merged, number_merged_PU,weight);
        fillHisto(m_vx_nVertices_split, number_split_PU,weight);
        fillHisto(m_vx_nVertices_fake, number_fake_PU,weight);
 
// new histo to delta z between HS and the closest one
      fillHisto(m_vx_hs_mindz, vx_hs_mindz, weight);
 
        // Now fill plots relating to the reconstruction of our truth HS vertex (efficiency and resolutions)
        if (!truthHSVertices.empty()) {
            if (truthHSVtxRecoed) {
                float residual_z = truthHSVtx->z() - bestRecoHSVtx_truth->z();
                float residual_r = std::sqrt(std::pow(truthHSVtx->x() - bestRecoHSVtx_truth->x(), 2) + std::pow(truthHSVtx->y() - bestRecoHSVtx_truth->y(), 2));
                float residual_x = truthHSVtx->x() - bestRecoHSVtx_truth->x();
                float residual_y = truthHSVtx->y() - bestRecoHSVtx_truth->y();
                fillHisto(m_vx_hs_reco_eff, localPUDensity, 1, weight);
                fillHisto(m_vx_hs_reco_sel_eff, localPUDensity, (recoHardScatter == bestRecoHSVtx_truth), weight);
                fillHisto(m_vx_hs_reco_eff_vs_ntruth, nTruthVertices, 1, weight);
                fillHisto(m_vx_hs_reco_sel_eff_vs_ntruth, nTruthVertices, (recoHardScatter == bestRecoHSVtx_truth), weight);
                fillHisto(m_vx_hs_reco_long_reso, localPUDensity, getRecoLongitudinalReso(bestRecoHSVtx_truth), weight);
                fillHisto(m_vx_hs_reco_trans_reso, localPUDensity, getRecoTransverseReso(bestRecoHSVtx_truth), weight);
 
                fillHisto(m_resHelper_PUdensity_hsVxTruthLong, localPUDensity, residual_z, weight);
                fillHisto(m_resHelper_PUdensity_hsVxTruthTransv, localPUDensity, residual_r, weight);
 
                const AmgSymMatrix(3)& covariance = bestRecoHSVtx_truth->covariancePosition();
                float vtxerr_x = Amg::error(covariance, 0);
                float vtxerr_y = Amg::error(covariance, 1);
                float vtxerr_z = Amg::error(covariance, 2);
 
                if(fabs(vtxerr_z) > 1e-7) fillHisto(m_vx_hs_z_pull, residual_z/vtxerr_z, weight);
                if(fabs(vtxerr_y) > 1e-7) fillHisto(m_vx_hs_y_pull, residual_y/vtxerr_y, weight);
                if(fabs(vtxerr_x) > 1e-7) fillHisto(m_vx_hs_x_pull, residual_x/vtxerr_x, weight);
 
                fillHisto(m_vx_hs_truth_z_res_vs_PU, localPUDensity, residual_z, weight);
                fillHisto(m_vx_hs_truth_x_res_vs_PU, localPUDensity, residual_x, weight);
                fillHisto(m_vx_hs_truth_y_res_vs_PU, localPUDensity, residual_y, weight);
 
                fillHisto(m_vx_hs_z_res, residual_z, weight);
                fillHisto(m_vx_hs_y_res, residual_y, weight);
                fillHisto(m_vx_hs_x_res, residual_x, weight);
 
                fillHisto(m_vx_hs_truth_z_pull_vs_PU, localPUDensity, residual_z/vtxerr_z, weight);
                fillHisto(m_vx_hs_truth_x_pull_vs_PU, localPUDensity, residual_x/vtxerr_x, weight);
                fillHisto(m_vx_hs_truth_y_pull_vs_PU, localPUDensity, residual_y/vtxerr_y, weight);
 
                fillHisto(m_vx_hs_truth_z_res_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_z, weight);
                fillHisto(m_vx_hs_truth_x_res_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_x, weight);
                fillHisto(m_vx_hs_truth_y_res_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_y, weight);
            
                fillHisto(m_vx_hs_truth_z_pull_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_z/vtxerr_z, weight);
                fillHisto(m_vx_hs_truth_x_pull_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_x/vtxerr_x, weight);
                fillHisto(m_vx_hs_truth_y_pull_vs_nTrk, bestRecoHSVtx_truth->nTrackParticles(), residual_y/vtxerr_y, weight);
 
            }
            else {
                fillHisto(m_vx_hs_reco_eff, localPUDensity, 0, weight);
                fillHisto(m_vx_hs_reco_eff_vs_ntruth, nTruthVertices, 0, weight);
            }
        }
 
        fillHisto(m_vx_nReco_vs_nTruth_matched, nTruthVertices, breakdown[InDetVertexTruthMatchUtils::VertexMatchType::MATCHED], weight);
        fillHisto(m_vx_nReco_vs_nTruth_merged,  nTruthVertices, breakdown[InDetVertexTruthMatchUtils::VertexMatchType::MERGED], weight);
        fillHisto(m_vx_nReco_vs_nTruth_split,   nTruthVertices, breakdown[InDetVertexTruthMatchUtils::VertexMatchType::SPLIT], weight);
        fillHisto(m_vx_nReco_vs_nTruth_fake,    nTruthVertices, breakdown[InDetVertexTruthMatchUtils::VertexMatchType::FAKE], weight);
        fillHisto(m_vx_nReco_vs_nTruth_dummy,   nTruthVertices, breakdown[InDetVertexTruthMatchUtils::VertexMatchType::DUMMY], weight);
        
        // And by hardscatter type:
        InDetVertexTruthMatchUtils::HardScatterType hsType = InDetVertexTruthMatchUtils::classifyHardScatter(vertexContainer);
        fillHisto(m_vx_hs_classification, hsType, weight);
        switch (hsType) {
            case InDetVertexTruthMatchUtils::HardScatterType::CLEAN: {
                fillHisto(m_vx_nReco_vs_nTruth_clean, nTruthVertices, nRecoVertices, weight);
                break;
            }
            case InDetVertexTruthMatchUtils::HardScatterType::LOWPU: {
                fillHisto(m_vx_nReco_vs_nTruth_lowpu, nTruthVertices, nRecoVertices, weight);
                break;
            }
            case InDetVertexTruthMatchUtils::HardScatterType::HIGHPU: {
                fillHisto(m_vx_nReco_vs_nTruth_highpu, nTruthVertices, nRecoVertices, weight);
                break;
            }
            case InDetVertexTruthMatchUtils::HardScatterType::HSSPLIT: {
                fillHisto(m_vx_nReco_vs_nTruth_hssplit, nTruthVertices, nRecoVertices, weight);
                break;
            }
            case InDetVertexTruthMatchUtils::HardScatterType::NONE: {
                fillHisto(m_vx_nReco_vs_nTruth_none, nTruthVertices, nRecoVertices, weight);
                break;
            }
            default: {
                break;
            }
        }  // End of switch
    }   // end of EXpert plots - (if (m_detailLevel >= 200))
 
} // end InDetPerfPlot_VertexTruthMatching::fill(const xAOD::VertexContainer& vertexContainer, const std::vector<const xAOD::TruthVertex*>& truthHSVertices, const std::vector<const xAOD::TruthVertex*>& truthPUVertices)

fillHisto() [1/9]

void InDetPlotBase::fillHisto ( TEfficiency * eff2d, const float xvalue, const float yvalue, const bool accepted, const float weight )

staticinherited

Definition at line 142 of file InDetPlotBase.cxx.

                                                                                                                            {
  if (eff2d and validArguments(xvalue, yvalue)) {
    if(weight==1.) eff2d->Fill(accepted, xvalue, yvalue);
    else eff2d->FillWeighted(accepted, weight, xvalue, yvalue);
  }
}

fillHisto() [2/9]

void InDetPlotBase::fillHisto ( TEfficiency * pTeff, const float value, const bool accepted, float weight )

staticinherited

Definition at line 134 of file InDetPlotBase.cxx.

                                                                                                  {
  if (pTeff and validArguments(value)) {
    if(weight==1.) pTeff->Fill(accepted, value); // To get proper error estimate when possible
    else pTeff->FillWeighted(accepted, weight, value);
  }
}

fillHisto() [3/9]

void InDetPlotBase::fillHisto ( TH1 * pTh1, const float value )

staticinherited

Definition at line 97 of file InDetPlotBase.cxx.

                                                     {
  if (pTh1 and validArguments(value)) {
    pTh1->Fill(value);
  }
}

fillHisto() [4/9]

void InDetPlotBase::fillHisto ( TH1 * pTh1, const float value, const float weight )

staticinherited

Definition at line 104 of file InDetPlotBase.cxx.

                                                                         {
  if (pTh1 and validArguments(value)) {
    pTh1->Fill(value, weight);
  }
}

fillHisto() [5/9]

void InDetPlotBase::fillHisto ( TH2 * pTh2, const float xval, const float yval )

staticinherited

Definition at line 112 of file InDetPlotBase.cxx.

                                                                      {
  if (pTh2 and validArguments(xval, yval)) {
    pTh2->Fill(xval, yval);
  }
}

fillHisto() [6/9]

void InDetPlotBase::fillHisto ( TH2 * pTh2, const float xval, const float yval, const float weight )

staticinherited

Definition at line 120 of file InDetPlotBase.cxx.

                                                                                          {
  if (pTh2 and validArguments(xval, yval)) {
    pTh2->Fill(xval, yval, weight);
  }
}

fillHisto() [7/9]

void InDetPlotBase::fillHisto ( TH3 * pTh3, const float xval, const float yval, const float zval )

staticinherited

Definition at line 127 of file InDetPlotBase.cxx.

                                                                                        {
  if (pTh3 and validArguments(xval, yval, zval)) {
    pTh3->Fill(xval, yval, zval);
  }
}

fillHisto() [8/9]

void InDetPlotBase::fillHisto ( TProfile * pTprofile, const float bin, const float weight, const float weight2 = 1.0 )

staticinherited

Definition at line 82 of file InDetPlotBase.cxx.

                                                                                                      {
  if (pTprofile and validArguments(bin, weight)) {
    pTprofile->Fill(bin, weight,weight2);
  }
}

fillHisto() [9/9]

void InDetPlotBase::fillHisto ( TProfile2D * pTprofile, const float xval, const float yval, const float weight, const float weight2 = 1.0 )

staticinherited

Definition at line 89 of file InDetPlotBase.cxx.

                                                                                                                           {
  if (pTprofile and validArguments(xval,yval, weight) and validArguments(weight2)) {
    pTprofile->Fill(xval,yval, weight,weight2);
  }
}

fillResoHist()

void InDetPerfPlot_VertexTruthMatching::fillResoHist ( TH1 * resoHist, const TH2 * resoHist2D )

staticprivate

Definition at line 487 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                         {
 
    TH1* projHist = nullptr;
    int safety_counter;
    TFitResultPtr fitResult;
    double mean;
    double rms;
    double itr_rms = -1.;
    double itr_rms_err;
 
    for (int i = 1; i < resoHist2D->GetNbinsX() + 1; i++) {
 
        projHist = resoHist2D->ProjectionY("projectionY", i, i);
 
        if (projHist->GetEntries() == 0.) {
            resoHist->SetBinContent(i, 0.);
            resoHist->SetBinError(i, 0.);
            continue;
        }
 
        safety_counter = 0;
 
        fitResult = projHist->Fit("gaus", "QS0");
        if (!fitResult.Get()) {
            // Is it necessary to also require fitResult->Status() % 1000 == 0 for a successful fit?
            // --> fitStatus = migradResult + 10 * minosResult + 100 * hesseResult + 1000 * improveResult
            resoHist->SetBinContent(i, 0.);
            resoHist->SetBinError(i, 0.);
            continue;
        }
        mean = fitResult->Parameter(1);
        rms  = fitResult->Parameter(2);
 
        while (true) {
 
            projHist->SetAxisRange(mean - 3 * rms, mean + 3 * rms, "X");
 
            fitResult = projHist->Fit("gaus", "QS0");
            if (!fitResult.Get()) {
                itr_rms     = 0.;
                itr_rms_err = 0.;
                break;
            }
            itr_rms     = fitResult->Parameter(2);
            itr_rms_err = fitResult->ParError(2);
 
            if ((fabs(itr_rms - rms) < 0.0001) || (safety_counter == 5)) {
                break;
            }
 
            safety_counter++;
            mean = fitResult->Parameter(1);
            rms  = itr_rms;
 
        }
 
        resoHist->SetBinContent(i, itr_rms);
        resoHist->SetBinError(i, itr_rms_err);
 
    }
}

finalize()

void PlotBase::finalize ( )

inherited

Definition at line 47 of file PlotBase.cxx.

                   {
  for (auto *subNode: m_vSubNodes) {
    subNode->finalize();
  }
  finalizePlots();
}

finalizePlots()

void InDetPerfPlot_VertexTruthMatching::finalizePlots ( )

privatevirtual

Reimplemented from PlotBase.

Definition at line 1248 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                      {
 
    if (m_detailLevel >= 200) {
        
        fillResoHist(m_resolution_vs_PUdensity_hsVxTruthLong, m_resHelper_PUdensity_hsVxTruthLong);
        fillResoHist(m_resolution_vs_PUdensity_hsVxTruthTransv, m_resHelper_PUdensity_hsVxTruthTransv);
    }
 
} // end InDetPerfPlot_VertexTruthMatching::finalizePlots()

getDirectory()

const std::string & PlotBase::getDirectory ( )

inlineinherited

Definition at line 89 of file PlotBase.h.

{return m_sDirectory;}

getHSRecoVertexSumPt2()

const xAOD::Vertex * InDetPerfPlot_VertexTruthMatching::getHSRecoVertexSumPt2 ( const xAOD::VertexContainer & recoVertices )

staticprivate

Definition at line 418 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                                  {
    const xAOD::Vertex* recoHSVertex = nullptr;
    float sumPtMax = -1.;
    const xAOD::TrackParticle* trackTmp = nullptr;
    float sumPtTmp;
    for (const auto& vtx : recoVertices.stdcont()) {
        if (vtx) {
            sumPtTmp = 0.;
            for (size_t i = 0; i < vtx->nTrackParticles(); i++) {
                trackTmp = vtx->trackParticle(i);
                if (trackTmp) {
                    sumPtTmp += std::pow(trackTmp->pt(), 2);
                }
            }
            if (sumPtTmp > sumPtMax) {
                sumPtMax = sumPtTmp;
                recoHSVertex = vtx;
            }
        }
    }
    return recoHSVertex;
}

getLocalPUDensity()

float InDetPerfPlot_VertexTruthMatching::getLocalPUDensity ( const xAOD::TruthVertex * vtxOfInterest, const std::vector< const xAOD::TruthVertex * > & truthHSVertices, const std::vector< const xAOD::TruthVertex * > & truthPUVertices, const float radialWindow = 2.0 ) const

private

Definition at line 447 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                                                                                                                                                                   {
    float radialWindow2 = std::pow(radialWindow, 2);
    int nTracksInWindow = 0;
    float localPUDensity;
    float radialDiff2;
    for (const auto& vtx : truthHSVertices) {
        if (vtx != vtxOfInterest) {
            radialDiff2 = getRadialDiff2(vtxOfInterest, vtx);
            if (radialDiff2 < radialWindow2) {
                nTracksInWindow += 1;
            }
        }
    }
    for (const auto& vtx : truthPUVertices) {
        if (vtx != vtxOfInterest) {
            radialDiff2 = getRadialDiff2(vtxOfInterest, vtx);
            if (radialDiff2 < radialWindow2) {
                nTracksInWindow += 1;
            }
        }
    }
    localPUDensity = (float)(nTracksInWindow) / (2 * radialWindow);
    return localPUDensity;
}

getRadialDiff2()

template<typename U, typename V>

float InDetPerfPlot_VertexTruthMatching::getRadialDiff2 ( const U * vtx1, const V * vtx2 ) const

private

Definition at line 443 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                          {
    return (std::pow((vtx1->x() - vtx2->x()), 2) + std::pow((vtx1->y() - vtx2->y()), 2) + std::pow((vtx1->z() - vtx2->z()), 2));
}

getRecoLongitudinalReso()

float InDetPerfPlot_VertexTruthMatching::getRecoLongitudinalReso ( const xAOD::Vertex * recoVtx )

staticprivate

Definition at line 472 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                          {
    return std::sqrt(recoVtx->covariancePosition()(2, 2));
}

getRecoTransverseReso()

float InDetPerfPlot_VertexTruthMatching::getRecoTransverseReso ( const xAOD::Vertex * recoVtx )

staticprivate

Definition at line 476 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                        {
    float x = recoVtx->x();
    float y = recoVtx->y();
    float xErr2 = recoVtx->covariancePosition()(0, 0);
    float yErr2 = recoVtx->covariancePosition()(1, 1);
    float xyCov = recoVtx->covariancePosition()(0, 1);
    float r2 = std::pow(x, 2) + std::pow(y, 2);
    return std::sqrt(std::pow(x, 2) / r2 * xErr2 + std::pow(y, 2) / r2 * yErr2 + 2 * x * y / r2 * xyCov);
}

getTruthVertex()

const xAOD::TruthVertex * InDetPerfPlot_VertexTruthMatching::getTruthVertex ( const xAOD::Vertex * recoVtx ) const

private

Definition at line 549 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                                                                        {
    const xAOD::TruthVertex* truthVtx = nullptr;
    if (recoVtx) {
        const static xAOD::Vertex::Decorator<std::vector<InDetVertexTruthMatchUtils::VertexTruthMatchInfo>> truthMatchingInfos("TruthEventMatchingInfos");
        try{
            if (!truthMatchingInfos.isAvailable(*recoVtx)){
                ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR not available -- returning nullptr!");
                return truthVtx;
            }
            const std::vector<InDetVertexTruthMatchUtils::VertexTruthMatchInfo>& truthInfos = truthMatchingInfos(*recoVtx);
            if (!truthInfos.empty()) {
                const InDetVertexTruthMatchUtils::VertexTruthMatchInfo& truthInfo = truthInfos.at(0);
                const ElementLink<xAOD::TruthEventBaseContainer> truthEventLink = std::get<0>(truthInfo);
                const xAOD::TruthEvent* truthEvent = nullptr;
                if (truthEventLink.isValid()) {
                    truthEvent = static_cast<const xAOD::TruthEvent*>(*truthEventLink);
                    if (truthEvent) {
                        size_t i_vtx = 0;
                        size_t n_vtx = truthEvent->nTruthVertices();
                        while(!truthVtx && i_vtx<n_vtx){
                          truthVtx = truthEvent->truthVertex(i_vtx);
                          i_vtx++;
                        }
                    }
                }
            }
            else {
                ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR yields empty vector -- returning nullptr!");
            }
        }
        catch (SG::ExcBadAuxVar &){
            ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR yields empty vector -- returning nullptr!");
        }
    }
    return truthVtx;
}

initialize()

void PlotBase::initialize ( )

inherited

Definition at line 39 of file PlotBase.cxx.

                     {
  for (auto *subNode: m_vSubNodes) {
    subNode->initialize();
  }
  initializePlots();
}

initializePlots()

void InDetPerfPlot_VertexTruthMatching::initializePlots ( )

privatevirtual

Reimplemented from PlotBase.

Definition at line 216 of file InDetPerfPlot_VertexTruthMatching.cxx.

                                                        {
 
    book(m_vx_type_truth,"vx_type_truth");
    book(m_vx_x_diff,"vx_x_diff");
    book(m_vx_x_diff_pull,"vx_x_diff_pull");
    book(m_vx_y_diff,"vx_y_diff");
    book(m_vx_y_diff_pull,"vx_y_diff_pull");
    book(m_vx_z_diff,"vx_z_diff");
    book(m_vx_z_diff_pull,"vx_z_diff_pull");
    if(m_isITk){
      book(m_vx_time_diff,"vx_time_diff");
      book(m_vx_time_diff_pull,"vx_time_diff_pull");
    }
    if (m_detailLevel >= 200) {
        book(m_vx_hs_classification,"vx_hs_classification");
        book(m_vx_nReco_vs_nTruth_inclusive,"vx_nReco_vs_nTruth_inclusive");
        book(m_vx_nReco_vs_nTruth_matched,"vx_nReco_vs_nTruth_matched");
        book(m_vx_nReco_vs_nTruth_merged,"vx_nReco_vs_nTruth_merged");
        book(m_vx_nReco_vs_nTruth_split,"vx_nReco_vs_nTruth_split");
        book(m_vx_nReco_vs_nTruth_fake,"vx_nReco_vs_nTruth_fake");
        book(m_vx_nReco_vs_nTruth_dummy,"vx_nReco_vs_nTruth_dummy");
        book(m_vx_nReco_vs_nTruth_clean,"vx_nReco_vs_nTruth_clean");
        book(m_vx_nReco_vs_nTruth_lowpu,"vx_nReco_vs_nTruth_lowpu");
        book(m_vx_nReco_vs_nTruth_highpu,"vx_nReco_vs_nTruth_highpu");
        book(m_vx_nReco_vs_nTruth_hssplit,"vx_nReco_vs_nTruth_hssplit");
        book(m_vx_nReco_vs_nTruth_none,"vx_nReco_vs_nTruth_none");
        book(m_vx_hs_reco_eff,"vx_hs_reco_eff");
        book(m_vx_hs_sel_eff,"vx_hs_sel_eff");
        book(m_vx_hs_sel_eff_vs_nReco,"vx_hs_sel_eff_vs_nReco");
        book(m_vx_hs_reco_sel_eff,"vx_hs_reco_sel_eff");
        book(m_vx_hs_sel_eff_dist,"vx_hs_sel_eff_dist");
        book(m_vx_hs_sel_eff_mu,"vx_hs_sel_eff_mu");
        book(m_vx_hs_sel_eff_dist_vs_nReco,"vx_hs_sel_eff_dist_vs_nReco");
        book(m_vx_hs_reco_eff_vs_ntruth,"vx_hs_reco_eff_vs_ntruth");
        book(m_vx_hs_sel_eff_vs_ntruth,"vx_hs_sel_eff_vs_ntruth");
        book(m_vx_hs_reco_sel_eff_vs_ntruth,"vx_hs_reco_sel_eff_vs_ntruth");
        book(m_vx_hs_reco_long_reso,"vx_hs_reco_long_reso");
        book(m_vx_hs_reco_trans_reso,"vx_hs_reco_trans_reso");
 
        //Helpers for resolution plots for HS vertex
        book(m_resHelper_PUdensity_hsVxTruthLong,"resHelper_PUdensity_hsVxTruthLong");
        book(m_resolution_vs_PUdensity_hsVxTruthLong,"resolution_vs_PUdensity_hsVxTruthLong");
        book(m_resmean_vs_PUdensity_hsVxTruthLong,"resmean_vs_PUdensity_hsVxTruthLong");
 
        book(m_resHelper_PUdensity_hsVxTruthTransv,"resHelper_PUdensity_hsVxTruthTransv");
        book(m_resolution_vs_PUdensity_hsVxTruthTransv,"resolution_vs_PUdensity_hsVxTruthTransv");
        book(m_resmean_vs_PUdensity_hsVxTruthTransv,"resmean_vs_PUdensity_hsVxTruthTransv");
        
        book(m_vx_hs_z_pull,"vx_TYPE_z_pull","vx_hs_z_pull");
        book(m_vx_hs_y_pull,"vx_TYPE_y_pull","vx_hs_y_pull");
        book(m_vx_hs_x_pull,"vx_TYPE_x_pull","vx_hs_x_pull");
   
        book(m_vx_all_z_pull,"vx_TYPE_z_pull","vx_all_z_pull");
        book(m_vx_all_y_pull,"vx_TYPE_y_pull","vx_all_y_pull");
        book(m_vx_all_x_pull,"vx_TYPE_x_pull","vx_all_x_pull");
 
        book(m_vx_hs_z_res,"vx_TYPE_z_reso","vx_hs_z_res");
        book(m_vx_hs_y_res,"vx_TYPE_y_reso","vx_hs_y_res");
        book(m_vx_hs_x_res,"vx_TYPE_x_reso","vx_hs_x_res");
        book(m_vx_all_z_res,"vx_TYPE_z_reso","vx_all_z_res");
        book(m_vx_all_y_res,"vx_TYPE_y_reso","vx_all_y_res");
        book(m_vx_all_x_res,"vx_TYPE_x_reso","vx_all_x_res");
 
        book(m_vx_all_truth_z_res_vs_PU, "vx_TYPE_truth_reso_z_vs_PU", "vx_all_truth_reso_z_vs_PU");
        book(m_vx_all_truth_x_res_vs_PU, "vx_TYPE_truth_reso_x_vs_PU", "vx_all_truth_reso_x_vs_PU");
        book(m_vx_all_truth_y_res_vs_PU, "vx_TYPE_truth_reso_y_vs_PU", "vx_all_truth_reso_y_vs_PU");
        book(m_vx_all_truth_z_res_vs_nTrk, "vx_TYPE_truth_reso_z_vs_nTrk", "vx_all_truth_reso_z_vs_nTrk");
        book(m_vx_all_truth_x_res_vs_nTrk, "vx_TYPE_truth_reso_x_vs_nTrk", "vx_all_truth_reso_x_vs_nTrk");
        book(m_vx_all_truth_y_res_vs_nTrk, "vx_TYPE_truth_reso_y_vs_nTrk", "vx_all_truth_reso_y_vs_nTrk");
 
        book(m_vx_all_truth_z_pull_vs_PU, "vx_TYPE_truth_pull_z_vs_PU", "vx_all_truth_pull_z_vs_PU");
        book(m_vx_all_truth_x_pull_vs_PU, "vx_TYPE_truth_pull_x_vs_PU", "vx_all_truth_pull_x_vs_PU");
        book(m_vx_all_truth_y_pull_vs_PU, "vx_TYPE_truth_pull_y_vs_PU", "vx_all_truth_pull_y_vs_PU");
        book(m_vx_all_truth_z_pull_vs_nTrk, "vx_TYPE_truth_pull_z_vs_nTrk", "vx_all_truth_pull_z_vs_nTrk");
        book(m_vx_all_truth_x_pull_vs_nTrk, "vx_TYPE_truth_pull_x_vs_nTrk", "vx_all_truth_pull_x_vs_nTrk");
        book(m_vx_all_truth_y_pull_vs_nTrk, "vx_TYPE_truth_pull_y_vs_nTrk", "vx_all_truth_pull_y_vs_nTrk");
 
        book(m_vx_hs_truth_z_res_vs_PU, "vx_TYPE_truth_reso_z_vs_PU", "vx_hs_truth_reso_z_vs_PU");
        book(m_vx_hs_truth_x_res_vs_PU, "vx_TYPE_truth_reso_x_vs_PU", "vx_hs_truth_reso_x_vs_PU");
        book(m_vx_hs_truth_y_res_vs_PU, "vx_TYPE_truth_reso_y_vs_PU", "vx_hs_truth_reso_y_vs_PU");
        book(m_vx_hs_truth_z_res_vs_nTrk, "vx_TYPE_truth_reso_z_vs_nTrk", "vx_hs_truth_reso_z_vs_nTrk");
        book(m_vx_hs_truth_x_res_vs_nTrk, "vx_TYPE_truth_reso_x_vs_nTrk", "vx_hs_truth_reso_x_vs_nTrk");
        book(m_vx_hs_truth_y_res_vs_nTrk, "vx_TYPE_truth_reso_y_vs_nTrk", "vx_hs_truth_reso_y_vs_nTrk");
 
        book(m_vx_hs_truth_z_pull_vs_PU, "vx_TYPE_truth_pull_z_vs_PU", "vx_hs_truth_pull_z_vs_PU");
        book(m_vx_hs_truth_x_pull_vs_PU, "vx_TYPE_truth_pull_x_vs_PU", "vx_hs_truth_pull_x_vs_PU");
        book(m_vx_hs_truth_y_pull_vs_PU, "vx_TYPE_truth_pull_y_vs_PU", "vx_hs_truth_pull_y_vs_PU");
        book(m_vx_hs_truth_z_pull_vs_nTrk, "vx_TYPE_truth_pull_z_vs_nTrk", "vx_hs_truth_pull_z_vs_nTrk");
        book(m_vx_hs_truth_x_pull_vs_nTrk, "vx_TYPE_truth_pull_x_vs_nTrk", "vx_hs_truth_pull_x_vs_nTrk");
        book(m_vx_hs_truth_y_pull_vs_nTrk, "vx_TYPE_truth_pull_y_vs_nTrk", "vx_hs_truth_pull_y_vs_nTrk");
     
        // book the new expert histos for vertex classifications
        book(m_vx_ntracks_matched,"vx_ntracks_matched");
        book(m_vx_ntracks_merged,"vx_ntracks_merged");
        book(m_vx_ntracks_split,"vx_ntracks_split");
        book(m_vx_ntracks_HS_matched,"vx_ntracks_HS_matched");
        book(m_vx_ntracks_HS_merged,"vx_ntracks_HS_merged");
        book(m_vx_ntracks_HS_split,"vx_ntracks_HS_split");
        book(m_vx_ntracks_ALL_matched,"vx_ntracks_ALL_matched");
        book(m_vx_ntracks_ALL_merged,"vx_ntracks_ALL_merged");
        book(m_vx_ntracks_ALL_split,"vx_ntracks_ALL_split");
        book(m_vx_sumpT_matched,"vx_sumpT_matched");
        book(m_vx_sumpT_merged,"vx_sumpT_merged");
        book(m_vx_sumpT_split,"vx_sumpT_split");
        book(m_vx_sumpT_HS_matched,"vx_sumpT_HS_matched");
        book(m_vx_sumpT_HS_merged,"vx_sumpT_HS_merged");
        book(m_vx_sumpT_HS_split,"vx_sumpT_HS_split");
        book(m_vx_sumpT_ALL_matched,"vx_sumpT_ALL_matched");
        book(m_vx_sumpT_ALL_merged,"vx_sumpT_ALL_merged");
        book(m_vx_sumpT_ALL_split,"vx_sumpT_ALL_split");
        
        book(m_vx_z_asym_matched,"vx_z_asym_matched");
        book(m_vx_z_asym_merged,"vx_z_asym_merged");
        book(m_vx_z_asym_split,"vx_z_asym_split");
        book(m_vx_z_asym_HS_matched,"vx_z_asym_HS_matched");
        book(m_vx_z_asym_HS_merged,"vx_z_asym_HS_merged");
        book(m_vx_z_asym_HS_split,"vx_z_asym_HS_split");
        book(m_vx_z_asym_ALL_matched,"vx_z_asym_ALL_matched");
        book(m_vx_z_asym_ALL_merged,"vx_z_asym_ALL_merged");
        book(m_vx_z_asym_ALL_split,"vx_z_asym_ALL_split");
        book(m_vx_z_asym_weighted_matched,"vx_z_asym_weighted_matched");
        book(m_vx_z_asym_weighted_merged,"vx_z_asym_weighted_merged");
        book(m_vx_z_asym_weighted_split,"vx_z_asym_weighted_split");
        book(m_vx_z_asym_weighted_HS_matched,"vx_z_asym_weighted_HS_matched");
        book(m_vx_z_asym_weighted_HS_merged,"vx_z_asym_weighted_HS_merged");
        book(m_vx_z_asym_weighted_HS_split,"vx_z_asym_weighted_HS_split");
        book(m_vx_z_asym_weighted_ALL_matched,"vx_z_asym_weighted_ALL_matched");
        book(m_vx_z_asym_weighted_ALL_merged,"vx_z_asym_weighted_ALL_merged");
        book(m_vx_z_asym_weighted_ALL_split,"vx_z_asym_weighted_ALL_split");
        
        book(m_vx_track_weight_matched, "vx_track_weight_matched");
        book(m_vx_track_weight_merged, "vx_track_weight_merged");
        book(m_vx_track_weight_split, "vx_track_weight_split");
        book(m_vx_track_weight_HS_matched, "vx_track_weight_HS_matched");
        book(m_vx_track_weight_HS_merged, "vx_track_weight_HS_merged");
        book(m_vx_track_weight_HS_split, "vx_track_weight_HS_split");
        book(m_vx_track_weight_ALL_matched, "vx_track_weight_ALL_matched");
        book(m_vx_track_weight_ALL_merged, "vx_track_weight_ALL_merged");
        book(m_vx_track_weight_ALL_split, "vx_track_weight_ALL_split");
 
        book(m_vx_normalised_track_weight_matched, "vx_normalised_track_weight_matched");
        book(m_vx_normalised_track_weight_merged, "vx_normalised_track_weight_merged");
        book(m_vx_normalised_track_weight_split, "vx_normalised_track_weight_split");
        book(m_vx_normalised_track_weight_HS_matched, "vx_normalised_track_weight_HS_matched");
        book(m_vx_normalised_track_weight_HS_merged, "vx_normalised_track_weight_HS_merged");
        book(m_vx_normalised_track_weight_HS_split, "vx_normalised_track_weight_HS_split");
        book(m_vx_normalised_track_weight_ALL_matched, "vx_normalised_track_weight_ALL_matched");
        book(m_vx_normalised_track_weight_ALL_merged, "vx_normalised_track_weight_ALL_merged");
        book(m_vx_normalised_track_weight_ALL_split, "vx_normalised_track_weight_ALL_split");
 
        book(m_vx_chi2Over_ndf_matched,"vx_chi2Over_ndf_matched");
        book(m_vx_chi2Over_ndf_merged,"vx_chi2Over_ndf_merged");
        book(m_vx_chi2Over_ndf_split,"vx_chi2Over_ndf_split");
        book(m_vx_chi2Over_ndf_HS_matched,"vx_chi2Over_ndf_HS_matched");
        book(m_vx_chi2Over_ndf_HS_merged,"vx_chi2Over_ndf_HS_merged");
        book(m_vx_chi2Over_ndf_HS_split,"vx_chi2Over_ndf_HS_split");
        book(m_vx_chi2Over_ndf_ALL_matched,"vx_chi2Over_ndf_ALL_matched");
        book(m_vx_chi2Over_ndf_ALL_merged,"vx_chi2Over_ndf_ALL_merged");
        book(m_vx_chi2Over_ndf_ALL_split,"vx_chi2Over_ndf_ALL_split");
        
        book(m_vx_z0_skewness_matched, "vx_z0_skewness_matched");
        book(m_vx_z0_skewness_merged, "vx_z0_skewness_merged");
        book(m_vx_z0_skewness_split, "vx_z0_skewness_split");
        book(m_vx_z0_skewness_HS_matched, "vx_z0_skewness_HS_matched");
        book(m_vx_z0_skewness_HS_merged, "vx_z0_skewness_HS_merged");
        book(m_vx_z0_skewness_HS_split, "vx_z0_skewness_HS_split");
        book(m_vx_z0_skewness_ALL_matched, "vx_z0_skewness_ALL_matched");
        book(m_vx_z0_skewness_ALL_merged, "vx_z0_skewness_ALL_merged");
        book(m_vx_z0_skewness_ALL_split, "vx_z0_skewness_ALL_split");
        book(m_vx_z0_kurtosis_matched,"vx_z0_kurtosis_matched");
        book(m_vx_z0_kurtosis_merged,"vx_z0_kurtosis_merged");
        book(m_vx_z0_kurtosis_split,"vx_z0_kurtosis_split");
        book(m_vx_z0_kurtosis_HS_matched,"vx_z0_kurtosis_HS_matched");
        book(m_vx_z0_kurtosis_HS_merged,"vx_z0_kurtosis_HS_merged");
        book(m_vx_z0_kurtosis_HS_split,"vx_z0_kurtosis_HS_split");
        book(m_vx_z0_kurtosis_ALL_matched,"vx_z0_kurtosis_ALL_matched");
        book(m_vx_z0_kurtosis_ALL_merged,"vx_z0_kurtosis_ALL_merged");
        book(m_vx_z0_kurtosis_ALL_split,"vx_z0_kurtosis_ALL_split");
 
 
        book(m_vx_nVertices_matched,"vx_nVertices_matched");
        book(m_vx_nVertices_merged,"vx_nVertices_merged");
        book(m_vx_nVertices_split, "vx_nVertices_split");
        book(m_vx_nVertices_fake, "vx_nVertices_fake");
        book(m_vx_nVertices_HS_matched,"vx_nVertices_HS_matched");
        book(m_vx_nVertices_HS_merged,"vx_nVertices_HS_merged");
        book(m_vx_nVertices_HS_split,"vx_nVertices_HS_split");
        book(m_vx_nVertices_HS_fake,"vx_nVertices_HS_fake");
        book(m_vx_nVertices_ALL_matched,"vx_nVertices_ALL_matched");
        book(m_vx_nVertices_ALL_merged,"vx_nVertices_ALL_merged");
        book(m_vx_nVertices_ALL_split,"vx_nVertices_ALL_split");
        book(m_vx_nVertices_ALL_fake,"vx_nVertices_ALL_fake");
 
        book(m_vx_hs_mindz,"vx_hs_mindz");
        book(m_vx_all_dz,"vx_all_dz");
 
        book(m_vx_PUdensity,"vx_PUdensity");
        book(m_vx_nTruth,"vx_nTruth");
        book(m_vx_nTruth_vs_PUdensity,"vx_nTruth_vs_PUdensity");
    }
 
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

mBook()

template<class T>

void InDetPlotBase::mBook ( T & pHisto, const std::string & histoIdentifier )

inlineprotectedinherited

book, for use by macro

Definition at line 84 of file InDetPlotBase.h.

                                                     {
    return book(pHisto, histoIdentifier.substr(2));
  }

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

RegisterSubPlot()

void PlotBase::RegisterSubPlot ( PlotBase * pPlotBase )

inlineinherited

Definition at line 42 of file PlotBase.h.

{m_vSubNodes.push_back(pPlotBase);}

retrieveBookedEfficiencies()

std::vector< EfficiencyData > PlotBase::retrieveBookedEfficiencies ( )

inherited

Retrieve all booked efficiency objects.

Definition at line 83 of file PlotBase.cxx.

                                     {
  std::vector<EfficiencyData> vBookedEfficiencies = m_vBookedEfficiencies;
  for (const auto &subNode: m_vSubNodes) {
    std::vector<EfficiencyData> subNodeHists = subNode->retrieveBookedEfficiencies();
    vBookedEfficiencies.insert(vBookedEfficiencies.end(), subNodeHists.begin(), subNodeHists.end());
  }
  return vBookedEfficiencies;
}

retrieveBookedHistograms()

std::vector< HistData > PlotBase::retrieveBookedHistograms ( )

inherited

Retrieve all booked histograms.

Definition at line 63 of file PlotBase.cxx.

                                   {
  std::vector<HistData> vBookedHistograms = m_vBookedHistograms;
  for (const auto &subNode: m_vSubNodes) {
    std::vector<HistData> subNodeHists = subNode->retrieveBookedHistograms();
    vBookedHistograms.insert(vBookedHistograms.end(), subNodeHists.begin(), subNodeHists.end());
  }
  return vBookedHistograms;
}

retrieveBookedTrees()

std::vector< TreeData > PlotBase::retrieveBookedTrees ( )

inherited

Retrieve all booked trees.

Definition at line 73 of file PlotBase.cxx.

                              {
  std::vector<TreeData> vBookedTrees = m_vBookedTrees;
  for (auto *subNode: m_vSubNodes) {
    std::vector<TreeData> subNodeTrees = subNode->retrieveBookedTrees();
    vBookedTrees.insert(vBookedTrees.end(), subNodeTrees.begin(), subNodeTrees.end());
  }
  return vBookedTrees;
}

retrieveDefinition()

SingleHistogramDefinition InDetPlotBase::retrieveDefinition ( std::string_view histoIdentifier, std::string_view folder = "default", std::string_view nameOverride = "" )

inherited

Retrieve a single histogram definition, given the unique string identifier.

Definition at line 151 of file InDetPlotBase.cxx.

                                                                                                                    {
 
  ATH_CHECK( m_histoDefSvc.retrieve(), {} );
 
  bool folderDefault = (folder.empty() or folder == "default");
  SingleHistogramDefinition s = m_histoDefSvc->definition(histoIdentifier, folder);
  // "default" and empty string should be equivalent
  if (folderDefault and s.empty()) {
    const std::string otherDefault = (folder.empty()) ? ("default") : "";
    s = m_histoDefSvc->definition(histoIdentifier, otherDefault);
  }
  if (s.empty()) {
    ATH_MSG_WARNING("Histogram definition is empty for identifier " << histoIdentifier);
  }
  if (!nameOverride.empty()){
    s.name = nameOverride; 
  }
  return s;
}

setDetailLevel()

void PlotBase::setDetailLevel ( int iDetailLevel )

inherited

Definition at line 55 of file PlotBase.cxx.

                                         {
  for (auto *subNode: m_vSubNodes) {
    subNode->setDetailLevel(iDetailLevel);
  }
  m_iDetailLevel = iDetailLevel;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_cutMinTruthRecoRadialDiff

float InDetPerfPlot_VertexTruthMatching::m_cutMinTruthRecoRadialDiff = 0.1

private

Definition at line 49 of file InDetPerfPlot_VertexTruthMatching.h.

m_detailLevel

int InDetPerfPlot_VertexTruthMatching::m_detailLevel {10}

private

Definition at line 48 of file InDetPerfPlot_VertexTruthMatching.h.

{10};

m_histoDefSvc

ServiceHandle<IHistogramDefinitionSvc> InDetPlotBase::m_histoDefSvc

privateinherited

Definition at line 89 of file InDetPlotBase.h.

m_iDetailLevel

int PlotBase::m_iDetailLevel

protectedinherited

Definition at line 102 of file PlotBase.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_isITk

bool InDetPerfPlot_VertexTruthMatching::m_isITk {false}

private

Definition at line 47 of file InDetPerfPlot_VertexTruthMatching.h.

{false};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_resHelper_PUdensity_hsVxTruthLong

TH2* InDetPerfPlot_VertexTruthMatching::m_resHelper_PUdensity_hsVxTruthLong

private

Definition at line 101 of file InDetPerfPlot_VertexTruthMatching.h.

m_resHelper_PUdensity_hsVxTruthTransv

TH2* InDetPerfPlot_VertexTruthMatching::m_resHelper_PUdensity_hsVxTruthTransv

private

Definition at line 104 of file InDetPerfPlot_VertexTruthMatching.h.

m_resmean_vs_PUdensity_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resmean_vs_PUdensity_hsVxTruthLong

private

Definition at line 103 of file InDetPerfPlot_VertexTruthMatching.h.

m_resmean_vs_PUdensity_hsVxTruthTransv

TH1* InDetPerfPlot_VertexTruthMatching::m_resmean_vs_PUdensity_hsVxTruthTransv

private

Definition at line 106 of file InDetPerfPlot_VertexTruthMatching.h.

m_resolution_vs_PUdensity_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resolution_vs_PUdensity_hsVxTruthLong

private

Definition at line 102 of file InDetPerfPlot_VertexTruthMatching.h.

m_resolution_vs_PUdensity_hsVxTruthTransv

TH1* InDetPerfPlot_VertexTruthMatching::m_resolution_vs_PUdensity_hsVxTruthTransv

private

Definition at line 105 of file InDetPerfPlot_VertexTruthMatching.h.

m_sDirectory

std::string PlotBase::m_sDirectory

protectedinherited

Definition at line 101 of file PlotBase.h.

m_vBookedEfficiencies

std::vector<EfficiencyData> PlotBase::m_vBookedEfficiencies

protectedinherited

Definition at line 100 of file PlotBase.h.

m_vBookedHistograms

std::vector<HistData> PlotBase::m_vBookedHistograms

protectedinherited

Definition at line 98 of file PlotBase.h.

m_vBookedTrees

std::vector<TreeData> PlotBase::m_vBookedTrees

protectedinherited

Definition at line 99 of file PlotBase.h.

m_vSubNodes

std::vector<PlotBase*> PlotBase::m_vSubNodes

protectedinherited

Definition at line 97 of file PlotBase.h.

m_vx_all_dz

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_dz

private

Definition at line 257 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_x_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_pull_vs_nTrk

private

Definition at line 134 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_x_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_pull_vs_PU

private

Definition at line 127 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_x_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_res_vs_nTrk

private

Definition at line 131 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_x_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_res_vs_PU

private

Definition at line 124 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_y_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_pull_vs_nTrk

private

Definition at line 135 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_y_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_pull_vs_PU

private

Definition at line 128 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_y_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_res_vs_nTrk

private

Definition at line 132 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_y_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_res_vs_PU

private

Definition at line 125 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_z_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_pull_vs_nTrk

private

Definition at line 133 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_z_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_pull_vs_PU

private

Definition at line 126 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_z_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_res_vs_nTrk

private

Definition at line 130 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_truth_z_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_res_vs_PU

private

Definition at line 123 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_x_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_x_pull

private

Definition at line 114 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_x_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_x_res

private

Definition at line 121 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_y_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_y_pull

private

Definition at line 113 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_y_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_y_res

private

Definition at line 120 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_z_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_z_pull

private

Definition at line 112 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_all_z_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_z_res

private

Definition at line 119 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_ALL_matched

private

Definition at line 232 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_ALL_merged

private

Definition at line 233 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_ALL_split

private

Definition at line 234 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_HS_matched

private

Definition at line 197 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_HS_merged

private

Definition at line 198 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_HS_split

private

Definition at line 199 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_matched

private

Definition at line 194 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_merged

private

Definition at line 195 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_chi2Over_ndf_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf_split

private

Definition at line 196 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_classification

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_classification {}

private

hardscatter classification

Definition at line 64 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_hs_mindz

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_mindz

private

Definition at line 258 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_eff

private

Definition at line 78 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_eff_vs_ntruth

private

Definition at line 92 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_long_reso

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_long_reso

private

Definition at line 98 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_sel_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_sel_eff

private

Definition at line 84 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_sel_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_sel_eff_vs_ntruth

private

Definition at line 96 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_reco_trans_reso

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_trans_reso

private

Definition at line 99 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff

private

Definition at line 80 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff_dist

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_dist

private

Definition at line 86 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff_dist_vs_nReco

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_dist_vs_nReco

private

Definition at line 90 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff_mu

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_mu

private

Definition at line 88 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff_vs_nReco

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_vs_nReco

private

Definition at line 82 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_sel_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_vs_ntruth

private

Definition at line 94 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_x_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_pull_vs_nTrk

private

Definition at line 148 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_x_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_pull_vs_PU

private

Definition at line 141 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_x_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_res_vs_nTrk

private

Definition at line 145 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_x_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_res_vs_PU

private

Definition at line 138 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_y_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_pull_vs_nTrk

private

Definition at line 149 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_y_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_pull_vs_PU

private

Definition at line 142 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_y_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_res_vs_nTrk

private

Definition at line 146 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_y_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_res_vs_PU

private

Definition at line 139 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_z_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_pull_vs_nTrk

private

Definition at line 147 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_z_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_pull_vs_PU

private

Definition at line 140 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_z_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_res_vs_nTrk

private

Definition at line 144 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_truth_z_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_res_vs_PU

private

Definition at line 137 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_x_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_x_pull

private

Definition at line 111 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_x_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_x_res

private

Definition at line 118 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_y_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_y_pull

private

Definition at line 110 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_y_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_y_res

private

Definition at line 117 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_z_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_z_pull

private

Definition at line 109 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_hs_z_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_z_res

private

Definition at line 116 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_ALL_matched

private

Definition at line 228 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_ALL_merged

private

Definition at line 229 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_ALL_split

private

Definition at line 230 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_HS_matched

private

Definition at line 190 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_HS_merged

private

Definition at line 191 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_HS_split

private

Definition at line 192 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_matched

private

Definition at line 187 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_merged

private

Definition at line 188 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_normalised_track_weight_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight_split

private

Definition at line 189 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_clean

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_clean

private

Definition at line 72 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_dummy

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_dummy

private

Definition at line 71 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_fake

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_fake

private

Definition at line 70 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_highpu

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_highpu

private

Definition at line 74 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_hssplit

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_hssplit

private

Definition at line 75 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_inclusive

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_inclusive

private

vertex reco efficiency

Definition at line 66 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_lowpu

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_lowpu

private

Definition at line 73 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_matched

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_matched

private

Definition at line 67 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_merged

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_merged

private

Definition at line 68 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_none

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_none

private

Definition at line 76 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nReco_vs_nTruth_split

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_split

private

Definition at line 69 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_ALL_matched

private

Definition at line 157 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_ALL_merged

private

Definition at line 158 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_ALL_split

private

Definition at line 159 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_HS_matched

private

Definition at line 154 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_HS_merged

private

Definition at line 155 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_HS_split

private

Definition at line 156 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_matched

private

Definition at line 151 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_merged

private

Definition at line 152 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_ntracks_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_ntracks_split

private

Definition at line 153 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nTruth

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nTruth

private

Definition at line 261 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nTruth_vs_PUdensity

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_nTruth_vs_PUdensity

private

Definition at line 262 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_ALL_fake

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_ALL_fake

private

Definition at line 246 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_ALL_matched

private

Definition at line 243 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_ALL_merged

private

Definition at line 244 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_ALL_split

private

Definition at line 245 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_fake

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_fake

private

Definition at line 254 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_HS_fake

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_HS_fake

private

Definition at line 250 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_HS_matched

private

Definition at line 247 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_HS_merged

private

Definition at line 248 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_HS_split

private

Definition at line 249 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_matched

private

Definition at line 251 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_merged

private

Definition at line 252 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_nVertices_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nVertices_split

private

Definition at line 253 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_PUdensity

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_PUdensity

private

Definition at line 260 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_ALL_matched

private

Definition at line 215 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_ALL_merged

private

Definition at line 216 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_ALL_split

private

Definition at line 217 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_HS_matched

private

Definition at line 163 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_HS_merged

private

Definition at line 164 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_HS_split

private

Definition at line 165 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_matched

private

Definition at line 160 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_merged

private

Definition at line 161 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_sumpT_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_sumpT_split

private

Definition at line 162 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_time_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_time_diff {}

private

vertex time

Definition at line 60 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_time_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_time_diff_pull {}

private

Definition at line 61 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_track_weight_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_ALL_matched

private

Definition at line 225 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_ALL_merged

private

Definition at line 226 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_ALL_split

private

Definition at line 227 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_HS_matched

private

Definition at line 183 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_HS_merged

private

Definition at line 184 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_HS_split

private

Definition at line 185 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_matched

private

Definition at line 180 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_merged

private

Definition at line 181 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_track_weight_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_track_weight_split

private

Definition at line 182 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_type_truth

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_type_truth {}

private

truth type

Definition at line 51 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_x_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_x_diff {}

private

Definition at line 52 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_x_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_x_diff_pull {}

private

Definition at line 53 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_y_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_y_diff {}

private

Definition at line 54 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_y_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_y_diff_pull {}

private

Definition at line 55 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_z0_kurtosis_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_ALL_matched

private

Definition at line 239 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_ALL_merged

private

Definition at line 240 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_ALL_split

private

Definition at line 241 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_HS_matched

private

Definition at line 210 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_HS_merged

private

Definition at line 211 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_HS_split

private

Definition at line 212 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_matched

private

Definition at line 207 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_merged

private

Definition at line 208 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_kurtosis_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis_split

private

Definition at line 209 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_ALL_matched

private

Definition at line 236 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_ALL_merged

private

Definition at line 237 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_ALL_split

private

Definition at line 238 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_HS_matched

private

Definition at line 204 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_HS_merged

private

Definition at line 205 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_HS_split

private

Definition at line 206 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_matched

private

Definition at line 201 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_merged

private

Definition at line 202 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z0_skewness_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness_split

private

Definition at line 203 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_ALL_matched

private

Definition at line 219 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_ALL_merged

private

Definition at line 220 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_ALL_split

private

Definition at line 221 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_HS_matched

private

Definition at line 170 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_HS_merged

private

Definition at line 171 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_HS_split

private

Definition at line 172 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_matched

private

Definition at line 167 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_merged

private

Definition at line 168 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_split

private

Definition at line 169 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_ALL_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_ALL_matched

private

Definition at line 222 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_ALL_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_ALL_merged

private

Definition at line 223 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_ALL_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_ALL_split

private

Definition at line 224 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_HS_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_HS_matched

private

Definition at line 176 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_HS_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_HS_merged

private

Definition at line 177 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_HS_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_HS_split

private

Definition at line 178 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_matched

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_matched

private

Definition at line 173 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_merged

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_merged

private

Definition at line 174 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_asym_weighted_split

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted_split

private

Definition at line 175 of file InDetPerfPlot_VertexTruthMatching.h.

m_vx_z_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_diff {}

private

Definition at line 56 of file InDetPerfPlot_VertexTruthMatching.h.

{};

m_vx_z_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_diff_pull {}

private

Definition at line 57 of file InDetPerfPlot_VertexTruthMatching.h.

{};

---

The documentation for this class was generated from the following files:

• InDetPerfPlot_VertexTruthMatching.h
• InDetPerfPlot_VertexTruthMatching.cxx