ATLAS Offline Software
Loading...
Searching...
No Matches
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 Types

using TH1_map = std::map<int, std::map<InDetVertexTruthMatchUtils::VertexMatchType, TH1*>>

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 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 = nullptr
 truth type
TH1 * m_vx_x_diff = nullptr
TH1 * m_vx_x_diff_pull = nullptr
TH1 * m_vx_y_diff = nullptr
TH1 * m_vx_y_diff_pull = nullptr
TH1 * m_vx_z_diff = nullptr
TH1 * m_vx_z_diff_pull = nullptr
TH1 * m_vx_time_diff = nullptr
 vertex time
TH1 * m_vx_time_diff_pull = nullptr
TH1 * m_vx_hs_classification = nullptr
 hardscatter classification
TProfile * m_vx_nReco_vs_nTruth_inclusive = nullptr
 vertex reco efficiency
TProfile * m_vx_nReco_vs_nTruth_matched = nullptr
TProfile * m_vx_nReco_vs_nTruth_merged = nullptr
TProfile * m_vx_nReco_vs_nTruth_split = nullptr
TProfile * m_vx_nReco_vs_nTruth_fake = nullptr
TProfile * m_vx_nReco_vs_nTruth_dummy = nullptr
TProfile * m_vx_nReco_vs_nTruth_clean = nullptr
TProfile * m_vx_nReco_vs_nTruth_lowpu = nullptr
TProfile * m_vx_nReco_vs_nTruth_highpu = nullptr
TProfile * m_vx_nReco_vs_nTruth_hssplit = nullptr
TProfile * m_vx_nReco_vs_nTruth_none = nullptr
TEfficiency * m_vx_hs_reco_eff = nullptr
TEfficiency * m_vx_hs_sel_eff = nullptr
TEfficiency * m_vx_hs_sel_eff_vs_nReco = nullptr
TEfficiency * m_vx_hs_reco_sel_eff = nullptr
TEfficiency * m_vx_hs_sel_eff_dist = nullptr
TEfficiency * m_vx_hs_sel_eff_mu = nullptr
TEfficiency * m_vx_hs_sel_eff_dist_vs_nReco = nullptr
TEfficiency * m_vx_hs_reco_eff_vs_ntruth = nullptr
TEfficiency * m_vx_hs_reco_eff_mu = nullptr
TEfficiency * m_vx_hs_sel_eff_vs_ntruth = nullptr
TEfficiency * m_vx_hs_reco_sel_eff_vs_ntruth = nullptr
TProfile * m_vx_hs_reco_long_reso = nullptr
TProfile * m_vx_hs_reco_trans_reso = nullptr
IDPVM::ResolutionHelper m_resolutionHelper {}
IDPVM::ResolutionHelper::methods m_resolutionMethod = IDPVM::ResolutionHelper::iterRMS_convergence
TH2 * m_resHelper_PUdensity_hsVxTruthLong = nullptr
TH1 * m_resolution_vs_PUdensity_hsVxTruthLong = nullptr
TH1 * m_resmean_vs_PUdensity_hsVxTruthLong = nullptr
TH2 * m_resHelper_PUdensity_hsVxTruthTransv = nullptr
TH1 * m_resolution_vs_PUdensity_hsVxTruthTransv = nullptr
TH1 * m_resmean_vs_PUdensity_hsVxTruthTransv = nullptr
TH2 * m_resHelper_mu_hsVxTruthLong = nullptr
TH1 * m_resolution_vs_mu_hsVxTruthLong = nullptr
TH1 * m_resmean_vs_mu_hsVxTruthLong = nullptr
TH1 * m_vx_hs_z_pull = nullptr
TH1 * m_vx_hs_y_pull = nullptr
TH1 * m_vx_hs_x_pull = nullptr
TH1 * m_vx_all_z_pull = nullptr
TH1 * m_vx_all_y_pull = nullptr
TH1 * m_vx_all_x_pull = nullptr
TH1 * m_vx_hs_z_res = nullptr
TH1 * m_vx_hs_y_res = nullptr
TH1 * m_vx_hs_x_res = nullptr
TH1 * m_vx_all_z_res = nullptr
TH1 * m_vx_all_y_res = nullptr
TH1 * m_vx_all_x_res = nullptr
TH2 * m_vx_all_truth_z_res_vs_PU = nullptr
TH2 * m_vx_all_truth_x_res_vs_PU = nullptr
TH2 * m_vx_all_truth_y_res_vs_PU = nullptr
TH2 * m_vx_all_truth_z_pull_vs_PU = nullptr
TH2 * m_vx_all_truth_x_pull_vs_PU = nullptr
TH2 * m_vx_all_truth_y_pull_vs_PU = nullptr
TH2 * m_vx_all_truth_z_res_vs_nTrk = nullptr
TH2 * m_vx_all_truth_x_res_vs_nTrk = nullptr
TH2 * m_vx_all_truth_y_res_vs_nTrk = nullptr
TH2 * m_vx_all_truth_z_pull_vs_nTrk = nullptr
TH2 * m_vx_all_truth_x_pull_vs_nTrk = nullptr
TH2 * m_vx_all_truth_y_pull_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_z_res_vs_PU = nullptr
TH2 * m_vx_hs_truth_x_res_vs_PU = nullptr
TH2 * m_vx_hs_truth_y_res_vs_PU = nullptr
TH2 * m_vx_hs_truth_z_pull_vs_PU = nullptr
TH2 * m_vx_hs_truth_x_pull_vs_PU = nullptr
TH2 * m_vx_hs_truth_y_pull_vs_PU = nullptr
TH2 * m_vx_hs_truth_z_res_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_x_res_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_y_res_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_z_pull_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_x_pull_vs_nTrk = nullptr
TH2 * m_vx_hs_truth_y_pull_vs_nTrk = nullptr
TH1_map m_vx_ntracks {}
TH1_map m_vx_sumpT {}
TH1_map m_vx_z_asym {}
TH1_map m_vx_z_asym_weighted {}
TH1_map m_vx_track_weight {}
TH1_map m_vx_normalised_track_weight {}
TH1_map m_vx_chi2Over_ndf {}
TH1_map m_vx_z0_skewness {}
TH1_map m_vx_z0_kurtosis {}
TH1_map m_vx_nVertices {}
TH1 * m_vx_all_dz = nullptr
TH1 * m_vx_hs_mindz = nullptr
TH1 * m_vx_PUdensity = nullptr
TH1 * m_vx_nTruth = nullptr
TH2 * m_vx_nTruth_vs_PUdensity = nullptr
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 43 of file InDetPerfPlot_VertexTruthMatching.h.

Member Typedef Documentation

◆ TH1_map

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.

21 :
22 InDetPlotBase(pParent, sDir), m_isITk(isITk), m_detailLevel(detailLevel) {}
InDetPlotBase(InDetPlotBase *pParent, const std::string &dirName)
Constructor taking parent node and directory name for plots.

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
pHistoPointer to the histogram to be booked (assumed to be initialized to nullptr)
histoIdentifierIdentifier (looked up in the XML file)
nameOverrideAllows 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.
folderFolder 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.

71 {
72 if (hd.isValid()) {
73 if(hd.nBinsY==0) {
74 pHisto = BookTEfficiency(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, false);
75 } else {
76 pHisto = BookTEfficiency(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first, hd.yAxis.second, false);
77 }
78 }
79 }
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.
Definition PlotBase.cxx:257
bool isValid() const
Is the histogram definition valid.
IHistogramDefinitionSvc::axesLimits_t xAxis
IHistogramDefinitionSvc::axesLimits_t yAxis

◆ book() [3/6]

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

Book a TH1 histogram.

Definition at line 43 of file InDetPlotBase.cxx.

43 {
44 if (hd.isValid()) {
45 pHisto = Book1D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, false);
46 }
47 }
TH1D * Book1D(std::string_view name, std::string_view labels, int nBins, float start, float end, bool prependDir=true)
Book a TH1D histogram.
Definition PlotBase.cxx:94

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

63 {
64 if (hd.isValid()) {
65 pHisto = Book2D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first,
66 hd.yAxis.second, false);
67 }
68 }
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.
Definition PlotBase.cxx:123

◆ book() [5/6]

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

Book a TProfile histogram.

Definition at line 49 of file InDetPlotBase.cxx.

49 {
50 if (hd.isValid()) {
51 pHisto = BookTProfile(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.yAxis.first,
52 hd.yAxis.second, false);
53 }
54 }
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.
Definition PlotBase.cxx:186

◆ book() [6/6]

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

Book a TProfile2D histogram.

Definition at line 56 of file InDetPlotBase.cxx.

56 {
57 if (hd.isValid()) {
58 pHisto = BookTProfile2D(hd.name, hd.allTitles, hd.nBinsX, hd.xAxis.first, hd.xAxis.second, hd.nBinsY, hd.yAxis.first,
59 hd.yAxis.second, false);
60 }
61 }
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.
Definition PlotBase.cxx:231

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

95 {
96 std::string prefix = constructPrefix(m_sDirectory, prependDir);
97 Bool_t oldstat = TH1::AddDirectoryStatus();
98 TH1::AddDirectory(false);
99 TH1D *hist = new TH1D(prefix.append(name).c_str(), labels.data(), nBins, start, end);
100 TH1::AddDirectory(oldstat);
101
102 hist->Sumw2();
103 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
104 return hist;
105}
static std::string constructPrefix(std::string dir, bool prependDir)
Definition PlotBase.cxx:289
std::vector< HistData > m_vBookedHistograms
Definition PlotBase.h:98
std::string m_sDirectory
Definition PlotBase.h:101

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

108 {
109 std::string prefix = constructPrefix(m_sDirectory, prependDir);
110 Bool_t oldstat = TH1::AddDirectoryStatus();
111 TH1::AddDirectory(false);
112 TH1D *hist = new TH1D(prefix.append(name).c_str(), labels.data(), refHist->GetNbinsX(),
113 refHist->GetXaxis()->GetXbins()->GetArray());
114 hist->Sumw2();
115 TH1::AddDirectory(oldstat);
116
117
118 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
119 return hist;
120}

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

145 {
146 std::string prefix = constructPrefix(m_sDirectory, prependDir);
147 Bool_t oldstat = TH2::AddDirectoryStatus();
148 TH2::AddDirectory(false);
149 TH2F *hist = new TH2F(prefix.append(name).c_str(), labels.data(), nBinsX, binsX, nBinsY, startY, endY);
150 hist->Sumw2();
151 TH2::AddDirectory(oldstat);
152 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
153 return hist;
154}
TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)

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

124 {
125 std::string prefix = constructPrefix(m_sDirectory, prependDir);
126 Bool_t oldstat = TH2::AddDirectoryStatus();
127 TH2::AddDirectory(false);
128 TH2F *hist = new TH2F(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, nBinsY, startY, endY);
129 hist->Sumw2();
130 TH2::AddDirectory(oldstat);
131
132
133 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
134 return hist;
135}

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

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

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

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

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

171 {
172 std::string prefix = constructPrefix(m_sDirectory, prependDir);
173 Bool_t oldstat = TH3::AddDirectoryStatus();
174 TH3::AddDirectory(false);
175 TH3F *hist = new TH3F(prefix.append(name).c_str(), labels.data(), refHist->GetNbinsX(),
176 refHist->GetXaxis()->GetXbins()->GetArray(), refHist->GetNbinsY(),
177 refHist->GetYaxis()->GetXbins()->GetArray(), refHist->GetNbinsZ(),
178 refHist->GetZaxis()->GetXbins()->GetArray());
179 TH3::AddDirectory(oldstat);
180
181 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
182 return hist;
183}

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

257 {
258 std::string prefix = constructPrefix(m_sDirectory, prependDir);
259 TEfficiency *hist = new TEfficiency(prefix.append(name).c_str(), labels.data(), nBinsX, xlo, xhi);
260 hist->SetDirectory(nullptr);
261 m_vBookedEfficiencies.emplace_back(hist, m_sDirectory);
262 return hist;
263}
std::vector< EfficiencyData > m_vBookedEfficiencies
Definition PlotBase.h:100

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

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

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

204 {
205 std::string prefix = constructPrefix(m_sDirectory, prependDir);
206 TProfile *hist(nullptr);
207 Bool_t oldstat = TProfile::AddDirectoryStatus();
208 TProfile::AddDirectory(false);
209
210 hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, binsX);
211 TProfile::AddDirectory(oldstat);
212 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
213 return hist;
214}

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

187 {
188 std::string prefix = constructPrefix(m_sDirectory, prependDir);
189 TProfile *hist(nullptr);
190 Bool_t oldstat = TProfile::AddDirectoryStatus();
191 TProfile::AddDirectory(false);
192 std::string opt = useRMS ? "S" : "";
193 if ((startY == -1) and (endY == -1)) {
194 hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, opt.c_str());
195 } else {
196 hist = new TProfile(prefix.append(name).c_str(), labels.data(), nBinsX, startX, endX, startY, endY, opt.c_str());
197 }
198 TProfile::AddDirectory(oldstat);
199 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
200 return hist;
201}

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

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

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

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

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

218 {
219 std::string prefix = constructPrefix(m_sDirectory, prependDir);
220 TProfile *hist(nullptr);
221 Bool_t oldstat = TProfile::AddDirectoryStatus();
222 TProfile::AddDirectory(false);
223
224 hist = new TProfile(prefix.append(name).c_str(), labels.data(), (Int_t) nBinsX, binsX, startY, endY);
225 TProfile::AddDirectory(oldstat);
226 m_vBookedHistograms.emplace_back(hist, m_sDirectory);
227 return hist;
228}

◆ BookTree()

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

Book a TTree.

Definition at line 277 of file PlotBase.cxx.

277 {
278 std::string prefix = constructPrefix(m_sDirectory, prependDir);
279 TTree *tree = new TTree(prefix.append(name).c_str(), "");
280
281 tree->SetAutoSave(0);
282 tree->SetAutoFlush(0);
283 tree->SetDirectory(nullptr);
284 m_vBookedTrees.emplace_back(tree, m_sDirectory);
285 return tree;
286}
std::vector< TreeData > m_vBookedTrees
Definition PlotBase.h:99
TChain * tree

◆ constructPrefix()

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

Definition at line 289 of file PlotBase.cxx.

289 {
290 if (!prependDir) {
291 return "";
292 }
293 std::replace(dir.begin(), dir.end(), '/', '_');
294 return dir;
295}

◆ fill() [1/2]

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

Definition at line 277 of file InDetPerfPlot_VertexTruthMatching.cxx.

277 {
278 // not sure how to deal with this type of histogram
279 if (tvrt) {
280 const float diff_x = vertex.x() - tvrt->x();
281 const float diff_y = vertex.y() - tvrt->y();
282 const float diff_z = vertex.z() - tvrt->z();
283 const AmgSymMatrix(3)& covariance = vertex.covariancePosition();
284 const float err_x = std::abs(Amg::error(covariance, 0)) > 1e-7 ? Amg::error(covariance, 0) : 1000.;
285 const float err_y = std::abs(Amg::error(covariance, 1)) > 1e-7 ? Amg::error(covariance, 1) : 1000.;
286 const float err_z = std::abs(Amg::error(covariance, 2)) > 1e-7 ? Amg::error(covariance, 2) : 1000.;
287 fillHisto(m_vx_x_diff, diff_x, weight);
288 fillHisto(m_vx_x_diff_pull, diff_x / err_x, weight);
289 fillHisto(m_vx_y_diff, diff_y, weight);
290 fillHisto(m_vx_y_diff_pull, diff_y / err_y, weight);
291 fillHisto(m_vx_z_diff, diff_z, weight);
292 fillHisto(m_vx_z_diff_pull, diff_z / err_z, weight);
293
294 if (m_isITk) {
295 static const SG::Accessor<uint8_t> accHasValidTime("hasValidTime");
296 static const SG::Accessor<float> accTime("time");
297 static const SG::Accessor<float> accTimeResolution("timeResolution");
298 if (accHasValidTime.isAvailable(vertex) && accTime.isAvailable(vertex) &&
299 accTimeResolution.isAvailable(vertex)) {
300
301 if (vertex.hasValidTime()) {
302 float diff_time = vertex.time() - tvrt->t() / Gaudi::Units::c_light;
303 float err_time = vertex.timeResolution();
304 fillHisto(m_vx_time_diff, diff_time, weight);
305 fillHisto(m_vx_time_diff_pull, diff_time / err_time, weight);
306 }
307 }
308 }
309 }
310
311 // Get the match type info for each vertex:
312 const static xAOD::Vertex::Decorator<InDetVertexTruthMatchUtils::VertexMatchType> recoVtxMatchTypeInfo("VertexMatchType");
314 if (recoVtxMatchTypeInfo.isAvailable(vertex)) {
315 try {
316 matchType = recoVtxMatchTypeInfo(vertex);
317 ATH_MSG_DEBUG("VERTEX DECORATOR ======= " << matchType << ", with nTRACKS === " << vertex.nTrackParticles() << ", vertex index = " << vertex.index() << " AT (x, y, z) = (" << vertex.x() << ", " << vertex.y() << ", " << vertex.z() << ")");
318 fillHisto(m_vx_type_truth, matchType, weight);
319 }
320 catch (SG::ExcBadAuxVar &) {
321 ATH_MSG_WARNING("VertexMatchType DECORATOR seems to be available, but may be broken ===========");
322 }
323 }
324 else {
325 ATH_MSG_WARNING("VertexMatchType DECORATOR is NOT available ===========");
326 }
327
328} // void InDetPerfPlot_VertexTruthMatching::fill(const xAOD::Vertex& vertex) {
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_WARNING(x,...)
#define AmgSymMatrix(dim)
static void fillHisto(TProfile *pTprofile, const float bin, const float weight, const float weight2=1.0)
float z() const
Vertex longitudinal distance along the beam line form the origin.
float y() const
Vertex y displacement.
float t() const
Vertex time.
float x() const
Vertex x displacement.
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...

◆ 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 330 of file InDetPerfPlot_VertexTruthMatching.cxx.

335 {
336
337 // Fill our histograms
339 fillHisto(m_vx_hs_classification, hsType, weight);
340
341 int nRecoVertices = static_cast<int>(vertexContainer.size()-1); //Not counting the dummy vertex of type 0
342
343 // Get the truth HS vertex
344 const xAOD::TruthVertex* truthHSVtx = nullptr;
345
346 // Check that we have *exactly* 1 truth HS vertex
347 if (!truthHSVertices.empty()) {
348 if (truthHSVertices.size() != 1) {
349 ATH_MSG_WARNING("Size of truth HS vertex vector is >1 -- only using the first one in the vector.");
350 }
351 truthHSVtx = truthHSVertices.at(0);
352 }
353 else {
354 ATH_MSG_WARNING("Size of truth HS vertex vector is 0 -- assuming truth HS vertex to NOT be reconstructed.");
355 }
356
357 if (!truthHSVtx){
358 ATH_MSG_INFO("No truthHSVtx vertex - not filling vertex truth matching.");
359 return;
360 }
361
362 bool isHSVtx_dist_matched = recoHardScatter ? getRadialDiff2(recoHardScatter, truthHSVtx) < std::pow(m_cutMinTruthRecoRadialDiff, 2) : false;
363 fillHisto(m_vx_hs_sel_eff_dist_vs_nReco, nRecoVertices, isHSVtx_dist_matched, weight);
364
365 // Best reco HS vertex identified via truth HS weights
366 const xAOD::Vertex* bestRecoHSVtx_truth = InDetVertexTruthMatchUtils::bestHardScatterMatch(vertexContainer);
367
368 bool isHSVtx_vtx_matched = bestRecoHSVtx_truth && (recoHardScatter == bestRecoHSVtx_truth);
369 fillHisto(m_vx_hs_sel_eff_mu, actualMu, isHSVtx_vtx_matched, weight);
370 fillHisto(m_vx_hs_sel_eff_vs_nReco, nRecoVertices, isHSVtx_vtx_matched, weight);
371
372 // Did we successfully reconstruct our truth HS vertex?
373 bool isHSVtx_reco = bestRecoHSVtx_truth ? getRadialDiff2(bestRecoHSVtx_truth, truthHSVtx) < std::pow(m_cutMinTruthRecoRadialDiff, 2) : false;
374 fillHisto(m_vx_hs_reco_eff_mu, actualMu, isHSVtx_reco, weight);
375
376 float residual_z = isHSVtx_reco ? truthHSVtx->z() - bestRecoHSVtx_truth->z() : -9999.;
377 if(isHSVtx_reco) fillHisto(m_resHelper_mu_hsVxTruthLong, actualMu, residual_z, weight);
378
379 if (m_detailLevel >= 200) {
380 // Inclusive:
381 int nTruthVertices = static_cast<int>(truthHSVertices.size() + truthPUVertices.size());
382 fillHisto(m_vx_nReco_vs_nTruth_inclusive, nTruthVertices, nRecoVertices, weight);
383 fillHisto(m_vx_nTruth, nTruthVertices, weight);
384
385 // Let's also plot the vertices by vertex match type:
386 const static xAOD::Vertex::Decorator<InDetVertexTruthMatchUtils::VertexMatchType> recoVtxMatchTypeInfo("VertexMatchType");
387 std::map<InDetVertexTruthMatchUtils::VertexMatchType, int> breakdown = {};
393
394 fillHisto(m_vx_hs_sel_eff_dist, nTruthVertices, isHSVtx_dist_matched, weight);
395
396 //Calculating the local PU density around the true HS vertex
397 float localPUDensity = getLocalPUDensity(truthHSVtx, truthHSVertices, truthPUVertices);
398 fillHisto(m_vx_PUdensity, localPUDensity, weight);
399 fillHisto(m_vx_nTruth_vs_PUdensity, nTruthVertices, localPUDensity, weight);
400
401 fillHisto(m_vx_hs_sel_eff, localPUDensity, isHSVtx_vtx_matched, weight);
402 fillHisto(m_vx_hs_sel_eff_vs_ntruth, nTruthVertices, isHSVtx_vtx_matched, weight);
403
404 // add variables here so that they are in correct scope (outside loop over vertices)
405 std::map<int, std::map<InDetVertexTruthMatchUtils::VertexMatchType, float>> numbers;
406
407 // variables for delta z between the HS and the closest one
408 float vx_hs_mindz=9999.;
409
410 // Iterate over vertices:
411 for (const auto& vertex : vertexContainer.stdcont()) {
412
413 unsigned int nTrackPart = vertex->nTrackParticles();
414 InDetVertexTruthMatchUtils::VertexMatchType matchType = recoVtxMatchTypeInfo(*vertex);
415 breakdown[matchType] += 1;
416
417 // Skip dummy vertex (last one in the container)
418 if (vertex->vertexType() == xAOD::VxType::NoVtx) {
419 continue;
420 }
421
422 fill(*vertex);
423
424 const xAOD::TruthVertex *matchVertex = getTruthVertex(vertex);
425 if(matchVertex){
426
427 std::vector<float> residuals = {
428 matchVertex->x() - vertex->x(),
429 matchVertex->y() - vertex->y(),
430 matchVertex->z() - vertex->z() };
431
432 const AmgSymMatrix(3)& covariance = vertex->covariancePosition();
433
434 std::vector<float> pulls;
435 for(unsigned int i=0; i<3; i++){
436 float vtxerr = Amg::error(covariance, i);
437 float pull = std::abs(vtxerr) > 1e-7 ? residuals[i]/vtxerr : 1000.;
438 pulls.push_back(pull);
439 }
440
441 fillHisto(m_vx_all_x_pull, pulls[0], weight);
442 fillHisto(m_vx_all_y_pull, pulls[1], weight);
443 fillHisto(m_vx_all_z_pull, pulls[2], weight);
444
445 float localPUDensity = getLocalPUDensity(matchVertex, truthHSVertices, truthPUVertices);
446
447 fillHisto(m_vx_all_truth_x_res_vs_PU, localPUDensity, pulls[0], weight);
448 fillHisto(m_vx_all_truth_y_res_vs_PU, localPUDensity, pulls[1], weight);
449 fillHisto(m_vx_all_truth_z_res_vs_PU, localPUDensity, pulls[2], weight);
450
451 fillHisto(m_vx_all_x_res, residuals[0], weight);
452 fillHisto(m_vx_all_y_res, residuals[1], weight);
453 fillHisto(m_vx_all_z_res, residuals[2], weight);
454
455 fillHisto(m_vx_all_truth_x_pull_vs_PU, localPUDensity, pulls[0], weight);
456 fillHisto(m_vx_all_truth_y_pull_vs_PU, localPUDensity, pulls[1], weight);
457 fillHisto(m_vx_all_truth_z_pull_vs_PU, localPUDensity, pulls[2], weight);
458
459 fillHisto(m_vx_all_truth_x_res_vs_nTrk, nTrackPart, residuals[0], weight);
460 fillHisto(m_vx_all_truth_y_res_vs_nTrk, nTrackPart, residuals[1], weight);
461 fillHisto(m_vx_all_truth_z_res_vs_nTrk, nTrackPart, residuals[2], weight);
462
463 fillHisto(m_vx_all_truth_x_pull_vs_nTrk, nTrackPart, pulls[0], weight);
464 fillHisto(m_vx_all_truth_y_pull_vs_nTrk, nTrackPart, pulls[1], weight);
465 fillHisto(m_vx_all_truth_z_pull_vs_nTrk, nTrackPart, pulls[2], weight);
466 }
467
468 // New Expert histograms for observables for vertex classifications for HS and PU
469 // For each vertex, loop over all tracks and get sumpt and sum of charges
470 // also use this to get the z asymmetry around the vertex.
471
472 // Declaring variables for the observables
473 const xAOD::TrackParticle* trackTmp = nullptr;
474 float sumPt =0;
475 float minpt = 20000 ; // minimum sum pt required for the 'All' vertices plots - 20 GeV
476 float trackPt = 0;
477
478 // variables for calculation of delta Z asymmetry and delta d asymmetry
479 float z_asym = 0;
480 float sumDZ = 0;
481 float deltaZ =0;
482 float modsumDZ =0;
483 float weighted_sumDZ = 0;
484 float weighted_deltaZ = 0;
485 float weighted_modsumDZ = 0;
486 float weighted_z_asym =0;
487
488 // make vector
489 std::vector<float> track_deltaZ;
490 std::vector<float> track_deltaPt;
491 std::vector<float> track_deltaZ_weighted;
492
493 // loop over tracks
494 for (size_t i = 0; i < nTrackPart; i++) {
495 trackTmp = vertex->trackParticle(i);
496
497 if (trackTmp) {
498 trackPt = trackTmp->pt(); // MeV
499 sumPt = sumPt + trackPt; // in MeV
500 deltaZ = trackTmp->z0() + trackTmp->vz() - vertex->z();
501 track_deltaZ.push_back(deltaZ);
502 // get the track weight for each track to get the deltaZ/trk_weight
503 float trk_weight = vertex->trackWeight(i);
504 weighted_deltaZ = deltaZ*trk_weight;
505 // sum of delta z
506 sumDZ = sumDZ + deltaZ;
507 modsumDZ = modsumDZ + std::abs(deltaZ);
508 weighted_sumDZ = weighted_sumDZ + weighted_deltaZ;
509 weighted_modsumDZ = weighted_modsumDZ + std::abs(weighted_deltaZ);
510 }
511 } // end loop over tracks
512
513 if (modsumDZ >0) z_asym = sumDZ/modsumDZ;
514 if (weighted_modsumDZ >0) weighted_z_asym = weighted_sumDZ/weighted_modsumDZ;
515
516 double number_tracks = track_deltaZ.size(); // get number of tracks
517
518 // calculate average
519 double mean_Dz = !track_deltaZ.empty() ? sumDZ/number_tracks : 0.;
520
521 double z_sd = 0; // standard deviation
522 double z_skew = 0; // skewness of DeltaZ asymmetry
523 double z_kurt = 0; // Kurtosis of DeltaZ asymmetry
524 double z_var=0; // variance of DeltaZ
525 double z_zbar=0; // for use in calculation below
526
527 for (auto i : track_deltaZ) {
528 z_zbar = (i - mean_Dz);
529 z_var += std::pow(z_zbar,2);
530 z_skew += std::pow(z_zbar,3);
531 z_kurt += std::pow(z_zbar,4);
532 }
533
534 if (number_tracks>1) {
535 z_var = z_var / (number_tracks -1);
536 z_sd = std::sqrt(z_var);
537 if (z_sd>0) {
538 z_skew = z_skew / ((number_tracks -1)*std::pow(z_sd,3));
539 z_kurt = z_kurt / ((number_tracks -1)*std::pow(z_sd,4));
540 }
541 }
542
543 float ndf = vertex->numberDoF();
544 float chi2_per_ndf = ndf>0 ? vertex->chiSquared()/ndf : 0.;
545
546 std::vector<int> categories;
547 if(vertex == bestRecoHSVtx_truth) categories.push_back(1);
548 else categories.push_back(0);
549 // fill some histograms that contain both HS and PU above a min pt - say 20GeV
550 if (sumPt > minpt) categories.push_back(2);
551
552 for(const auto& cat : categories){
553 // Count the number of vertices for each type per event
554 numbers[cat][matchType]++;
555
559 fillHisto(m_vx_ntracks[cat][matchType], nTrackPart, weight);
560 fillHisto(m_vx_sumpT[cat][matchType], sumPt, weight);
561 fillHisto(m_vx_z_asym[cat][matchType], z_asym, weight);
562 fillHisto(m_vx_z_asym_weighted[cat][matchType], weighted_z_asym, weight);
563 fillHisto(m_vx_chi2Over_ndf[cat][matchType], chi2_per_ndf, weight);
564 fillHisto(m_vx_z0_skewness[cat][matchType], z_skew, weight);
565 fillHisto(m_vx_z0_kurtosis[cat][matchType], z_kurt, weight);
566
567 for (const float& trkWeight : vertex->trackWeights()) {
568 fillHisto(m_vx_track_weight[cat][matchType], trkWeight, weight);
569 float norm_track_weight = number_tracks>0. ? trkWeight/number_tracks : 0.;
570 fillHisto(m_vx_normalised_track_weight[cat][matchType], norm_track_weight, weight);
571 }
572 }
573 }
574
575 // delta z between HS and nearby vertices
576 if(bestRecoHSVtx_truth && bestRecoHSVtx_truth != vertex) {
577 float dz = bestRecoHSVtx_truth->z() - vertex->z();
578 if(std::abs(dz) < std::abs(vx_hs_mindz)) vx_hs_mindz = dz;
579 }
580
581 // loop over vertices again for dz of every vertices pair
582 for (const auto& vertex2 : vertexContainer.stdcont()) {
583 if (vertex2->vertexType() == xAOD::VxType::NoVtx) continue;
584 if(vertex2 == vertex) continue;
585 fillHisto(m_vx_all_dz, vertex->z() - vertex2->z(), 0.5*weight);
586 }
587
588 } // end loop over vertices
589
590 // new histos to count number of vertices per event
591 std::vector<int> categories = {0, 1, 2};
592 std::vector<InDetVertexTruthMatchUtils::VertexMatchType> types = {
597
598 for(const auto& cat : categories) {
599 for(const auto& type : types) {
600 fillHisto(m_vx_nVertices[cat][type], numbers[cat][type], weight);
601 }
602 }
603
604 // new histo to delta z between HS and the closest one
605 fillHisto(m_vx_hs_mindz, vx_hs_mindz, weight);
606
607 // Now fill plots relating to the reconstruction of our truth HS vertex (efficiency and resolutions)
608 if (!truthHSVertices.empty()) {
609 if (isHSVtx_reco) {
610 fillHisto(m_vx_hs_reco_eff, localPUDensity, 1, weight);
611 fillHisto(m_vx_hs_reco_sel_eff, localPUDensity, (recoHardScatter == bestRecoHSVtx_truth), weight);
612 fillHisto(m_vx_hs_reco_eff_vs_ntruth, nTruthVertices, 1, weight);
613 fillHisto(m_vx_hs_reco_sel_eff_vs_ntruth, nTruthVertices, (recoHardScatter == bestRecoHSVtx_truth), weight);
614
615 fillHisto(m_vx_hs_reco_long_reso, localPUDensity,
616 getRecoLongitudinalReso(bestRecoHSVtx_truth), weight);
617 fillHisto(m_vx_hs_reco_trans_reso, localPUDensity,
618 getRecoTransverseReso(bestRecoHSVtx_truth), weight);
619
620 float residual_x = truthHSVtx->x() - bestRecoHSVtx_truth->x();
621 float residual_y = truthHSVtx->y() - bestRecoHSVtx_truth->y();
622 float residual_r = std::hypot(residual_x, residual_y);
623
624 fillHisto(m_resHelper_PUdensity_hsVxTruthLong, localPUDensity, residual_z, weight);
625 fillHisto(m_resHelper_PUdensity_hsVxTruthTransv, localPUDensity, residual_r, weight);
626
627 std::vector<float> residuals = {residual_x, residual_y, residual_z};
628
629 const AmgSymMatrix(3)& covariance = bestRecoHSVtx_truth->covariancePosition();
630
631 std::vector<float> pulls;
632 for(unsigned int i=0; i<3; i++){
633 float vtxerr = Amg::error(covariance, i);
634 float pull = std::abs(vtxerr) > 1e-7 ? residuals[i]/vtxerr : 1000.;
635 pulls.push_back(pull);
636 }
637
638 fillHisto(m_vx_hs_x_pull, pulls[0], weight);
639 fillHisto(m_vx_hs_y_pull, pulls[1], weight);
640 fillHisto(m_vx_hs_z_pull, pulls[2], weight);
641
642 fillHisto(m_vx_hs_truth_x_res_vs_PU, localPUDensity, residuals[0], weight);
643 fillHisto(m_vx_hs_truth_y_res_vs_PU, localPUDensity, residuals[1], weight);
644 fillHisto(m_vx_hs_truth_z_res_vs_PU, localPUDensity, residuals[2], weight);
645
646 fillHisto(m_vx_hs_x_res, residuals[0], weight);
647 fillHisto(m_vx_hs_y_res, residuals[1], weight);
648 fillHisto(m_vx_hs_z_res, residuals[2], weight);
649
650 fillHisto(m_vx_hs_truth_x_pull_vs_PU, localPUDensity, pulls[0], weight);
651 fillHisto(m_vx_hs_truth_y_pull_vs_PU, localPUDensity, pulls[1], weight);
652 fillHisto(m_vx_hs_truth_z_pull_vs_PU, localPUDensity, pulls[2], weight);
653
654 int nTrackPart = bestRecoHSVtx_truth->nTrackParticles();
655 fillHisto(m_vx_hs_truth_x_res_vs_nTrk, nTrackPart, residuals[0], weight);
656 fillHisto(m_vx_hs_truth_y_res_vs_nTrk, nTrackPart, residuals[1], weight);
657 fillHisto(m_vx_hs_truth_z_res_vs_nTrk, nTrackPart, residuals[2], weight);
658
659 fillHisto(m_vx_hs_truth_x_pull_vs_nTrk, nTrackPart, pulls[0], weight);
660 fillHisto(m_vx_hs_truth_y_pull_vs_nTrk, nTrackPart, pulls[1], weight);
661 fillHisto(m_vx_hs_truth_z_pull_vs_nTrk, nTrackPart, pulls[2], weight);
662
663 } else {
664 fillHisto(m_vx_hs_reco_eff, localPUDensity, 0, weight);
665 fillHisto(m_vx_hs_reco_eff_vs_ntruth, nTruthVertices, 0, weight);
666 }
667 }
668
674
675 // And by hardscatter type:
676 switch (hsType) {
678 fillHisto(m_vx_nReco_vs_nTruth_clean, nTruthVertices, nRecoVertices, weight);
679 break;
680 }
682 fillHisto(m_vx_nReco_vs_nTruth_lowpu, nTruthVertices, nRecoVertices, weight);
683 break;
684 }
686 fillHisto(m_vx_nReco_vs_nTruth_highpu, nTruthVertices, nRecoVertices, weight);
687 break;
688 }
690 fillHisto(m_vx_nReco_vs_nTruth_hssplit, nTruthVertices, nRecoVertices, weight);
691 break;
692 }
694 fillHisto(m_vx_nReco_vs_nTruth_none, nTruthVertices, nRecoVertices, weight);
695 break;
696 }
697 default: {
698 break;
699 }
700 } // End of switch
701
702 } // end of Expert plots - (if (m_detailLevel >= 200))
703
704} // end InDetPerfPlot_VertexTruthMatching::fill(const xAOD::VertexContainer& vertexContainer, const std::vector<const xAOD::TruthVertex*>& truthHSVertices, const std::vector<const xAOD::TruthVertex*>& truthPUVertices)
#define ATH_MSG_INFO(x,...)
static const std::vector< std::string > types
const PtrVector & stdcont() const
Return the underlying std::vector of the container.
size_type size() const noexcept
Returns the number of elements in the collection.
void fill(const xAOD::Vertex &vertex, const xAOD::TruthVertex *tvrt=0, float weight=1.0)
TH1 * m_vx_hs_classification
hardscatter classification
static float getRecoLongitudinalReso(const xAOD::Vertex *recoVtx)
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
TProfile * m_vx_nReco_vs_nTruth_inclusive
vertex reco efficiency
static float getRecoTransverseReso(const xAOD::Vertex *recoVtx)
float getRadialDiff2(const U *vtx1, const V *vtx2) const
const xAOD::TruthVertex * getTruthVertex(const xAOD::Vertex *recoVtx) const
float z0() const
Returns the parameter.
float vz() const
The z origin for the parameters.
virtual double pt() const override final
The transverse momentum ( ) of the particle.
float z() const
Returns the z position.
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
float y() const
Returns the y position.
float x() const
Returns the x position.
const xAOD::Vertex * bestHardScatterMatch(const xAOD::VertexContainer &vxContainer)
HardScatterType classifyHardScatter(const xAOD::VertexContainer &vxContainer)
bool trackPt(const xAOD::TauJet &, const xAOD::TauTrack &track, float &out)
@ NoVtx
Dummy vertex. TrackParticle was not used in vertex fit.
TruthVertex_v1 TruthVertex
Typedef to implementation.
Definition TruthVertex.h:15
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Vertex_v1 Vertex
Define the latest version of the vertex class.

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

142 {
143 if (eff2d and validArguments(xvalue, yvalue)) {
144 if(weight==1.) eff2d->Fill(accepted, xvalue, yvalue);
145 else eff2d->FillWeighted(accepted, weight, xvalue, yvalue);
146 }
147}

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

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

◆ fillHisto() [3/9]

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

Definition at line 97 of file InDetPlotBase.cxx.

97 {
98 if (pTh1 and validArguments(value)) {
99 pTh1->Fill(value);
100 }
101}

◆ fillHisto() [4/9]

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

Definition at line 104 of file InDetPlotBase.cxx.

104 {
105 if (pTh1 and validArguments(value)) {
106 pTh1->Fill(value, weight);
107 }
108}

◆ fillHisto() [5/9]

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

Definition at line 112 of file InDetPlotBase.cxx.

112 {
113 if (pTh2 and validArguments(xval, yval)) {
114 pTh2->Fill(xval, yval);
115 }
116}

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

120 {
121 if (pTh2 and validArguments(xval, yval)) {
122 pTh2->Fill(xval, yval, weight);
123 }
124}

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

127 {
128 if (pTh3 and validArguments(xval, yval, zval)) {
129 pTh3->Fill(xval, yval, zval);
130 }
131}

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

82 {
83 if (pTprofile and validArguments(bin, weight)) {
84 pTprofile->Fill(bin, weight,weight2);
85 }
86}

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

89 {
90 if (pTprofile and validArguments(xval,yval, weight) and validArguments(weight2)) {
91 pTprofile->Fill(xval,yval, weight,weight2);
92 }
93}

◆ finalize()

void PlotBase::finalize ( )
inherited

Definition at line 47 of file PlotBase.cxx.

47 {
48 for (auto *subNode: m_vSubNodes) {
49 subNode->finalize();
50 }
52}
std::vector< PlotBase * > m_vSubNodes
Definition PlotBase.h:97
virtual void finalizePlots()
Definition PlotBase.h:93

◆ finalizePlots()

void InDetPerfPlot_VertexTruthMatching::finalizePlots ( )
privatevirtual

Reimplemented from PlotBase.

Definition at line 707 of file InDetPerfPlot_VertexTruthMatching.cxx.

707 {
708
713
714 if (m_detailLevel >= 200) {
723 }
724
725} // end InDetPerfPlot_VertexTruthMatching::finalizePlots()
IDPVM::ResolutionHelper::methods m_resolutionMethod

◆ getDirectory()

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

Definition at line 89 of file PlotBase.h.

89{return m_sDirectory;}

◆ getHSRecoVertexSumPt2()

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

Definition at line 176 of file InDetPerfPlot_VertexTruthMatching.cxx.

176 {
177 const xAOD::Vertex* recoHSVertex = nullptr;
178 float sumPtMax = -1.;
179 const xAOD::TrackParticle* trackTmp = nullptr;
180 float sumPtTmp;
181 for (const auto& vtx : recoVertices.stdcont()) {
182 if (vtx) {
183 sumPtTmp = 0.;
184 for (size_t i = 0; i < vtx->nTrackParticles(); i++) {
185 trackTmp = vtx->trackParticle(i);
186 if (trackTmp) {
187 sumPtTmp += std::pow(trackTmp->pt(), 2);
188 }
189 }
190 if (sumPtTmp > sumPtMax) {
191 sumPtMax = sumPtTmp;
192 recoHSVertex = vtx;
193 }
194 }
195 }
196 return recoHSVertex;
197}

◆ 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 205 of file InDetPerfPlot_VertexTruthMatching.cxx.

205 {
206 float radialWindow2 = std::pow(radialWindow, 2);
207 int nTracksInWindow = 0;
208 float localPUDensity;
209 float radialDiff2;
210 for (const auto& vtx : truthHSVertices) {
211 if (vtx != vtxOfInterest) {
212 radialDiff2 = getRadialDiff2(vtxOfInterest, vtx);
213 if (radialDiff2 < radialWindow2) {
214 nTracksInWindow += 1;
215 }
216 }
217 }
218 for (const auto& vtx : truthPUVertices) {
219 if (vtx != vtxOfInterest) {
220 radialDiff2 = getRadialDiff2(vtxOfInterest, vtx);
221 if (radialDiff2 < radialWindow2) {
222 nTracksInWindow += 1;
223 }
224 }
225 }
226 localPUDensity = static_cast<float>(nTracksInWindow) / (2 * radialWindow);
227 return localPUDensity;
228}

◆ getRadialDiff2()

template<typename U, typename V>
float InDetPerfPlot_VertexTruthMatching::getRadialDiff2 ( const U * vtx1,
const V * vtx2 ) const
private

Definition at line 201 of file InDetPerfPlot_VertexTruthMatching.cxx.

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

◆ getRecoLongitudinalReso()

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

Definition at line 230 of file InDetPerfPlot_VertexTruthMatching.cxx.

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

◆ getRecoTransverseReso()

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

Definition at line 234 of file InDetPerfPlot_VertexTruthMatching.cxx.

234 {
235 float x = recoVtx->x();
236 float y = recoVtx->y();
237 float xErr2 = recoVtx->covariancePosition()(0, 0);
238 float yErr2 = recoVtx->covariancePosition()(1, 1);
239 float xyCov = recoVtx->covariancePosition()(0, 1);
240 float r2 = std::pow(x, 2) + std::pow(y, 2);
241 return std::sqrt(std::pow(x, 2) / r2 * xErr2 + std::pow(y, 2) / r2 * yErr2 + 2 * x * y / r2 * xyCov);
242}
#define y
#define x

◆ getTruthVertex()

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

Definition at line 244 of file InDetPerfPlot_VertexTruthMatching.cxx.

244 {
245 const xAOD::TruthVertex* truthVtx = nullptr;
246 if (recoVtx) {
247 const static xAOD::Vertex::Decorator<std::vector<InDetVertexTruthMatchUtils::VertexTruthMatchInfo>> truthMatchingInfos("TruthEventMatchingInfos");
248 try{
249 if (!truthMatchingInfos.isAvailable(*recoVtx)){
250 ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR not available -- returning nullptr!");
251 return truthVtx;
252 }
253 const std::vector<InDetVertexTruthMatchUtils::VertexTruthMatchInfo>& truthInfos = truthMatchingInfos(*recoVtx);
254 if (!truthInfos.empty()) {
255 const InDetVertexTruthMatchUtils::VertexTruthMatchInfo& truthInfo = truthInfos.at(0);
256 const ElementLink<xAOD::TruthEventBaseContainer> truthEventLink = std::get<0>(truthInfo);
257 if (truthEventLink.isValid() && *truthEventLink) {
258 size_t i_vtx = 0;
259 size_t n_vtx = (*truthEventLink)->nTruthVertices();
260 while(!truthVtx && i_vtx<n_vtx){
261 truthVtx = (*truthEventLink)->truthVertex(i_vtx);
262 i_vtx++;
263 }
264 }
265 }
266 else {
267 ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR yields empty vector -- returning nullptr!");
268 }
269 }
270 catch (SG::ExcBadAuxVar &){
271 ATH_MSG_WARNING("TruthEventMatchingInfos DECORATOR yields empty vector -- returning nullptr!");
272 }
273 }
274 return truthVtx;
275}
std::tuple< ElementLink< xAOD::TruthEventBaseContainer >, float, float > VertexTruthMatchInfo

◆ initialize()

void PlotBase::initialize ( )
inherited

Definition at line 39 of file PlotBase.cxx.

39 {
40 for (auto *subNode: m_vSubNodes) {
41 subNode->initialize();
42 }
44}
virtual void initializePlots()
Definition PlotBase.h:92

◆ initializePlots()

void InDetPerfPlot_VertexTruthMatching::initializePlots ( )
privatevirtual

Reimplemented from PlotBase.

Definition at line 25 of file InDetPerfPlot_VertexTruthMatching.cxx.

25 {
26
27 book(m_vx_type_truth,"vx_type_truth");
28 book(m_vx_x_diff,"vx_x_diff");
29 book(m_vx_x_diff_pull,"vx_x_diff_pull");
30 book(m_vx_y_diff,"vx_y_diff");
31 book(m_vx_y_diff_pull,"vx_y_diff_pull");
32 book(m_vx_z_diff,"vx_z_diff");
33 book(m_vx_z_diff_pull,"vx_z_diff_pull");
34 if(m_isITk){
35 book(m_vx_time_diff,"vx_time_diff");
36 book(m_vx_time_diff_pull,"vx_time_diff_pull");
37 }
38
39 book(m_vx_hs_classification,"vx_hs_classification");
40 book(m_vx_hs_sel_eff_dist_vs_nReco,"vx_hs_sel_eff_dist_vs_nReco");
41 book(m_vx_hs_sel_eff_mu,"vx_hs_sel_eff_mu");
42 book(m_vx_hs_sel_eff_vs_nReco,"vx_hs_sel_eff_vs_nReco");
43 book(m_vx_hs_reco_eff_mu,"vx_hs_reco_eff_mu");
44
45 book(m_resHelper_mu_hsVxTruthLong,"resHelper_mu_hsVxTruthLong");
46 book(m_resolution_vs_mu_hsVxTruthLong,"resolution_vs_mu_hsVxTruthLong");
47 book(m_resmean_vs_mu_hsVxTruthLong,"resmean_vs_mu_hsVxTruthLong");
48
49 if (m_detailLevel >= 200) {
50
51 book(m_vx_hs_reco_eff,"vx_hs_reco_eff");
52 book(m_vx_hs_sel_eff,"vx_hs_sel_eff");
53 book(m_vx_hs_sel_eff_dist,"vx_hs_sel_eff_dist");
54 book(m_vx_hs_reco_sel_eff,"vx_hs_reco_sel_eff");
55 book(m_vx_hs_reco_eff_vs_ntruth,"vx_hs_reco_eff_vs_ntruth");
56 book(m_vx_hs_sel_eff_vs_ntruth,"vx_hs_sel_eff_vs_ntruth");
57 book(m_vx_hs_reco_sel_eff_vs_ntruth,"vx_hs_reco_sel_eff_vs_ntruth");
58
59 book(m_vx_nReco_vs_nTruth_inclusive,"vx_nReco_vs_nTruth_inclusive");
60 book(m_vx_nReco_vs_nTruth_matched,"vx_nReco_vs_nTruth_matched");
61 book(m_vx_nReco_vs_nTruth_merged,"vx_nReco_vs_nTruth_merged");
62 book(m_vx_nReco_vs_nTruth_split,"vx_nReco_vs_nTruth_split");
63 book(m_vx_nReco_vs_nTruth_fake,"vx_nReco_vs_nTruth_fake");
64 book(m_vx_nReco_vs_nTruth_dummy,"vx_nReco_vs_nTruth_dummy");
65 book(m_vx_nReco_vs_nTruth_clean,"vx_nReco_vs_nTruth_clean");
66 book(m_vx_nReco_vs_nTruth_lowpu,"vx_nReco_vs_nTruth_lowpu");
67 book(m_vx_nReco_vs_nTruth_highpu,"vx_nReco_vs_nTruth_highpu");
68 book(m_vx_nReco_vs_nTruth_hssplit,"vx_nReco_vs_nTruth_hssplit");
69 book(m_vx_nReco_vs_nTruth_none,"vx_nReco_vs_nTruth_none");
70
71 book(m_vx_hs_z_pull,"vx_TYPE_z_pull","vx_hs_z_pull");
72 book(m_vx_hs_y_pull,"vx_TYPE_y_pull","vx_hs_y_pull");
73 book(m_vx_hs_x_pull,"vx_TYPE_x_pull","vx_hs_x_pull");
74
75 book(m_vx_all_z_pull,"vx_TYPE_z_pull","vx_all_z_pull");
76 book(m_vx_all_y_pull,"vx_TYPE_y_pull","vx_all_y_pull");
77 book(m_vx_all_x_pull,"vx_TYPE_x_pull","vx_all_x_pull");
78
79 book(m_vx_hs_z_res,"vx_TYPE_z_reso","vx_hs_z_res");
80 book(m_vx_hs_y_res,"vx_TYPE_y_reso","vx_hs_y_res");
81 book(m_vx_hs_x_res,"vx_TYPE_x_reso","vx_hs_x_res");
82 book(m_vx_all_z_res,"vx_TYPE_z_reso","vx_all_z_res");
83 book(m_vx_all_y_res,"vx_TYPE_y_reso","vx_all_y_res");
84 book(m_vx_all_x_res,"vx_TYPE_x_reso","vx_all_x_res");
85
86 book(m_vx_all_truth_z_res_vs_PU, "vx_TYPE_truth_reso_z_vs_PU", "vx_all_truth_reso_z_vs_PU");
87 book(m_vx_all_truth_x_res_vs_PU, "vx_TYPE_truth_reso_x_vs_PU", "vx_all_truth_reso_x_vs_PU");
88 book(m_vx_all_truth_y_res_vs_PU, "vx_TYPE_truth_reso_y_vs_PU", "vx_all_truth_reso_y_vs_PU");
89 book(m_vx_all_truth_z_res_vs_nTrk, "vx_TYPE_truth_reso_z_vs_nTrk", "vx_all_truth_reso_z_vs_nTrk");
90 book(m_vx_all_truth_x_res_vs_nTrk, "vx_TYPE_truth_reso_x_vs_nTrk", "vx_all_truth_reso_x_vs_nTrk");
91 book(m_vx_all_truth_y_res_vs_nTrk, "vx_TYPE_truth_reso_y_vs_nTrk", "vx_all_truth_reso_y_vs_nTrk");
92
93 book(m_vx_all_truth_z_pull_vs_PU, "vx_TYPE_truth_pull_z_vs_PU", "vx_all_truth_pull_z_vs_PU");
94 book(m_vx_all_truth_x_pull_vs_PU, "vx_TYPE_truth_pull_x_vs_PU", "vx_all_truth_pull_x_vs_PU");
95 book(m_vx_all_truth_y_pull_vs_PU, "vx_TYPE_truth_pull_y_vs_PU", "vx_all_truth_pull_y_vs_PU");
96 book(m_vx_all_truth_z_pull_vs_nTrk, "vx_TYPE_truth_pull_z_vs_nTrk", "vx_all_truth_pull_z_vs_nTrk");
97 book(m_vx_all_truth_x_pull_vs_nTrk, "vx_TYPE_truth_pull_x_vs_nTrk", "vx_all_truth_pull_x_vs_nTrk");
98 book(m_vx_all_truth_y_pull_vs_nTrk, "vx_TYPE_truth_pull_y_vs_nTrk", "vx_all_truth_pull_y_vs_nTrk");
99
100 book(m_vx_hs_truth_z_res_vs_PU, "vx_TYPE_truth_reso_z_vs_PU", "vx_hs_truth_reso_z_vs_PU");
101 book(m_vx_hs_truth_x_res_vs_PU, "vx_TYPE_truth_reso_x_vs_PU", "vx_hs_truth_reso_x_vs_PU");
102 book(m_vx_hs_truth_y_res_vs_PU, "vx_TYPE_truth_reso_y_vs_PU", "vx_hs_truth_reso_y_vs_PU");
103 book(m_vx_hs_truth_z_res_vs_nTrk, "vx_TYPE_truth_reso_z_vs_nTrk", "vx_hs_truth_reso_z_vs_nTrk");
104 book(m_vx_hs_truth_x_res_vs_nTrk, "vx_TYPE_truth_reso_x_vs_nTrk", "vx_hs_truth_reso_x_vs_nTrk");
105 book(m_vx_hs_truth_y_res_vs_nTrk, "vx_TYPE_truth_reso_y_vs_nTrk", "vx_hs_truth_reso_y_vs_nTrk");
106
107 book(m_vx_hs_truth_z_pull_vs_PU, "vx_TYPE_truth_pull_z_vs_PU", "vx_hs_truth_pull_z_vs_PU");
108 book(m_vx_hs_truth_x_pull_vs_PU, "vx_TYPE_truth_pull_x_vs_PU", "vx_hs_truth_pull_x_vs_PU");
109 book(m_vx_hs_truth_y_pull_vs_PU, "vx_TYPE_truth_pull_y_vs_PU", "vx_hs_truth_pull_y_vs_PU");
110 book(m_vx_hs_truth_z_pull_vs_nTrk, "vx_TYPE_truth_pull_z_vs_nTrk", "vx_hs_truth_pull_z_vs_nTrk");
111 book(m_vx_hs_truth_x_pull_vs_nTrk, "vx_TYPE_truth_pull_x_vs_nTrk", "vx_hs_truth_pull_x_vs_nTrk");
112 book(m_vx_hs_truth_y_pull_vs_nTrk, "vx_TYPE_truth_pull_y_vs_nTrk", "vx_hs_truth_pull_y_vs_nTrk");
113
114 // book the new expert histos for vertex classifications
115 std::vector<int> categories = {0, 1, 2};
116 std::vector<InDetVertexTruthMatchUtils::VertexMatchType> types = {
121
122 for(const auto& cat : categories) {
123 for(const auto& type : types) {
124 std::string suffix = "_";
125 if(cat==1) suffix += "HS_";
126 else if(cat==2) suffix += "ALL_";
127
129 suffix += "matched";
131 suffix += "merged";
133 suffix += "split";
135 suffix += "fake";
136
137 book(m_vx_nVertices[cat][type], "vx_nVertices" + suffix);
139
140 book(m_vx_ntracks[cat][type], "vx_ntracks" + suffix);
141 book(m_vx_sumpT[cat][type], "vx_sumpT" + suffix);
142 book(m_vx_z_asym[cat][type], "vx_z_asym"+suffix);
143 book(m_vx_z_asym_weighted[cat][type], "vx_z_asym_weighted"+suffix);
144 book(m_vx_track_weight[cat][type], "vx_track_weight"+suffix);
145 book(m_vx_normalised_track_weight[cat][type], "vx_normalised_track_weight"+suffix);
146 book(m_vx_chi2Over_ndf[cat][type], "vx_chi2Over_ndf"+suffix);
147 book(m_vx_z0_skewness[cat][type], "vx_z0_skewness"+suffix);
148 book(m_vx_z0_kurtosis[cat][type], "vx_z0_kurtosis"+suffix);
149 }
150 }
151
152 book(m_vx_hs_mindz,"vx_hs_mindz");
153 book(m_vx_all_dz,"vx_all_dz");
154
155 book(m_vx_hs_reco_long_reso,"vx_hs_reco_long_reso");
156 book(m_vx_hs_reco_trans_reso,"vx_hs_reco_trans_reso");
157
158 //Helpers for resolution plots for HS vertex
159 book(m_resHelper_PUdensity_hsVxTruthLong,"resHelper_PUdensity_hsVxTruthLong");
160 book(m_resolution_vs_PUdensity_hsVxTruthLong,"resolution_vs_PUdensity_hsVxTruthLong");
161 book(m_resmean_vs_PUdensity_hsVxTruthLong,"resmean_vs_PUdensity_hsVxTruthLong");
162
163 book(m_resHelper_PUdensity_hsVxTruthTransv,"resHelper_PUdensity_hsVxTruthTransv");
164 book(m_resolution_vs_PUdensity_hsVxTruthTransv,"resolution_vs_PUdensity_hsVxTruthTransv");
165 book(m_resmean_vs_PUdensity_hsVxTruthTransv,"resmean_vs_PUdensity_hsVxTruthTransv");
166
167 book(m_vx_PUdensity,"vx_PUdensity");
168 book(m_vx_nTruth,"vx_nTruth");
169 book(m_vx_nTruth_vs_PUdensity,"vx_nTruth_vs_PUdensity");
170 }
171
172}
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.

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

40{
42 // If user did not set an explicit level, set a default
43 if (m_lvl == MSG::NIL) {
44 m_lvl = m_imsg ?
45 static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
46 MSG::INFO;
47 }
48}
std::string m_nm
Message source name.
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
std::atomic< MSG::Level > m_lvl
Current logging level.
IMessageSvc * getMessageSvc(bool quiet=false)
int outputLevel(const IMessageSvc *ims, const std::string &source)

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

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

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

168{
169 MsgStream* ms = m_msg_tls.get();
170 if (!ms) {
171 if (!m_initialized.test_and_set()) initMessaging();
172 ms = new MsgStream(m_imsg,m_nm);
173 m_msg_tls.reset( ms );
174 }
175
176 ms->setLevel (m_lvl);
177 return *ms;
178}
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels).
void initMessaging() const
Initialize our message level and MessageSvc.

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

183{ return msg() << lvl; }
MsgStream & msg() const
The standard message stream.

◆ msgLvl()

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

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152{
153 // If user did not set explicit message level we have to initialize
154 // the messaging and retrieve the default via the MessageSvc.
155 if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
156
157 if (m_lvl <= lvl) {
158 msg() << lvl;
159 return true;
160 } else {
161 return false;
162 }
163}

◆ RegisterSubPlot()

void PlotBase::RegisterSubPlot ( PlotBase * pPlotBase)
inlineinherited

Definition at line 42 of file PlotBase.h.

42{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.

83 {
84 std::vector<EfficiencyData> vBookedEfficiencies = m_vBookedEfficiencies;
85 for (const auto &subNode: m_vSubNodes) {
86 std::vector<EfficiencyData> subNodeHists = subNode->retrieveBookedEfficiencies();
87 vBookedEfficiencies.insert(vBookedEfficiencies.end(), subNodeHists.begin(), subNodeHists.end());
88 }
89 return vBookedEfficiencies;
90}

◆ retrieveBookedHistograms()

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

Retrieve all booked histograms.

Definition at line 63 of file PlotBase.cxx.

63 {
64 std::vector<HistData> vBookedHistograms = m_vBookedHistograms;
65 for (const auto &subNode: m_vSubNodes) {
66 std::vector<HistData> subNodeHists = subNode->retrieveBookedHistograms();
67 vBookedHistograms.insert(vBookedHistograms.end(), subNodeHists.begin(), subNodeHists.end());
68 }
69 return vBookedHistograms;
70}

◆ retrieveBookedTrees()

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

Retrieve all booked trees.

Definition at line 73 of file PlotBase.cxx.

73 {
74 std::vector<TreeData> vBookedTrees = m_vBookedTrees;
75 for (auto *subNode: m_vSubNodes) {
76 std::vector<TreeData> subNodeTrees = subNode->retrieveBookedTrees();
77 vBookedTrees.insert(vBookedTrees.end(), subNodeTrees.begin(), subNodeTrees.end());
78 }
79 return vBookedTrees;
80}

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

151 {
152
153 ATH_CHECK( m_histoDefSvc.retrieve(), {} );
154
155 bool folderDefault = (folder.empty() or folder == "default");
156 SingleHistogramDefinition s = m_histoDefSvc->definition(histoIdentifier, folder);
157 // "default" and empty string should be equivalent
158 if (folderDefault and s.empty()) {
159 const std::string otherDefault = (folder.empty()) ? ("default") : "";
160 s = m_histoDefSvc->definition(histoIdentifier, otherDefault);
161 }
162 if (s.empty()) {
163 ATH_MSG_WARNING("Histogram definition is empty for identifier " << histoIdentifier);
164 }
165 if (!nameOverride.empty()){
166 s.name = nameOverride;
167 }
168 return s;
169}
#define ATH_CHECK
Evaluate an expression and check for errors.
ServiceHandle< IHistogramDefinitionSvc > m_histoDefSvc

◆ setDetailLevel()

void PlotBase::setDetailLevel ( int iDetailLevel)
inherited

Definition at line 55 of file PlotBase.cxx.

55 {
56 for (auto *subNode: m_vSubNodes) {
57 subNode->setDetailLevel(iDetailLevel);
58 }
59 m_iDetailLevel = iDetailLevel;
60}
int m_iDetailLevel
Definition PlotBase.h:102

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

29{
30 m_lvl = lvl;
31}

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 51 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_detailLevel

int InDetPerfPlot_VertexTruthMatching::m_detailLevel {10}
private

Definition at line 50 of file InDetPerfPlot_VertexTruthMatching.h.

50{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.

135{ nullptr };

◆ m_isITk

bool InDetPerfPlot_VertexTruthMatching::m_isITk {false}
private

Definition at line 49 of file InDetPerfPlot_VertexTruthMatching.h.

49{false};

◆ m_lvl

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

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ 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_mu_hsVxTruthLong

TH2* InDetPerfPlot_VertexTruthMatching::m_resHelper_mu_hsVxTruthLong = nullptr
private

Definition at line 117 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resHelper_PUdensity_hsVxTruthLong

TH2* InDetPerfPlot_VertexTruthMatching::m_resHelper_PUdensity_hsVxTruthLong = nullptr
private

Definition at line 111 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resHelper_PUdensity_hsVxTruthTransv

TH2* InDetPerfPlot_VertexTruthMatching::m_resHelper_PUdensity_hsVxTruthTransv = nullptr
private

Definition at line 114 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resmean_vs_mu_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resmean_vs_mu_hsVxTruthLong = nullptr
private

Definition at line 119 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resmean_vs_PUdensity_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resmean_vs_PUdensity_hsVxTruthLong = nullptr
private

Definition at line 113 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resmean_vs_PUdensity_hsVxTruthTransv

TH1* InDetPerfPlot_VertexTruthMatching::m_resmean_vs_PUdensity_hsVxTruthTransv = nullptr
private

Definition at line 116 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resolution_vs_mu_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resolution_vs_mu_hsVxTruthLong = nullptr
private

Definition at line 118 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resolution_vs_PUdensity_hsVxTruthLong

TH1* InDetPerfPlot_VertexTruthMatching::m_resolution_vs_PUdensity_hsVxTruthLong = nullptr
private

Definition at line 112 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resolution_vs_PUdensity_hsVxTruthTransv

TH1* InDetPerfPlot_VertexTruthMatching::m_resolution_vs_PUdensity_hsVxTruthTransv = nullptr
private

Definition at line 115 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_resolutionHelper

IDPVM::ResolutionHelper InDetPerfPlot_VertexTruthMatching::m_resolutionHelper {}
private

Definition at line 108 of file InDetPerfPlot_VertexTruthMatching.h.

108{};

◆ m_resolutionMethod

IDPVM::ResolutionHelper::methods InDetPerfPlot_VertexTruthMatching::m_resolutionMethod = IDPVM::ResolutionHelper::iterRMS_convergence
private

Definition at line 109 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 = nullptr
private

Definition at line 177 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_x_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_pull_vs_nTrk = nullptr
private

Definition at line 146 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_x_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_pull_vs_PU = nullptr
private

Definition at line 139 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_x_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_res_vs_nTrk = nullptr
private

Definition at line 143 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_x_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_x_res_vs_PU = nullptr
private

Definition at line 136 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_y_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_pull_vs_nTrk = nullptr
private

Definition at line 147 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_y_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_pull_vs_PU = nullptr
private

Definition at line 140 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_y_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_res_vs_nTrk = nullptr
private

Definition at line 144 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_y_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_y_res_vs_PU = nullptr
private

Definition at line 137 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_z_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_pull_vs_nTrk = nullptr
private

Definition at line 145 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_z_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_pull_vs_PU = nullptr
private

Definition at line 138 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_z_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_res_vs_nTrk = nullptr
private

Definition at line 142 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_truth_z_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_all_truth_z_res_vs_PU = nullptr
private

Definition at line 135 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_x_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_x_pull = nullptr
private

Definition at line 126 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_x_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_x_res = nullptr
private

Definition at line 133 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_y_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_y_pull = nullptr
private

Definition at line 125 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_y_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_y_res = nullptr
private

Definition at line 132 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_z_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_z_pull = nullptr
private

Definition at line 124 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_all_z_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_all_z_res = nullptr
private

Definition at line 131 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_chi2Over_ndf

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_chi2Over_ndf {}
private

Definition at line 171 of file InDetPerfPlot_VertexTruthMatching.h.

171{};

◆ m_vx_hs_classification

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_classification = nullptr
private

hardscatter classification

Definition at line 66 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_mindz

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_mindz = nullptr
private

Definition at line 178 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_eff = nullptr
private

Definition at line 80 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_eff_mu

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_eff_mu = nullptr
private

Definition at line 96 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_eff_vs_ntruth = nullptr
private

Definition at line 94 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_long_reso

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_long_reso = nullptr
private

Definition at line 104 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_sel_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_sel_eff = nullptr
private

Definition at line 86 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_sel_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_sel_eff_vs_ntruth = nullptr
private

Definition at line 100 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_reco_trans_reso

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_hs_reco_trans_reso = nullptr
private

Definition at line 105 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff = nullptr
private

Definition at line 82 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff_dist

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_dist = nullptr
private

Definition at line 88 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff_dist_vs_nReco

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_dist_vs_nReco = nullptr
private

Definition at line 92 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff_mu

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_mu = nullptr
private

Definition at line 90 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff_vs_nReco

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_vs_nReco = nullptr
private

Definition at line 84 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_sel_eff_vs_ntruth

TEfficiency* InDetPerfPlot_VertexTruthMatching::m_vx_hs_sel_eff_vs_ntruth = nullptr
private

Definition at line 98 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_x_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_pull_vs_nTrk = nullptr
private

Definition at line 160 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_x_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_pull_vs_PU = nullptr
private

Definition at line 153 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_x_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_res_vs_nTrk = nullptr
private

Definition at line 157 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_x_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_x_res_vs_PU = nullptr
private

Definition at line 150 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_y_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_pull_vs_nTrk = nullptr
private

Definition at line 161 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_y_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_pull_vs_PU = nullptr
private

Definition at line 154 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_y_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_res_vs_nTrk = nullptr
private

Definition at line 158 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_y_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_y_res_vs_PU = nullptr
private

Definition at line 151 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_z_pull_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_pull_vs_nTrk = nullptr
private

Definition at line 159 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_z_pull_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_pull_vs_PU = nullptr
private

Definition at line 152 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_z_res_vs_nTrk

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_res_vs_nTrk = nullptr
private

Definition at line 156 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_truth_z_res_vs_PU

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_hs_truth_z_res_vs_PU = nullptr
private

Definition at line 149 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_x_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_x_pull = nullptr
private

Definition at line 123 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_x_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_x_res = nullptr
private

Definition at line 130 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_y_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_y_pull = nullptr
private

Definition at line 122 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_y_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_y_res = nullptr
private

Definition at line 129 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_z_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_z_pull = nullptr
private

Definition at line 121 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_hs_z_res

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_hs_z_res = nullptr
private

Definition at line 128 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_normalised_track_weight

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_normalised_track_weight {}
private

Definition at line 170 of file InDetPerfPlot_VertexTruthMatching.h.

170{};

◆ m_vx_nReco_vs_nTruth_clean

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_clean = nullptr
private

Definition at line 74 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_dummy

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_dummy = nullptr
private

Definition at line 73 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_fake

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_fake = nullptr
private

Definition at line 72 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_highpu

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_highpu = nullptr
private

Definition at line 76 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_hssplit

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_hssplit = nullptr
private

Definition at line 77 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_inclusive

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_inclusive = nullptr
private

vertex reco efficiency

Definition at line 68 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_lowpu

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_lowpu = nullptr
private

Definition at line 75 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_matched

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_matched = nullptr
private

Definition at line 69 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_merged

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_merged = nullptr
private

Definition at line 70 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_none

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_none = nullptr
private

Definition at line 78 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nReco_vs_nTruth_split

TProfile* InDetPerfPlot_VertexTruthMatching::m_vx_nReco_vs_nTruth_split = nullptr
private

Definition at line 71 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_ntracks

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_ntracks {}
private

Definition at line 165 of file InDetPerfPlot_VertexTruthMatching.h.

165{};

◆ m_vx_nTruth

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_nTruth = nullptr
private

Definition at line 181 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nTruth_vs_PUdensity

TH2* InDetPerfPlot_VertexTruthMatching::m_vx_nTruth_vs_PUdensity = nullptr
private

Definition at line 182 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_nVertices

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_nVertices {}
private

Definition at line 174 of file InDetPerfPlot_VertexTruthMatching.h.

174{};

◆ m_vx_PUdensity

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_PUdensity = nullptr
private

Definition at line 180 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_sumpT

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_sumpT {}
private

Definition at line 166 of file InDetPerfPlot_VertexTruthMatching.h.

166{};

◆ m_vx_time_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_time_diff = nullptr
private

vertex time

Definition at line 62 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_time_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_time_diff_pull = nullptr
private

Definition at line 63 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_track_weight

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_track_weight {}
private

Definition at line 169 of file InDetPerfPlot_VertexTruthMatching.h.

169{};

◆ m_vx_type_truth

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_type_truth = nullptr
private

truth type

Definition at line 53 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_x_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_x_diff = nullptr
private

Definition at line 54 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_x_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_x_diff_pull = nullptr
private

Definition at line 55 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_y_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_y_diff = nullptr
private

Definition at line 56 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_y_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_y_diff_pull = nullptr
private

Definition at line 57 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_z0_kurtosis

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_z0_kurtosis {}
private

Definition at line 173 of file InDetPerfPlot_VertexTruthMatching.h.

173{};

◆ m_vx_z0_skewness

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_z0_skewness {}
private

Definition at line 172 of file InDetPerfPlot_VertexTruthMatching.h.

172{};

◆ m_vx_z_asym

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_z_asym {}
private

Definition at line 167 of file InDetPerfPlot_VertexTruthMatching.h.

167{};

◆ m_vx_z_asym_weighted

TH1_map InDetPerfPlot_VertexTruthMatching::m_vx_z_asym_weighted {}
private

Definition at line 168 of file InDetPerfPlot_VertexTruthMatching.h.

168{};

◆ m_vx_z_diff

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_diff = nullptr
private

Definition at line 58 of file InDetPerfPlot_VertexTruthMatching.h.

◆ m_vx_z_diff_pull

TH1* InDetPerfPlot_VertexTruthMatching::m_vx_z_diff_pull = nullptr
private

Definition at line 59 of file InDetPerfPlot_VertexTruthMatching.h.


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