TauAnalysisTools Namespace Reference

Classes
class	BuildTruthTaus
class	BuildTruthTausAlg
class	CommonDiTauEfficiencyTool
class	CommonDiTauSmearingTool
class	CommonEfficiencyTool
class	CommonSmearingTool
class	DiTauEfficiencyCorrectionsTool
class	DiTauSelectionCut
class	DiTauSelectionCutAbsCharge
class	DiTauSelectionCutAbsEta
class	DiTauSelectionCutNSubjets
class	DiTauSelectionCutOmniIDWP
class	DiTauSelectionCutOmniScore
class	DiTauSelectionCutPt
class	DiTauSelectionTool
class	DiTauSmearingTool
class	DiTauTruthMatchingTool
class	IBuildTruthTaus
class	IDiTauEfficiencyCorrectionsTool
class	IDiTauSelectionTool
	Interface for tau selector tool. More...
class	IDiTauSmearingTool
class	IDiTauTruthMatchingTool
class	ITauEfficiencyCorrectionsTool
class	ITauSelectionTool
	Interface for tau selector tool. More...
class	ITauSmearingTool
class	ITauTruthMatchingTool
class	ITauTruthTrackMatchingTool
class	TauAnalysisToolsExampleAthena
class	TauEfficiencyCorrectionsTool
class	TauSelectionCut
class	TauSelectionCutAbsCharge
class	TauSelectionCutAbsEta
class	TauSelectionCutEleIDWP
class	TauSelectionCutGNTauScoreSigTrans
class	TauSelectionCutJetIDWP
class	TauSelectionCutMuonOLR
class	TauSelectionCutNTracks
class	TauSelectionCutPt
class	TauSelectionCutRNNEleScoreSigTrans
class	TauSelectionCutRNNJetScoreSigTrans
class	TauSelectionTool
class	TauSmearingTool
class	TauTruthMatchingTool
class	TauTruthTrackMatchingTool

Enumerations
enum	JetID {   JETIDNONEUNCONFIGURED = 0 , JETIDNONE = 1 , JETIDBDTVERYLOOSE = 2 , JETIDBDTLOOSE = 3 ,   JETIDBDTMEDIUM = 4 , JETIDBDTTIGHT = 5 , JETIDRNNVERYLOOSE = 6 , JETIDRNNLOOSE = 7 ,   JETIDRNNMEDIUM = 8 , JETIDRNNTIGHT = 9 , JETIDGNTAUVERYLOOSE = 10 , JETIDGNTAULOOSE = 11 ,   JETIDGNTAUMEDIUM = 12 , JETIDGNTAUTIGHT = 13 }
enum	OmniID {   OMNIIDNONE = 0 , OMNIIDVERYLOOSE = 1 , OMNIIDLOOSE = 2 , OMNIIDMEDIUM = 3 ,   OMNIIDTIGHT = 4 }
enum	EleID {   ELEIDNONEUNCONFIGURED = 0 , ELEIDNONE = 1 , ELEIDRNNLOOSE = 2 , ELEIDRNNMEDIUM = 3 ,   ELEIDRNNTIGHT = 4 }
enum	SelectionCuts {   NoCut = 0 , CutPt = 1 , CutAbsEta = 1<<1 , CutPhi = 1<<2 ,   CutNTrack = 1<<3 , CutAbsCharge = 1<<4 , CutJetIDWP = 1<<5 , CutEleRNNScoreSigTrans = 1<<6 ,   CutEleIDWP = 1<<7 , CutMuonOLR = 1<<8 , CutJetRNNScoreSigTrans = 1<<9 , CutGNTauScoreSigTrans = 1<<10 }
enum	DiTauSelectionCuts {   NoDiTauCut = 0 , DiTauCutPt = 1 , DiTauCutAbsEta = 1<<1 , DiTauCutNSubjets = 1<<2 ,   DiTauCutAbsCharge = 1<<3 , DiTauCutOmniScore = 1<<4 , DiTauCutOmniIDWP = 1<<5 }
enum	EfficiencyCorrectionType {   SFRecoHadTau = 0 , SFJetIDHadTau = 4 , SFEleIDHadTau = 8 , SFEleIDElectron = 10 ,   SFTriggerHadTau = 12 , SFDecayModeHadTau = 16 }
enum	EfficiencyCorrectionSystematicType { STAT = 1 , SYST = 2 }
enum	TruthMatchedParticleType {   Unknown = 0 , TruthHadronicTau = 1 , TruthLeptonicTau = 2 , TruthMuon = 3 ,   TruthElectron = 4 , TruthJet = 5 , TruthHadronicDiTau = 6 }
enum	TrackType_t {   UnclassifiedTrack = 0 , TauTrack = 1 , ConversionTrack = 2 , UnderlyingEventTrack = 3 ,   SecondaryTrack = 4 , PileupTrack = 5 , FakeTrack = 6 }

Functions
double	TruthLeadPt (const xAOD::DiTauJet &xDiTau)
	return the truth vis pT of the leading pT matched particle.
double	TruthSubleadPt (const xAOD::DiTauJet &xDiTau)
	return the truth vis pT of the subleading pT matched particle.
double	TruthDeltaR (const xAOD::DiTauJet &xDiTau)
	return the dR of between the leading and subleading pT matched particle.
void	split (const std::string &sInput, const char cDelim, std::vector< std::string > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< std::string > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< size_t > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< int > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< unsigned > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< float > &vOut)
void	split (TEnv &rEnv, const std::string &sIn, const char cDelim, std::vector< double > &vOut)
double	tauPt (const xAOD::TauJet &xTau)
	return tau pt in GeV
double	tauP (const xAOD::TauJet &xTau)
	return tau P in GeV
double	tauEta (const xAOD::TauJet &xTau)
	return tau eta
double	tauAbsEta (const xAOD::TauJet &xTau)
	return absolute tau eta
double	finalTauPt (const xAOD::TauJet &xTau)
	return MVA based tau pt in GeV
double	finalTauEta (const xAOD::TauJet &xTau)
	return MVA based tau eta
double	finalTauAbsEta (const xAOD::TauJet &xTau)
	return MVA based absolute tau eta
double	finalTauP (const xAOD::TauJet &xTau)
	return MVA based tau P in GeV
double	tauLeadTrackEta (const xAOD::TauJet &xTau)
	return leading charge tau track eta
double	truthTauPt (const xAOD::TauJet &xTau)
	return truth match tau pt in GeV (if hadronic truth tau match)
double	truthVisTauPt (const xAOD::TauJet &xTau)
	return truth match visible tau pt in GeV (if hadronic truth tau match)
double	truthTauAbsEta (const xAOD::TauJet &xTau)
	return truth match tau eta (if hadronic truth tau match)
double	truthDecayMode (const xAOD::TauJet &xTau)
	return truth decay mode (if hadronic truth tau match)
xAOD::TauJetParameters::DecayMode	getTruthDecayMode (const xAOD::TruthParticle &xTruthTau)
	Get the Truth Decay Mode from TruthTau particle.
xAOD::TauJetParameters::DecayMode	getTruthDecayMode (const xAOD::TauJet &xTau)
	Get the Truth Decay Mode from TruthTau particle.
int	getNTauDecayParticles (const xAOD::TruthParticle &xTruthTau, int iPdgId, bool bCompareAbsoluteValues)
	Count truth matched decay particles of a particular PDGID.
bool	testFileForEOFContainsCharacters (const std::string &sFileName)
	returns true if last line in file is empty or the line starts with the number sign
void	createPi0Vectors (const xAOD::TauJet *xTau, std::vector< TLorentzVector > &vPi0s)
void	correctedPi0Vectors (const xAOD::TauJet *xTau, std::vector< TLorentzVector > &correctedPi0s, TLorentzVector &TauP4)
TruthMatchedParticleType	getTruthParticleType (const xAOD::TauJet &xTau)
	return TauJet match type
TruthMatchedParticleType	getTruthParticleType (const xAOD::DiTauJet &xDiTau)
	return DiTauJet match type
std::vector< const xAOD::TauJet * >	combineTauJetsWithMuonRM (const xAOD::TauJetContainer *taus_std, const xAOD::TauJetContainer *taus_muonRM)
	combine the standard taujets container with the muon removal container

Enumeration Type Documentation

DiTauSelectionCuts

enum TauAnalysisTools::DiTauSelectionCuts

Enumerator
NoDiTauCut
DiTauCutPt
DiTauCutAbsEta
DiTauCutNSubjets
DiTauCutAbsCharge
DiTauCutOmniScore
DiTauCutOmniIDWP

Definition at line 64 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  { 
    NoDiTauCut           = 0,    // 000000000000
    DiTauCutPt           = 1,    // 000000000001
    DiTauCutAbsEta       = 1<<1, // 000000000010
    DiTauCutNSubjets     = 1<<2, // 000000000100
    DiTauCutAbsCharge    = 1<<3, // 000000001000
    DiTauCutOmniScore    = 1<<4, // 000000010000 
    DiTauCutOmniIDWP     = 1<<5, // 000000100000
  };

EfficiencyCorrectionSystematicType

enum TauAnalysisTools::EfficiencyCorrectionSystematicType

Enumerator
STAT
SYST

Definition at line 100 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    STAT = 1,
    SYST = 2
  };

EfficiencyCorrectionType

enum TauAnalysisTools::EfficiencyCorrectionType

Enumerator
SFRecoHadTau
SFJetIDHadTau
SFEleIDHadTau
SFEleIDElectron
SFTriggerHadTau
SFDecayModeHadTau

Definition at line 75 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    SFRecoHadTau     = 0,
    // SFRecoJet        = 1,
    // SFRecoElectron   = 2,
    // SFRecoMuon       = 3,
 
    SFJetIDHadTau    = 4,
    // SFJetIDJet       = 5,
    // SFJetIDElectron  = 6,
    // SFJetIDMuon      = 7,
 
    SFEleIDHadTau    = 8,
    // SFEleIDJet       = 9,
    SFEleIDElectron  = 10,
    // SFEleIDMuon      = 11,
 
    SFTriggerHadTau  = 12,
    // SFEleIDJet       = 13,
    // SFEleIDElectron  = 14,
    // SFEleIDMuon      = 15,
 
    SFDecayModeHadTau = 16,
  };

EleID

enum TauAnalysisTools::EleID

Enumerator
ELEIDNONEUNCONFIGURED
ELEIDNONE
ELEIDRNNLOOSE
ELEIDRNNMEDIUM
ELEIDRNNTIGHT

Definition at line 38 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    ELEIDNONEUNCONFIGURED = 0,
    ELEIDNONE         = 1,
    ELEIDRNNLOOSE     = 2,
    ELEIDRNNMEDIUM    = 3,
    ELEIDRNNTIGHT     = 4,
  };

JetID

enum TauAnalysisTools::JetID

Enumerator
JETIDNONEUNCONFIGURED
JETIDNONE
JETIDBDTVERYLOOSE
JETIDBDTLOOSE
JETIDBDTMEDIUM
JETIDBDTTIGHT
JETIDRNNVERYLOOSE
JETIDRNNLOOSE
JETIDRNNMEDIUM
JETIDRNNTIGHT
JETIDGNTAUVERYLOOSE
JETIDGNTAULOOSE
JETIDGNTAUMEDIUM
JETIDGNTAUTIGHT

Definition at line 11 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    JETIDNONEUNCONFIGURED  = 0,
    JETIDNONE              = 1,
    JETIDBDTVERYLOOSE      = 2,
    JETIDBDTLOOSE          = 3,
    JETIDBDTMEDIUM         = 4,
    JETIDBDTTIGHT          = 5,
    JETIDRNNVERYLOOSE      = 6,
    JETIDRNNLOOSE          = 7,
    JETIDRNNMEDIUM         = 8,
    JETIDRNNTIGHT          = 9,
    JETIDGNTAUVERYLOOSE    = 10,
    JETIDGNTAULOOSE        = 11,
    JETIDGNTAUMEDIUM       = 12,
    JETIDGNTAUTIGHT        = 13,
  };

OmniID

enum TauAnalysisTools::OmniID

Enumerator
OMNIIDNONE
OMNIIDVERYLOOSE
OMNIIDLOOSE
OMNIIDMEDIUM
OMNIIDTIGHT

Definition at line 29 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    OMNIIDNONE              = 0,
    OMNIIDVERYLOOSE         = 1,
    OMNIIDLOOSE             = 2,
    OMNIIDMEDIUM            = 3,
    OMNIIDTIGHT             = 4,
  };

SelectionCuts

enum TauAnalysisTools::SelectionCuts

Enumerator
NoCut
CutPt
CutAbsEta
CutPhi
CutNTrack
CutAbsCharge
CutJetIDWP
CutEleRNNScoreSigTrans
CutEleIDWP
CutMuonOLR
CutJetRNNScoreSigTrans
CutGNTauScoreSigTrans

Definition at line 47 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    // FIXME: harmonise names for RNN score cuts: "CutEleRNNScore" vs "CutJetRNNScoreSigTrans"
    NoCut           = 0,    // 000000000000
    CutPt           = 1,    // 000000000001
    CutAbsEta       = 1<<1, // 000000000010
    CutPhi          = 1<<2, // 000000000100
    CutNTrack       = 1<<3, // 000000001000
    CutAbsCharge    = 1<<4, // 000000010000
    CutJetIDWP      = 1<<5, // 000000100000
    CutEleRNNScoreSigTrans  = 1<<6, // 000001000000
    CutEleIDWP              = 1<<7, // 000010000000
    CutMuonOLR              = 1<<8,        // 000100000000
    CutJetRNNScoreSigTrans  = 1<<9, // 001000000000
    CutGNTauScoreSigTrans   = 1<<10 // 010000000000        
  };

TrackType_t

enum TauAnalysisTools::TrackType_t

Enumerator
UnclassifiedTrack
TauTrack
ConversionTrack
UnderlyingEventTrack
SecondaryTrack
PileupTrack
FakeTrack

Definition at line 27 of file TauTruthTrackMatchingTool.h.

{
  UnclassifiedTrack     = 0, // Track is unclassified
  TauTrack              = 1, // Track is from direct tau decay
  ConversionTrack       = 2, // Track is from conversion
  UnderlyingEventTrack  = 3, // Track is from underlying event
  SecondaryTrack        = 4, // Track is a secondary track
  PileupTrack           = 5, // Track is from pileup
  FakeTrack             = 6  // Track is a fake
};

TruthMatchedParticleType

enum TauAnalysisTools::TruthMatchedParticleType

Enumerator
Unknown
TruthHadronicTau
TruthLeptonicTau
TruthMuon
TruthElectron
TruthJet
TruthHadronicDiTau

Definition at line 106 of file PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h.

  {
    Unknown          = 0,
    TruthHadronicTau = 1,
    TruthLeptonicTau = 2,
    TruthMuon        = 3,
    TruthElectron    = 4,
    TruthJet         = 5,
    TruthHadronicDiTau = 6
  };

Function Documentation

combineTauJetsWithMuonRM()

std::vector< const xAOD::TauJet * > TauAnalysisTools::combineTauJetsWithMuonRM	(	const xAOD::TauJetContainer *	taus_std,
		const xAOD::TauJetContainer *	taus_muonRM )

combine the standard taujets container with the muon removal container

Special function to combine the muon-removed taus with the standard taus. This can impact your MET calculation and OLR. You will know if you need this, otherwise please consult TauCP group.

Definition at line 537 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

                                                                                                                                                  {
  // std::string message = "found " + std::to_string(taus_muonRM->size()) + " muon-removal taus";
  // Info("TauAnalysisTools::getTauJetsWithMuonRM", message.c_str());
  std::vector<const xAOD::TauJet*> taus_murm_vec(taus_muonRM->begin(), taus_muonRM->end());
  std::vector<const xAOD::TauJet*> taus_combined;
  static const SG::ConstAccessor<ElementLink<xAOD::TauJetContainer> >
    originalTauJetAcc ("originalTauJet");
  for(const xAOD::TauJet* tau_std : *taus_std){
    auto replacement_itr = std::find_if(taus_murm_vec.begin(), taus_murm_vec.end(), 
      [&](const xAOD::TauJet* tau_murm){
        auto link_to_ori_tau = originalTauJetAcc (*tau_murm);
        if (!link_to_ori_tau.isValid()) { return false; }
        if (*link_to_ori_tau == tau_std){ return true;  }
        return false;
      }
    );
    if (replacement_itr == taus_murm_vec.end()) { taus_combined.push_back(tau_std); }
    else { 
      // message = "replacement found at TauJets_MuonRM index " + std::to_string((*replacement_itr)->index()) + " for TauJets index " +  std::to_string(tau_std->index());
      // Info("TauAnalysisTools::getTauJetsWithMuonRM", message.c_str());
      taus_combined.push_back(*replacement_itr); 
      taus_murm_vec.erase(replacement_itr);
      // message = std::to_string(taus_murm_vec.size()) + " muon-removal taus left";
      // Info("TauAnalysisTools::getTauJetsWithMuonRM", message.c_str());
    }
  }
  // Every muon-removal tau should have been used, otherwise there is a problem.
  assert(taus_murm_vec.empty());
  return taus_combined;
}

correctedPi0Vectors()

void TauAnalysisTools::correctedPi0Vectors	(	const xAOD::TauJet *	xTau,
		std::vector< TLorentzVector > &	correctedPi0s,
		TLorentzVector &	TauP4 )

Definition at line 374 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

                                                                                                                                 {
  //reset the pi0s
  correctedPi0s.clear();
 
  int iDecayMode = -1;  
 
  if (!(xTau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, iDecayMode)))
  {
    Error("TauAnalysisTools::correctedPi0Vectors", "Failed to retrieve panTauDetail decay mode.");
    return;
  }
 
  //Reading in the pi0 vector from createPi0Vectors
  std::vector<TLorentzVector> vPi0s;
  createPi0Vectors(xTau,vPi0s);
 
  if(iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1p1n || iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1pXn || iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_3pXn){  
    //Adding up Pi0 P4s from createPi0Vectors
    TLorentzVector Sum_vPi0s;
    for(unsigned int i = 0; i < vPi0s.size() ; i++){
      Sum_vPi0s += vPi0s[i];
    }
    
    //Get sum of the chargedPFO (i.e. tau track) p4
    TLorentzVector Sum_ChrgPFOP4;
    for(const xAOD::TauTrack* track : xTau->tracks()) {
      Sum_ChrgPFOP4 += track->p4();
    }
    
    //Get tau FinalCalib P4 (explicitly requiring p4(xAOD::TauJetParameters::TauCalibType::FinalCalib) should be superfluous, as FinalCalib is the default p4)
    TLorentzVector FinalCalibP4 = xTau->p4();
    
    //Calculate the difference 3-vector between FinalCalib and Sum of chargedPFOP4
    double px = FinalCalibP4.Px() - Sum_ChrgPFOP4.Px();
    double py = FinalCalibP4.Py() - Sum_ChrgPFOP4.Py();
    double pz = FinalCalibP4.Pz() - Sum_ChrgPFOP4.Pz();
 
    double p_correctedPi0s = std::sqrt( std::pow(px,2.) + std::pow(py,2.) + std::pow(pz,2.) );
    double p_vPi0s = Sum_vPi0s.P();
 
    //Calucate scale factor for the pi0 3-vector momentum
    double X = p_correctedPi0s/p_vPi0s;
 
    //Scale the pi0s with X and recalculate the new pi0 energy
    double px_scaled, py_scaled, pz_scaled, e;
    double mPi0 = ParticleConstants::piZeroMassInMeV;
    for(unsigned int i = 0; i < vPi0s.size() ; i++){
      px_scaled = vPi0s[i].Px() * X;
      py_scaled = vPi0s[i].Py() * X;
      pz_scaled = vPi0s[i].Pz() * X;
      e = std::sqrt( std::pow(px_scaled,2.) + std::pow(py_scaled,2.) + std::pow(pz_scaled,2.) + std::pow(mPi0,2.) );
 
      //Append the corrected pi0P4 to correctedPi0s
      TLorentzVector P4_correctedPi0s;
      P4_correctedPi0s.SetPxPyPzE(px_scaled,py_scaled,pz_scaled,e);
      correctedPi0s.push_back(P4_correctedPi0s);
    }
  }else{
    correctedPi0s = vPi0s;
  }
 
  //Correct angles between pi0s for 1pXn decays with 1 cluster
  if(iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1pXn && xTau->nPi0PFOs() == 1){
 
    //Get Function of Delta R between the two Pi0s
    TF1 DeltaRdist("DeltaRdist", "pol3", 0, 67500);
    DeltaRdist.SetParameter(0, 0.07924);
    DeltaRdist.SetParameter(1, -2.078/1000000.);
    DeltaRdist.SetParameter(2,  2.619/100000000000.);
    DeltaRdist.SetParameter(3, -1.238/10000000000000000.);
  
    //Get Sum of pi0 P4.Pt()
    TLorentzVector SumPi0_P4;
    for( unsigned int i = 0 ; i < correctedPi0s.size() ; i++){
      SumPi0_P4 += correctedPi0s[i];
    }
 
    float SumPi0_pt = SumPi0_P4.Pt();
 
    //Get delta R value (mean of true DeltaR distribution)
    float deltaR;
    if(SumPi0_pt >= 67500){
      deltaR = 0.020; // = DeltaRdist.Eval(67500);
    } else{
      deltaR = DeltaRdist.Eval(SumPi0_pt);
    }
 
    TLorentzVector correctedPi0_0, correctedPi0_1;
    correctedPi0_0.SetPtEtaPhiM( correctedPi0s[0].Pt()/cos(0.5*deltaR/std::sqrt(2.0)), correctedPi0s[0].Eta()+0.5*deltaR/std::sqrt(2.0), correctedPi0s[0].Phi()+0.5*deltaR/std::sqrt(2.0), correctedPi0s[0].M() );
    correctedPi0_1.SetPtEtaPhiM( correctedPi0s[1].Pt()/cos(0.5*deltaR/std::sqrt(2.0)), correctedPi0s[1].Eta()-0.5*deltaR/std::sqrt(2.0), correctedPi0s[1].Phi()-0.5*deltaR/std::sqrt(2.0), correctedPi0s[1].M() );
 
    std::vector<TLorentzVector> AngleCorrectedPi0s;
    AngleCorrectedPi0s.push_back(correctedPi0_0);
    AngleCorrectedPi0s.push_back(correctedPi0_1);
 
    //Reparametrise: Delta R -> mass of pi0 Cluster
    TLorentzVector PionCluster_angleCorrected = AngleCorrectedPi0s[0]+AngleCorrectedPi0s[1];
    
    double dNewMomentum = std::sqrt(PionCluster_angleCorrected.E()/2. * PionCluster_angleCorrected.E()/2. - PionCluster_angleCorrected.M() / 2. * PionCluster_angleCorrected.M() / 2.);
    correctedPi0s[0].SetVectM(PionCluster_angleCorrected.Vect() * (dNewMomentum / PionCluster_angleCorrected.P()), PionCluster_angleCorrected.M() / 2.);
    correctedPi0s[1] = correctedPi0s[0];
  }
 
  //Calculate the new tau P4
  for(const xAOD::TauTrack* track : xTau->tracks()) {
    TauP4 += track->p4();
  }
 
  for(unsigned int iPi0=0; iPi0 < correctedPi0s.size(); iPi0++) {
    TauP4 += correctedPi0s[iPi0];
  }
 
}

createPi0Vectors()

void TauAnalysisTools::createPi0Vectors	(	const xAOD::TauJet *	xTau,
		std::vector< TLorentzVector > &	vPi0s )

Definition at line 312 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // reset the pi0s
  vPi0s.clear();
 
  // Since the PFO links as they come out of reconstruction, only correspond to
  // calorimeter clusters, whereas we want the consts_pi0 vectors to correspond
  // to real pi0s, we need to be careful to collect the PFOs correctly to pi0s
  // for the cases where number of pi0s does not match to the decay mode:
  size_t iNumPi0PFO = xTau->nPi0PFOs();
 
  int iDecayMode = -1;
 
  if (!(xTau->panTauDetail(xAOD::TauJetParameters::PanTauDetails::PanTau_DecayMode, iDecayMode)))
  {
    Error("TauAnalysisTools::createPi0Vectors", "Failed to retrieve panTauDetail decay mode.");
    return;
  }
 
  if (iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1p1n && iNumPi0PFO > 1)
  {
    // float fMassPi0 = ParticleConstants::piZeroMassInMeV;
    float fMassPi0Squared = ParticleConstants::piZeroMassInMeV*ParticleConstants::piZeroMassInMeV;
 
    // combine both photons (with 0 mass from Pantau) to one pi0 vector:
    const xAOD::PFO* xPfo1 = xTau->pi0PFO(0);
    const xAOD::PFO* xPfo2 = xTau->pi0PFO(1);
    vPi0s.push_back(xPfo1->p4() + xPfo2->p4());
 
    // re-set the mass to one pi0:
    double dNewMomentum = std::sqrt(vPi0s[0].E() * vPi0s[0].E() - fMassPi0Squared);
    vPi0s[0].SetPxPyPzE(vPi0s[0].Vect().Unit().Px() * dNewMomentum,
                        vPi0s[0].Vect().Unit().Py() * dNewMomentum,
                        vPi0s[0].Vect().Unit().Pz() * dNewMomentum,
                        vPi0s[0].E());
  }
  else if (iDecayMode == xAOD::TauJetParameters::DecayMode::Mode_1pXn && iNumPi0PFO == 1)
  {
    // make a single pi0 from a PFO that contains two pi0s:
    const xAOD::PFO* xPfo = xTau->pi0PFO(0);
    // add the 2-pi0 vector preliminarily to the pi0vector:
    vPi0s.push_back(xPfo->p4());
 
    // re-set the mass back to one pi0:
    double dNewMomentum = std::sqrt(vPi0s[0].E() / 2 * vPi0s[0].E() / 2 - vPi0s[0].M() / 2. * vPi0s[0].M() / 2.);
    vPi0s[0].SetVectM(vPi0s[0].Vect() * (dNewMomentum / vPi0s[0].P()), vPi0s[0].M() / 2.);
 
    // create another pi0 from the same vector:
    vPi0s.push_back(vPi0s[0]);
  }
  else
  {
    // if it's not any of the special cases above then just collect the PFOs:
    for (size_t iPFO = 0; iPFO < iNumPi0PFO; iPFO++)
    {
      vPi0s.push_back(xTau->pi0PFO(iPFO)->p4());
    }
  }
}

finalTauAbsEta()

double TauAnalysisTools::finalTauAbsEta

(

const xAOD::TauJet &

xTau

)

return MVA based absolute tau eta

Definition at line 127 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return MVA based absolute tau eta
  return std::abs(xTau.etaFinalCalib());
}

finalTauEta()

double TauAnalysisTools::finalTauEta

(

const xAOD::TauJet &

xTau

)

return MVA based tau eta

Definition at line 120 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return MVA based tau eta
  return xTau.etaFinalCalib();
}

finalTauP()

double TauAnalysisTools::finalTauP

(

const xAOD::TauJet &

xTau

)

return MVA based tau P in GeV

Definition at line 134 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return tau P in GeV
  return xTau.p4(xAOD::TauJetParameters::FinalCalib).P()/GeV;
}

finalTauPt()

double TauAnalysisTools::finalTauPt

(

const xAOD::TauJet &

xTau

)

return MVA based tau pt in GeV

Definition at line 113 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return MVA based tau pt in GeV
  return xTau.ptFinalCalib()/GeV;
}

getNTauDecayParticles()

int TauAnalysisTools::getNTauDecayParticles	(	const xAOD::TruthParticle &	xTruthTau,
		int	iPdgId,
		bool	bCompareAbsoluteValues )

Count truth matched decay particles of a particular PDGID.

Parameters

xTruthTau	TruthTau
iPdgId	PDGID to count over
bCompareAbsoluteValues	true to ignore pdgid charge

Returns

int

Definition at line 252 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  int iNum = 0;
  static const SG::ConstAccessor<std::vector<int> > accDecayModeVector("DecayModeVector");
  if (!accDecayModeVector.isAvailable(xTruthTau))
  {
    Warning("TauAnalysisTools::getNTauDecayParticles", "passed truth particle is not a truth tau, return 0");
    return 0;
  }
 
  for(auto iPdgId2 : accDecayModeVector(xTruthTau))
    if (!bCompareAbsoluteValues)
    {
      if (iPdgId2 == iPdgId) iNum++;
    }
    else
    {
      if (std::abs(iPdgId2) == std::abs(iPdgId)) iNum++;
    }
  return iNum;
}

getTruthDecayMode() [1/2]

xAOD::TauJetParameters::DecayMode TauAnalysisTools::getTruthDecayMode

(

const xAOD::TauJet &

xTau

)

Get the Truth Decay Mode from TruthTau particle.

check hadronic truth match and get getTruthDecayMode from truth particle

Definition at line 207 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  const xAOD::TruthParticle* xTruthTau = xAOD::TauHelpers::getTruthParticle(&xTau);
 
  static const SG::ConstAccessor<char> accIsHadronicTau ("IsHadronicTau");
  if (xTruthTau!=nullptr && accIsHadronicTau(*xTruthTau))
    return getTruthDecayMode(*xTruthTau);
  else
    return xAOD::TauJetParameters::Mode_Error;
}

getTruthDecayMode() [2/2]

xAOD::TauJetParameters::DecayMode TauAnalysisTools::getTruthDecayMode

(

const xAOD::TruthParticle &

xTruthTau

)

Get the Truth Decay Mode from TruthTau particle.

Counts p0 and charged Kaons and pions

Parameters

xTruthTau

TruthParticle

Returns

xAOD::TauJetParameters::DecayMode

Note

Method returns Mode_Error if TruthParticle is not decorated as hadronic TruthTau

Definition at line 219 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  static const SG::ConstAccessor<size_t> accNumCharged ("numCharged");
  if (!(accNumCharged.isAvailable(xTruthTau)))
  {
    // passed truth particle is not a truth tau
    return xAOD::TauJetParameters::Mode_Error;
  }
 
  int iCharged = getNTauDecayParticles(xTruthTau,MC::PIPLUS, true) + getNTauDecayParticles(xTruthTau,MC::KPLUS, true);
  int iNeutral = getNTauDecayParticles(xTruthTau,MC::PI0, true);
  if (iCharged == 1)
  {
    if (iNeutral == 0) return xAOD::TauJetParameters::DecayMode::Mode_1p0n;
    if (iNeutral == 1) return xAOD::TauJetParameters::DecayMode::Mode_1p1n;
    if (iNeutral >= 2) return xAOD::TauJetParameters::DecayMode::Mode_1pXn;
  }
  else if (iCharged == 3)
  {
    if (iNeutral == 0) return xAOD::TauJetParameters::DecayMode::Mode_3p0n;
    if (iNeutral >= 1) return xAOD::TauJetParameters::DecayMode::Mode_3pXn;
  }
 
  if (iCharged == 2 or iCharged == 4 or iCharged == 5)
    return xAOD::TauJetParameters::DecayMode::Mode_Other;
  if (iCharged == 0 or iCharged >=6)
    return xAOD::TauJetParameters::DecayMode::Mode_NotSet;
 
  // if you got here, something should have gone wrong
  return xAOD::TauJetParameters::DecayMode::Mode_Error;
}

getTruthParticleType() [1/2]

TruthMatchedParticleType TauAnalysisTools::getTruthParticleType

(

const xAOD::DiTauJet &

xDiTau

)

return DiTauJet match type

Definition at line 523 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  static const SG::ConstAccessor<char> accIsTruthHadronic("IsTruthHadronic");
  if (!accIsTruthHadronic.isAvailable(xDiTau))
    Error("TauAnalysisTools::getTruthParticleType", "No truth match information available. Please run DiTauTruthMatchingTool first");
 
  TruthMatchedParticleType eTruthMatchedParticleType = Unknown;
 
  if (accIsTruthHadronic(xDiTau))
    eTruthMatchedParticleType = TruthHadronicDiTau;
 
  return eTruthMatchedParticleType;
}

getTruthParticleType() [2/2]

TruthMatchedParticleType TauAnalysisTools::getTruthParticleType

(

const xAOD::TauJet &

xTau

)

return TauJet match type

Definition at line 489 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  typedef ElementLink< xAOD::TruthParticleContainer > Link_t;
  static const SG::ConstAccessor< Link_t > accTruthParticleLink("truthParticleLink");
  if (!accTruthParticleLink.isAvailable(xTau))
    Error("TauAnalysisTools::getTruthParticleType", "No truth match information available. Please run TauTruthMatchingTool first.");
 
  const xAOD::TruthParticle* xTruthParticle = xAOD::TauHelpers::getTruthParticle(&xTau);
  if (xTruthParticle)
  {
    if (xTruthParticle->isTau())
      {
      static const SG::ConstAccessor<char> accIsHadronicTau("IsHadronicTau");
      if (static_cast<bool>(accIsHadronicTau(*xTruthParticle)))
        return TruthHadronicTau;
      else
        return TruthLeptonicTau;
    }
    if (xTruthParticle->isMuon())
      return TruthMuon;
    if (xTruthParticle->isElectron())
      return TruthElectron;
  }
  
  // TODO: use const xAOD::Jet* xTruthJet = xAOD::TauHelpers::getLink<xAOD::Jet>(&xTau, "truthJetLink");
  // currently it is unavailable as templated class is not in icc file
  static const SG::ConstAccessor< ElementLink< xAOD::JetContainer > > accTruthJetLink("truthJetLink");
  const ElementLink< xAOD::JetContainer > lTruthParticleLink = accTruthJetLink(xTau);
  if (lTruthParticleLink.isValid())
    return TruthJet;
 
  return Unknown;
}

split() [1/7]

void TauAnalysisTools::split	(	const std::string &	sInput,
		const char	cDelim,
		std::vector< std::string > &	vOut )

Definition at line 23 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(sInput);
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(sItem);
}

split() [2/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< double > &	vOut )

Definition at line 77 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(stod(sItem));
}

split() [3/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< float > &	vOut )

Definition at line 68 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(stof(sItem));
}

split() [4/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< int > &	vOut )

Definition at line 50 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(stoi(sItem));
}

split() [5/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< size_t > &	vOut )

Definition at line 41 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(size_t(stoi(sItem)));
}

split() [6/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< std::string > &	vOut )

Definition at line 32 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(sItem);
}

split() [7/7]

void TauAnalysisTools::split	(	TEnv &	rEnv,
		const std::string &	sIn,
		const char	cDelim,
		std::vector< unsigned > &	vOut )

Definition at line 59 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  std::stringstream sSS(rEnv.GetValue(sKey.c_str(),""));
  std::string sItem;
  while (std::getline(sSS, sItem, cDelim))
    vOut.push_back(stoi(sItem));
}

tauAbsEta()

double TauAnalysisTools::tauAbsEta

(

const xAOD::TauJet &

xTau

)

return absolute tau eta

Definition at line 106 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return absolute tau eta
  return std::abs(xTau.eta());
}

tauEta()

double TauAnalysisTools::tauEta

(

const xAOD::TauJet &

xTau

)

return tau eta

Definition at line 99 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return tau eta
  return xTau.eta();
}

tauLeadTrackEta()

double TauAnalysisTools::tauLeadTrackEta

(

const xAOD::TauJet &

xTau

)

return leading charge tau track eta

Definition at line 141 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return leading charge tau track eta
  double dTrackEta = 0.;
  double dTrackMaxPt = 0.;
  for( unsigned int iNumTrack = 0; iNumTrack < xTau.nTracks(); iNumTrack++)
  {
    if (xTau.track(iNumTrack)->pt() > dTrackMaxPt)
    {
      dTrackMaxPt = xTau.track(iNumTrack)->pt();
      dTrackEta = xTau.track(iNumTrack)->eta();
    }
  }
  return dTrackEta;
}

tauP()

double TauAnalysisTools::tauP

(

const xAOD::TauJet &

xTau

)

return tau P in GeV

Definition at line 92 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return tau P in GeV
  return xTau.p4().P()/1000.;
}

tauPt()

double TauAnalysisTools::tauPt

(

const xAOD::TauJet &

xTau

)

return tau pt in GeV

Definition at line 85 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return tau pt in GeV
  return xTau.pt()/1000.;
}

testFileForEOFContainsCharacters()

bool TauAnalysisTools::testFileForEOFContainsCharacters

(

const std::string &

sFileName

)

returns true if last line in file is empty or the line starts with the number sign

Definition at line 275 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // returns true if last line in file is empty or the line starts with the
  // number sign #
 
  std::ifstream fInputFile;
  fInputFile.open(sFileName);
  if(!fInputFile.is_open())
    return true;
 
  fInputFile.seekg(-1,fInputFile.end);
 
  bool bKeepLooping = true;
  while(bKeepLooping)
  {
    char ch;
    fInputFile.get(ch);
 
    if(static_cast<int>(fInputFile.tellg()) <= 1)
    {
      fInputFile.seekg(0);
      bKeepLooping = false;
    }
    else if(ch == '\n')
      bKeepLooping = false;
    else
      fInputFile.seekg(-2,fInputFile.cur);
  }
 
  std::string sLastLine;
  getline(fInputFile,sLastLine);
  fInputFile.close();
 
  return (sLastLine.size() == 0 or sLastLine[0] == '#');
}

truthDecayMode()

double TauAnalysisTools::truthDecayMode

(

const xAOD::TauJet &

xTau

)

return truth decay mode (if hadronic truth tau match)

Definition at line 199 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return truth tau decay mode.
  int iDecayMode = getTruthDecayMode(xTau);
  return static_cast<double>(iDecayMode);
}

TruthDeltaR()

double TauAnalysisTools::TruthDeltaR

(

const xAOD::DiTauJet &

xDiTau

)

return the dR of between the leading and subleading pT matched particle.

Definition at line 336 of file CommonDiTauEfficiencyTool.cxx.

{
  // return truth taus distance delta R
  static const SG::ConstAccessor< float > acc( "TruthVisDeltaR" );
  return acc( xDiTau );
}

TruthLeadPt()

double TauAnalysisTools::TruthLeadPt

(

const xAOD::DiTauJet &

xDiTau

)

return the truth vis pT of the leading pT matched particle.

Definition at line 320 of file CommonDiTauEfficiencyTool.cxx.

{
  // return leading truth tau pt in GeV
  static const SG::ConstAccessor< float > acc( "TruthVisLeadPt" );
  return acc( xDiTau ) * 0.001;
}

TruthSubleadPt()

double TauAnalysisTools::TruthSubleadPt

(

const xAOD::DiTauJet &

xDiTau

)

return the truth vis pT of the subleading pT matched particle.

Definition at line 328 of file CommonDiTauEfficiencyTool.cxx.

{
  // return subleading truth tau pt in GeV
  static const SG::ConstAccessor< float > acc( "TruthVisSubleadPt" );
  return acc( xDiTau ) * 0.001;
}

truthTauAbsEta()

double TauAnalysisTools::truthTauAbsEta

(

const xAOD::TauJet &

xTau

)

return truth match tau eta (if hadronic truth tau match)

Definition at line 185 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return truth tau absolute eta
  const xAOD::TruthParticle* xTruthTau = xAOD::TauHelpers::getTruthParticle(&xTau);
 
  // if there is a truth tau return absolute eta, otherwise return -5 (getTruth will print an error)
  static const SG::ConstAccessor<char> accIsHadronicTau ("IsHadronicTau");
  if (xTruthTau!=nullptr && accIsHadronicTau (*xTruthTau))
    return std::abs(xTruthTau->eta());
  else
    return -5.;
}

truthTauPt()

double TauAnalysisTools::truthTauPt

(

const xAOD::TauJet &

xTau

)

return truth match tau pt in GeV (if hadronic truth tau match)

Definition at line 158 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return truth tau Pt in GeV
  const xAOD::TruthParticle* xTruthTau = xAOD::TauHelpers::getTruthParticle(&xTau);
 
  // if there is a truth tau return pT, otherwise return 0 (getTruth will print an error)
  static const SG::ConstAccessor<char> accIsHadronicTau ("IsHadronicTau");
  if (xTruthTau!=nullptr && accIsHadronicTau (*xTruthTau))
    return xTruthTau->pt()/GeV;
  else
    return 0.;
}

truthVisTauPt()

double TauAnalysisTools::truthVisTauPt

(

const xAOD::TauJet &

xTau

)

return truth match visible tau pt in GeV (if hadronic truth tau match)

Definition at line 171 of file PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx.

{
  // return truth visible tau Pt in GeV
  const xAOD::TruthParticle* xTruthTau = xAOD::TauHelpers::getTruthParticle(&xTau);
 
  // if there is a truth tau return visible pT, otherwise return 0 (getTruth will print an error)
  static const SG::ConstAccessor<char> accIsHadronicTau ("IsHadronicTau");
  static const SG::ConstAccessor<double> accPtVis("pt_vis");
  if (xTruthTau!=nullptr && accIsHadronicTau (*xTruthTau))
    return (accPtVis(*xTruthTau)/GeV);
  else
    return 0.; 
}