InDetPerfPlot_Hits Class Reference

class holding Pt plots for Inner Detector RTT Validation and implementing fill methods More...

#include <InDetPerfPlot_Hits.h>

Inheritance diagram for InDetPerfPlot_Hits:

Collaboration diagram for InDetPerfPlot_Hits:

Public Member Functions
	InDetPerfPlot_Hits (InDetPlotBase *pParent, const std::string &dirName, bool isITk)
void	fill (const xAOD::TrackParticle &track, float mu, float weight)
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 ()
virtual void	finalizePlots ()
void	initMessaging () const
	Initialize our message level and MessageSvc.

Static Private Member Functions
static std::string	constructPrefix (std::string dir, bool prependDir)

Private Attributes
bool	m_isITk
TH1 *	m_nInnerMostPixelHits {nullptr}
TH1 *	m_nInnerMostPixelEndcapHits {nullptr}
TH1 *	m_nNextToInnerMostPixelHits {nullptr}
TH1 *	m_nNextToInnerMostPixelEndcapHits {nullptr}
TH1 *	m_nPixelHits {nullptr}
TH1 *	m_nSCTHits {nullptr}
TH1 *	m_nTRTHits {nullptr}
TH1 *	m_nTRTHitsXe {nullptr}
TH1 *	m_nTRTHitsAr {nullptr}
TH1 *	m_nPixelHoles {nullptr}
TH1 *	m_nSCTHoles {nullptr}
TH1 *	m_nTRTHighThresholdHits {nullptr}
TH1 *	m_nTRTHighThresholdHitsXe {nullptr}
TH1 *	m_nTRTHighThresholdHitsAr {nullptr}
TH1 *	m_nInnerMostPixelOutliers {nullptr}
TH1 *	m_nInnerMostPixelEndcapOutliers {nullptr}
TH1 *	m_nInnerMostPixelSharedHits {nullptr}
TH1 *	m_nInnerMostPixelSharedEndcapHits {nullptr}
TH1 *	m_nInnerMostPixelSplitHits {nullptr}
TH1 *	m_nInnerMostPixelSplitEndcapHits {nullptr}
TH1 *	m_nExpectedInnerMostPixelHits {nullptr}
TH1 *	m_nExpectedNextToInnerMostPixelHits {nullptr}
TH1 *	m_nPixelOutliers {nullptr}
TH1 *	m_nPixelContribLayers {nullptr}
TH1 *	m_nPixelSharedHits {nullptr}
TH1 *	m_nPixelSplitHits {nullptr}
TH1 *	m_nPixelGangedHits {nullptr}
TH1 *	m_nPixelGangedHitsFlaggedFakes {nullptr}
TH1 *	m_nSCTOutliers {nullptr}
TH1 *	m_nSCTDoubleHoles {nullptr}
TH1 *	m_nSCTSharedHits {nullptr}
TH1 *	m_nTRTOutliers {nullptr}
TH1 *	m_nTRTHighThresholdOutliers {nullptr}
TH1 *	m_nPixelDeadSensors {nullptr}
TH1 *	m_nSCTDeadSensors {nullptr}
TH1 *	m_pixeldEdx {nullptr}
TProfile *	m_nInnerMostPixelHits_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelEndcapHits_vs_eta {nullptr}
TProfile *	m_nNextToInnerMostPixelHits_vs_eta {nullptr}
TProfile *	m_nNextToInnerMostPixelEndcapHits_vs_eta {nullptr}
TProfile *	m_nPixelHits_vs_eta {nullptr}
TProfile *	m_nSCTHits_vs_eta {nullptr}
TProfile *	m_nTRTHits_vs_eta {nullptr}
TProfile *	m_nTRTHitsXe_vs_eta {nullptr}
TProfile *	m_nTRTHitsAr_vs_eta {nullptr}
TProfile *	m_nPixelHoles_vs_eta {nullptr}
TProfile *	m_nSCTHoles_vs_eta {nullptr}
TProfile *	m_nTRTHighThresholdHits_vs_eta {nullptr}
TProfile *	m_nTRTHighThresholdHitsXe_vs_eta {nullptr}
TProfile *	m_nTRTHighThresholdHitsAr_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelOutliers_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelEndcapOutliers_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelSharedHits_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelSharedEndcapHits_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelSplitHits_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelSplitEndcapHits_vs_eta {nullptr}
TProfile *	m_nExpectedInnerMostPixelHits_vs_eta {nullptr}
TProfile *	m_nExpectedNextToInnerMostPixelHits_vs_eta {nullptr}
TProfile *	m_nPixelOutliers_vs_eta {nullptr}
TProfile *	m_nPixelContribLayers_vs_eta {nullptr}
TProfile *	m_nPixelSharedHits_vs_eta {nullptr}
TProfile *	m_nPixelSplitHits_vs_eta {nullptr}
TProfile *	m_nPixelGangedHits_vs_eta {nullptr}
TProfile *	m_nPixelGangedHitsFlaggedFakes_vs_eta {nullptr}
TProfile *	m_nSCTOutliers_vs_eta {nullptr}
TProfile *	m_nSCTDoubleHoles_vs_eta {nullptr}
TProfile *	m_nSCTSharedHits_vs_eta {nullptr}
TProfile *	m_nTRTOutliers_vs_eta {nullptr}
TProfile *	m_nTRTHighThresholdOutliers_vs_eta {nullptr}
TProfile *	m_nPixelDeadSensors_vs_eta {nullptr}
TProfile *	m_nSCTDeadSensors_vs_eta {nullptr}
TProfile *	m_nInnerMostPixelHits_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelEndcapHits_vs_phi {nullptr}
TProfile *	m_nNextToInnerMostPixelHits_vs_phi {nullptr}
TProfile *	m_nNextToInnerMostPixelEndcapHits_vs_phi {nullptr}
TProfile *	m_nPixelHits_vs_phi {nullptr}
TProfile *	m_nSCTHits_vs_phi {nullptr}
TProfile *	m_nTRTHits_vs_phi {nullptr}
TProfile *	m_nPixelHoles_vs_phi {nullptr}
TProfile *	m_nSCTHoles_vs_phi {nullptr}
TProfile *	m_nTRTHighThresholdHits_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelOutliers_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelEndcapOutliers_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelSharedHits_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelSharedEndcapHits_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelSplitHits_vs_phi {nullptr}
TProfile *	m_nInnerMostPixelSplitEndcapHits_vs_phi {nullptr}
TProfile *	m_nExpectedInnerMostPixelHits_vs_phi {nullptr}
TProfile *	m_nExpectedNextToInnerMostPixelHits_vs_phi {nullptr}
TProfile *	m_nPixelOutliers_vs_phi {nullptr}
TProfile *	m_nPixelContribLayers_vs_phi {nullptr}
TProfile *	m_nPixelSharedHits_vs_phi {nullptr}
TProfile *	m_nPixelSplitHits_vs_phi {nullptr}
TProfile *	m_nPixelGangedHits_vs_phi {nullptr}
TProfile *	m_nPixelGangedHitsFlaggedFakes_vs_phi {nullptr}
TProfile *	m_nSCTOutliers_vs_phi {nullptr}
TProfile *	m_nSCTDoubleHoles_vs_phi {nullptr}
TProfile *	m_nSCTSharedHits_vs_phi {nullptr}
TProfile *	m_nTRTOutliers_vs_phi {nullptr}
TProfile *	m_nTRTHighThresholdOutliers_vs_phi {nullptr}
TProfile *	m_nPixelDeadSensors_vs_phi {nullptr}
TProfile *	m_nSCTDeadSensors_vs_phi {nullptr}
TProfile2D *	m_nInnerMostPixelHits_vs_etaphi {nullptr}
TProfile2D *	m_nInnerMostPixelEndcapHits_vs_etaphi {nullptr}
TProfile2D *	m_nExpectedInnerMostPixelHits_vs_etaphi {nullptr}
TProfile2D *	m_nNextToInnerMostPixelHits_vs_etaphi {nullptr}
TProfile2D *	m_nNextToInnerMostPixelEndcapHits_vs_etaphi {nullptr}
TProfile2D *	m_nExpectedNextToInnerMostPixelHits_vs_etaphi {nullptr}
TProfile2D *	m_nPixelHits_vs_etaphi {nullptr}
TProfile2D *	m_nPixelHoles_vs_etaphi {nullptr}
TProfile2D *	m_nPixelDeadSensors_vs_etaphi {nullptr}
TProfile2D *	m_nSCTHits_vs_etaphi {nullptr}
TProfile2D *	m_nSCTHoles_vs_etaphi {nullptr}
TProfile2D *	m_nSCTDeadSensors_vs_etaphi {nullptr}
TProfile2D *	m_nSCTDoubleHoles_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHits_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHitsXe_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHitsAr_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHighThresholdHits_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHighThresholdHitsXe_vs_etaphi {nullptr}
TProfile2D *	m_nTRTHighThresholdHitsAr_vs_etaphi {nullptr}
TProfile *	m_nInnerMostPixelHits_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelEndcapHits_vs_mu {nullptr}
TProfile *	m_nNextToInnerMostPixelHits_vs_mu {nullptr}
TProfile *	m_nNextToInnerMostPixelEndcapHits_vs_mu {nullptr}
TProfile *	m_nPixelHits_vs_mu {nullptr}
TProfile *	m_nSCTHits_vs_mu {nullptr}
TProfile *	m_nTRTHits_vs_mu {nullptr}
TProfile *	m_nTRTHitsXe_vs_mu_central {nullptr}
TProfile *	m_nTRTHitsXe_vs_mu_ECsideA {nullptr}
TProfile *	m_nTRTHitsXe_vs_mu_ECsideC {nullptr}
TProfile *	m_nTRTHitsAr_vs_mu_central {nullptr}
TProfile *	m_nTRTHitsAr_vs_mu_ECsideA {nullptr}
TProfile *	m_nTRTHitsAr_vs_mu_ECsideC {nullptr}
TProfile *	m_nPixelHoles_vs_mu {nullptr}
TProfile *	m_nSCTHoles_vs_mu {nullptr}
TProfile *	m_nTRTHighThresholdHits_vs_mu {nullptr}
TProfile *	m_nTRTHighThresholdHitsXe_vs_mu_central {nullptr}
TProfile *	m_nTRTHighThresholdHitsXe_vs_mu_ECsideA {nullptr}
TProfile *	m_nTRTHighThresholdHitsXe_vs_mu_ECsideC {nullptr}
TProfile *	m_nTRTHighThresholdHitsAr_vs_mu_central {nullptr}
TProfile *	m_nTRTHighThresholdHitsAr_vs_mu_ECsideA {nullptr}
TProfile *	m_nTRTHighThresholdHitsAr_vs_mu_ECsideC {nullptr}
TProfile *	m_nInnerMostPixelOutliers_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelEndcapOutliers_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelSharedHits_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelSharedEndcapHits_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelSplitHits_vs_mu {nullptr}
TProfile *	m_nInnerMostPixelSplitEndcapHits_vs_mu {nullptr}
TProfile *	m_nExpectedInnerMostPixelHits_vs_mu {nullptr}
TProfile *	m_nExpectedNextToInnerMostPixelHits_vs_mu {nullptr}
TProfile *	m_nPixelOutliers_vs_mu {nullptr}
TProfile *	m_nPixelContribLayers_vs_mu {nullptr}
TProfile *	m_nPixelSharedHits_vs_mu {nullptr}
TProfile *	m_nPixelSplitHits_vs_mu {nullptr}
TProfile *	m_nPixelGangedHits_vs_mu {nullptr}
TProfile *	m_nPixelGangedHitsFlaggedFakes_vs_mu {nullptr}
TProfile *	m_nSCTOutliers_vs_mu {nullptr}
TProfile *	m_nSCTDoubleHoles_vs_mu {nullptr}
TProfile *	m_nSCTSharedHits_vs_mu {nullptr}
TProfile *	m_nTRTOutliers_vs_mu {nullptr}
TProfile *	m_nTRTHighThresholdOutliers_vs_mu {nullptr}
TProfile *	m_nPixelDeadSensors_vs_mu {nullptr}
TProfile *	m_nSCTDeadSensors_vs_mu {nullptr}
TH1 *	m_nHGTDHits {nullptr}
TH1 *	m_nHGTDHoles {nullptr}
TProfile *	m_nHGTDHits_vs_eta {nullptr}
TProfile *	m_nHGTDHoles_vs_eta {nullptr}
TProfile *	m_nHGTDHits_vs_phi {nullptr}
TProfile *	m_nHGTDHoles_vs_phi {nullptr}
TH1 *	m_nHGTDSharedHits {nullptr}
TProfile *	m_nHGTDSharedHits_vs_eta {nullptr}
TProfile *	m_nHGTDSharedHits_vs_phi {nullptr}
TProfile2D *	m_nHGTDHits_vs_etaphi {nullptr}
TProfile2D *	m_nHGTDHoles_vs_etaphi {nullptr}
TH1 *	m_nHGTDOutliers {nullptr}
TProfile *	m_nHGTDOutliers_vs_eta {nullptr}
TProfile *	m_nHGTDOutliers_vs_phi {nullptr}
TProfile *	m_nHGTDHits_vs_mu {nullptr}
TProfile *	m_nHGTDHoles_vs_mu {nullptr}
TProfile *	m_nHGTDSharedHits_vs_mu {nullptr}
TProfile *	m_nHGTDOutliers_vs_mu {nullptr}
bool	m_addHGTDHistos =true
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 Pt plots for Inner Detector RTT Validation and implementing fill methods

Definition at line 24 of file InDetPerfPlot_Hits.h.

Constructor & Destructor Documentation

InDetPerfPlot_Hits()

InDetPerfPlot_Hits::InDetPerfPlot_Hits	(	InDetPlotBase *	pParent,
		const std::string &	dirName,
		bool	isITk )

Definition at line 14 of file InDetPerfPlot_Hits.cxx.

                                                                                                : InDetPlotBase(pParent, sDir), m_isITk{isITk},
                                                                                                      m_addHGTDHistos{isITk} {
  //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()

void InDetPerfPlot_Hits::fill	(	const xAOD::TrackParticle &	track,
		float	mu,
		float	weight )

Definition at line 260 of file InDetPerfPlot_Hits.cxx.

                                                                               {
 
  float eta = track.eta();
  float phi = track.phi();
  float pixeldEdx = 0;
 
  uint8_t iInnerMostPixelHits(0), iInnerMostPixelEndcapHits(0), iNextToInnerMostPixelHits(0), 
          iNextToInnerMostPixelEndcapHits(0), iPixHits(0), iSctHits(0), iTrtHits(0), iTrtXeHits(0);
  uint8_t iPixHoles(0), iSCTHoles(0), iTrtHTHits(0), iTrtHTXeHits(0); 
  uint8_t iInnerMostPixelShared(0), iInnerMostPixelEndcapShared(0), iPixelShared(0), iSCTShared(0); 
 
  if (track.summaryValue(iInnerMostPixelHits, xAOD::numberOfInnermostPixelLayerHits)) {
    fillHisto(m_nInnerMostPixelHits, iInnerMostPixelHits, weight);
    fillHisto(m_nInnerMostPixelHits_vs_eta, eta, iInnerMostPixelHits, weight);
    fillHisto(m_nInnerMostPixelHits_vs_phi, phi, iInnerMostPixelHits, weight);
    fillHisto(m_nInnerMostPixelHits_vs_etaphi, eta,phi, iInnerMostPixelHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nInnerMostPixelHits_vs_mu, mu, iInnerMostPixelHits, weight);
  }
  if (track.summaryValue(iInnerMostPixelEndcapHits, xAOD::numberOfInnermostPixelLayerEndcapHits)) {
    fillHisto(m_nInnerMostPixelEndcapHits, iInnerMostPixelEndcapHits, weight);
    fillHisto(m_nInnerMostPixelEndcapHits_vs_eta, eta, iInnerMostPixelEndcapHits, weight);
    fillHisto(m_nInnerMostPixelEndcapHits_vs_phi, phi, iInnerMostPixelEndcapHits, weight);
    fillHisto(m_nInnerMostPixelEndcapHits_vs_etaphi, eta,phi, iInnerMostPixelEndcapHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nInnerMostPixelEndcapHits_vs_mu, mu, iInnerMostPixelEndcapHits, weight);
  }
  if (track.summaryValue(iNextToInnerMostPixelHits, xAOD::numberOfNextToInnermostPixelLayerHits)) {
    fillHisto(m_nNextToInnerMostPixelHits, iNextToInnerMostPixelHits, weight);
    fillHisto(m_nNextToInnerMostPixelHits_vs_eta, eta, iNextToInnerMostPixelHits, weight);
    fillHisto(m_nNextToInnerMostPixelHits_vs_phi, phi, iNextToInnerMostPixelHits, weight);
    fillHisto(m_nNextToInnerMostPixelHits_vs_etaphi, eta,phi, iNextToInnerMostPixelHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nNextToInnerMostPixelHits_vs_mu, mu, iNextToInnerMostPixelHits, weight);
  }
  if (track.summaryValue(iNextToInnerMostPixelEndcapHits, xAOD::numberOfNextToInnermostPixelLayerEndcapHits)) {
    fillHisto(m_nNextToInnerMostPixelEndcapHits, iNextToInnerMostPixelEndcapHits, weight);
    fillHisto(m_nNextToInnerMostPixelEndcapHits_vs_eta, eta, iNextToInnerMostPixelEndcapHits, weight);
    fillHisto(m_nNextToInnerMostPixelEndcapHits_vs_phi, phi, iNextToInnerMostPixelEndcapHits, weight);
    fillHisto(m_nNextToInnerMostPixelEndcapHits_vs_etaphi, eta,phi, iNextToInnerMostPixelEndcapHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nNextToInnerMostPixelEndcapHits_vs_mu, mu, iNextToInnerMostPixelEndcapHits, weight);
  }
  if (track.summaryValue(iPixHits, xAOD::numberOfPixelHits)) {
    fillHisto(m_nPixelHits, iPixHits, weight);
    fillHisto(m_nPixelHits_vs_eta, eta, iPixHits, weight);
    fillHisto(m_nPixelHits_vs_phi, phi, iPixHits, weight);
    fillHisto(m_nPixelHits_vs_etaphi, eta,phi, iPixHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nPixelHits_vs_mu, mu, iPixHits, weight);
  }
  if (track.summaryValue(iSctHits, xAOD::numberOfSCTHits)) {
    fillHisto(m_nSCTHits, iSctHits, weight);
    fillHisto(m_nSCTHits_vs_eta, eta, iSctHits, weight);
    fillHisto(m_nSCTHits_vs_phi, phi, iSctHits, weight);
    fillHisto(m_nSCTHits_vs_etaphi, eta, phi, iSctHits, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nSCTHits_vs_mu, mu, iSctHits, weight);
  }
  if (m_addHGTDHistos) {
    uint8_t iHgtdHits(0);
    if (track.summaryValue(iHgtdHits, xAOD::numberOfHGTDHits)) {
      fillHisto(m_nHGTDHits, iHgtdHits, weight);
      fillHisto(m_nHGTDHits_vs_eta, eta, iHgtdHits, weight);
      fillHisto(m_nHGTDHits_vs_phi, phi, iHgtdHits, weight);
      fillHisto(m_nHGTDHits_vs_etaphi, eta, phi, iHgtdHits, weight);
      if (m_iDetailLevel >= 100) fillHisto(m_nHGTDHits_vs_mu, mu, iHgtdHits, weight);
    }
  }
 
  if (!m_isITk && track.summaryValue(iTrtHits, xAOD::numberOfTRTHits)) {
    fillHisto(m_nTRTHits, iTrtHits, weight);
    fillHisto(m_nTRTHits_vs_eta, eta, iTrtHits, weight);
    fillHisto(m_nTRTHits_vs_phi, phi, iTrtHits, weight);
    fillHisto(m_nTRTHits_vs_etaphi, eta, phi, iTrtHits, weight);
 
    if (m_iDetailLevel >= 100) fillHisto(m_nTRTHits_vs_mu, mu, iTrtHits, weight);
    if (track.summaryValue(iTrtXeHits, xAOD::numberOfTRTXenonHits)) {
      fillHisto(m_nTRTHitsXe, iTrtXeHits, weight);
      fillHisto(m_nTRTHitsXe_vs_eta, eta, iTrtXeHits, weight);
      fillHisto(m_nTRTHitsXe_vs_etaphi, eta, phi, iTrtXeHits, weight);
      fillHisto(m_nTRTHitsAr, iTrtHits-iTrtXeHits, weight);
      fillHisto(m_nTRTHitsAr_vs_eta, eta, iTrtHits-iTrtXeHits, weight);
      fillHisto(m_nTRTHitsAr_vs_etaphi, eta, phi, iTrtHits-iTrtXeHits, weight);
 
      if (m_iDetailLevel >= 100){ 
        if(eta < -1){
          fillHisto(m_nTRTHitsXe_vs_mu_ECsideC, mu, iTrtXeHits, weight);
          fillHisto(m_nTRTHitsAr_vs_mu_ECsideC, mu, iTrtHits-iTrtXeHits, weight);
        }
        else if(eta < 1){
          fillHisto(m_nTRTHitsXe_vs_mu_central, mu, iTrtXeHits, weight);
          fillHisto(m_nTRTHitsAr_vs_mu_central, mu, iTrtHits-iTrtXeHits, weight);
        }
        else{
          fillHisto(m_nTRTHitsXe_vs_mu_ECsideA, mu, iTrtXeHits, weight);
          fillHisto(m_nTRTHitsAr_vs_mu_ECsideA, mu, iTrtHits-iTrtXeHits, weight);
        }
      }
    }
  }
  if (track.summaryValue(iPixHoles, xAOD::numberOfPixelHoles)) {
    fillHisto(m_nPixelHoles, iPixHoles, weight);
    fillHisto(m_nPixelHoles_vs_eta, eta, iPixHoles, weight);
    fillHisto(m_nPixelHoles_vs_phi, phi, iPixHoles, weight);
    fillHisto(m_nPixelHoles_vs_etaphi, eta, phi, iPixHoles, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nPixelHoles_vs_mu, mu, iPixHoles, weight);
  }
  if (track.summaryValue(iSCTHoles, xAOD::numberOfSCTHoles)) {
    fillHisto(m_nSCTHoles, iSCTHoles, weight);
    fillHisto(m_nSCTHoles_vs_eta, eta, iSCTHoles, weight);
    fillHisto(m_nSCTHoles_vs_phi, phi, iSCTHoles, weight);
    fillHisto(m_nSCTHoles_vs_etaphi, eta, phi, iSCTHoles, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nSCTHoles_vs_mu, mu, iSCTHoles, weight);
  }
  if (m_addHGTDHistos) {
     uint8_t iHGTDHoles{};
     if (track.summaryValue(iHGTDHoles, xAOD::numberOfHGTDHoles)) {
        fillHisto(m_nHGTDHoles, iHGTDHoles, weight);
        fillHisto(m_nHGTDHoles_vs_eta, eta, iHGTDHoles, weight);
        fillHisto(m_nHGTDHoles_vs_phi, phi, iHGTDHoles, weight);
        fillHisto(m_nHGTDHoles_vs_etaphi, eta, phi, iHGTDHoles, weight);
        if (m_iDetailLevel >= 100) fillHisto(m_nHGTDHoles_vs_mu, mu, iHGTDHoles, weight);
     }
  }
  if (!m_isITk && track.summaryValue(iTrtHTHits, xAOD::numberOfTRTHighThresholdHitsTotal)) {
    fillHisto(m_nTRTHighThresholdHits, iTrtHTHits, weight);
    fillHisto(m_nTRTHighThresholdHits_vs_eta, eta, iTrtHTHits, weight);
    fillHisto(m_nTRTHighThresholdHits_vs_phi, phi, iTrtHTHits, weight);
    fillHisto(m_nTRTHighThresholdHits_vs_etaphi, eta, phi, iTrtHTHits, weight);
 
    if (m_iDetailLevel >= 100) fillHisto(m_nTRTHighThresholdHits_vs_mu, mu, iTrtHTHits, weight);
    if (track.summaryValue(iTrtHTXeHits, xAOD::numberOfTRTHighThresholdHits)) {
      fillHisto(m_nTRTHighThresholdHitsXe, iTrtHTXeHits, weight);
      fillHisto(m_nTRTHighThresholdHitsXe_vs_eta, eta, iTrtHTXeHits, weight);
      fillHisto(m_nTRTHighThresholdHitsXe_vs_etaphi, eta, phi, iTrtHTXeHits, weight);
      fillHisto(m_nTRTHighThresholdHitsAr, iTrtHTHits-iTrtHTXeHits, weight);
      fillHisto(m_nTRTHighThresholdHitsAr_vs_eta, eta, iTrtHTHits-iTrtHTXeHits, weight);
      fillHisto(m_nTRTHighThresholdHitsAr_vs_etaphi, eta, phi, iTrtHTHits-iTrtHTXeHits, weight);
      if (m_iDetailLevel >= 100){ 
        if(eta < -1){
          fillHisto(m_nTRTHighThresholdHitsXe_vs_mu_ECsideC, mu, iTrtHTXeHits, weight);
          fillHisto(m_nTRTHighThresholdHitsAr_vs_mu_ECsideC, mu, iTrtHTHits-iTrtHTXeHits, weight);
        }
        else if(eta < 1){
          fillHisto(m_nTRTHighThresholdHitsXe_vs_mu_central, mu, iTrtHTXeHits, weight);
          fillHisto(m_nTRTHighThresholdHitsAr_vs_mu_central, mu, iTrtHTHits-iTrtHTXeHits, weight);
        }
        else{
          fillHisto(m_nTRTHighThresholdHitsXe_vs_mu_ECsideA, mu, iTrtHTXeHits, weight);
          fillHisto(m_nTRTHighThresholdHitsAr_vs_mu_ECsideA, mu, iTrtHTHits-iTrtHTXeHits, weight);
        }
      }
    }
  }
  if (track.summaryValue(iInnerMostPixelShared, xAOD::numberOfInnermostPixelLayerSharedHits)) {
    fillHisto(m_nInnerMostPixelSharedHits, iInnerMostPixelShared, weight);
    fillHisto(m_nInnerMostPixelSharedHits_vs_eta, eta, iInnerMostPixelShared, weight);
    fillHisto(m_nInnerMostPixelSharedHits_vs_phi, phi, iInnerMostPixelShared, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nInnerMostPixelSharedHits_vs_mu, mu, iInnerMostPixelShared, weight);
  }
  if (track.summaryValue(iInnerMostPixelEndcapShared, xAOD::numberOfInnermostPixelLayerSharedEndcapHits)) {
    fillHisto(m_nInnerMostPixelSharedEndcapHits, iInnerMostPixelEndcapShared, weight);
    fillHisto(m_nInnerMostPixelSharedEndcapHits_vs_eta, eta, iInnerMostPixelEndcapShared, weight);
    fillHisto(m_nInnerMostPixelSharedEndcapHits_vs_phi, phi, iInnerMostPixelEndcapShared, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nInnerMostPixelSharedEndcapHits_vs_mu, mu, iInnerMostPixelEndcapShared, weight);
  }
  if (track.summaryValue(iPixelShared, xAOD::numberOfPixelSharedHits)) {
    fillHisto(m_nPixelSharedHits, iPixelShared, weight);
    fillHisto(m_nPixelSharedHits_vs_eta, eta, iPixelShared, weight);
    fillHisto(m_nPixelSharedHits_vs_phi, phi, iPixelShared, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nPixelSharedHits_vs_mu, mu, iPixelShared, weight);
  }
  if (track.summaryValue(iSCTShared, xAOD::numberOfSCTSharedHits)) {
    fillHisto(m_nSCTSharedHits, iSCTShared, weight);
    fillHisto(m_nSCTSharedHits_vs_eta, eta, iSCTShared, weight);
    fillHisto(m_nSCTSharedHits_vs_phi, phi, iSCTShared, weight);
    if (m_iDetailLevel >= 100) fillHisto(m_nSCTSharedHits_vs_mu, mu, iSCTShared, weight);
  }
  if (m_addHGTDHistos) {
     std::uint8_t iHGTDShared{};
     if (track.summaryValue(iHGTDShared, xAOD::numberOfHGTDSharedHits)) {
        fillHisto(m_nHGTDSharedHits, iHGTDShared, weight);
        fillHisto(m_nHGTDSharedHits_vs_eta, eta, iHGTDShared, weight);
        fillHisto(m_nHGTDSharedHits_vs_phi, phi, iHGTDShared, weight);
        if (m_iDetailLevel >= 100) fillHisto(m_nHGTDSharedHits_vs_mu, mu, iHGTDShared, weight);
     }
  }
  if (track.summaryValue(pixeldEdx, xAOD::pixeldEdx)) {
    fillHisto(m_pixeldEdx, pixeldEdx, weight);
  }
 
  // expert plots
  if (m_iDetailLevel >= 100) {
    uint8_t iInnerMostPixelOutliers(0), iInnerMostPixelEndcapOutliers(0), iInnerMostPixelSplit(0), iInnerMostPixelEndcapSplit(0);
    uint8_t iExpectedInnerMostPixelHits(0), iExpectedNextToInnerMostPixelHits(0);
    uint8_t iPixelOutliers(0), iPixelContribLayers(0), iPixelSplit(0), iPixelGanged(0), iPixelGangedFakes(0);
    uint8_t iSCTOutliers(0), iSCTDoubleHoles(0); 
    uint8_t iTRTOutliers(0), iTRTHTOutliers(0);
    uint8_t iPixelDeadSensors(0), iSCTDeadSensors(0);
 
    if (track.summaryValue(iInnerMostPixelOutliers, xAOD::numberOfInnermostPixelLayerOutliers)) {
      fillHisto(m_nInnerMostPixelOutliers, iInnerMostPixelOutliers, weight);
      fillHisto(m_nInnerMostPixelOutliers_vs_eta, eta, iInnerMostPixelOutliers, weight);
      fillHisto(m_nInnerMostPixelOutliers_vs_phi, phi, iInnerMostPixelOutliers, weight);
      fillHisto(m_nInnerMostPixelOutliers_vs_mu, mu, iInnerMostPixelOutliers, weight);
    }
    if (track.summaryValue(iInnerMostPixelEndcapOutliers, xAOD::numberOfInnermostPixelLayerEndcapOutliers)) {
      fillHisto(m_nInnerMostPixelEndcapOutliers, iInnerMostPixelEndcapOutliers, weight);
      fillHisto(m_nInnerMostPixelEndcapOutliers_vs_eta, eta, iInnerMostPixelEndcapOutliers, weight);
      fillHisto(m_nInnerMostPixelEndcapOutliers_vs_phi, phi, iInnerMostPixelEndcapOutliers, weight);
      fillHisto(m_nInnerMostPixelEndcapOutliers_vs_mu, mu, iInnerMostPixelEndcapOutliers, weight);
    }
    if (track.summaryValue(iInnerMostPixelSplit, xAOD::numberOfInnermostPixelLayerSplitHits)) {
      fillHisto(m_nInnerMostPixelSplitHits, iInnerMostPixelSplit, weight);
      fillHisto(m_nInnerMostPixelSplitHits_vs_eta, eta, iInnerMostPixelSplit, weight);
      fillHisto(m_nInnerMostPixelSplitHits_vs_phi, phi, iInnerMostPixelSplit, weight);
      fillHisto(m_nInnerMostPixelSplitHits_vs_mu, mu, iInnerMostPixelSplit, weight);
    }
    if (track.summaryValue(iInnerMostPixelEndcapSplit, xAOD::numberOfInnermostPixelLayerSplitEndcapHits)) {
      fillHisto(m_nInnerMostPixelSplitEndcapHits, iInnerMostPixelEndcapSplit, weight);
      fillHisto(m_nInnerMostPixelSplitEndcapHits_vs_eta, eta, iInnerMostPixelEndcapSplit, weight);
      fillHisto(m_nInnerMostPixelSplitEndcapHits_vs_phi, phi, iInnerMostPixelEndcapSplit, weight);
      fillHisto(m_nInnerMostPixelSplitEndcapHits_vs_mu, mu, iInnerMostPixelEndcapSplit, weight);
    }
    if (track.summaryValue(iExpectedInnerMostPixelHits, xAOD::expectInnermostPixelLayerHit)) {
      fillHisto(m_nExpectedInnerMostPixelHits, iExpectedInnerMostPixelHits, weight);
      fillHisto(m_nExpectedInnerMostPixelHits_vs_eta, eta, iExpectedInnerMostPixelHits, weight);
      fillHisto(m_nExpectedInnerMostPixelHits_vs_phi, phi, iExpectedInnerMostPixelHits, weight);
      fillHisto(m_nExpectedInnerMostPixelHits_vs_etaphi, eta, phi, iExpectedInnerMostPixelHits, weight);
      fillHisto(m_nExpectedInnerMostPixelHits_vs_mu, mu, iExpectedInnerMostPixelHits, weight);
    }
    if (track.summaryValue(iExpectedNextToInnerMostPixelHits, xAOD::expectNextToInnermostPixelLayerHit)) {
      fillHisto(m_nExpectedNextToInnerMostPixelHits, iExpectedNextToInnerMostPixelHits, weight);
      fillHisto(m_nExpectedNextToInnerMostPixelHits_vs_eta, eta, iExpectedNextToInnerMostPixelHits, weight);
      fillHisto(m_nExpectedNextToInnerMostPixelHits_vs_phi, phi, iExpectedNextToInnerMostPixelHits, weight);
      fillHisto(m_nExpectedNextToInnerMostPixelHits_vs_etaphi, eta, phi, iExpectedNextToInnerMostPixelHits, weight);
      fillHisto(m_nExpectedNextToInnerMostPixelHits_vs_mu, mu, iExpectedNextToInnerMostPixelHits, weight);
    }
    if (track.summaryValue(iPixelOutliers, xAOD::numberOfPixelOutliers)) {
      fillHisto(m_nPixelOutliers, iPixelOutliers, weight);
      fillHisto(m_nPixelOutliers_vs_eta, eta, iPixelOutliers, weight);
      fillHisto(m_nPixelOutliers_vs_phi, phi, iPixelOutliers, weight);
      fillHisto(m_nPixelOutliers_vs_mu, mu, iPixelOutliers, weight);
    }
    if (track.summaryValue(iPixelContribLayers, xAOD::numberOfContribPixelLayers)) {
      fillHisto(m_nPixelContribLayers, iPixelContribLayers, weight);
      fillHisto(m_nPixelContribLayers_vs_eta, eta, iPixelContribLayers, weight);
      fillHisto(m_nPixelContribLayers_vs_phi, phi, iPixelContribLayers, weight);
      fillHisto(m_nPixelContribLayers_vs_mu, mu, iPixelContribLayers, weight);
    }
    if (track.summaryValue(iPixelSplit, xAOD::numberOfPixelSplitHits)) {
      fillHisto(m_nPixelSplitHits, iPixelSplit, weight);
      fillHisto(m_nPixelSplitHits_vs_eta, eta, iPixelSplit, weight);
      fillHisto(m_nPixelSplitHits_vs_phi, phi, iPixelSplit, weight);
      fillHisto(m_nPixelSplitHits_vs_mu, mu, iPixelSplit, weight);
    }
    if (track.summaryValue(iPixelGanged, xAOD::numberOfGangedPixels)) {
      fillHisto(m_nPixelGangedHits, iPixelGanged, weight);
      fillHisto(m_nPixelGangedHits_vs_eta, eta, iPixelGanged, weight);
      fillHisto(m_nPixelGangedHits_vs_phi, phi, iPixelGanged, weight);
      fillHisto(m_nPixelGangedHits_vs_mu, mu, iPixelGanged, weight);
    }
    if (track.summaryValue(iPixelGangedFakes, xAOD::numberOfGangedFlaggedFakes)) {
      fillHisto(m_nPixelGangedHitsFlaggedFakes, iPixelGangedFakes, weight);
      fillHisto(m_nPixelGangedHitsFlaggedFakes_vs_eta, eta, iPixelGangedFakes, weight);
      fillHisto(m_nPixelGangedHitsFlaggedFakes_vs_phi, phi, iPixelGangedFakes, weight);
      fillHisto(m_nPixelGangedHitsFlaggedFakes_vs_mu, mu, iPixelGangedFakes, weight);
    }
    if (track.summaryValue(iSCTOutliers, xAOD::numberOfSCTOutliers)) {
      fillHisto(m_nSCTOutliers, iSCTOutliers, weight);
      fillHisto(m_nSCTOutliers_vs_eta, eta, iSCTOutliers, weight);
      fillHisto(m_nSCTOutliers_vs_phi, phi, iSCTOutliers, weight);
      fillHisto(m_nSCTOutliers_vs_mu, mu, iSCTOutliers, weight);
    }
    if (m_addHGTDHistos) {
      std::uint8_t iHGTDOutliers{};
      if (track.summaryValue(iHGTDOutliers, xAOD::numberOfHGTDOutliers)) {
        fillHisto(m_nHGTDOutliers, iHGTDOutliers, weight);
        fillHisto(m_nHGTDOutliers_vs_eta, eta, iHGTDOutliers, weight);
        fillHisto(m_nHGTDOutliers_vs_phi, phi, iHGTDOutliers, weight);
        fillHisto(m_nHGTDOutliers_vs_mu, mu, iHGTDOutliers, weight);
      }
    }
    if (track.summaryValue(iSCTDoubleHoles, xAOD::numberOfSCTDoubleHoles)) {
      fillHisto(m_nSCTDoubleHoles, iSCTDoubleHoles, weight);
      fillHisto(m_nSCTDoubleHoles_vs_eta, eta, iSCTDoubleHoles, weight);
      fillHisto(m_nSCTDoubleHoles_vs_phi, phi, iSCTDoubleHoles, weight);
      fillHisto(m_nSCTDoubleHoles_vs_etaphi, eta,phi, iSCTDoubleHoles, weight);
      fillHisto(m_nSCTDoubleHoles_vs_mu, mu, iSCTDoubleHoles, weight);
    }
    if (!m_isITk && track.summaryValue(iTRTOutliers, xAOD::numberOfTRTOutliers)) {
      fillHisto(m_nTRTOutliers, iTRTOutliers, weight);
      fillHisto(m_nTRTOutliers_vs_eta, eta, iTRTOutliers, weight);
      fillHisto(m_nTRTOutliers_vs_phi, phi, iTRTOutliers, weight);
      fillHisto(m_nTRTOutliers_vs_mu, mu, iTRTOutliers, weight);
    }
    if (!m_isITk && track.summaryValue(iTRTHTOutliers, xAOD::numberOfTRTHighThresholdOutliers)) {
      fillHisto(m_nTRTHighThresholdOutliers, iTRTHTOutliers, weight);
      fillHisto(m_nTRTHighThresholdOutliers_vs_eta, eta, iTRTHTOutliers, weight);
      fillHisto(m_nTRTHighThresholdOutliers_vs_phi, phi, iTRTHTOutliers, weight);
      fillHisto(m_nTRTHighThresholdOutliers_vs_mu, mu, iTRTHTOutliers, weight);
    }
    if (track.summaryValue(iPixelDeadSensors, xAOD::numberOfPixelDeadSensors)) {
      fillHisto(m_nPixelDeadSensors, iPixelDeadSensors, weight);
      fillHisto(m_nPixelDeadSensors_vs_eta, eta, iPixelDeadSensors, weight);
      fillHisto(m_nPixelDeadSensors_vs_phi, phi, iPixelDeadSensors, weight);
      fillHisto(m_nPixelDeadSensors_vs_etaphi, eta, phi, iPixelDeadSensors, weight);
      fillHisto(m_nPixelDeadSensors_vs_mu, mu, iPixelDeadSensors, weight);
    }
    if (track.summaryValue(iSCTDeadSensors, xAOD::numberOfSCTDeadSensors)) {
      fillHisto(m_nSCTDeadSensors, iSCTDeadSensors, weight);
      fillHisto(m_nSCTDeadSensors_vs_eta, eta, iSCTDeadSensors, weight);
      fillHisto(m_nSCTDeadSensors_vs_phi, phi, iSCTDeadSensors, weight);
      fillHisto(m_nSCTDeadSensors_vs_etaphi, eta, phi, iSCTDeadSensors, weight);
      fillHisto(m_nSCTDeadSensors_vs_mu, mu, iSCTDeadSensors, weight);
    }
 
  }
 
}

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);
  }
}

finalize()

void PlotBase::finalize ( )

inherited

Definition at line 47 of file PlotBase.cxx.

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

finalizePlots()

virtual void PlotBase::finalizePlots ( )

inlineprivatevirtualinherited

Reimplemented in IDTPM::DuplicateRatePlots, IDTPM::EfficiencyPlots, IDTPM::FakeRatePlots, IDTPM::HitsOnTracksPlots, IDTPM::NtracksPlots, IDTPM::OfflineElectronPlots, IDTPM::ResolutionPlots, IDTPM::SummaryPlots, IDTPM::TrackParametersPlots, IDTPM::VertexParametersPlots, InDetBasicPlot, InDetPerfPlot_Duplicate, InDetPerfPlot_Efficiency, InDetPerfPlot_FakeRate, InDetPerfPlot_Resolution, InDetPerfPlot_TrackParameters, InDetPerfPlot_TRTExtension, InDetPerfPlot_VertexTruthMatching, JetTagDQA::BTaggingValidationPlots, TCCPlots, Trk::EfficiencyPlots, ZeeValidation::ReconElectronsPlots, ZeeValidation::TrueElectronsPlots, and ZeeValidation::TrueFwdElectronsPlots.

Definition at line 93 of file PlotBase.h.

{;}

getDirectory()

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

inlineinherited

Definition at line 89 of file PlotBase.h.

{return m_sDirectory;}

initialize()

void PlotBase::initialize ( )

inherited

Definition at line 39 of file PlotBase.cxx.

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

initializePlots()

void InDetPerfPlot_Hits::initializePlots ( )

privatevirtual

Reimplemented from PlotBase.

Definition at line 20 of file InDetPerfPlot_Hits.cxx.

                                    {
 
  book(m_nInnerMostPixelHits, "nInnerMostPixelHits");
  book(m_nNextToInnerMostPixelHits, "nNextToInnerMostPixelHits");
  if(m_isITk){
    book(m_nInnerMostPixelEndcapHits, "nInnerMostPixelEndcapHits");
    book(m_nNextToInnerMostPixelEndcapHits, "nNextToInnerMostPixelEndcapHits");
  }
  book(m_nPixelHits, "nPixelHits");
  book(m_nSCTHits, "nSCTHits");
  if(!m_isITk){
    book(m_nTRTHits, "nTRTHits");
    book(m_nTRTHitsXe, "nTRTHitsXe");
    book(m_nTRTHitsAr, "nTRTHitsAr");
  }
  book(m_nPixelHoles, "nPixelHoles");
  book(m_nSCTHoles, "nSCTHoles");
  if(!m_isITk){
    book(m_nTRTHighThresholdHits, "nTRTHighThresholdHits");
    book(m_nTRTHighThresholdHitsXe, "nTRTHighThresholdHitsXe");
    book(m_nTRTHighThresholdHitsAr, "nTRTHighThresholdHitsAr");
  }
  book(m_nInnerMostPixelHits_vs_eta, "nInnerMostPixelHits_vs_eta");
  book(m_nNextToInnerMostPixelHits_vs_eta, "nNextToInnerMostPixelHits_vs_eta");
  if(m_isITk){
    book(m_nInnerMostPixelEndcapHits_vs_eta, "nInnerMostPixelEndcapHits_vs_eta");
    book(m_nNextToInnerMostPixelEndcapHits_vs_eta, "nNextToInnerMostPixelEndcapHits_vs_eta");
  }
  book(m_nPixelHits_vs_eta, "nPixelHits_vs_eta");
  book(m_nSCTHits_vs_eta, "nSCTHits_vs_eta");
  if(!m_isITk){
    book(m_nTRTHits_vs_eta, "nTRTHits_vs_eta");
    book(m_nTRTHitsXe_vs_eta, "nTRTHitsXe_vs_eta");
    book(m_nTRTHitsAr_vs_eta, "nTRTHitsAr_vs_eta");
  }
  book(m_nPixelHoles_vs_eta, "nPixelHoles_vs_eta");
  book(m_nSCTHoles_vs_eta, "nSCTHoles_vs_eta");
  if(!m_isITk){
    book(m_nTRTHighThresholdHits_vs_eta, "nTRTHighThresholdHits_vs_eta");
    book(m_nTRTHighThresholdHitsXe_vs_eta, "nTRTHighThresholdHitsXe_vs_eta");
    book(m_nTRTHighThresholdHitsAr_vs_eta, "nTRTHighThresholdHitsAr_vs_eta");
  }
  book(m_nInnerMostPixelHits_vs_phi, "nInnerMostPixelHits_vs_phi");
  book(m_nNextToInnerMostPixelHits_vs_phi, "nNextToInnerMostPixelHits_vs_phi");
  if(m_isITk){
    book(m_nInnerMostPixelEndcapHits_vs_phi, "nInnerMostPixelEndcapHits_vs_phi");
    book(m_nNextToInnerMostPixelEndcapHits_vs_phi, "nNextToInnerMostPixelEndcapHits_vs_phi");
  }
  book(m_nPixelHits_vs_phi, "nPixelHits_vs_phi");
  book(m_nSCTHits_vs_phi, "nSCTHits_vs_phi");
  if(!m_isITk) book(m_nTRTHits_vs_phi, "nTRTHits_vs_phi");
  book(m_nPixelHoles_vs_phi, "nPixelHoles_vs_phi");
  book(m_nSCTHoles_vs_phi, "nSCTHoles_vs_phi");
  if(!m_isITk) book(m_nTRTHighThresholdHits_vs_phi, "nTRTHighThresholdHits_vs_phi");
 
  book(m_nInnerMostPixelSharedHits, "nInnerMostPixelSharedHits");
  if(m_isITk) book(m_nInnerMostPixelSharedEndcapHits, "nInnerMostPixelSharedEndcapHits");
  book(m_nPixelSharedHits, "nPixelSharedHits");
  book(m_nSCTSharedHits, "nSCTSharedHits");
  book(m_nInnerMostPixelSharedHits_vs_eta, "nInnerMostPixelSharedHits_vs_eta");
  if(m_isITk) book(m_nInnerMostPixelSharedEndcapHits_vs_eta, "nInnerMostPixelSharedEndcapHits_vs_eta");
  book(m_nPixelSharedHits_vs_eta, "nPixelSharedHits_vs_eta");
  book(m_nSCTSharedHits_vs_eta, "nSCTSharedHits_vs_eta");
  book(m_nInnerMostPixelSharedHits_vs_phi, "nInnerMostPixelSharedHits_vs_phi");
  if(m_isITk) book(m_nInnerMostPixelSharedEndcapHits_vs_phi, "nInnerMostPixelSharedEndcapHits_vs_phi");
  book(m_nPixelSharedHits_vs_phi, "nPixelSharedHits_vs_phi");
  book(m_nSCTSharedHits_vs_phi, "nSCTSharedHits_vs_phi");
 
  book(m_nInnerMostPixelHits_vs_etaphi, "nInnerMostPixelHits_vs_etaphi");
  if(m_isITk) book(m_nInnerMostPixelEndcapHits_vs_etaphi, "nInnerMostPixelEndcapHits_vs_etaphi");
  book(m_nNextToInnerMostPixelHits_vs_etaphi, "nNextToInnerMostPixelHits_vs_etaphi");
  if(m_isITk) book(m_nNextToInnerMostPixelEndcapHits_vs_etaphi, "nNextToInnerMostPixelEndcapHits_vs_etaphi");
  book(m_nPixelHits_vs_etaphi, "nPixelHits_vs_etaphi");
  book(m_nPixelHoles_vs_etaphi, "nPixelHoles_vs_etaphi");
  book(m_nSCTHits_vs_etaphi, "nSCTHits_vs_etaphi");
  book(m_nSCTHoles_vs_etaphi, "nSCTHoles_vs_etaphi");
 
  if(!m_isITk){
    book(m_nTRTHits_vs_etaphi, "nTRTHits_vs_etaphi");
    book(m_nTRTHitsXe_vs_etaphi, "nTRTHitsXe_vs_etaphi");
    book(m_nTRTHitsAr_vs_etaphi, "nTRTHitsAr_vs_etaphi");
    book(m_nTRTHighThresholdHits_vs_etaphi, "nTRTHighThresholdHits_vs_etaphi");
    book(m_nTRTHighThresholdHitsXe_vs_etaphi, "nTRTHighThresholdHitsXe_vs_etaphi");
    book(m_nTRTHighThresholdHitsAr_vs_etaphi, "nTRTHighThresholdHitsAr_vs_etaphi");
  }
 
  book(m_pixeldEdx, "pixeldEdx");
 
  if (m_iDetailLevel >= 100){
    book(m_nInnerMostPixelOutliers, "nInnerMostPixelOutliers");
    if(m_isITk) book(m_nInnerMostPixelEndcapOutliers, "nInnerMostPixelEndcapOutliers");
    book(m_nInnerMostPixelSplitHits, "nInnerMostPixelSplitHits");
    if(m_isITk) book(m_nInnerMostPixelSplitEndcapHits, "nInnerMostPixelSplitEndcapHits");
    book(m_nExpectedInnerMostPixelHits, "nExpectedInnerMostPixelHits");
    book(m_nExpectedNextToInnerMostPixelHits, "nExpectedNextToInnerMostPixelHits");
    book(m_nPixelOutliers, "nPixelOutliers");
    book(m_nPixelContribLayers, "nPixelContribLayers");
    book(m_nPixelSplitHits, "nPixelSplitHits");
    book(m_nPixelGangedHits, "nPixelGangedHits");
    book(m_nPixelGangedHitsFlaggedFakes, "nPixelGangedHitsFlaggedFakes");
    book(m_nSCTOutliers, "nSCTOutliers");
    book(m_nSCTDoubleHoles, "nSCTDoubleHoles");
    if(!m_isITk){
      book(m_nTRTOutliers, "nTRTOutliers");
      book(m_nTRTHighThresholdOutliers, "nTRTHighThresholdOutliers");
    }
    book(m_nPixelDeadSensors, "nPixelDeadSensors");
    book(m_nSCTDeadSensors, "nSCTDeadSensors");
  
    book(m_nInnerMostPixelOutliers_vs_eta, "nInnerMostPixelOutliers_vs_eta");
    book(m_nInnerMostPixelSplitHits_vs_eta, "nInnerMostPixelSplitHits_vs_eta");
    if(m_isITk){
      book(m_nInnerMostPixelEndcapOutliers_vs_eta, "nInnerMostPixelEndcapOutliers_vs_eta");
      book(m_nInnerMostPixelSplitEndcapHits_vs_eta, "nInnerMostPixelSplitEndcapHits_vs_eta");
    }
    book(m_nExpectedInnerMostPixelHits_vs_eta, "nExpectedInnerMostPixelHits_vs_eta");
    book(m_nExpectedNextToInnerMostPixelHits_vs_eta, "nExpectedNextToInnerMostPixelHits_vs_eta");
    book(m_nPixelOutliers_vs_eta, "nPixelOutliers_vs_eta");
    book(m_nPixelContribLayers_vs_eta, "nPixelContribLayers_vs_eta");
    book(m_nPixelSplitHits_vs_eta, "nPixelSplitHits_vs_eta");
    book(m_nPixelGangedHits_vs_eta, "nPixelGangedHits_vs_eta");
    book(m_nPixelGangedHitsFlaggedFakes_vs_eta, "nPixelGangedHitsFlaggedFakes_vs_eta");
    book(m_nSCTOutliers_vs_eta, "nSCTOutliers_vs_eta");
    book(m_nSCTDoubleHoles_vs_eta, "nSCTDoubleHoles_vs_eta");
    if(!m_isITk){
      book(m_nTRTOutliers_vs_eta, "nTRTOutliers_vs_eta");
      book(m_nTRTHighThresholdOutliers_vs_eta, "nTRTHighThresholdOutliers_vs_eta");
    }
    book(m_nPixelDeadSensors_vs_eta, "nPixelDeadSensors_vs_eta");
    book(m_nSCTDeadSensors_vs_eta, "nSCTDeadSensors_vs_eta");
 
    book(m_nInnerMostPixelOutliers_vs_phi, "nInnerMostPixelOutliers_vs_phi");
    book(m_nInnerMostPixelSplitHits_vs_phi, "nInnerMostPixelSplitHits_vs_phi");
    if(m_isITk){
      book(m_nInnerMostPixelEndcapOutliers_vs_phi, "nInnerMostPixelEndcapOutliers_vs_phi");
      book(m_nInnerMostPixelSplitEndcapHits_vs_phi, "nInnerMostPixelSplitEndcapHits_vs_phi");
    }
    book(m_nExpectedInnerMostPixelHits_vs_phi, "nExpectedInnerMostPixelHits_vs_phi");
    book(m_nExpectedNextToInnerMostPixelHits_vs_phi, "nExpectedNextToInnerMostPixelHits_vs_phi");
    book(m_nPixelOutliers_vs_phi, "nPixelOutliers_vs_phi");
    book(m_nPixelContribLayers_vs_phi, "nPixelContribLayers_vs_phi");
    book(m_nPixelSplitHits_vs_phi, "nPixelSplitHits_vs_phi");
    book(m_nPixelGangedHits_vs_phi, "nPixelGangedHits_vs_phi");
    book(m_nPixelGangedHitsFlaggedFakes_vs_phi, "nPixelGangedHitsFlaggedFakes_vs_phi");
    book(m_nSCTOutliers_vs_phi, "nSCTOutliers_vs_phi");
    book(m_nSCTDoubleHoles_vs_phi, "nSCTDoubleHoles_vs_phi");
    if(!m_isITk){
      book(m_nTRTOutliers_vs_phi, "nTRTOutliers_vs_phi");
      book(m_nTRTHighThresholdOutliers_vs_phi, "nTRTHighThresholdOutliers_vs_phi");
    }
    else if (m_addHGTDHistos) {
      book(m_nHGTDHits, "nHGTDHits");
      book(m_nHGTDHoles, "nHGTDHoles");
      book(m_nHGTDHits_vs_eta, "nHGTDHits_vs_eta");
      book(m_nHGTDHoles_vs_eta, "nHGTDHoles_vs_eta");
      book(m_nHGTDHits_vs_phi, "nHGTDHits_vs_phi");
      book(m_nHGTDHoles_vs_phi, "nHGTDHoles_vs_phi");
      book(m_nHGTDSharedHits, "nHGTDSharedHits");
      book(m_nHGTDSharedHits_vs_eta, "nHGTDSharedHits_vs_eta");
      book(m_nHGTDSharedHits_vs_phi, "nHGTDSharedHits_vs_phi");
      book(m_nHGTDHits_vs_etaphi, "nHGTDHits_vs_etaphi");
      book(m_nHGTDHoles_vs_etaphi, "nHGTDHoles_vs_etaphi");
      book(m_nHGTDOutliers, "nHGTDOutliers");
      book(m_nHGTDOutliers_vs_eta, "nHGTDOutliers_vs_eta");
      book(m_nHGTDOutliers_vs_phi, "nHGTDOutliers_vs_phi");
      if (m_iDetailLevel >= 100) {
         book(m_nHGTDHits_vs_mu, "nHGTDHits_vs_mu");
         book(m_nHGTDHoles_vs_mu, "nHGTDHoles_vs_mu");
         book(m_nHGTDSharedHits_vs_mu, "nHGTDSharedHits_vs_mu");
         book(m_nHGTDOutliers_vs_mu, "nHGTDOutliers_vs_mu");
      }
    }
    book(m_nPixelDeadSensors_vs_phi, "nPixelDeadSensors_vs_phi");
    book(m_nSCTDeadSensors_vs_phi, "nSCTDeadSensors_vs_phi");
 
    book(m_nExpectedInnerMostPixelHits_vs_etaphi, "nExpectedInnerMostPixelHits_vs_etaphi");
    book(m_nExpectedNextToInnerMostPixelHits_vs_etaphi, "nExpectedNextToInnerMostPixelHits_vs_etaphi");
    book(m_nPixelDeadSensors_vs_etaphi, "nPixelDeadSensors_vs_etaphi");
    book(m_nSCTDeadSensors_vs_etaphi, "nSCTDeadSensors_vs_etaphi");
    book(m_nSCTDoubleHoles_vs_etaphi, "nSCTDoubleHoles_vs_etaphi");
 
    book(m_nInnerMostPixelHits_vs_mu, "nInnerMostPixelHits_vs_mu");
    book(m_nNextToInnerMostPixelHits_vs_mu, "nNextToInnerMostPixelHits_vs_mu");
    if(m_isITk){
      book(m_nInnerMostPixelEndcapHits_vs_mu, "nInnerMostPixelEndcapHits_vs_mu");
      book(m_nNextToInnerMostPixelEndcapHits_vs_mu, "nNextToInnerMostPixelEndcapHits_vs_mu");
    }
    book(m_nPixelHits_vs_mu, "nPixelHits_vs_mu");
    book(m_nSCTHits_vs_mu, "nSCTHits_vs_mu");
    if(!m_isITk){
      book(m_nTRTHits_vs_mu, "nTRTHits_vs_mu");
      book(m_nTRTHitsXe_vs_mu_central, "nTRTHitsXe_vs_mu_central");
      book(m_nTRTHitsXe_vs_mu_ECsideA, "nTRTHitsXe_vs_mu_ECsideA");
      book(m_nTRTHitsXe_vs_mu_ECsideC, "nTRTHitsXe_vs_mu_ECsideC");
      book(m_nTRTHitsAr_vs_mu_central, "nTRTHitsAr_vs_mu_central");
      book(m_nTRTHitsAr_vs_mu_ECsideA, "nTRTHitsAr_vs_mu_ECsideA");
      book(m_nTRTHitsAr_vs_mu_ECsideC, "nTRTHitsAr_vs_mu_ECsideC");
    }
    book(m_nPixelHoles_vs_mu, "nPixelHoles_vs_mu");
    book(m_nSCTHoles_vs_mu, "nSCTHoles_vs_mu");
    if(!m_isITk){
      book(m_nTRTHighThresholdHits_vs_mu, "nTRTHighThresholdHits_vs_mu");
      book(m_nTRTHighThresholdHitsXe_vs_mu_central, "nTRTHighThresholdHitsXe_vs_mu_central");
      book(m_nTRTHighThresholdHitsXe_vs_mu_ECsideA, "nTRTHighThresholdHitsXe_vs_mu_ECsideA");
      book(m_nTRTHighThresholdHitsXe_vs_mu_ECsideC, "nTRTHighThresholdHitsXe_vs_mu_ECsideC");
      book(m_nTRTHighThresholdHitsAr_vs_mu_central, "nTRTHighThresholdHitsAr_vs_mu_central");
      book(m_nTRTHighThresholdHitsAr_vs_mu_ECsideA, "nTRTHighThresholdHitsAr_vs_mu_ECsideA");
      book(m_nTRTHighThresholdHitsAr_vs_mu_ECsideC, "nTRTHighThresholdHitsAr_vs_mu_ECsideC");
    }
    book(m_nInnerMostPixelSharedHits_vs_mu, "nInnerMostPixelSharedHits_vs_mu");
    if(m_isITk) book(m_nInnerMostPixelSharedEndcapHits_vs_mu, "nInnerMostPixelSharedEndcapHits_vs_mu");
    book(m_nPixelSharedHits_vs_mu, "nPixelSharedHits_vs_mu");
    book(m_nSCTSharedHits_vs_mu, "nSCTSharedHits_vs_mu");
    book(m_nInnerMostPixelOutliers_vs_mu, "nInnerMostPixelOutliers_vs_mu");
    book(m_nInnerMostPixelSplitHits_vs_mu, "nInnerMostPixelSplitHits_vs_mu");
    if(m_isITk){
      book(m_nInnerMostPixelEndcapOutliers_vs_mu, "nInnerMostPixelEndcapOutliers_vs_mu");
      book(m_nInnerMostPixelSplitEndcapHits_vs_mu, "nInnerMostPixelSplitEndcapHits_vs_mu");
    }
    book(m_nExpectedInnerMostPixelHits_vs_mu, "nExpectedInnerMostPixelHits_vs_mu");
    book(m_nExpectedNextToInnerMostPixelHits_vs_mu, "nExpectedNextToInnerMostPixelHits_vs_mu");
    book(m_nPixelOutliers_vs_mu, "nPixelOutliers_vs_mu");
    book(m_nPixelContribLayers_vs_mu, "nPixelContribLayers_vs_mu");
    book(m_nPixelSplitHits_vs_mu, "nPixelSplitHits_vs_mu");
    book(m_nPixelGangedHits_vs_mu, "nPixelGangedHits_vs_mu");
    book(m_nPixelGangedHitsFlaggedFakes_vs_mu, "nPixelGangedHitsFlaggedFakes_vs_mu");
    book(m_nSCTOutliers_vs_mu, "nSCTOutliers_vs_mu");
    book(m_nSCTDoubleHoles_vs_mu, "nSCTDoubleHoles_vs_mu");
    if(!m_isITk){
      book(m_nTRTOutliers_vs_mu, "nTRTOutliers_vs_mu");
      book(m_nTRTHighThresholdOutliers_vs_mu, "nTRTHighThresholdOutliers_vs_mu");
    }
    book(m_nPixelDeadSensors_vs_mu, "nPixelDeadSensors_vs_mu");
    book(m_nSCTDeadSensors_vs_mu, "nSCTDeadSensors_vs_mu");
 
  }
 
}

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_addHGTDHistos

bool InDetPerfPlot_Hits::m_addHGTDHistos =true

private

Definition at line 233 of file InDetPerfPlot_Hits.h.

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_Hits::m_isITk

private

Definition at line 29 of file InDetPerfPlot_Hits.h.

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_nExpectedInnerMostPixelHits

TH1* InDetPerfPlot_Hits::m_nExpectedInnerMostPixelHits {nullptr}

private

Definition at line 53 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedInnerMostPixelHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nExpectedInnerMostPixelHits_vs_eta {nullptr}

private

Definition at line 92 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedInnerMostPixelHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nExpectedInnerMostPixelHits_vs_etaphi {nullptr}

private

Definition at line 147 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedInnerMostPixelHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nExpectedInnerMostPixelHits_vs_mu {nullptr}

private

Definition at line 198 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedInnerMostPixelHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nExpectedInnerMostPixelHits_vs_phi {nullptr}

private

Definition at line 126 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedNextToInnerMostPixelHits

TH1* InDetPerfPlot_Hits::m_nExpectedNextToInnerMostPixelHits {nullptr}

private

Definition at line 54 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedNextToInnerMostPixelHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nExpectedNextToInnerMostPixelHits_vs_eta {nullptr}

private

Definition at line 93 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedNextToInnerMostPixelHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nExpectedNextToInnerMostPixelHits_vs_etaphi {nullptr}

private

Definition at line 150 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedNextToInnerMostPixelHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nExpectedNextToInnerMostPixelHits_vs_mu {nullptr}

private

Definition at line 199 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nExpectedNextToInnerMostPixelHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nExpectedNextToInnerMostPixelHits_vs_phi {nullptr}

private

Definition at line 127 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHits

TH1* InDetPerfPlot_Hits::m_nHGTDHits {nullptr}

private

Definition at line 214 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nHGTDHits_vs_eta {nullptr}

private

Definition at line 216 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nHGTDHits_vs_etaphi {nullptr}

private

Definition at line 223 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nHGTDHits_vs_mu {nullptr}

private

Definition at line 228 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nHGTDHits_vs_phi {nullptr}

private

Definition at line 218 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHoles

TH1* InDetPerfPlot_Hits::m_nHGTDHoles {nullptr}

private

Definition at line 215 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHoles_vs_eta

TProfile* InDetPerfPlot_Hits::m_nHGTDHoles_vs_eta {nullptr}

private

Definition at line 217 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHoles_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nHGTDHoles_vs_etaphi {nullptr}

private

Definition at line 224 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHoles_vs_mu

TProfile* InDetPerfPlot_Hits::m_nHGTDHoles_vs_mu {nullptr}

private

Definition at line 229 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDHoles_vs_phi

TProfile* InDetPerfPlot_Hits::m_nHGTDHoles_vs_phi {nullptr}

private

Definition at line 219 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDOutliers

TH1* InDetPerfPlot_Hits::m_nHGTDOutliers {nullptr}

private

Definition at line 225 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nHGTDOutliers_vs_eta {nullptr}

private

Definition at line 226 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nHGTDOutliers_vs_mu {nullptr}

private

Definition at line 231 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nHGTDOutliers_vs_phi {nullptr}

private

Definition at line 227 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDSharedHits

TH1* InDetPerfPlot_Hits::m_nHGTDSharedHits {nullptr}

private

Definition at line 220 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDSharedHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nHGTDSharedHits_vs_eta {nullptr}

private

Definition at line 221 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDSharedHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nHGTDSharedHits_vs_mu {nullptr}

private

Definition at line 230 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nHGTDSharedHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nHGTDSharedHits_vs_phi {nullptr}

private

Definition at line 222 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapHits {nullptr}

private

Definition at line 34 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapHits_vs_eta {nullptr}

private

Definition at line 73 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapHits_vs_etaphi {nullptr}

private

Definition at line 146 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapHits_vs_mu {nullptr}

private

Definition at line 171 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapHits_vs_phi {nullptr}

private

Definition at line 111 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapOutliers

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapOutliers {nullptr}

private

Definition at line 48 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapOutliers_vs_eta {nullptr}

private

Definition at line 87 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapOutliers_vs_mu {nullptr}

private

Definition at line 193 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelEndcapOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelEndcapOutliers_vs_phi {nullptr}

private

Definition at line 121 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelHits {nullptr}

private

Definition at line 33 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelHits_vs_eta {nullptr}

private

Definition at line 72 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nInnerMostPixelHits_vs_etaphi {nullptr}

private

Definition at line 145 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelHits_vs_mu {nullptr}

private

Definition at line 170 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelHits_vs_phi {nullptr}

private

Definition at line 110 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelOutliers

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelOutliers {nullptr}

private

Definition at line 47 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelOutliers_vs_eta {nullptr}

private

Definition at line 86 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelOutliers_vs_mu {nullptr}

private

Definition at line 192 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelOutliers_vs_phi {nullptr}

private

Definition at line 120 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedEndcapHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelSharedEndcapHits {nullptr}

private

Definition at line 50 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedEndcapHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedEndcapHits_vs_eta {nullptr}

private

Definition at line 89 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedEndcapHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedEndcapHits_vs_mu {nullptr}

private

Definition at line 195 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedEndcapHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedEndcapHits_vs_phi {nullptr}

private

Definition at line 123 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelSharedHits {nullptr}

private

Definition at line 49 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedHits_vs_eta {nullptr}

private

Definition at line 88 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedHits_vs_mu {nullptr}

private

Definition at line 194 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSharedHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSharedHits_vs_phi {nullptr}

private

Definition at line 122 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitEndcapHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelSplitEndcapHits {nullptr}

private

Definition at line 52 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitEndcapHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitEndcapHits_vs_eta {nullptr}

private

Definition at line 91 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitEndcapHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitEndcapHits_vs_mu {nullptr}

private

Definition at line 197 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitEndcapHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitEndcapHits_vs_phi {nullptr}

private

Definition at line 125 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitHits

TH1* InDetPerfPlot_Hits::m_nInnerMostPixelSplitHits {nullptr}

private

Definition at line 51 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitHits_vs_eta {nullptr}

private

Definition at line 90 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitHits_vs_mu {nullptr}

private

Definition at line 196 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nInnerMostPixelSplitHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nInnerMostPixelSplitHits_vs_phi {nullptr}

private

Definition at line 124 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_nNextToInnerMostPixelEndcapHits

TH1* InDetPerfPlot_Hits::m_nNextToInnerMostPixelEndcapHits {nullptr}

private

Definition at line 36 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelEndcapHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelEndcapHits_vs_eta {nullptr}

private

Definition at line 75 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelEndcapHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nNextToInnerMostPixelEndcapHits_vs_etaphi {nullptr}

private

Definition at line 149 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelEndcapHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelEndcapHits_vs_mu {nullptr}

private

Definition at line 173 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelEndcapHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelEndcapHits_vs_phi {nullptr}

private

Definition at line 113 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelHits

TH1* InDetPerfPlot_Hits::m_nNextToInnerMostPixelHits {nullptr}

private

Definition at line 35 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelHits_vs_eta {nullptr}

private

Definition at line 74 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nNextToInnerMostPixelHits_vs_etaphi {nullptr}

private

Definition at line 148 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelHits_vs_mu {nullptr}

private

Definition at line 172 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nNextToInnerMostPixelHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nNextToInnerMostPixelHits_vs_phi {nullptr}

private

Definition at line 112 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelContribLayers

TH1* InDetPerfPlot_Hits::m_nPixelContribLayers {nullptr}

private

Definition at line 56 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelContribLayers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelContribLayers_vs_eta {nullptr}

private

Definition at line 95 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelContribLayers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelContribLayers_vs_mu {nullptr}

private

Definition at line 201 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelContribLayers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelContribLayers_vs_phi {nullptr}

private

Definition at line 129 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelDeadSensors

TH1* InDetPerfPlot_Hits::m_nPixelDeadSensors {nullptr}

private

Definition at line 66 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelDeadSensors_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelDeadSensors_vs_eta {nullptr}

private

Definition at line 105 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelDeadSensors_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nPixelDeadSensors_vs_etaphi {nullptr}

private

Definition at line 153 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelDeadSensors_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelDeadSensors_vs_mu {nullptr}

private

Definition at line 211 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelDeadSensors_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelDeadSensors_vs_phi {nullptr}

private

Definition at line 139 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHits

TH1* InDetPerfPlot_Hits::m_nPixelGangedHits {nullptr}

private

Definition at line 59 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHits_vs_eta {nullptr}

private

Definition at line 98 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHits_vs_mu {nullptr}

private

Definition at line 204 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHits_vs_phi {nullptr}

private

Definition at line 132 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHitsFlaggedFakes

TH1* InDetPerfPlot_Hits::m_nPixelGangedHitsFlaggedFakes {nullptr}

private

Definition at line 60 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHitsFlaggedFakes_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHitsFlaggedFakes_vs_eta {nullptr}

private

Definition at line 99 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHitsFlaggedFakes_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHitsFlaggedFakes_vs_mu {nullptr}

private

Definition at line 205 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelGangedHitsFlaggedFakes_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelGangedHitsFlaggedFakes_vs_phi {nullptr}

private

Definition at line 133 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHits

TH1* InDetPerfPlot_Hits::m_nPixelHits {nullptr}

private

Definition at line 37 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelHits_vs_eta {nullptr}

private

Definition at line 76 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nPixelHits_vs_etaphi {nullptr}

private

Definition at line 151 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelHits_vs_mu {nullptr}

private

Definition at line 174 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelHits_vs_phi {nullptr}

private

Definition at line 114 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHoles

TH1* InDetPerfPlot_Hits::m_nPixelHoles {nullptr}

private

Definition at line 42 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHoles_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelHoles_vs_eta {nullptr}

private

Definition at line 81 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHoles_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nPixelHoles_vs_etaphi {nullptr}

private

Definition at line 152 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHoles_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelHoles_vs_mu {nullptr}

private

Definition at line 183 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelHoles_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelHoles_vs_phi {nullptr}

private

Definition at line 117 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelOutliers

TH1* InDetPerfPlot_Hits::m_nPixelOutliers {nullptr}

private

Definition at line 55 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelOutliers_vs_eta {nullptr}

private

Definition at line 94 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelOutliers_vs_mu {nullptr}

private

Definition at line 200 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelOutliers_vs_phi {nullptr}

private

Definition at line 128 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSharedHits

TH1* InDetPerfPlot_Hits::m_nPixelSharedHits {nullptr}

private

Definition at line 57 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSharedHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelSharedHits_vs_eta {nullptr}

private

Definition at line 96 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSharedHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelSharedHits_vs_mu {nullptr}

private

Definition at line 202 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSharedHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelSharedHits_vs_phi {nullptr}

private

Definition at line 130 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSplitHits

TH1* InDetPerfPlot_Hits::m_nPixelSplitHits {nullptr}

private

Definition at line 58 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSplitHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nPixelSplitHits_vs_eta {nullptr}

private

Definition at line 97 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSplitHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nPixelSplitHits_vs_mu {nullptr}

private

Definition at line 203 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nPixelSplitHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nPixelSplitHits_vs_phi {nullptr}

private

Definition at line 131 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDeadSensors

TH1* InDetPerfPlot_Hits::m_nSCTDeadSensors {nullptr}

private

Definition at line 67 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDeadSensors_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTDeadSensors_vs_eta {nullptr}

private

Definition at line 106 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDeadSensors_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nSCTDeadSensors_vs_etaphi {nullptr}

private

Definition at line 157 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDeadSensors_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTDeadSensors_vs_mu {nullptr}

private

Definition at line 212 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDeadSensors_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTDeadSensors_vs_phi {nullptr}

private

Definition at line 140 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDoubleHoles

TH1* InDetPerfPlot_Hits::m_nSCTDoubleHoles {nullptr}

private

Definition at line 62 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDoubleHoles_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTDoubleHoles_vs_eta {nullptr}

private

Definition at line 101 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDoubleHoles_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nSCTDoubleHoles_vs_etaphi {nullptr}

private

Definition at line 158 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDoubleHoles_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTDoubleHoles_vs_mu {nullptr}

private

Definition at line 207 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTDoubleHoles_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTDoubleHoles_vs_phi {nullptr}

private

Definition at line 135 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHits

TH1* InDetPerfPlot_Hits::m_nSCTHits {nullptr}

private

Definition at line 38 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTHits_vs_eta {nullptr}

private

Definition at line 77 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nSCTHits_vs_etaphi {nullptr}

private

Definition at line 155 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTHits_vs_mu {nullptr}

private

Definition at line 175 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTHits_vs_phi {nullptr}

private

Definition at line 115 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHoles

TH1* InDetPerfPlot_Hits::m_nSCTHoles {nullptr}

private

Definition at line 43 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHoles_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTHoles_vs_eta {nullptr}

private

Definition at line 82 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHoles_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nSCTHoles_vs_etaphi {nullptr}

private

Definition at line 156 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHoles_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTHoles_vs_mu {nullptr}

private

Definition at line 184 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTHoles_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTHoles_vs_phi {nullptr}

private

Definition at line 118 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTOutliers

TH1* InDetPerfPlot_Hits::m_nSCTOutliers {nullptr}

private

Definition at line 61 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTOutliers_vs_eta {nullptr}

private

Definition at line 100 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTOutliers_vs_mu {nullptr}

private

Definition at line 206 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTOutliers_vs_phi {nullptr}

private

Definition at line 134 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTSharedHits

TH1* InDetPerfPlot_Hits::m_nSCTSharedHits {nullptr}

private

Definition at line 63 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTSharedHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nSCTSharedHits_vs_eta {nullptr}

private

Definition at line 102 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTSharedHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nSCTSharedHits_vs_mu {nullptr}

private

Definition at line 208 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nSCTSharedHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nSCTSharedHits_vs_phi {nullptr}

private

Definition at line 136 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHits

TH1* InDetPerfPlot_Hits::m_nTRTHighThresholdHits {nullptr}

private

Definition at line 44 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHits_vs_eta {nullptr}

private

Definition at line 83 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHighThresholdHits_vs_etaphi {nullptr}

private

Definition at line 163 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHits_vs_mu {nullptr}

private

Definition at line 185 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHits_vs_phi {nullptr}

private

Definition at line 119 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr

TH1* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr {nullptr}

private

Definition at line 46 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr_vs_eta {nullptr}

private

Definition at line 85 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr_vs_etaphi {nullptr}

private

Definition at line 165 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr_vs_mu_central

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr_vs_mu_central {nullptr}

private

Definition at line 189 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr_vs_mu_ECsideA

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr_vs_mu_ECsideA {nullptr}

private

Definition at line 190 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsAr_vs_mu_ECsideC

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsAr_vs_mu_ECsideC {nullptr}

private

Definition at line 191 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe

TH1* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe {nullptr}

private

Definition at line 45 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe_vs_eta {nullptr}

private

Definition at line 84 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe_vs_etaphi {nullptr}

private

Definition at line 164 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe_vs_mu_central

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe_vs_mu_central {nullptr}

private

Definition at line 186 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe_vs_mu_ECsideA

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe_vs_mu_ECsideA {nullptr}

private

Definition at line 187 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdHitsXe_vs_mu_ECsideC

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdHitsXe_vs_mu_ECsideC {nullptr}

private

Definition at line 188 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdOutliers

TH1* InDetPerfPlot_Hits::m_nTRTHighThresholdOutliers {nullptr}

private

Definition at line 65 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdOutliers_vs_eta {nullptr}

private

Definition at line 104 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdOutliers_vs_mu {nullptr}

private

Definition at line 210 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHighThresholdOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nTRTHighThresholdOutliers_vs_phi {nullptr}

private

Definition at line 138 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHits

TH1* InDetPerfPlot_Hits::m_nTRTHits {nullptr}

private

Definition at line 39 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHits_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHits_vs_eta {nullptr}

private

Definition at line 78 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHits_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHits_vs_etaphi {nullptr}

private

Definition at line 160 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHits_vs_mu

TProfile* InDetPerfPlot_Hits::m_nTRTHits_vs_mu {nullptr}

private

Definition at line 176 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHits_vs_phi

TProfile* InDetPerfPlot_Hits::m_nTRTHits_vs_phi {nullptr}

private

Definition at line 116 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr

TH1* InDetPerfPlot_Hits::m_nTRTHitsAr {nullptr}

private

Definition at line 41 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHitsAr_vs_eta {nullptr}

private

Definition at line 80 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHitsAr_vs_etaphi {nullptr}

private

Definition at line 162 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr_vs_mu_central

TProfile* InDetPerfPlot_Hits::m_nTRTHitsAr_vs_mu_central {nullptr}

private

Definition at line 180 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr_vs_mu_ECsideA

TProfile* InDetPerfPlot_Hits::m_nTRTHitsAr_vs_mu_ECsideA {nullptr}

private

Definition at line 181 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsAr_vs_mu_ECsideC

TProfile* InDetPerfPlot_Hits::m_nTRTHitsAr_vs_mu_ECsideC {nullptr}

private

Definition at line 182 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe

TH1* InDetPerfPlot_Hits::m_nTRTHitsXe {nullptr}

private

Definition at line 40 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTHitsXe_vs_eta {nullptr}

private

Definition at line 79 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe_vs_etaphi

TProfile2D* InDetPerfPlot_Hits::m_nTRTHitsXe_vs_etaphi {nullptr}

private

Definition at line 161 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe_vs_mu_central

TProfile* InDetPerfPlot_Hits::m_nTRTHitsXe_vs_mu_central {nullptr}

private

Definition at line 177 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe_vs_mu_ECsideA

TProfile* InDetPerfPlot_Hits::m_nTRTHitsXe_vs_mu_ECsideA {nullptr}

private

Definition at line 178 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTHitsXe_vs_mu_ECsideC

TProfile* InDetPerfPlot_Hits::m_nTRTHitsXe_vs_mu_ECsideC {nullptr}

private

Definition at line 179 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTOutliers

TH1* InDetPerfPlot_Hits::m_nTRTOutliers {nullptr}

private

Definition at line 64 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTOutliers_vs_eta

TProfile* InDetPerfPlot_Hits::m_nTRTOutliers_vs_eta {nullptr}

private

Definition at line 103 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTOutliers_vs_mu

TProfile* InDetPerfPlot_Hits::m_nTRTOutliers_vs_mu {nullptr}

private

Definition at line 209 of file InDetPerfPlot_Hits.h.

{nullptr};

m_nTRTOutliers_vs_phi

TProfile* InDetPerfPlot_Hits::m_nTRTOutliers_vs_phi {nullptr}

private

Definition at line 137 of file InDetPerfPlot_Hits.h.

{nullptr};

m_pixeldEdx

TH1* InDetPerfPlot_Hits::m_pixeldEdx {nullptr}

private

Definition at line 68 of file InDetPerfPlot_Hits.h.

{nullptr};

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.

---

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

• InDetPerfPlot_Hits.h
• InDetPerfPlot_Hits.cxx