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
str	manual_sel_evetowp = "medium":
	noEffSF
	saveDetailedSF
	containerName
	use_eVeto
	saveCombinedSF

Protected Member Functions
	_eVetoEleIDLevel (self)

Detailed Description

the ConfigBlock for the tau working point efficiency computation

Definition at line 355 of file TauAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.__init__

(

self

)

Definition at line 358 of file TauAnalysisConfig.py.

    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.")
 

Member Function Documentation

_eVetoEleIDLevel()

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig._eVetoEleIDLevel ( self )

protected

the EleIDLevel for the eVeto scale factors

Definition at line 408 of file TauAnalysisConfig.py.

    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
 

instanceName()

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 401 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 416 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 (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)
            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)
                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)
                    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)
                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 455 of file TauAnalysisConfig.py.

manual_sel_evetowp

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

Definition at line 412 of file TauAnalysisConfig.py.

noEffSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.noEffSF

Definition at line 435 of file TauAnalysisConfig.py.

saveCombinedSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.saveCombinedSF

Definition at line 550 of file TauAnalysisConfig.py.

saveDetailedSF

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.saveDetailedSF

Definition at line 454 of file TauAnalysisConfig.py.

use_eVeto

python.TauAnalysisConfig.TauWorkingPointEfficiencyConfig.use_eVeto

Definition at line 492 of file TauAnalysisConfig.py.

---

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

• TauAnalysisConfig.py