TrigTauPrecisionIDHypoTool Class Reference

Precision step hypothesis tool for applying ID cuts (standard chains) More...

#include <TrigTauPrecisionIDHypoTool.h>

Inheritance diagram for TrigTauPrecisionIDHypoTool:

Collaboration diagram for TrigTauPrecisionIDHypoTool:

Public Member Functions
	TrigTauPrecisionIDHypoTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	decide (std::vector< ITrigTauJetHypoTool::ToolInfo > &input) const override
virtual bool	decide (const ITrigTauJetHypoTool::ToolInfo &i) const override

Private Types
enum	IDMethod { Disabled = 0 , RNN = 1 , Decorator = 2 }
enum	IDWP { None = 0 , Standard = 1 , HighPt = 2 }

Private Attributes
HLT::Identifier	m_decisionId
Gaudi::Property< float >	m_ptMin {this, "PtMin", 0, "Tau pT minimum cut"}
Gaudi::Property< int >	m_numTrackMin {this, "NTracksMin", 0, "Minimum number of tracks"}
Gaudi::Property< int >	m_numTrackMax {this, "NTracksMax", 5, "Maximum number of tracks"}
Gaudi::Property< int >	m_numIsoTrackMax {this, "NIsoTracksMax", 999, "Maximum number of isolation tracks"}
Gaudi::Property< float >	m_trackPtCut {this, "TrackPtCut", -1, "Only count tracks above this pT threshold (override the 1 GeV cut in the InDetTrackSelectorTool)"}
Gaudi::Property< int >	m_idMethod {this, "IDMethod", IDMethod::Disabled, "ID WP evaluation method (0: Disabled, 1: RNN, 2: Decorator)"}
Gaudi::Property< std::string >	m_idWP {this, "IDWP", "", "Minimum ID Working Point decorated flag (e.g. 'GNTau_Medium', or 'medium' for built-in RNN WPs)"}
Gaudi::Property< float >	m_highPtTrkThr {this, "HighPtSelectionTrkThr", 200000, "Tau pT threshold for disabling the NTrackMin and NIsoTrackMax cuts" }
Gaudi::Property< float >	m_highPtIdThr {this, "HighPtSelectionIDThr", 280000, "Tau pT threshold for switching to the high-pT ID WP cut"}
Gaudi::Property< std::string >	m_highPtIdWP {this, "HighPtIDWP", "", "High pT ID Working Point (e.g. 'GNTau_Loose', or 'loose' for built-in RNN WPs)"}
Gaudi::Property< float >	m_highPtJetThr {this, "HighPtSelectionJetThr", 440000, "Tau pT threshold for disabling IDWP and NTrackMax cuts"}
Gaudi::Property< bool >	m_acceptAll {this, "AcceptAll", false, "Ignore selection"}
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
Gaudi::Property< std::map< std::string, std::pair< std::string, std::string > > >	m_monitoredIdScores {this, "MonitoredIDScores", {}, "Pairs of the TauID score and signal-transformed scores for each TauID algorithm to be monitored"}
std::map< std::string, std::pair< SG::ConstAccessor< float >, SG::ConstAccessor< float > > >	m_monitoredIdAccessors
SG::ConstAccessor< char >	m_id_wp_acc {"none"}
SG::ConstAccessor< char >	m_highpt_id_wp_acc {"none"}
unsigned int	m_rnn_id_wp = 0
unsigned int	m_rnn_highpt_id_wp = 0

Detailed Description

Precision step hypothesis tool for applying ID cuts (standard chains)

Definition at line 23 of file TrigTauPrecisionIDHypoTool.h.

Member Enumeration Documentation

IDMethod

enum TrigTauPrecisionIDHypoTool::IDMethod

private

Enumerator
Disabled
RNN
Decorator

Definition at line 33 of file TrigTauPrecisionIDHypoTool.h.

                  {
        Disabled = 0,
        RNN = 1,
        Decorator = 2
    };

IDWP

enum TrigTauPrecisionIDHypoTool::IDWP

private

Enumerator
None
Standard
HighPt

Definition at line 39 of file TrigTauPrecisionIDHypoTool.h.

              {
        None = 0,
        Standard = 1,
        HighPt = 2
    };

Constructor & Destructor Documentation

TrigTauPrecisionIDHypoTool()

TrigTauPrecisionIDHypoTool::TrigTauPrecisionIDHypoTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 15 of file TrigTauPrecisionIDHypoTool.cxx.

  : base_class(type, name, parent), 
    m_decisionId(HLT::Identifier::fromToolName(name))
{
 
}

Member Function Documentation

decide() [1/2]

bool TrigTauPrecisionIDHypoTool::decide ( const ITrigTauJetHypoTool::ToolInfo & i ) const

overridevirtual

Definition at line 104 of file TrigTauPrecisionIDHypoTool.cxx.

{
    ATH_MSG_DEBUG(name() << ": in execute()");
 
    auto NInputTaus         = Monitored::Scalar<int>("NInputTaus", -1);
    auto passedCuts         = Monitored::Scalar<int>("CutCounter", 0);
    auto PtAccepted         = Monitored::Scalar<float>("PtAccepted", -1);
    auto NTracksAccepted    = Monitored::Scalar<int>("NTracksAccepted", -1);
    auto NIsoTracksAccepted = Monitored::Scalar<int>("NIsoTracksAccepted", -1);
 
    std::map<std::string, Monitored::Scalar<float>> monitoredIdVariables;
    for(const auto& [key, p] : m_monitoredIdScores) {
        monitoredIdVariables.emplace(key + "_TauJetScoreAccepted_0p", Monitored::Scalar<float>(key + "_TauJetScoreAccepted_0p", -1));
        monitoredIdVariables.emplace(key + "_TauJetScoreTransAccepted_0p", Monitored::Scalar<float>(key + "_TauJetScoreTransAccepted_0p", -1));
        monitoredIdVariables.emplace(key + "_TauJetScoreAccepted_1p", Monitored::Scalar<float>(key + "_TauJetScoreAccepted_1p", -1));
        monitoredIdVariables.emplace(key + "_TauJetScoreTransAccepted_1p", Monitored::Scalar<float>(key + "_TauJetScoreTransAccepted_1p", -1));
        monitoredIdVariables.emplace(key + "_TauJetScoreAccepted_mp", Monitored::Scalar<float>(key + "_TauJetScoreAccepted_mp", -1));
        monitoredIdVariables.emplace(key + "_TauJetScoreTransAccepted_mp", Monitored::Scalar<float>(key + "_TauJetScoreTransAccepted_mp", -1));
    }
 
    std::vector<std::reference_wrapper<Monitored::IMonitoredVariable>> monVars = {
        std::ref(NInputTaus), std::ref(passedCuts), std::ref(PtAccepted), std::ref(NTracksAccepted), std::ref(NIsoTracksAccepted)
    };
    for(auto& [key, var] : monitoredIdVariables) monVars.push_back(std::ref(var));
    auto monitorIt = Monitored::Group(m_monTool, monVars);
 
 
    // Tau pass flag
    bool pass = false;
 
    if(m_acceptAll) {
        pass = true;
        ATH_MSG_DEBUG("AcceptAll property is set: taking all events");
    }
 
    // Debugging location of the TauJet RoI
    ATH_MSG_DEBUG("Input RoI eta: " << input.roi->eta() << ", phi: " << input.roi->phi() << ", z: " << input.roi->zed());
 
    const xAOD::TauJetContainer* TauContainer = input.tauContainer;
    NInputTaus = TauContainer->size();
    // There should only be a single TauJet in the TauJetContainer; just in case we still run the loop
    for(const xAOD::TauJet* Tau : *TauContainer) {
        ATH_MSG_DEBUG(" New HLT TauJet candidate:");
        
        float pT = Tau->pt();
        
        //---------------------------------------------------------
        // Calibrated tau pT cut ('idperf' step)
        //---------------------------------------------------------
        ATH_MSG_DEBUG(" pT: " << pT / Gaudi::Units::GeV);
 
        if(!(pT > m_ptMin)) continue;
        passedCuts++;
        PtAccepted = pT / Gaudi::Units::GeV;
 
 
        //---------------------------------------------------------
        // Track counting ('perf' step)
        //---------------------------------------------------------
        int numTrack = 0, numIsoTrack = 0;
        if(m_trackPtCut > 0) {
            // Raise the track pT threshold when counting tracks in the 'perf' step, to reduce sensitivity to pileup tracks
            // Overrides the default 1 GeV cut by the InDetTrackSelectorTool used during the TauJet construction
            for(const auto* track : Tau->tracks(xAOD::TauJetParameters::TauTrackFlag::classifiedCharged)) {
                if(track->pt() > m_trackPtCut) numTrack++;
            }
            for(const auto* track : Tau->tracks(xAOD::TauJetParameters::TauTrackFlag::classifiedIsolation)) {
                if(track->pt() > m_trackPtCut) numIsoTrack++;
            }
        } else {
            // Use the default 1 GeV selection in the InDetTrackSelectorTool, executed during the TauJet construction
            numTrack = Tau->nTracks();
            numIsoTrack = Tau->nTracksIsolation();
        }
 
        ATH_MSG_DEBUG(" N Tracks: " << numTrack);
        ATH_MSG_DEBUG(" N Iso Tracks: " << numIsoTrack);
 
        // Apply track multiplicity cuts, except for idperf
        if(!m_acceptAll) {
            // NTrackMin and NIsoTracksMax
            if(pT < m_highPtTrkThr) {
                if(numTrack < m_numTrackMin) continue;
                if(numIsoTrack > m_numIsoTrackMax) continue;
            }
            // NTrackMax
            if(pT < m_highPtJetThr) {
                if(numTrack > m_numTrackMax) continue;
            }
        }
        // Note: we disabled the track selection for high pT taus
 
        passedCuts++;
        NTracksAccepted = numTrack;
        NIsoTracksAccepted = numIsoTrack;  
 
 
        //---------------------------------------------------------
        // ID WP selection (ID step)
        //---------------------------------------------------------
        int local_id_wp = IDWP::Standard;
        if(pT > m_highPtIdThr) local_id_wp = IDWP::HighPt; // Set ID to HighPt WP
        if(pT > m_highPtJetThr) local_id_wp = IDWP::None; // Disable the ID WP cut
 
        if(!m_acceptAll && m_idMethod != IDMethod::Disabled && local_id_wp != IDWP::None) {
            if(m_idMethod == IDMethod::Decorator) { // Decorated scores (e.g. for GNTau)
                if(local_id_wp == IDWP::Standard) {
                    if(!m_id_wp_acc.isAvailable(*Tau)) ATH_MSG_ERROR("The TauID '" << m_idWP << "' variable is not available!");
                    if(!m_id_wp_acc(*Tau)) continue;
                } else if(local_id_wp == IDWP::HighPt) {
                    if(!m_highpt_id_wp_acc.isAvailable(*Tau)) ATH_MSG_ERROR("The HighPt TauID '" << m_highPtIdWP << "' variable is not available!");
                    if(!m_highpt_id_wp_acc(*Tau)) continue;
                }
 
            } else if(m_idMethod == IDMethod::RNN) { // Legacy RNN/DeepSet scores
                if(!Tau->hasDiscriminant(xAOD::TauJetParameters::RNNJetScoreSigTrans)) {
                    ATH_MSG_ERROR(" RNNJetScoreSigTrans not available. Make sure the TauWPDecorator is run for the RNN Tau ID!");
                }
                
                if(local_id_wp == IDWP::Standard && !Tau->isTau(static_cast<xAOD::TauJetParameters::IsTauFlag>(m_rnn_id_wp))) continue;
                else if(local_id_wp == IDWP::HighPt && !Tau->isTau(static_cast<xAOD::TauJetParameters::IsTauFlag>(m_rnn_highpt_id_wp))) continue;
            }
        }
 
        // TauID Score monitoring
        for(const auto& [key, p] : m_monitoredIdAccessors) {
            if(!p.first.isAvailable(*Tau))
                ATH_MSG_WARNING("TauID Score " << m_monitoredIdScores.value().at(key).first << " is not available. Make sure the correct inferences are included in the chain reconstruction sequence!");
 
            if(!p.second.isAvailable(*Tau))
                ATH_MSG_WARNING("TauID ScoreSigTrans " << m_monitoredIdScores.value().at(key).second << " is not available. Make sure the correct inferences are included in the chain reconstruction sequence!");
 
            ATH_MSG_DEBUG(" TauID \"" << key << "\" ScoreSigTrans: " << p.second(*Tau));
 
            // Monitor ID scores
            if(Tau->nTracks() == 0) {
                monitoredIdVariables.at(key + "_TauJetScoreAccepted_0p") = p.first(*Tau);
                monitoredIdVariables.at(key + "_TauJetScoreTransAccepted_0p") = p.second(*Tau);
            } else if(Tau->nTracks() == 1) {
                monitoredIdVariables.at(key + "_TauJetScoreAccepted_1p") = p.first(*Tau);
                monitoredIdVariables.at(key + "_TauJetScoreTransAccepted_1p") = p.second(*Tau);
            } else { // MP tau
                monitoredIdVariables.at(key + "_TauJetScoreAccepted_mp") = p.first(*Tau);
                monitoredIdVariables.at(key + "_TauJetScoreTransAccepted_mp") = p.second(*Tau);
            }
        }
 
        passedCuts++;
 
        
        //---------------------------------------------------------
        // At least one Tau passed all the cuts. Accept the event!
        //---------------------------------------------------------
        pass = true;
 
        ATH_MSG_DEBUG(" Pass hypo tool: " << pass);
    }
  
    return pass;
}

decide() [2/2]

StatusCode TrigTauPrecisionIDHypoTool::decide ( std::vector< ITrigTauJetHypoTool::ToolInfo > & input ) const

overridevirtual

Definition at line 266 of file TrigTauPrecisionIDHypoTool.cxx.

                                                                                                 {
    for(ITrigTauJetHypoTool::ToolInfo& i : input) {
        if(passed(m_decisionId.numeric(), i.previousDecisionIDs)) {
            if(decide(i)) {
                addDecisionID(m_decisionId, i.decision);
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode TrigTauPrecisionIDHypoTool::initialize ( )

overridevirtual

Definition at line 23 of file TrigTauPrecisionIDHypoTool.cxx.

{
    ATH_MSG_DEBUG(name() << ": in initialize()");
 
    ATH_MSG_DEBUG("TrigTauPrecisionIDHypoTool will cut on:");
    ATH_MSG_DEBUG(" - PtMin: " << m_ptMin.value());
    ATH_MSG_DEBUG(" - NTracksMin: " << m_numTrackMin.value());
    ATH_MSG_DEBUG(" - NTracksMax: " << m_numTrackMax.value());
    ATH_MSG_DEBUG(" - NIsoTracksMax: " << m_numIsoTrackMax.value());
    if(m_trackPtCut >= 0) ATH_MSG_DEBUG(" - trackPtCut: " << m_trackPtCut.value());
    ATH_MSG_DEBUG(" - IDMethod: " << m_idMethod.value());
    ATH_MSG_DEBUG(" - IDWP: " << m_idWP.value());
    ATH_MSG_DEBUG(" - HighPtSelectionTrkThr: " << m_highPtTrkThr.value());
    ATH_MSG_DEBUG(" - HighPtSelectionIDThr: " << m_highPtIdThr.value());
    ATH_MSG_DEBUG(" - HighPtIDWP: " << m_highPtIdWP.value());
    ATH_MSG_DEBUG(" - HighPtSelectionJetThr: " << m_highPtJetThr.value());
 
    if((m_numTrackMin > m_numTrackMax) || (m_highPtIdThr > m_highPtJetThr)) {
        ATH_MSG_ERROR("Invalid tool configuration!");
        return StatusCode::FAILURE;
    }
 
    if(!(m_idMethod == IDMethod::Disabled || m_idMethod == IDMethod::RNN || m_idMethod == IDMethod::Decorator)) {
        ATH_MSG_ERROR("Invalid IDMethod value, " << m_idMethod.value());
        return StatusCode::FAILURE;
    } else if(m_idMethod == IDMethod::Disabled && (!m_idWP.empty() || !m_highPtIdWP.empty())) {
        ATH_MSG_ERROR("Must not set IDWP or HighPtIDWP if using IDMethod=0");
        return StatusCode::FAILURE;
    } else if(m_idMethod != IDMethod::Disabled) {
        if(m_idWP.empty()) {
            ATH_MSG_ERROR("Must provide an ID WP");
            return StatusCode::FAILURE;
        }
        
        // Fallback to default ID WP
        if(m_highPtIdWP.empty()) m_highPtIdWP = m_idWP;
 
        // Initialize WP accessors
        m_id_wp_acc = SG::ConstAccessor<char>(m_idWP);
        m_highpt_id_wp_acc = SG::ConstAccessor<char>(m_highPtIdWP);
    }
 
    // Parse RNN ID WPs
    if(m_idMethod == IDMethod::RNN) {
        if(m_idWP == "veryloose") m_rnn_id_wp = xAOD::TauJetParameters::JetRNNSigVeryLoose;
        else if(m_idWP == "loose") m_rnn_id_wp = xAOD::TauJetParameters::JetRNNSigLoose;
        else if(m_idWP == "medium") m_rnn_id_wp = xAOD::TauJetParameters::JetRNNSigMedium;
        else if(m_idWP == "tight") m_rnn_id_wp = xAOD::TauJetParameters::JetRNNSigTight;
        else {
            ATH_MSG_ERROR("Invalid RNN ID WP: " << m_idWP.value());
            return StatusCode::FAILURE;
        }
 
        if(m_highPtIdWP == "veryloose") m_rnn_highpt_id_wp = xAOD::TauJetParameters::JetRNNSigVeryLoose;
        else if(m_highPtIdWP == "loose") m_rnn_highpt_id_wp = xAOD::TauJetParameters::JetRNNSigLoose;
        else if(m_highPtIdWP == "medium") m_rnn_highpt_id_wp = xAOD::TauJetParameters::JetRNNSigMedium;
        else if(m_highPtIdWP == "tight") m_rnn_highpt_id_wp = xAOD::TauJetParameters::JetRNNSigTight;
        else {
            ATH_MSG_ERROR("Invalid High-pT RNN ID WP: " << m_highPtIdWP.value());
            return StatusCode::FAILURE;
        }
    }
 
    // Now create the "cache" of TauID score accessors for the Monitoring...
    ATH_MSG_DEBUG("TauID score monitoring: ");
    for(const auto& [key, p] : m_monitoredIdScores) {
        ATH_MSG_DEBUG("   - IDName: " << key);
        ATH_MSG_DEBUG("      - IDScoreName: " << p.first);
        ATH_MSG_DEBUG("      - IDScoreSigTransName: " << p.second);
        if(p.first.empty() || p.second.empty()) {
            ATH_MSG_ERROR("Invalid score variable names; skipping this entry for the monitoring!");
            continue;
        }
 
        m_monitoredIdAccessors.emplace(key, std::make_pair(SG::ConstAccessor<float>(p.first), SG::ConstAccessor<float>(p.second)));
    }
 
    return StatusCode::SUCCESS;
}

Member Data Documentation

m_acceptAll

Gaudi::Property<bool> TrigTauPrecisionIDHypoTool::m_acceptAll {this, "AcceptAll", false, "Ignore selection"}

private

Definition at line 63 of file TrigTauPrecisionIDHypoTool.h.

{this, "AcceptAll", false, "Ignore selection"};

m_decisionId

HLT::Identifier TrigTauPrecisionIDHypoTool::m_decisionId

private

Definition at line 45 of file TrigTauPrecisionIDHypoTool.h.

m_highpt_id_wp_acc

SG::ConstAccessor<char> TrigTauPrecisionIDHypoTool::m_highpt_id_wp_acc {"none"}

private

Definition at line 71 of file TrigTauPrecisionIDHypoTool.h.

{"none"};

m_highPtIdThr

Gaudi::Property<float> TrigTauPrecisionIDHypoTool::m_highPtIdThr {this, "HighPtSelectionIDThr", 280000, "Tau pT threshold for switching to the high-pT ID WP cut"}

private

Definition at line 59 of file TrigTauPrecisionIDHypoTool.h.

{this, "HighPtSelectionIDThr", 280000, "Tau pT threshold for switching to the high-pT ID WP cut"};

m_highPtIdWP

Gaudi::Property<std::string> TrigTauPrecisionIDHypoTool::m_highPtIdWP {this, "HighPtIDWP", "", "High pT ID Working Point (e.g. 'GNTau_Loose', or 'loose' for built-in RNN WPs)"}

private

Definition at line 60 of file TrigTauPrecisionIDHypoTool.h.

{this, "HighPtIDWP", "", "High pT ID Working Point (e.g. 'GNTau_Loose', or 'loose' for built-in RNN WPs)"};

m_highPtJetThr

Gaudi::Property<float> TrigTauPrecisionIDHypoTool::m_highPtJetThr {this, "HighPtSelectionJetThr", 440000, "Tau pT threshold for disabling IDWP and NTrackMax cuts"}

private

Definition at line 61 of file TrigTauPrecisionIDHypoTool.h.

{this, "HighPtSelectionJetThr", 440000, "Tau pT threshold for disabling IDWP and NTrackMax cuts"};

m_highPtTrkThr

Gaudi::Property<float> TrigTauPrecisionIDHypoTool::m_highPtTrkThr {this, "HighPtSelectionTrkThr", 200000, "Tau pT threshold for disabling the NTrackMin and NIsoTrackMax cuts" }

private

Definition at line 58 of file TrigTauPrecisionIDHypoTool.h.

{this, "HighPtSelectionTrkThr", 200000, "Tau pT threshold for disabling the NTrackMin and NIsoTrackMax cuts" };

m_id_wp_acc

SG::ConstAccessor<char> TrigTauPrecisionIDHypoTool::m_id_wp_acc {"none"}

private

Definition at line 70 of file TrigTauPrecisionIDHypoTool.h.

{"none"};

m_idMethod

Gaudi::Property<int> TrigTauPrecisionIDHypoTool::m_idMethod {this, "IDMethod", IDMethod::Disabled, "ID WP evaluation method (0: Disabled, 1: RNN, 2: Decorator)"}

private

Definition at line 54 of file TrigTauPrecisionIDHypoTool.h.

{this, "IDMethod", IDMethod::Disabled, "ID WP evaluation method (0: Disabled, 1: RNN, 2: Decorator)"};

m_idWP

Gaudi::Property<std::string> TrigTauPrecisionIDHypoTool::m_idWP {this, "IDWP", "", "Minimum ID Working Point decorated flag (e.g. 'GNTau_Medium', or 'medium' for built-in RNN WPs)"}

private

Definition at line 55 of file TrigTauPrecisionIDHypoTool.h.

{this, "IDWP", "", "Minimum ID Working Point decorated flag (e.g. 'GNTau_Medium', or 'medium' for built-in RNN WPs)"};

m_monitoredIdAccessors

std::map<std::string, std::pair<SG::ConstAccessor<float>, SG::ConstAccessor<float> > > TrigTauPrecisionIDHypoTool::m_monitoredIdAccessors

private

Definition at line 67 of file TrigTauPrecisionIDHypoTool.h.

m_monitoredIdScores

Gaudi::Property<std::map<std::string, std::pair<std::string, std::string> > > TrigTauPrecisionIDHypoTool::m_monitoredIdScores {this, "MonitoredIDScores", {}, "Pairs of the TauID score and signal-transformed scores for each TauID algorithm to be monitored"}

private

Definition at line 66 of file TrigTauPrecisionIDHypoTool.h.

{this, "MonitoredIDScores", {}, "Pairs of the TauID score and signal-transformed scores for each TauID algorithm to be monitored"};

m_monTool

ToolHandle<GenericMonitoringTool> TrigTauPrecisionIDHypoTool::m_monTool {this, "MonTool", "", "Monitoring tool"}

private

Definition at line 65 of file TrigTauPrecisionIDHypoTool.h.

{this, "MonTool", "", "Monitoring tool"};

m_numIsoTrackMax

Gaudi::Property<int> TrigTauPrecisionIDHypoTool::m_numIsoTrackMax {this, "NIsoTracksMax", 999, "Maximum number of isolation tracks"}

private

Definition at line 51 of file TrigTauPrecisionIDHypoTool.h.

{this, "NIsoTracksMax", 999, "Maximum number of isolation tracks"};

m_numTrackMax

Gaudi::Property<int> TrigTauPrecisionIDHypoTool::m_numTrackMax {this, "NTracksMax", 5, "Maximum number of tracks"}

private

Definition at line 50 of file TrigTauPrecisionIDHypoTool.h.

{this, "NTracksMax", 5, "Maximum number of tracks"};

m_numTrackMin

Gaudi::Property<int> TrigTauPrecisionIDHypoTool::m_numTrackMin {this, "NTracksMin", 0, "Minimum number of tracks"}

private

Definition at line 49 of file TrigTauPrecisionIDHypoTool.h.

{this, "NTracksMin", 0, "Minimum number of tracks"};

m_ptMin

Gaudi::Property<float> TrigTauPrecisionIDHypoTool::m_ptMin {this, "PtMin", 0, "Tau pT minimum cut"}

private

Definition at line 47 of file TrigTauPrecisionIDHypoTool.h.

{this, "PtMin", 0, "Tau pT minimum cut"};

m_rnn_highpt_id_wp

unsigned int TrigTauPrecisionIDHypoTool::m_rnn_highpt_id_wp = 0

private

Definition at line 75 of file TrigTauPrecisionIDHypoTool.h.

m_rnn_id_wp

unsigned int TrigTauPrecisionIDHypoTool::m_rnn_id_wp = 0

private

Definition at line 74 of file TrigTauPrecisionIDHypoTool.h.

m_trackPtCut

Gaudi::Property<float> TrigTauPrecisionIDHypoTool::m_trackPtCut {this, "TrackPtCut", -1, "Only count tracks above this pT threshold (override the 1 GeV cut in the InDetTrackSelectorTool)"}

private

Definition at line 52 of file TrigTauPrecisionIDHypoTool.h.

{this, "TrackPtCut", -1, "Only count tracks above this pT threshold (override the 1 GeV cut in the InDetTrackSelectorTool)"};

---

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

• TrigTauPrecisionIDHypoTool.h
• TrigTauPrecisionIDHypoTool.cxx