python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig Class Reference

Inheritance diagram for python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig:

Collaboration diagram for python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig:

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

Public Attributes
	noEffSF
	saveDetailedSF
	containerName
	use_eVeto
str	manual_sel_evetowp = "loose":
	saveCombinedSF

Detailed Description

the ConfigBlock for the tau working point efficiency computation

Definition at line 337 of file TauAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.__init__

(

self

)

Definition at line 340 of file TauAnalysisConfig.py.

    def __init__ (self) :
        super (TauWorkingPointEfficiencyConfig, self).__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.")
        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 ('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.")
 

Member Function Documentation

instanceName()

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.instanceName

(

self

)

Return the instance name for this block

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

Definition at line 387 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
 
        if self.quality is not None and 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")
 
        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]
 
 
            campaign = "mc23" if config.geometry() is LHCPeriod.Run3 else "mc20" 
 
            # TauEfficiencyCorrectionTool for Identification, use only in case TauID is requested in TauSelectionTool
            if self.quality not in ('VeryLoose','Baseline','BaselineForFakes'):
                # current recommendations are for RNN ID Run2/Run3 or GNTAU for Run3, 
                if (not self.useGNTau or (self.useGNTau and campaign == "mc23")): 
 
                    alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                   'TauEfficiencyCorrectionsAlgID' )
                    config.addPrivateTool( 'efficiencyCorrectionsTool',
                                'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                    alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [4]
 
                    jetIDLevels = (
                        {"Loose": 11, "Medium": 12, "Tight": 13}
                        if self.useGNTau
                        else {"Loose": 7, "Medium": 8, "Tight": 9}
                    )
                    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(
                            'Invalid tauID: "'
                            + str(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)
                    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:
                # eVeto correction for fake tau are for RNN ID Run2/Run3, or for GNTau for Run3   
                if (not self.useGNTau or (self.useGNTau and campaign == "mc23")):
                    # 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 = 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 = (
                        {"Loose": 11, "Medium": 12, "Tight": 13}
                        if self.useGNTau
                        else {"Loose": 7, "Medium": 8, "Tight": 9}
                    )
                    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(
                            'Invalid tauID: "'
                            + str(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)
                    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%'
                # 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.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.TauWorkingPointEfficiencyConfig.containerName

Definition at line 427 of file TauAnalysisConfig.py.

manual_sel_evetowp

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

Definition at line 487 of file TauAnalysisConfig.py.

noEffSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.noEffSF

Definition at line 407 of file TauAnalysisConfig.py.

saveCombinedSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.saveCombinedSF

Definition at line 553 of file TauAnalysisConfig.py.

saveDetailedSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.saveDetailedSF

Definition at line 426 of file TauAnalysisConfig.py.

use_eVeto

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.use_eVeto

Definition at line 475 of file TauAnalysisConfig.py.

---

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

• TauAnalysisConfig.py