TauAnalysisConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
# AnaAlgorithm import(s):
from AnalysisAlgorithmsConfig.ConfigAccumulator import DataType
from AnalysisAlgorithmsConfig.ConfigSequence import groupBlocks
from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
from AthenaCommon.Logging import logging
from AthenaConfiguration.Enums import LHCPeriod
from Campaigns.Utils import Campaign
 
from TriggerAnalysisAlgorithms.TriggerAnalysisSFConfig import trigger_set
 
# working points following the Enums from https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h
_RNN_JETID_LEVELS = {"Loose": 7, "Medium": 8, "Tight": 9}
_GNTAU_JETID_LEVELS = {"Loose": 11, "Medium": 12, "Tight": 13}
_MANUAL_RNN_JETIDWP = {"veryloose": 6, "loose": 7, "medium": 8, "tight": 9}
_MANUAL_GNTAU_JETIDWP = {"veryloose": 10, "loose": 11, "medium": 12, "tight": 13}
_MANUAL_ELEIDWP = {"loose": 2, "medium": 3, "tight": 4}
 
 
def _campaign(config):
    """the tau CP tool campaign for the current geometry"""
    return "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20"
 
 
class TauCalibrationConfig (ConfigBlock):
    """the ConfigBlock for the tau four-momentum correction"""
 
    def __init__ (self) :
        super().__init__()
        self.setBlockName('Taus')
        self.addOption ('inputContainer', '', type=str,
            info="the name of the input tau-jet container. If left empty, automatically defaults "
            "to `'AnalysisTauJets'` for PHYSLITE and `'TauJets'` otherwise.")
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the output container after calibration.",
            meta={'role':'container'})
        self.addOption ('postfix', '', type=str,
            info="a postfix to apply to decorations and algorithm names. "
            "Typically not needed here since the calibration is common to "
            "all tau-jets.")
        self.addOption ('rerunTruthMatching', True, type=bool,
            info="whether to rerun truth matching (sets up an instance of "
            "`CP::TauTruthMatchingAlg`).")
        self.addOption ('decorateTruth', False, type=bool,
            info="decorate the truth particle information on the reconstructed one.")
        self.addOption ('decorateExtraVariables', True, type=bool,
            info="decorate extra variables for the reconstructed tau-jet.")
        self.addOption ('addGlobalFELinksDep', False, type=bool,
            info="whether to add dependencies for the global FE links (needed for PHYSLITE production)",
            expertMode=True)
        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)
 
    def instanceName (self) :
        """Return the instance name for this block"""
        return self.containerName + self.postfix
 
    def makeAlgs (self, config) :
 
        # protection for EleRM taus, which are available only from 2024 onward
        if 'EleRM' in self.inputContainer:
            if config.dataType() is DataType.Data and config.dataYear() <= 2023:
                raise RuntimeError("EleRM taus are only available from 2024 dataset onward")
            elif config.dataType() is not DataType.Data and config.campaign() <= Campaign.MC23d:
                raise RuntimeError("EleRM taus are only available from 2024 dataset onward")
 
        postfix = self.postfix
        if postfix != '' and postfix[0] != '_' :
            postfix = '_' + postfix
 
        inputContainer = "AnalysisTauJets" if config.isPhyslite() else "TauJets"
        if self.inputContainer:
            inputContainer = self.inputContainer
        config.setSourceName (self.containerName, inputContainer)
 
        # Set up a shallow copy to decorate
        if config.wantCopy (self.containerName) :
            alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'TauShallowCopyAlg' )
            alg.input = config.readName (self.containerName)
            alg.output = config.copyName (self.containerName)
            alg.outputType = 'xAOD::TauJetContainer'
 
            extraInputs = [
                ( 'SG::AuxVectorBase' , f'StoreGateSvc+{inputContainer}.EleRNNLoose_v1' ),
                ( 'SG::AuxVectorBase' , f'StoreGateSvc+{inputContainer}.TESCompatibility' )
            ]
            config.setExtraInputs (extraInputs)
 
            decorations = []
            if self.addGlobalFELinksDep:
                decorations += ['neutralGlobalFELinks', 'chargedGlobalFELinks']
            if config.dataType() is not DataType.Data:
                decorations += ['IsTruthMatched', 'truthJetLink', 'truthParticleLink']
            if decorations:
                alg.declareDecorations = decorations
 
        # Set up the tau truth matching algorithm:
        if self.rerunTruthMatching and config.dataType() is not DataType.Data:
            alg = config.createAlgorithm( 'CP::TauTruthMatchingAlg',
                                          'TauTruthMatchingAlg' )
            config.addPrivateTool( 'matchingTool',
                                   'TauAnalysisTools::TauTruthMatchingTool' )
            alg.matchingTool.TruthJetContainerName = 'AntiKt4TruthDressedWZJets'
            alg.taus = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        # decorate truth tau information on the reconstructed object:
        if self.decorateTruth and config.dataType() is not DataType.Data:
            alg = config.createAlgorithm( 'CP::TauTruthDecorationsAlg',
                                          'TauTruthDecorationsAlg',
                                           reentrant=True )
            alg.taus = config.readName (self.containerName, nominal=True)
            alg.doubleDecorations = ['pt_vis', 'pt_invis', 'eta_vis', 'eta_invis', 'phi_vis', 'phi_invis', 'm_vis', 'm_invis']
            alg.floatDecorations = []
            alg.intDecorations = ['pdgId']
            alg.unsignedIntDecorations = ['classifierParticleOrigin', 'classifierParticleType']
            alg.charDecorations = ['IsHadronicTau']
            alg.prefix = 'truth_'
 
            # these are "_ListHelper" objects, and not "list", need to copy to lists to allow concatenate
            intTruthVars = ['DecayMode', 'ParticleType', 'PartonTruthLabelID']
            for var in intTruthVars + alg.doubleDecorations[:] + alg.floatDecorations[:] + alg.intDecorations[:] + alg.unsignedIntDecorations[:] + alg.charDecorations[:]:
                branchName = alg.prefix + var
                if 'classifierParticle' in var:
                    branchOutput = alg.prefix + var.replace('classifierParticle', '').lower()
                else:
                    branchOutput = branchName
                auxType = 'int' if var in intTruthVars else None
                config.addOutputVar (self.containerName, branchName, branchOutput, noSys=True, auxType=auxType)
 
        # Decorate extra variables
        if self.decorateExtraVariables:
            alg = config.createAlgorithm( 'CP::TauExtraVariablesAlg',
                                          'TauExtraVariablesAlg',
                                          reentrant=True )
            alg.taus = config.readName (self.containerName, nominal=True)
 
        # Set up the tau 4-momentum smearing algorithm:
        alg = config.createAlgorithm( 'CP::TauSmearingAlg', 'TauSmearingAlg' )
        config.addPrivateTool( 'smearingTool', 'TauAnalysisTools::TauSmearingTool' )
        alg.smearingTool.useFastSim = config.dataType() is DataType.FastSim
        alg.smearingTool.Campaign = _campaign(config)
        alg.smearingTool.useGNTau = self.useGNTau
        alg.taus = config.readName (self.containerName)
        alg.tausOut = config.copyName (self.containerName)
        config.setExtraOutputs ({('xAOD::IParticleContainer' , 'StoreGateSvc+' + config.readName(self.containerName, nominal=True) + '.RNNEleScoreSigTrans_v1')})
        alg.preselection = config.getPreselection (self.containerName, '')
 
        # Additional decorations
        alg = config.createAlgorithm( 'CP::AsgEnergyDecoratorAlg', 'EnergyDecorator' )
        alg.particles = config.readName (self.containerName)
 
        config.addOutputVar (self.containerName, 'pt', 'pt', auxType='float')
        config.addOutputVar (self.containerName, 'eta', 'eta', noSys=True, auxType='float')
        config.addOutputVar (self.containerName, 'phi', 'phi', noSys=True, auxType='float')
        config.addOutputVar (self.containerName, 'e_%SYS%', 'e', auxType='float')
        config.addOutputVar (self.containerName, 'charge', 'charge', noSys=True, auxType='float')
        config.addOutputVar (self.containerName, 'NNDecayMode', 'NNDecayMode', noSys=True, auxType='int')
        config.addOutputVar (self.containerName, 'passTATTauMuonOLR', 'passTATTauMuonOLR', noSys=True, auxType='char')
        config.addOutputVar (self.containerName, 'TESCompatibility', 'TESCompatibility', auxType='char')
        if self.decorateExtraVariables:
            config.addOutputVar (self.containerName, 'nTracksCharged', 'nTracksCharged', noSys=True, auxType='int')
 
 
class TauWorkingPointSelectionConfig (ConfigBlock) :
    """the ConfigBlock for the tau working point selection"""
 
    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.")
 
    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
 
    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)
 
 
class TauWorkingPointEfficiencyConfig (ConfigBlock) :
    """the ConfigBlock for the tau working point efficiency computation"""
 
    def __init__ (self) :
        super().__init__()
        self.setBlockName('TauWorkingPointEfficiency')
        self.addDependency('TauWorkingPointSelection', required=True)
        self.addDependency('EventSelection', required=False)
        self.addDependency('EventSelectionMerger', required=False)
        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 ('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 ('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_evetowp', None, type=str, 
            info="eveto working point 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.")
 
    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
 
    def _eVetoEleIDLevel (self) :
        """the EleIDLevel for the eVeto scale factors"""
        # since all TauSelectionTool config files have loose eRNN, code only this option for now
        #overwrite decision in case user selects a WP different than "loose" manually
        if self.manual_sel_evetowp == "medium":
            return 3
        return 2
 
    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
 
        if self.quality is not None and 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")
 
        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 = _campaign(config)
            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, auxType='float')
            sfList += [alg.scaleFactorDecoration]
 
 
            campaign = _campaign(config)
 
            # TauEfficiencyCorrectionTool for Identification, use only in case TauID is requested in TauSelectionTool
            if self.quality not in ('VeryLoose','Baseline','BaselineForFakes'):
                alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                               'TauEfficiencyCorrectionsAlgID' )
                config.addPrivateTool( 'efficiencyCorrectionsTool',
                            'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [4]
 
                jetIDLevels = _GNTAU_JETID_LEVELS if self.useGNTau else _RNN_JETID_LEVELS
                wp = self.quality
                if not self.useGNTau and self.manual_sel_rnnwp is not None:
                    wp = self.manual_sel_rnnwp.capitalize()
                if wp not in jetIDLevels:
                    raise ValueError(f'Invalid tauID: "{wp}". Allowed values are Loose, Medium, Tight')
 
                alg.efficiencyCorrectionsTool.JetIDLevel = jetIDLevels[wp]
                alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
                alg.efficiencyCorrectionsTool.Campaign = campaign
                alg.efficiencyCorrectionsTool.useGNTau = self.useGNTau
                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, auxType='float')
                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:
                #use only in case TauID is requested in TauSelectionTool
                if self.quality not in ('VeryLoose','Baseline','BaselineForFakes'): 
                    # correction for fake tau
                    alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                        'TauEfficiencyCorrectionsAlgEvetoFakeTau' )
                    config.addPrivateTool( 'efficiencyCorrectionsTool',
                                    'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                    alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [10]
                    alg.efficiencyCorrectionsTool.EleIDLevel = self._eVetoEleIDLevel()
 
                    alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
                    alg.efficiencyCorrectionsTool.Campaign = campaign
                    alg.efficiencyCorrectionsTool.useGNTau = self.useGNTau
                    alg.scaleFactorDecoration = 'tau_EvetoFakeTau_effSF' + selectionPostfix + '_%SYS%'
 
                    # for 2025-prerec, eVeto recommendations are given separately for Loose and Medium RNN
                    jetIDLevels = _GNTAU_JETID_LEVELS if self.useGNTau else _RNN_JETID_LEVELS
                    wp = self.quality
                    if not self.useGNTau and self.manual_sel_rnnwp is not None:
                        wp = self.manual_sel_rnnwp.capitalize()
                    if wp not in jetIDLevels:
                        raise ValueError(f'Invalid tauID: "{wp}". Allowed values are Loose, Medium, Tight')
                    if wp == "Tight":
                        log.warning(
                            "eVeto SFs are not available for Tight WP -> fallback to Medium WP"
                        )
                        wp = "Medium"
 
                    alg.efficiencyCorrectionsTool.JetIDLevel = jetIDLevels[wp]
                    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, auxType='float')
                    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 = _campaign(config)
                alg.scaleFactorDecoration = 'tau_EvetoTrueTau_effSF' + selectionPostfix + '_%SYS%'
                alg.efficiencyCorrectionsTool.EleIDLevel = self._eVetoEleIDLevel()
                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, auxType='float')
                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, auxType='float')
 
                
class EXPERIMENTAL_TauCombineMuonRemovalConfig (ConfigBlock) :
    def __init__ (self) :
        super().__init__()
        self.addOption (
            'inputTaus', 'TauJets', type=str,
            noneAction='error',
            info="the name of the input tau container."
        )
        self.addOption (
            'inputTausMuRM', 'TauJets_MuonRM', type=str,
            noneAction='error',
            info="the name of the input tau container with muon removal applied."
        )
        self.addOption (
            'outputTaus', 'TauJets_MuonRmCombined', type=str,
            noneAction='error',
            info="the name of the output tau container."
        )
 
    def instanceName (self) :
        """Return the instance name for this block"""
        return self.outputTaus
 
    def makeAlgs (self, config) :
 
        if config.isPhyslite() :
            raise(RuntimeError("Muon removal taus is not available in Physlite mode"))
 
        alg = config.createAlgorithm( 'CP::TauCombineMuonRMTausAlg', 'TauCombineMuonRMTausAlg' )
        alg.taus = self.inputTaus
        alg.muonrm_taus = self.inputTausMuRM
        alg.combined_taus = self.outputTaus
 
class TauTriggerAnalysisSFBlock (ConfigBlock):
 
    def __init__ (self) :
        super().__init__()
        self.addDependency('EventSelection', required=False)
        self.addDependency('EventSelectionMerger', required=False)
        self.addOption ('triggerChainsPerYear', {}, type=dict,
                        info="a dictionary with key (string) the year and value (list of "
                        "strings) the trigger chains.")
        self.addOption ('useGNTau', False, type=bool,
                        info="use GNTau-based ID instead of RNNTau ID. "
                        "Recommendations: experimental feature and might become default soon.")
        self.addOption ('tauID', '', type=str,
                        info="the tau-jet quality WP to use.")
        self.addOption ('prefixSF', 'trigEffSF', type=str,
                        info="the decoration prefix for trigger scale factors.")
        self.addOption ('includeAllYearsPerRun', False, type=bool,
                        info="all configured years in the LHC run will "
                        "be included in all jobs.")
        self.addOption ('removeHLTPrefix', True, type=bool,
                        info="remove the HLT prefix from trigger chain names.")
        self.addOption ('containerName', '', type=str,
                        info="the input tau-jet container, with a possible selection, in "
                        "the format `container` or `container.selection`.",
                        meta={'role':'containerRef'})
 
    def instanceName (self) :
        """Return the instance name for this block"""
        return self.containerName + '_' + self.prefixSF + '_' + self.tauID
 
    def makeAlgs (self, config) :
 
        if config.dataType() is not DataType.Data:
            log = logging.getLogger('TauTriggerAnalysisSF')
 
            # Temporary skip all MC campaigns apart from MC23a when using GNTau until SFs are available
            if( self.useGNTau and config.campaign() is not Campaign.MC23a ):
                log.warning("Tau trigger scale factors are only available for MC23a when using GNTau offline ID")
                return 
 
            # Temporary skip for MC23e until SFs are available
            if config.campaign() is Campaign.MC23e:
                log.warning("Tau trigger scale factors are not available yet for MC23e")
                return
            # Temporary skip for MC23g until SFs are available
            if config.campaign() is Campaign.MC23g:
                log.warning("Tau trigger scale factors are not available yet for MC23g")
                return
 
            triggers = trigger_set(config, self.triggerChainsPerYear,
                                   self.includeAllYearsPerRun)
            for chain in triggers:
                chain_noHLT = chain.replace("HLT_", "")
                chain_out = chain_noHLT if self.removeHLTPrefix else chain
                alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                              'TauTrigEfficiencyCorrectionsAlg_' + chain )
                config.addPrivateTool( 'efficiencyCorrectionsTool',
                                       'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                # SFTriggerHadTau correction type from
                # https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h#L79
                alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [12]
                if config.geometry() is LHCPeriod.Run2:
                    alg.efficiencyCorrectionsTool.Campaign = "mc20"
                else:
                    alg.efficiencyCorrectionsTool.Campaign = config.campaign().value
                alg.efficiencyCorrectionsTool.TriggerName = chain
                alg.efficiencyCorrectionsTool.useGNTau = self.useGNTau 
 
                # JetIDLevel from
                # https://gitlab.cern.ch/atlas/athena/-/blob/main/PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h#L79
                if self.tauID not in _RNN_JETID_LEVELS:
                    raise ValueError (f"invalid tauID: \"{self.tauID}\". Allowed values are Loose, Medium, Tight")
                alg.efficiencyCorrectionsTool.JetIDLevel = _RNN_JETID_LEVELS[self.tauID]
                alg.efficiencyCorrectionsTool.TriggerSFMeasurement = "combined"
                alg.efficiencyCorrectionsTool.useFastSim = config.dataType() is DataType.FastSim
 
                alg.scaleFactorDecoration = f"tau_{self.prefixSF}_{chain_out}_%SYS%"
                alg.outOfValidity = 2 #silent
                alg.outOfValidityDeco = f"bad_eff_tautrig_{chain_out}"
                alg.taus = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, self.tauID)
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration, f"{self.prefixSF}_{chain_out}", auxType='float')
 
@groupBlocks
def TauWorkingPoint(seq):
    seq.append(TauWorkingPointSelectionConfig())
    seq.append(TauWorkingPointEfficiencyConfig())