python.TauAnalysisConfig.TauWorkingPointSelectionConfig Class Reference

Inheritance diagram for python.TauAnalysisConfig.TauWorkingPointSelectionConfig:

Collaboration diagram for python.TauAnalysisConfig.TauWorkingPointSelectionConfig:

Public Member Functions
	__init__ (self)
	instanceName (self)
	makeAlgs (self, config)

Public Attributes
	useSelectionConfigFile
	useLowPt
	useGNTau
	dropPtCut
	use_eVeto
	use_muonOLR
	containerName
	selectionName

Detailed Description

the ConfigBlock for the tau working point selection

Definition at line 169 of file TauAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.__init__

(

self

)

Definition at line 172 of file TauAnalysisConfig.py.

    def __init__ (self) :
        super().__init__()
        self.setBlockName('TauWorkingPointSelection')
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the input container.",
            meta={'role':'containerRef'})
        self.addOption ('selectionName', '', type=str,
            noneAction='error',
            info="the name of the tau-jet selection to define (e.g. `tight` or "
            "`loose`).",
            meta={'role':'selection'})
        self.addOption ('postfix', None, type=str,
            info="a postfix to apply to decorations and algorithm names. "
            "Typically not needed here as selectionName is used internally.")
        self.addOption ('quality', None, type=str,
            info="the ID WP to use. Supported ID WPs: `Tight`, `Medium`, "
            "`Loose`, `VeryLoose`, `Baseline`, `BaselineForFakes`.",
            meta={'choices':(['Tight','Medium','Loose','VeryLoose','Baseline','BaselineForFakes'],1)})
        self.addOption ('use_eVeto', False, type=bool,
            info="use selection with or without eVeto combined with TauID. "
            "Recommendations: set it to `True` if electrons mis-reconstructed as tau-jets are a large background for your analysis.")
        self.addOption ('use_muonOLR', False, type=bool,
            info="use selection with or without muonOLR with TauID. "
            "Recommendations: set it to `True` if muons mis-reconstructed as tau-jets are a large background for your analysis.")
        self.addOption ('useGNTau', False, type=bool,
            info="use GNTau-based ID instead of RNNTau ID. "
            "Recommendations: experimental feature and might become default soon.",
            expertMode=True)
        self.addOption ('dropPtCut', False, type=bool,
            info=r"select tau-jets without an explicit minimum $p_\mathrm{T}$ cut. For PHYS/PHYSLITE, this would mean selecting tau-jets starting from 13 GeV. "
            "Recommendations: experimental feature and not supported for all combinations of ID/eVeto WPs.",
            expertMode=True)
        self.addOption ('useLowPt', False, type=bool, 
            info="select taus starting from 15 GeV instead of the default 20 GeV cut "
            "recommendations: experimental feature and not supported for all combinations of ID/eVeto WPs.",
            expertMode=True)
        self.addOption ('useSelectionConfigFile', True, type=bool,
            info="use pre-defined configuration files for selecting tau-jets. "
            "Recommendations: set this to `False` only if you want to test/optimise the tau-jet selection for selections not already provided through config files.")
        self.addOption ('manual_sel_minpt', 20.0, type=float,
            info=r"minimum $p_\mathrm{T}$ cut (in GeV) used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_absetaregion', [0, 1.37, 1.52, 2.5], type=list,
            info=r"$\vert\eta\vert$ regions cut used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_abscharges', [1,], type=list,
            info="charge of the tau-jet cut used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_ntracks', [1,3], type=list,
            info="number of tau-jet tracks used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_minrnnscore', -1, type=float,
            info="minimum RNN score cut used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_mingntauscore', -1, type=float,
            info="minimum GNTau score selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_rnnwp', None, type=str,
            info="RNN working point used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_gntauwp', None, type=str,
            info="GNTau working point used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_evetowp', None, type=str, 
            info="eveto working point used for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('manual_sel_muonolr', False, type=bool,
            info="use `muonolr` for tau-jet selection when `useSelectionConfigFile` is set to `False`.")
        self.addOption ('addSelectionToPreselection', True, type=bool,
            info="whether to retain only tau-jets satisfying the working point "
            "requirements.")
 

Member Function Documentation

instanceName()

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 236 of file TauAnalysisConfig.py.

    def instanceName (self) :
        """Return the instance name for this block"""
        if self.postfix is not None:
            return self.containerName + '_' + self.selectionName + self.postfix
        else:
            return self.containerName + '_' + self.selectionName
 

makeAlgs()

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.makeAlgs	(		self,
			config )

Definition at line 243 of file TauAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        selectionPostfix = self.selectionName
        if selectionPostfix != '' and selectionPostfix[0] != '_' :
            selectionPostfix = '_' + selectionPostfix
 
        postfix = self.postfix
        if postfix is None :
            postfix = self.selectionName
        if postfix != '' and postfix[0] != '_' :
            postfix = '_' + postfix
 
        # do tau seletion through external txt config file
        if self.useSelectionConfigFile:
            if self.dropPtCut and self.useLowPt:
                raise ValueError ("dropPtCut and useLowPt cannot both be set")
            if self.dropPtCut and not self.useGNTau:
                raise ValueError ("dropPtCut is only supported together with useGNTau")
            nameFormat = 'TauAnalysisAlgorithms/tau_selection_'
            if self.dropPtCut:
                nameFormat = nameFormat + 'nopt_'
            if self.useLowPt:
                nameFormat = nameFormat + 'lowpt_'
            if self.useGNTau:
                nameFormat = nameFormat + 'gntau_'
            nameFormat = nameFormat + '{}_'
            if self.use_eVeto:
                nameFormat = nameFormat + 'eleid'
            else:
                nameFormat = nameFormat + 'noeleid'
            if self.use_muonOLR:
                nameFormat = nameFormat + '_muonolr' 
            nameFormat = nameFormat + '.conf'    
 
            if self.quality not in ['Tight', 'Medium', 'Loose', 'VeryLoose', 'Baseline', 'BaselineForFakes'] :
                raise ValueError (f"invalid tau quality: \"{self.quality}\", allowed values are Tight, Medium, Loose, "
                                  "VeryLoose, Baseline, BaselineForFakes")
 
        # Set up the algorithm selecting taus:
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'TauSelectionAlg' )
        config.addPrivateTool( 'selectionTool', 'TauAnalysisTools::TauSelectionTool' )
        alg.selectionTool.TauContainerName = config.readName (self.containerName, nominal=True)
        if self.useSelectionConfigFile:
            inputfile = nameFormat.format(self.quality.lower())
            alg.selectionTool.ConfigPath = inputfile
        else:
            #build selection from user handmade selection
            from ROOT import TauAnalysisTools
            selectioncuts = TauAnalysisTools.SelectionCuts
            alg.selectionTool.ConfigPath = ""
            alg.selectionTool.SelectionCuts = int(selectioncuts.CutPt | 
                                                  selectioncuts.CutAbsEta | 
                                                  selectioncuts.CutAbsCharge | 
                                                  selectioncuts.CutNTrack | 
                                                  selectioncuts.CutJetRNNScoreSigTrans |
                                                  selectioncuts.CutGNTauScoreSigTrans |
                                                  selectioncuts.CutJetIDWP |
                                                  selectioncuts.CutEleIDWP |
                                                  selectioncuts.CutMuonOLR)
 
            alg.selectionTool.PtMin = self.manual_sel_minpt
            alg.selectionTool.AbsEtaRegion = self.manual_sel_absetaregion
            alg.selectionTool.AbsCharges = self.manual_sel_abscharges
            alg.selectionTool.NTracks = self.manual_sel_ntracks 
            alg.selectionTool.JetRNNSigTransMin = self.manual_sel_minrnnscore 
            alg.selectionTool.GNTauSigTransMin = self.manual_sel_mingntauscore
            #cross-check that min rnn score and min gntau score are not both set at the same time
            if self.manual_sel_minrnnscore != -1 and self.manual_sel_mingntauscore != -1:
               raise RuntimeError("manual_sel_minrnnscore and manual_sel_mingntauscore have been both set; please choose only one type of ID: RNN or GNTau, not both") 
            # cross-check that RNN and GNTau WPs are not set at the same time
            if self.manual_sel_rnnwp is not None and self.manual_sel_gntauwp is not None:
                raise RuntimeError("manual_sel_rnnwp and manual_sel_gntauwp have been both set; please choose only one type of ID: RNN or GNTau, not both")
            # working point following the Enums from https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h
            alg.selectionTool.JetIDWP = 1
            if self.manual_sel_rnnwp is not None:
                if self.manual_sel_rnnwp not in _MANUAL_RNN_JETIDWP:
                    raise ValueError (f"invalid RNN TauID WP: \"{self.manual_sel_rnnwp}\". Allowed values are None, veryloose, loose, medium, tight")
                alg.selectionTool.JetIDWP = _MANUAL_RNN_JETIDWP[self.manual_sel_rnnwp]
 
            # cross-check that min rnn score and RNN WPs are not set at the same time
            if self.manual_sel_minrnnscore != -1 and self.manual_sel_rnnwp is not None:
                raise RuntimeError("manual_sel_minrnnscore and manual_sel_rnnwp have been both set; please set only one of them") 
 
            if self.manual_sel_gntauwp is not None:
                if self.manual_sel_gntauwp not in _MANUAL_GNTAU_JETIDWP:
                    raise ValueError (f"invalid GNN Tau ID WP: \"{self.manual_sel_gntauwp}\". Allowed values are None, veryloose, loose, medium, tight")
                alg.selectionTool.JetIDWP = _MANUAL_GNTAU_JETIDWP[self.manual_sel_gntauwp]
 
            # cross-check that min gntau score and GNTau WPs are not set at the same time
            if self.manual_sel_mingntauscore != -1 and self.manual_sel_gntauwp is not None:
                raise RuntimeError("manual_sel_mingntauscore and manual_sel_gntauwp have been both set; please set only one of them")
 
            # working point following the Enums from https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h 
            if self.manual_sel_evetowp is None:
                alg.selectionTool.EleIDWP = 1
            elif self.manual_sel_evetowp in _MANUAL_ELEIDWP:
                alg.selectionTool.EleIDWP = _MANUAL_ELEIDWP[self.manual_sel_evetowp]
            else:
                raise ValueError (f"invalid eVeto WP: \"{self.manual_sel_evetowp}\". Allowed values are None, loose, medium, tight")
 
            # set MuonOLR option:
            alg.selectionTool.MuonOLR = self.manual_sel_muonolr
 
        alg.selectionDecoration = 'selected_tau' + selectionPostfix + ',as_char'
        alg.particles = config.readName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, self.selectionName)
        config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration,
                             preselection=self.addSelectionToPreselection)
 
 

Member Data Documentation

containerName

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.containerName

Definition at line 349 of file TauAnalysisConfig.py.

dropPtCut

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.dropPtCut

Definition at line 262 of file TauAnalysisConfig.py.

selectionName

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.selectionName

Definition at line 349 of file TauAnalysisConfig.py.

use_eVeto

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.use_eVeto

Definition at line 269 of file TauAnalysisConfig.py.

use_muonOLR

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.use_muonOLR

Definition at line 273 of file TauAnalysisConfig.py.

useGNTau

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.useGNTau

Definition at line 259 of file TauAnalysisConfig.py.

useLowPt

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.useLowPt

Definition at line 257 of file TauAnalysisConfig.py.

useSelectionConfigFile

python.TauAnalysisConfig.TauWorkingPointSelectionConfig.useSelectionConfigFile

Definition at line 256 of file TauAnalysisConfig.py.

---

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

• TauAnalysisConfig.py