python.TauAnalysisConfig.TauWorkingPointConfig Class Reference

Inheritance diagram for python.TauAnalysisConfig.TauWorkingPointConfig:

Collaboration diagram for python.TauAnalysisConfig.TauWorkingPointConfig:

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

Public Attributes
	useSelectionConfigFile
	dropPtCut
	useLowPt
# current recommendations are for RNN ID, so donCPTauEfficiencyCorrectionsAlgTauEfficiencyCorrectionsAlgIDefficiencyCorrectionsToolTauAnalysisToolsTauEfficiencyCorrectionsTooltau_ID_effSF_%SYS%bad_ID_effID_effSFt use them for GNTau	useGNTau
	use_eVeto
	use_muonOLR
str	manual_sel_rnnwp = "veryloose":
str	manual_sel_gntauwp = "veryloose":
str	manual_sel_evetowp = "loose":
	containerName
	selectionName
	noEffSF
	saveDetailedSF
str	quality = "loose":
	saveCombinedSF

Detailed Description

the ConfigBlock for the tau working point

This may at some point be split into multiple blocks (16 Mar 22).

Definition at line 123 of file TauAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.TauAnalysisConfig.TauWorkingPointConfig.__init__

(

self

)

Definition at line 128 of file TauAnalysisConfig.py.

    def __init__ (self) :
        super (TauWorkingPointConfig, self).__init__ ()
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the input container.")
        self.addOption ('selectionName', '', type=str,
            noneAction='error',
            info="the name of the tau-jet selection to define (e.g. `tight` or "
            "`loose`).")
        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`.")
        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 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` used for tau-jet selection when `useSelectionConfigFile` is set to `False`")    
        self.addOption ('noEffSF', False, type=bool,
            info="disables the calculation of efficiencies and scale factors. "
            "Experimental! only useful to test a new WP for which scale "
            "factors are not available.",
            expertMode=True)
        self.addOption ('saveDetailedSF', True, type=bool,
            info="save all the independent detailed object scale factors.")
        self.addOption ('saveCombinedSF', False, type=bool,
            info="save the combined object scale factor.")
        self.addOption ('addSelectionToPreselection', True, type=bool,
            info="whether to retain only tau-jets satisfying the working point "
            "requirements.")
 

Member Function Documentation

instanceName()

python.TauAnalysisConfig.TauWorkingPointConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 197 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.TauWorkingPointConfig.makeAlgs	(		self,
			config )

Definition at line 204 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:
            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 ("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' )
        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") 
            # working point following the Enums from https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h
            if self.manual_sel_rnnwp is None:
               alg.selectionTool.JetIDWP = 1 
            elif self.manual_sel_rnnwp == "veryloose":
               alg.selectionTool.JetIDWP = 6
            elif self.manual_sel_rnnwp == "loose":
               alg.selectionTool.JetIDWP = 7
            elif self.manual_sel_rnnwp == "medium":
               alg.selectionTool.JetIDWP = 8
            elif self.manual_sel_rnnwp == "tight":
               alg.selectionTool.JetIDWP = 9
            else:   
               raise ValueError ("invalid RNN TauID WP: \"" + self.manual_sel_rnnwp + "\". Allowed values are None, veryloose, loose, medium, tight")
 
            # 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") 
 
            # working point following the Enums from https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h
            if self.manual_sel_gntauwp is None:
               alg.selectionTool.JetIDWP = 1
            elif self.manual_sel_gntauwp == "veryloose":
               alg.selectionTool.JetIDWP = 10
            elif self.manual_sel_gntauwp == "loose":
               alg.selectionTool.JetIDWP = 11
            elif self.manual_sel_gntauwp == "medium":
               alg.selectionTool.JetIDWP = 12
            elif self.manual_sel_gntauwp == "tight":
               alg.selectionTool.JetIDWP = 13  
            else:
               raise ValueError ("invalid GNN Tau ID WP: \"" + self.manual_sel_gntauwp + "\". Allowed values are None, veryloose, loose, medium, tight")
 
            # 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 == "loose":
               alg.selectionTool.EleIDWP = 2
            elif self.manual_sel_evetowp == "medium":
               alg.selectionTool.EleIDWP = 3
            elif self.manual_sel_evetowp == "tight":
               alg.selectionTool.EleIDWP = 4   
            else:
               raise ValueError ("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)
 
        sfList = []
        # Set up the algorithm calculating the efficiency scale factors for the
        # taus:
        if config.dataType() is not DataType.Data and not self.noEffSF:
            log = logging.getLogger('TauJetSFConfig')
            # need multiple instances of the TauEfficiencyCorrectionTool
            # 1) Reco 2) TauID, 3) eVeto for fake tau 4) eVeto for true tau
            # 3) and 4) are optional if eVeto is used in TauSelectionTool
 
            # TauEfficiencyCorrectionTool for Reco, this should be always enabled
            alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                   'TauEfficiencyCorrectionsAlgReco' )
            config.addPrivateTool( 'efficiencyCorrectionsTool',
                            'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
            alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [0]
            alg.efficiencyCorrectionsTool.Campaign = "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20"
            alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
            alg.scaleFactorDecoration = 'tau_Reco_effSF' + selectionPostfix + '_%SYS%'
            alg.outOfValidity = 2 #silent
            alg.outOfValidityDeco = 'bad_Reco_eff' + selectionPostfix
            alg.taus = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, self.selectionName)
            if self.saveDetailedSF:
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                     'Reco_effSF' + postfix)
            sfList += [alg.scaleFactorDecoration]
 
            # TauEfficiencyCorrectionTool for Identification, use only in case TauID is requested in TauSelectionTool
            if self.quality not in ('VeryLoose','Baseline','BaselineForFakes'):
                if not self.useGNTau: # current recommendations are for RNN ID, so don't use in case of GNTau
 
                    alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                   'TauEfficiencyCorrectionsAlgID' )
                    config.addPrivateTool( 'efficiencyCorrectionsTool',
                                'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                    alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [4]
                    if self.quality=="Loose" or self.manual_sel_rnnwp == "loose":
                        JetIDLevel = 7
                    elif self.quality=="Medium" or self.manual_sel_rnnwp == "medium":
                        JetIDLevel = 8
                    elif self.quality=="Tight" or self.manual_sel_rnnwp == "tight":
                        JetIDLevel = 9
                    else:
                        raise ValueError ("invalid tauID: \"" + self.quality + "\". Allowed values are loose, medium, tight")
 
                    alg.efficiencyCorrectionsTool.JetIDLevel = JetIDLevel
                    alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
                    alg.efficiencyCorrectionsTool.Campaign = "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20"
                    alg.scaleFactorDecoration = 'tau_ID_effSF' + selectionPostfix + '_%SYS%'
                    alg.outOfValidity = 2 #silent
                    alg.outOfValidityDeco = 'bad_ID_eff' + selectionPostfix
                    alg.taus = config.readName (self.containerName)
                    alg.preselection = config.getPreselection (self.containerName, self.selectionName)
                    if self.saveDetailedSF:
                        config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                             'ID_effSF' + postfix)
                    sfList += [alg.scaleFactorDecoration]
 
            # TauEfficiencyCorrectionTool for eVeto both on true tau and fake tau, use only in case eVeto is requested in TauSelectionTool
            if self.use_eVeto:
                if not self.useGNTau: # eVeto correction for fake tau are for RNN ID, so don't use them for GNTau
                    # correction for fake tau
                    alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                       'TauEfficiencyCorrectionsAlgEvetoFakeTau' )
                    config.addPrivateTool( 'efficiencyCorrectionsTool',
                                    'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                    alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [10]
                    # since all TauSelectionTool config files have loose eRNN, code only this option for now
                    alg.efficiencyCorrectionsTool.EleIDLevel = 2
                    #overwrite decision in case user selects a WP manually
                    if self.manual_sel_evetowp == "loose":
                        alg.efficiencyCorrectionsTool.EleIDLevel = 2
                    elif self.manual_sel_evetowp == "medium":
                        alg.efficiencyCorrectionsTool.EleIDLevel = 3
                        
                    alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
                    alg.efficiencyCorrectionsTool.Campaign = "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20"
                    alg.scaleFactorDecoration = 'tau_EvetoFakeTau_effSF' + selectionPostfix + '_%SYS%'
                    # for 2025-prerec, eVeto recommendations are given separately for Loose and Medium RNN 
                    if self.quality=="Loose" or self.manual_sel_rnnwp == "loose":
                        JetIDLevel = 7
                    elif self.quality=="Medium" or self.manual_sel_rnnwp == "medium":
                        JetIDLevel = 8
                    elif self.quality=="Tight" or self.manual_sel_rnnwp == "tight": 
                        log.warning("eVeto SFs are not available for Tight WP -> fallback to Medium WP")
                        JetIDLevel = 8
                    alg.efficiencyCorrectionsTool.JetIDLevel = JetIDLevel 
                    alg.outOfValidity = 2 #silent
                    alg.outOfValidityDeco = 'bad_EvetoFakeTau_eff' + selectionPostfix
                    alg.taus = config.readName (self.containerName)
                    alg.preselection = config.getPreselection (self.containerName, self.selectionName)
                    if self.saveDetailedSF:
                        config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                             'EvetoFakeTau_effSF' + postfix)
                    sfList += [alg.scaleFactorDecoration]
 
                # correction for true tau
                alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                   'TauEfficiencyCorrectionsAlgEvetoTrueTau' )
                config.addPrivateTool( 'efficiencyCorrectionsTool',
                                'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [8]
                alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
                alg.efficiencyCorrectionsTool.Campaign = "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20"
                alg.scaleFactorDecoration = 'tau_EvetoTrueTau_effSF' + selectionPostfix + '_%SYS%'
                alg.outOfValidity = 2 #silent
                alg.outOfValidityDeco = 'bad_EvetoTrueTau_eff' + selectionPostfix
                alg.taus = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, self.selectionName)
                if self.saveDetailedSF:
                    config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                         'EvetoTrueTau_effSF' + postfix)
                sfList += [alg.scaleFactorDecoration]
 
            if self.saveCombinedSF:
                alg = config.createAlgorithm( 'CP::AsgObjectScaleFactorAlg',
                                              'TauCombinedEfficiencyScaleFactorAlg' )
                alg.particles = config.readName (self.containerName)
                alg.inScaleFactors = sfList
                alg.outScaleFactor = 'effSF' + postfix + '_%SYS%'
                config.addOutputVar (self.containerName, alg.outScaleFactor,
                                     'effSF' + postfix)
 
 

Member Data Documentation

containerName

python.TauAnalysisConfig.TauWorkingPointConfig.containerName

Definition at line 323 of file TauAnalysisConfig.py.

dropPtCut

python.TauAnalysisConfig.TauWorkingPointConfig.dropPtCut

Definition at line 219 of file TauAnalysisConfig.py.

manual_sel_evetowp

str python.TauAnalysisConfig.TauWorkingPointConfig.manual_sel_evetowp = "loose":

Definition at line 308 of file TauAnalysisConfig.py.

manual_sel_gntauwp

str python.TauAnalysisConfig.TauWorkingPointConfig.manual_sel_gntauwp = "veryloose":

Definition at line 290 of file TauAnalysisConfig.py.

manual_sel_rnnwp

str python.TauAnalysisConfig.TauWorkingPointConfig.manual_sel_rnnwp = "veryloose":

Definition at line 272 of file TauAnalysisConfig.py.

noEffSF

python.TauAnalysisConfig.TauWorkingPointConfig.noEffSF

Definition at line 329 of file TauAnalysisConfig.py.

quality

str python.TauAnalysisConfig.TauWorkingPointConfig.quality = "loose":

Definition at line 405 of file TauAnalysisConfig.py.

saveCombinedSF

python.TauAnalysisConfig.TauWorkingPointConfig.saveCombinedSF

Definition at line 440 of file TauAnalysisConfig.py.

saveDetailedSF

python.TauAnalysisConfig.TauWorkingPointConfig.saveDetailedSF

Definition at line 348 of file TauAnalysisConfig.py.

selectionName

python.TauAnalysisConfig.TauWorkingPointConfig.selectionName

Definition at line 323 of file TauAnalysisConfig.py.

use_eVeto

python.TauAnalysisConfig.TauWorkingPointConfig.use_eVeto

Definition at line 226 of file TauAnalysisConfig.py.

use_muonOLR

python.TauAnalysisConfig.TauWorkingPointConfig.use_muonOLR

Definition at line 230 of file TauAnalysisConfig.py.

useGNTau

# current recommendations are for RNN ID, so donCPTauEfficiencyCorrectionsAlgTauEfficiencyCorrectionsAlgIDefficiencyCorrectionsToolTauAnalysisToolsTauEfficiencyCorrectionsTooltau_ID_effSF_%SYS%bad_ID_effID_effSFt use them for GNTau python.TauAnalysisConfig.TauWorkingPointConfig.useGNTau

Definition at line 223 of file TauAnalysisConfig.py.

useLowPt

python.TauAnalysisConfig.TauWorkingPointConfig.useLowPt

Definition at line 221 of file TauAnalysisConfig.py.

useSelectionConfigFile

python.TauAnalysisConfig.TauWorkingPointConfig.useSelectionConfigFile

Definition at line 217 of file TauAnalysisConfig.py.

---

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

• TauAnalysisConfig.py