Tau::CorePlots Class Reference

#include <CorePlots.h>

Inheritance diagram for Tau::CorePlots:

Collaboration diagram for Tau::CorePlots:

Public Member Functions
	CorePlots (PlotBase *pParent, const std::string &sDir, std::string sTauJetContainerName)
virtual	~CorePlots ()
void	fill (const xAOD::TauJet &tau, float weight)
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 (const std::string &name, bool prependDir=true)
	Book a TTree.
const std::string &	getDirectory ()
Methods to book monitoring histograms
Note: methods starting with capitals should be deprecated in favour of camel-cased methods
TH1D *	Book1D (const std::string &name, const std::string &labels, int nBins, float start, float end, bool prependDir=true)
	Book a TH1D histogram.
TH1D *	Book1D (const std::string &name, TH1 *refHist, const std::string &labels, bool prependDir=true)
	Book a TH1D histogram using refHist as reference for number of bins and axis range.
TH2F *	Book2D (const std::string &name, const std::string &labels, int nBinsX, float startX, float endX, int nBinsY, float startY, float endY, bool prependDir=true)
	Book a TH2F histogram.
TH2F *	Book2D (const std::string &name, TH2 *refHist, const std::string &labels, bool prependDir=true)
	Book a TH2D histogram using refHist as reference for number of bins and axis range.
TH2F *	Book2D (const std::string &name, const std::string &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 (const std::string &name, const std::string &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 (const std::string &name, TH3 *refHist, const std::string &labels, bool prependDir=true)
	Book a TH3F histogram using refHist as reference for number of bins and axis range.
TProfile *	BookTProfile (const std::string &name, const std::string &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 (const std::string &name, const std::string &labels, int nBinsX, float *binsX, bool prependDir=true)
	Book a TProfile histogram with variable binning in x-axis.
TProfile *	BookTProfileRangeY (const std::string &name, const std::string &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 (const std::string &name, const std::string &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 (const std::string &name, const std::string &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 (const std::string &name, const std::string &labels, const int nBinsX, const float xlo, const float xhi, const bool prependDir=true)
	Book a (1-D) TEfficiency histogram.
TEfficiency *	BookTEfficiency (const std::string &name, const std::string &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.

Public Attributes
TH1 *	m_ipZ0SinThetaSigLeadTrk {}
TH1 *	m_etOverPtLeadTrk {}
TH1 *	m_ipSigLeadTrk {}
TH1 *	m_massTrkSys {}
TH1 *	m_trFlightPathSig {}
TH1 *	m_tauDRMax {}
TH1 *	m_isolFrac {}
TH1 *	m_centFrac {}
TH1 *	m_trkAvgDist {}
TH1 *	m_mEflowTopo {}
TH1 *	m_ptRatioEflowTopo {}
TH1 *	m_PSSFraction {}
TH1 *	m_ChPiEMEOverCaloEME {}
TH1 *	m_EMPOverTrkSysP {}
TH1 *	m_innerTrkAvgDist {}
TH1 *	m_ptRatioEflowApprox {}
TH1 *	m_mEflowApprox {}
TH1 *	m_logSeedJetPt {}
TH1 *	m_track_logPt {}
TH1 *	m_track_eta {}
TH1 *	m_track_d0TJVA {}
TH1 *	m_track_z0SinthetaTJVA {}
TH1 *	m_track_d0SigTJVA {}
TH1 *	m_track_z0sinthetaSigTJVA {}
TH1 *	m_track_charge {}
TH1 *	m_track_qOverP {}
TH1 *	m_track_logRConv {}
TH1 *	m_track_tanhRConvII {}
TH1 *	m_track_ptRatioSeedJet {}
TH1 *	m_track_dRJetSeedAxis {}
TH1 *	m_track_nInnermostPixHits {}
TH1 *	m_track_nPixHits {}
TH1 *	m_track_nSiHits {}
TH1 *	m_track_nTRTHits {}
TH1 *	m_track_eProbabilityHT {}
TH1 *	m_track_eProbabilityNN {}
TH1 *	m_track_eProbabilityHTorNN {}
TH1 *	m_track_idScoreCharged {}
TH1 *	m_track_idScoreIso {}
TH1 *	m_track_idScoreConv {}
TH1 *	m_cluster_logEt {}
TH1 *	m_cluster_eta {}
TH1 *	m_cluster_phi {}
TH1 *	m_cluster_secondR {}
TH1 *	m_cluster_secondLambda {}
TH1 *	m_cluster_centerLambda {}
TH1 *	m_cluster_firstEngDens {}
TH1 *	m_cluster_EMproba {}
TH1 *	m_clustersMeanCenterLambda {}
TH1 *	m_clustersMeanFirstEngDens {}
TH1 *	m_clustersMeanEMProbability {}
TH1 *	m_clustersMeanSecondLambda {}
TH1 *	m_clustersMeanPresamplerFrac {}
TH1 *	m_PFOEngRelDiff {}
TH1 *	m_TVz {}

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

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

Private Attributes
std::string	m_sTauJetContainerName

Detailed Description

Definition at line 13 of file TauDQA/src/CorePlots.h.

Constructor & Destructor Documentation

CorePlots()

Tau::CorePlots::CorePlots	(	PlotBase *	pParent,
		const std::string &	sDir,
		std::string	sTauJetContainerName )

Definition at line 10 of file TauDQA/src/CorePlots.cxx.

                                                                                              :
    PlotBase(pParent, sDir),
    m_sTauJetContainerName(std::move(sTauJetContainerName))
  { 
  }

~CorePlots()

Tau::CorePlots::~CorePlots ( )

virtual

Definition at line 16 of file TauDQA/src/CorePlots.cxx.

  {
  }

Member Function Documentation

Book1D() [1/2]

TH1D * PlotBase::Book1D ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), nBins, start, end);
  TH1::AddDirectory(oldstat);
 
  hist->Sumw2();
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

Book1D() [2/2]

TH1D * PlotBase::Book1D ( const std::string & name, TH1 * refHist, const std::string & 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 + name).c_str(), labels.c_str(), 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 ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), 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 ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), 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 ( const std::string & name, TH2 * refHist, const std::string & 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 ( const std::string & name, const std::string & 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 + name).c_str(),
                        labels.c_str(), 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 ( const std::string & name, TH3 * refHist, const std::string & 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 + name).c_str(), labels.c_str(), 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 ( const std::string & name, const std::string & 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);
  //Bool_t oldstat = TEfficiency::AddDirectoryStatus();
  TEfficiency *hist = new TEfficiency((prefix + name).c_str(), labels.c_str(), nBinsX, xlo, xhi);
  //hist->SetAutoSave(0);
  //hist->SetAtoFlush(0);
  hist->SetDirectory(nullptr);
  m_vBookedEfficiencies.emplace_back(hist, m_sDirectory);
  //TEfficiency::AddDirectory(oldstat);
  return hist;
}

BookTEfficiency() [2/2]

TEfficiency * PlotBase::BookTEfficiency ( const std::string & name, const std::string & 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 270 of file PlotBase.cxx.

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

BookTProfile() [1/2]

TProfile * PlotBase::BookTProfile ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), nBinsX, binsX);
  TProfile::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfile() [2/2]

TProfile * PlotBase::BookTProfile ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), nBinsX, startX, endX, opt.c_str());
  } else {
    hist = new TProfile((prefix + name).c_str(), labels.c_str(), 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 ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), 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 ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), nBinsX, binsX, nBinsY, binsY, opt.c_str());
  TProfile2D::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTProfileRangeY()

TProfile * PlotBase::BookTProfileRangeY ( const std::string & name, const std::string & 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 + name).c_str(), labels.c_str(), (Int_t) nBinsX, binsX, startY, endY);
  TProfile::AddDirectory(oldstat);
  m_vBookedHistograms.emplace_back(hist, m_sDirectory);
  return hist;
}

BookTree()

TTree * PlotBase::BookTree ( const std::string & name, bool prependDir = true )

inherited

Book a TTree.

Definition at line 281 of file PlotBase.cxx.

                                                         {
  std::string prefix = constructPrefix(m_sDirectory, prependDir);
  TTree *tree = new TTree((prefix + 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 293 of file PlotBase.cxx.

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

fill()

void Tau::CorePlots::fill	(	const xAOD::TauJet &	tau,
		float	weight )

Definition at line 84 of file TauDQA/src/CorePlots.cxx.

                                                          {
 
    float avariable = 0.;
 
    static const SG::ConstAccessor<float> acc_z0sinthetaSigTJVA("z0sinthetaSigTJVA");
    if(tau.nTracks()>0 && acc_z0sinthetaSigTJVA.isAvailable(*tau.track(0))) {
      m_ipZ0SinThetaSigLeadTrk->Fill(tau.track(0)->z0sinthetaSigTJVA(), weight);
      m_ipSigLeadTrk->Fill(tau.track(0)->d0SigTJVA(), weight);
    }
 
    bool test = tau.detail(xAOD::TauJetParameters::etOverPtLeadTrk, avariable);
    if(test) m_etOverPtLeadTrk->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::massTrkSys, avariable);
    if(test) m_massTrkSys->Fill(avariable/Athena::Units::GeV, weight);
 
    test = tau.detail(xAOD::TauJetParameters::trFlightPathSig, avariable);
    if(test) m_trFlightPathSig->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::isolFrac, avariable);
    if(test) m_isolFrac->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::centFrac, avariable);
    if(test) m_centFrac->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::trkAvgDist, avariable);
    if(test) m_trkAvgDist->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::PSSFraction, avariable);
    if(test) m_PSSFraction->Fill(avariable, weight);
  
    test = tau.detail(xAOD::TauJetParameters::ChPiEMEOverCaloEME, avariable);
    if(test) m_ChPiEMEOverCaloEME->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::EMPOverTrkSysP, avariable);
    if(test) m_EMPOverTrkSysP->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::dRmax, avariable);
    if(test) m_tauDRMax->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::innerTrkAvgDist, avariable);
    if(test) m_innerTrkAvgDist->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::ptRatioEflowApprox, avariable);
    if(test) m_ptRatioEflowApprox->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::mEflowApprox, avariable);
    if(test) m_mEflowApprox->Fill(avariable, weight);
 
 
    double tauSeedPt = tau.ptJetSeed();
    double logTauSeedPt = std::log(tauSeedPt);
    m_logSeedJetPt->Fill(logTauSeedPt, weight);
 
    // tracks
    static const SG::ConstAccessor<float> acc_trackScoreCharged("rnn_chargedScore");
    static const SG::ConstAccessor<float> acc_trackScoreIso("rnn_isolationScore");
    static const SG::ConstAccessor<float> acc_trackScoreConv("rnn_conversionScore");
    static const SG::ConstAccessor<float> acc_z0sinthetaTJVA("z0sinthetaTJVA");
    // rnn_fakeScore may not be available (it is not provided by the TauJets smart slimming list), it can be obtained from unitarity
 
    for(const xAOD::TauTrack* track : tau.allTracks()) {
 
      // protection against thinned tracks
      static const SG::Accessor< xAOD::TauTrack::TrackParticleLinks_t > trackAcc( "trackLinks" );
      if(!trackAcc(*track)[0]) {
    continue;
      }
 
      const xAOD::TrackParticle* trackParticle = track->track();
 
      // old vs new track IPs... initialise to old
      float d0TJVA = track->track()->d0();
      float z0SinthetaTJVA = track->z0sinThetaTJVA(tau);
      float d0SigTJVA = 999.;
      float z0sinthetaSigTJVA = 999.;
      float rConv = 999.;
      float rConvII = 999.;
      if(acc_z0sinthetaTJVA.isAvailable(*track)) {
    d0TJVA = track->d0TJVA();
    z0SinthetaTJVA = track->z0sinthetaTJVA();
    d0SigTJVA = track->d0SigTJVA();
    z0sinthetaSigTJVA = track->z0sinthetaSigTJVA();
    rConv = track->rConv();
    rConvII = track->rConvII();
      }
 
      double dRJetSeedAxis = track->p4().DeltaR(tau.p4(xAOD::TauJetParameters::JetSeed));
      double qOverP = trackParticle->qOverP();
      double trackPt = trackParticle->pt();
 
      uint8_t nInnermostPixelLayerHits = 0;
      trackParticle->summaryValue(nInnermostPixelLayerHits, xAOD::numberOfInnermostPixelLayerHits);
      uint8_t nPixelHits = 0;
      trackParticle->summaryValue(nPixelHits, xAOD::numberOfPixelHits);
      uint8_t nPixelDeadSensors = 0;
      trackParticle->summaryValue(nPixelDeadSensors, xAOD::numberOfPixelDeadSensors);
      uint8_t nSCTHits = 0;
      trackParticle->summaryValue(nSCTHits, xAOD::numberOfSCTHits);
      uint8_t nSCTDeadSensors = 0;
      trackParticle->summaryValue(nSCTDeadSensors, xAOD::numberOfSCTDeadSensors);
      uint8_t nTRTHighThresholdHits = 0;
      trackParticle->summaryValue(nTRTHighThresholdHits, xAOD::numberOfTRTHighThresholdHits);
      uint8_t nTRTHits = 0;
      trackParticle->summaryValue(nTRTHits, xAOD::numberOfTRTHits);
      uint8_t numberOfPixelHoles = 0;
      trackParticle->summaryValue(numberOfPixelHoles, xAOD::numberOfPixelHoles);
      uint8_t numberOfSCTHoles = 0;
      trackParticle->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles);
      float eProbabilityHT = 0.;
      trackParticle->summaryValue(eProbabilityHT, xAOD::eProbabilityHT);
      static const SG::ConstAccessor<float> acc_eProbabilityNN("eProbabilityNN");
      float eProbabilityNN = acc_eProbabilityNN.withDefault(*trackParticle, -1);
      // hybrid variable (eProbabilityNN is not computed for tracks with pt < 2 GeV)
      float eProbabilityHTorNN = (trackPt>2000.) ? eProbabilityNN : eProbabilityHT;
 
      m_track_logPt->Fill(std::log(trackPt), weight);
      m_track_eta->Fill(track->eta(), weight);
      m_track_d0TJVA->Fill(std::tanh(d0TJVA/10.), weight);
      m_track_z0SinthetaTJVA->Fill(z0SinthetaTJVA, weight);
      m_track_d0SigTJVA->Fill(d0SigTJVA, weight);
      m_track_z0sinthetaSigTJVA->Fill(z0sinthetaSigTJVA, weight);
      m_track_charge->Fill(trackParticle->charge(), weight);
      m_track_qOverP->Fill(qOverP*Athena::Units::GeV, weight);
      m_track_logRConv->Fill(std::log(rConv), weight);
      m_track_tanhRConvII->Fill( std::tanh(rConvII/500.0), weight);
      m_track_ptRatioSeedJet->Fill(trackPt/tauSeedPt, weight);
      m_track_dRJetSeedAxis->Fill(dRJetSeedAxis, weight);
      m_track_nInnermostPixHits->Fill(nInnermostPixelLayerHits, weight);
      m_track_nPixHits->Fill(nPixelHits + nPixelDeadSensors, weight);
      m_track_nSiHits->Fill(nPixelHits + nPixelDeadSensors + nSCTHits + nSCTDeadSensors, weight);
      m_track_nTRTHits->Fill(nTRTHits, weight);
      m_track_eProbabilityHT->Fill(eProbabilityHT, weight);
      m_track_eProbabilityNN->Fill(eProbabilityNN, weight);
      m_track_eProbabilityHTorNN->Fill(eProbabilityHTorNN);
 
      if (acc_trackScoreCharged.isAvailable(*track)) {
    float chargedScore = acc_trackScoreCharged(*track);
    float isolationScore = acc_trackScoreIso(*track);
    float conversionScore = acc_trackScoreConv(*track);
    m_track_idScoreCharged->Fill(chargedScore, weight);
    m_track_idScoreIso->Fill(isolationScore, weight);
    m_track_idScoreConv->Fill(conversionScore, weight);
      }
    }
 
 
    // clusters
    std::vector<const xAOD::IParticle*> particleList = tau.clusters();  
    std::vector<xAOD::CaloVertexedTopoCluster> clusters;
    const xAOD::Vertex* vertex = nullptr;
    if(tau.vertexLink().isValid()) vertex = tau.vertex();
 
    for (const xAOD::IParticle* particle : particleList) {
      const xAOD::CaloCluster* cluster = static_cast<const xAOD::CaloCluster*>(particle);
      if (vertex) {
    clusters.emplace_back(*cluster, xAOD::CaloCluster::State::CALIBRATED, vertex->position());
      }
      else {
    clusters.emplace_back(*cluster, xAOD::CaloCluster::State::CALIBRATED);
      }
    }
 
    // sort by decreasing Et
    auto et_cmp = [](const xAOD::CaloVertexedTopoCluster& lhs,
             const xAOD::CaloVertexedTopoCluster& rhs) {
      return lhs.p4().Et() > rhs.p4().Et();
    };
    std::sort(clusters.begin(), clusters.end(), et_cmp);
 
    // keep first 20 leading clusters as in GNTau
    if (clusters.size() > 20) {
      clusters.resize(20, clusters[0]);
    }
 
    double moment;
    for(const auto& vertexedCluster : clusters) {
      m_cluster_logEt->Fill(std::log10(vertexedCluster.p4().Et()), weight);
      m_cluster_eta->Fill(vertexedCluster.eta(), weight);
      m_cluster_phi->Fill(vertexedCluster.phi(), weight);
 
      const xAOD::CaloCluster& cluster = vertexedCluster.clust();
 
      cluster.retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_R, moment);
      m_cluster_secondR->Fill(std::log10(moment + 0.1), weight);
 
      cluster.retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_LAMBDA, moment);
      m_cluster_secondLambda->Fill(std::log10(moment + 0.1), weight);
 
      cluster.retrieveMoment(xAOD::CaloCluster::MomentType::CENTER_LAMBDA, moment);
      m_cluster_centerLambda->Fill(std::log10(moment + 1e-6), weight);
 
      cluster.retrieveMoment(xAOD::CaloCluster::MomentType::FIRST_ENG_DENS, moment);
      if(moment!=0.) moment = std::log10(std::abs(moment));
      m_cluster_firstEngDens->Fill(moment, weight);
 
      cluster.retrieveMoment(xAOD::CaloCluster::MomentType::EM_PROBABILITY, moment);
      m_cluster_EMproba->Fill(moment, weight);
    }
 
    // Et-weighted average of cluster moments (MVA TES)
    test = tau.detail(xAOD::TauJetParameters::ClustersMeanCenterLambda, avariable);
    if(test) m_clustersMeanCenterLambda->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::ClustersMeanFirstEngDens, avariable);
    if(test) m_clustersMeanFirstEngDens->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::ClustersMeanEMProbability, avariable);
    if(test) m_clustersMeanEMProbability->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::ClustersMeanSecondLambda, avariable);
    if(test) m_clustersMeanSecondLambda->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::ClustersMeanPresamplerFrac, avariable);
    if(test) m_clustersMeanPresamplerFrac->Fill(avariable, weight);
 
    test = tau.detail(xAOD::TauJetParameters::PFOEngRelDiff, avariable);
    if(test) m_PFOEngRelDiff->Fill(avariable, weight);
 
    // tau vertex
    if(vertex) {
      m_TVz->Fill(vertex->z(), weight);
    }
  }

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 92 of file PlotBase.h.

{;}

getDirectory()

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

inlineinherited

Definition at line 88 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 Tau::CorePlots::initializePlots ( )

privatevirtual

Reimplemented from PlotBase.

Definition at line 20 of file TauDQA/src/CorePlots.cxx.

                                 {
 
    m_ipZ0SinThetaSigLeadTrk           = Book1D("ipZ0SinThetaSigLeadTrk",m_sTauJetContainerName + "Tau ipZ0SinThetaSigLeadTrk ;ipZ0SinThetaSigLeadTrk ;# of Taus", 50, -10, 10);
    m_etOverPtLeadTrk                  = Book1D("etOverPtLeadTrk",m_sTauJetContainerName + "Tau etOverPtLeadTrk ;etOverPtLeadTrk ;# of Taus", 50, 0, 4.);
    m_ipSigLeadTrk               = Book1D("ipSigLeadTrk",m_sTauJetContainerName + "Tau ipSigLeadTrk ;ipSigLeadTrk ;# of Taus", 50,  -15, 15);
    m_massTrkSys               = Book1D("massTrkSys",m_sTauJetContainerName + "Tau massTrkSys ;massTrkSys ;# of Taus", 40, 0., 2.);
    m_trFlightPathSig                 = Book1D("trFlightPathSig",m_sTauJetContainerName + "Tau trFlightPathSig ;trFlightPathSig ;# of Taus", 100, -5, 30);
    m_isolFrac                           = Book1D("Seed_Calo_isolFrac",m_sTauJetContainerName + "Tau Seed Calo isolFrac ;isolFrac ;# of Taus",    40,  0., 1.);     
    m_centFrac                           = Book1D("Seed_Calo_centFrac",m_sTauJetContainerName + "Tau Seed Calo centFrac ;centFrac ;# of Taus",    40,  0., 1.2);
    m_trkAvgDist                       = Book1D("Seed_Calo_trkavgdist",m_sTauJetContainerName + "Tau Seed Calo trkavgdist ;trkavgdist ;# of Taus",  50, 0., 0.4);
    m_tauDRMax                         = Book1D("DRMax",m_sTauJetContainerName + " Tau DR Max track-seed; DRMax; # Taus",20,0.,0.4);
    m_PSSFraction                      = Book1D("PSSFraction",m_sTauJetContainerName + "Tau PSSFraction; PSSFraction; # of Taus", 30, -15, 15);
    m_ChPiEMEOverCaloEME               = Book1D("ChPiEMEOverCaloEME",m_sTauJetContainerName + "Tau ChPiEMEOverCaloEME; ChPiEMEOverCaloEME; # of Taus", 40, -5, 5);
    m_EMPOverTrkSysP                   = Book1D("EMPOverTrkSysP",m_sTauJetContainerName + "Tau EMPOverTrkSysP; EMPOverTrkSysP; # of Taus", 62, -1, 30);
    m_innerTrkAvgDist                  = Book1D("innerTrkAvgDist",m_sTauJetContainerName + "Tau innerTrkAvgDist; innerTrkAvgDist; # of Taus",40,0.,0.2);
    m_ptRatioEflowApprox               = Book1D("ptRatioEflowApprox",m_sTauJetContainerName + "Tau ptRatioEflowApprox; ptRatioEflowApprox; # of Taus", 40, 0, 3.);
    m_mEflowApprox               = Book1D("mEflowApprox",m_sTauJetContainerName + "Tau mEflowApprox; mEflowApprox; # Taus", 30, 0., 10000.);
 
    // track variables used for track classification and RNN tau ID
    m_logSeedJetPt = Book1D("logSeedJetPt" , "log(ptJetSeed);log(ptJetSeed);Entries",50,10.,14.5);
    m_track_logPt = Book1D("track_logPt" , "track log(p_{T});track log(p_{T});Entries",50,6.,15);
    m_track_eta = Book1D("track_eta" , "track eta;track eta;Entries",50,-2.6,2.6);
    m_track_d0TJVA = Book1D("track_d0TJVA" , "track tanh(d0TJVA);track tanh(d0TJVA);Entries",50,-0.1,0.1);
    m_track_z0SinthetaTJVA = Book1D("track_z0SinthetaTJVA" , "track z0SinthetaTJVA;track z0SinthetaTJVA;Entries",50,-100.,100);
    m_track_d0SigTJVA = Book1D("track_d0SigTJVA" , "track d0SigTJVA;track d0SigTJVA;Entries",50,-10.,10.);
    m_track_z0sinthetaSigTJVA = Book1D("track_z0sinthetaSigTJVA", "track z0sinthetaSigTJVA;track z0sinthetaSigTJVA;Entries",50,-10.,10.);
    m_track_charge = Book1D("track_charge" , "track charge;track charge;Entries",8,-4.,4.);
    m_track_qOverP = Book1D("track_qOverP" , "track qOverP;track qOverP;Entries",50,-2.,2.);
    m_track_logRConv = Book1D("track_logRConv" , "track log(rConv);track log(rConv);Entries",50,0.,7.);
    m_track_tanhRConvII = Book1D("track_tanhRConvII" , "track tanh(rConvII/500);track tanh(rConvII/500);Entries",50,-0.4,0.4);
    m_track_ptRatioSeedJet = Book1D("track_ptRatioSeedJet" , "(track p_{T})/(ptJetSeed);(track p_{T})/(ptJetSeed);Entries",50,0.,0.1);
    m_track_dRJetSeedAxis = Book1D("track_dRJetSeedAxis" , "#DeltaR(tau,track);#DeltaR(tau,track);Entries",50,0.,0.5);
    m_track_nInnermostPixHits = Book1D("track_nInnermostPixHits" , "track nInnermostPixHits;track nInnermostPixHits;Entries",5,0.,5.);
    m_track_nPixHits = Book1D("track_nPixHits" , "track nPixHits;track nPixHits;Entries",10,0.,10.);
    m_track_nSiHits = Book1D("track_nSiHits" , "track nSiHits;track nSiHits;Entries",20,0.,20.);
    m_track_nTRTHits = Book1D("track_nTRTHits" , "track nTRTHits;track nTRTHits;Entries",60,0.,60.);
    m_track_eProbabilityHT = Book1D("track_eProbabilityHT" , "track eProbabilityHT;track eProbabilityHT;Entries",50,0.,1.);    
    m_track_eProbabilityNN = Book1D("track_eProbabilityNN" , "track eProbabilityNN;track eProbabilityNN;Entries",50,0.,1.);    
    m_track_eProbabilityHTorNN = Book1D("track_eProbabilityHTorNN" , "track eProbabilityHTorNN;track eProbabilityHTorNN;Entries",50,0.,1.);    
    m_track_idScoreCharged = Book1D("track_idScoreCharged" , "track RNN idScoreCharged;track idScoreCharged;Entries",50,0.,1.);
    m_track_idScoreIso = Book1D("track_idScoreIso" , "track RNN idScoreIso;track idScoreIso;Entries",50,0.,1.);
    m_track_idScoreConv = Book1D("track_idScoreConv" , "track RNN idScoreConv;track idScoreConv;Entries",50,0.,1.);
 
    // cluster variables used for RNN tau ID
    m_cluster_logEt = Book1D("cluster_logEt" , "log(cluster E_{T});log(cluster E_{T});Entries",50,1.5,6.5);
    m_cluster_eta = Book1D("cluster_eta" , "cluster eta;cluster eta;Entries",50,-2.6,2.6);
    m_cluster_phi = Book1D("cluster_phi" , "cluster phi;cluster phi;Entries",32,-3.2,3.2);
    m_cluster_secondR = Book1D("cluster_secondR" , "cluster SECOND_R;cluster SECOND_R;Entries",50,-1.,6.);
    m_cluster_secondLambda = Book1D("cluster_secondLambda" , "cluster SECOND_LAMBDA;cluster SECOND_LAMBDA;Entries",50,2.,6.5);
    m_cluster_centerLambda = Book1D("cluster_centerLambda" , "cluster CENTER_LAMBDA;cluster CENTER_LAMBDA;Entries",50,1.,4.);
    m_cluster_firstEngDens = Book1D("cluster_firstEngDens" , "cluster FIRST_ENG_DENS;cluster FIRST_ENG_DENS;Entries",50,-6.,1.);
    m_cluster_EMproba = Book1D("cluster_EMproba" , "cluster EM_PROBABILITY;cluster EM_PROBABILITY;Entries",20,0.,1.); 
 
    // Et-weighted average of cluster moments used in MVA TES
    m_clustersMeanCenterLambda = Book1D("clustersMeanCenterLambda" , "clustersMeanCenterLambda;clustersMeanCenterLambda;Entries",40,0.,2500.);
    m_clustersMeanFirstEngDens = Book1D("clustersMeanFirstEngDens" , "clustersMeanFirstEngDens;clustersMeanFirstEngDens;Entries",40,-8.7,-5.5);
    m_clustersMeanEMProbability = Book1D("clustersMeanEMProbability" , "clustersMeanEMProbability;clustersMeanEMProbability;Entries",20,0.,1.);
    m_clustersMeanSecondLambda = Book1D("clustersMeanSecondLambda" , "clustersMeanSecondLambda;clustersMeanSecondLambda;Entries",20,0.,6e5);
    m_clustersMeanPresamplerFrac = Book1D("clustersMeanPresamplerFrac" , "clustersMeanPresamplerFrac;clustersMeanPresamplerFrac;Entries",20,0.,0.2);
    m_PFOEngRelDiff = Book1D("PFOEngRelDiff", "PFOEngRelDiff;PFOEngRelDiff;Entries",20,-1.,1.);
 
    m_TVz = Book1D("tauVertexZ", "tau vertex z:tau vertex z [mmm]",24,-120.,120.);
 }

RegisterSubPlot()

void PlotBase::RegisterSubPlot ( PlotBase * pPlotBase )

inlineinherited

Definition at line 41 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;
}

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

Member Data Documentation

m_centFrac

TH1* Tau::CorePlots::m_centFrac {}

Definition at line 26 of file TauDQA/src/CorePlots.h.

{};

m_ChPiEMEOverCaloEME

TH1* Tau::CorePlots::m_ChPiEMEOverCaloEME {}

Definition at line 31 of file TauDQA/src/CorePlots.h.

{};

m_cluster_centerLambda

TH1* Tau::CorePlots::m_cluster_centerLambda {}

Definition at line 66 of file TauDQA/src/CorePlots.h.

{};

m_cluster_EMproba

TH1* Tau::CorePlots::m_cluster_EMproba {}

Definition at line 68 of file TauDQA/src/CorePlots.h.

{};

m_cluster_eta

TH1* Tau::CorePlots::m_cluster_eta {}

Definition at line 62 of file TauDQA/src/CorePlots.h.

{};

m_cluster_firstEngDens

TH1* Tau::CorePlots::m_cluster_firstEngDens {}

Definition at line 67 of file TauDQA/src/CorePlots.h.

{};

m_cluster_logEt

TH1* Tau::CorePlots::m_cluster_logEt {}

Definition at line 61 of file TauDQA/src/CorePlots.h.

{};

m_cluster_phi

TH1* Tau::CorePlots::m_cluster_phi {}

Definition at line 63 of file TauDQA/src/CorePlots.h.

{};

m_cluster_secondLambda

TH1* Tau::CorePlots::m_cluster_secondLambda {}

Definition at line 65 of file TauDQA/src/CorePlots.h.

{};

m_cluster_secondR

TH1* Tau::CorePlots::m_cluster_secondR {}

Definition at line 64 of file TauDQA/src/CorePlots.h.

{};

m_clustersMeanCenterLambda

TH1* Tau::CorePlots::m_clustersMeanCenterLambda {}

Definition at line 70 of file TauDQA/src/CorePlots.h.

{};

m_clustersMeanEMProbability

TH1* Tau::CorePlots::m_clustersMeanEMProbability {}

Definition at line 72 of file TauDQA/src/CorePlots.h.

{};

m_clustersMeanFirstEngDens

TH1* Tau::CorePlots::m_clustersMeanFirstEngDens {}

Definition at line 71 of file TauDQA/src/CorePlots.h.

{};

m_clustersMeanPresamplerFrac

TH1* Tau::CorePlots::m_clustersMeanPresamplerFrac {}

Definition at line 74 of file TauDQA/src/CorePlots.h.

{};

m_clustersMeanSecondLambda

TH1* Tau::CorePlots::m_clustersMeanSecondLambda {}

Definition at line 73 of file TauDQA/src/CorePlots.h.

{};

m_EMPOverTrkSysP

TH1* Tau::CorePlots::m_EMPOverTrkSysP {}

Definition at line 32 of file TauDQA/src/CorePlots.h.

{};

m_etOverPtLeadTrk

TH1* Tau::CorePlots::m_etOverPtLeadTrk {}

Definition at line 20 of file TauDQA/src/CorePlots.h.

{};

m_iDetailLevel

int PlotBase::m_iDetailLevel

protectedinherited

Definition at line 101 of file PlotBase.h.

m_innerTrkAvgDist

TH1* Tau::CorePlots::m_innerTrkAvgDist {}

Definition at line 33 of file TauDQA/src/CorePlots.h.

{};

m_ipSigLeadTrk

TH1* Tau::CorePlots::m_ipSigLeadTrk {}

Definition at line 21 of file TauDQA/src/CorePlots.h.

{};

m_ipZ0SinThetaSigLeadTrk

TH1* Tau::CorePlots::m_ipZ0SinThetaSigLeadTrk {}

Definition at line 19 of file TauDQA/src/CorePlots.h.

{};

m_isolFrac

TH1* Tau::CorePlots::m_isolFrac {}

Definition at line 25 of file TauDQA/src/CorePlots.h.

{};

m_logSeedJetPt

TH1* Tau::CorePlots::m_logSeedJetPt {}

Definition at line 37 of file TauDQA/src/CorePlots.h.

{};

m_massTrkSys

TH1* Tau::CorePlots::m_massTrkSys {}

Definition at line 22 of file TauDQA/src/CorePlots.h.

{};

m_mEflowApprox

TH1* Tau::CorePlots::m_mEflowApprox {}

Definition at line 35 of file TauDQA/src/CorePlots.h.

{};

m_mEflowTopo

TH1* Tau::CorePlots::m_mEflowTopo {}

Definition at line 28 of file TauDQA/src/CorePlots.h.

{};

m_PFOEngRelDiff

TH1* Tau::CorePlots::m_PFOEngRelDiff {}

Definition at line 75 of file TauDQA/src/CorePlots.h.

{};

m_PSSFraction

TH1* Tau::CorePlots::m_PSSFraction {}

Definition at line 30 of file TauDQA/src/CorePlots.h.

{};

m_ptRatioEflowApprox

TH1* Tau::CorePlots::m_ptRatioEflowApprox {}

Definition at line 34 of file TauDQA/src/CorePlots.h.

{};

m_ptRatioEflowTopo

TH1* Tau::CorePlots::m_ptRatioEflowTopo {}

Definition at line 29 of file TauDQA/src/CorePlots.h.

{};

m_sDirectory

std::string PlotBase::m_sDirectory

protectedinherited

Definition at line 100 of file PlotBase.h.

m_sTauJetContainerName

std::string Tau::CorePlots::m_sTauJetContainerName

private

Definition at line 81 of file TauDQA/src/CorePlots.h.

m_tauDRMax

TH1* Tau::CorePlots::m_tauDRMax {}

Definition at line 24 of file TauDQA/src/CorePlots.h.

{};

m_track_charge

TH1* Tau::CorePlots::m_track_charge {}

Definition at line 44 of file TauDQA/src/CorePlots.h.

{};

m_track_d0SigTJVA

TH1* Tau::CorePlots::m_track_d0SigTJVA {}

Definition at line 42 of file TauDQA/src/CorePlots.h.

{};

m_track_d0TJVA

TH1* Tau::CorePlots::m_track_d0TJVA {}

Definition at line 40 of file TauDQA/src/CorePlots.h.

{};

m_track_dRJetSeedAxis

TH1* Tau::CorePlots::m_track_dRJetSeedAxis {}

Definition at line 49 of file TauDQA/src/CorePlots.h.

{};

m_track_eProbabilityHT

TH1* Tau::CorePlots::m_track_eProbabilityHT {}

Definition at line 54 of file TauDQA/src/CorePlots.h.

{};

m_track_eProbabilityHTorNN

TH1* Tau::CorePlots::m_track_eProbabilityHTorNN {}

Definition at line 56 of file TauDQA/src/CorePlots.h.

{};

m_track_eProbabilityNN

TH1* Tau::CorePlots::m_track_eProbabilityNN {}

Definition at line 55 of file TauDQA/src/CorePlots.h.

{};

m_track_eta

TH1* Tau::CorePlots::m_track_eta {}

Definition at line 39 of file TauDQA/src/CorePlots.h.

{};

m_track_idScoreCharged

TH1* Tau::CorePlots::m_track_idScoreCharged {}

Definition at line 57 of file TauDQA/src/CorePlots.h.

{};

m_track_idScoreConv

TH1* Tau::CorePlots::m_track_idScoreConv {}

Definition at line 59 of file TauDQA/src/CorePlots.h.

{};

m_track_idScoreIso

TH1* Tau::CorePlots::m_track_idScoreIso {}

Definition at line 58 of file TauDQA/src/CorePlots.h.

{};

m_track_logPt

TH1* Tau::CorePlots::m_track_logPt {}

Definition at line 38 of file TauDQA/src/CorePlots.h.

{};

m_track_logRConv

TH1* Tau::CorePlots::m_track_logRConv {}

Definition at line 46 of file TauDQA/src/CorePlots.h.

{};

m_track_nInnermostPixHits

TH1* Tau::CorePlots::m_track_nInnermostPixHits {}

Definition at line 50 of file TauDQA/src/CorePlots.h.

{};

m_track_nPixHits

TH1* Tau::CorePlots::m_track_nPixHits {}

Definition at line 51 of file TauDQA/src/CorePlots.h.

{};

m_track_nSiHits

TH1* Tau::CorePlots::m_track_nSiHits {}

Definition at line 52 of file TauDQA/src/CorePlots.h.

{};

m_track_nTRTHits

TH1* Tau::CorePlots::m_track_nTRTHits {}

Definition at line 53 of file TauDQA/src/CorePlots.h.

{};

m_track_ptRatioSeedJet

TH1* Tau::CorePlots::m_track_ptRatioSeedJet {}

Definition at line 48 of file TauDQA/src/CorePlots.h.

{};

m_track_qOverP

TH1* Tau::CorePlots::m_track_qOverP {}

Definition at line 45 of file TauDQA/src/CorePlots.h.

{};

m_track_tanhRConvII

TH1* Tau::CorePlots::m_track_tanhRConvII {}

Definition at line 47 of file TauDQA/src/CorePlots.h.

{};

m_track_z0sinthetaSigTJVA

TH1* Tau::CorePlots::m_track_z0sinthetaSigTJVA {}

Definition at line 43 of file TauDQA/src/CorePlots.h.

{};

m_track_z0SinthetaTJVA

TH1* Tau::CorePlots::m_track_z0SinthetaTJVA {}

Definition at line 41 of file TauDQA/src/CorePlots.h.

{};

m_trFlightPathSig

TH1* Tau::CorePlots::m_trFlightPathSig {}

Definition at line 23 of file TauDQA/src/CorePlots.h.

{};

m_trkAvgDist

TH1* Tau::CorePlots::m_trkAvgDist {}

Definition at line 27 of file TauDQA/src/CorePlots.h.

{};

m_TVz

TH1* Tau::CorePlots::m_TVz {}

Definition at line 77 of file TauDQA/src/CorePlots.h.

{};

m_vBookedEfficiencies

std::vector<EfficiencyData> PlotBase::m_vBookedEfficiencies

protectedinherited

Definition at line 99 of file PlotBase.h.

m_vBookedHistograms

std::vector<HistData> PlotBase::m_vBookedHistograms

protectedinherited

Definition at line 97 of file PlotBase.h.

m_vBookedTrees

std::vector<TreeData> PlotBase::m_vBookedTrees

protectedinherited

Definition at line 98 of file PlotBase.h.

m_vSubNodes

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

protectedinherited

Definition at line 96 of file PlotBase.h.

---

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

• TauDQA/src/CorePlots.h
• TauDQA/src/CorePlots.cxx