Inheritance diagram for python.TauAnalysisConfig.TauWorkingPointConfig:

Collaboration diagram for python.TauAnalysisConfig.TauWorkingPointConfig:

Public Member Functions
def	__init__ (self, containerName='', selectionName='')

def	makeAlgs (self, config)

Public Attributes
	quality

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 105 of file TauAnalysisConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.TauAnalysisConfig.TauWorkingPointConfig.__init__	(	self,
		containerName = `''`,
		selectionName = `''`
	)

Definition at line 110 of file TauAnalysisConfig.py.

     def __init__ (self, containerName='', selectionName='') :
         super (TauWorkingPointConfig, self).__init__ ()
         self.addOption ('containerName', containerName, type=str,
             noneAction='error',
             info="the name of the input container.")
         self.addOption ('selectionName', 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 (string) 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 electron mis-reconstructed as tau is a large background for your analysis")
         self.addOption ('useGNTau', False, type=bool,
             info="use GNTau based ID instead of RNNTau ID "
             "recommendations: that's new experimental feature and might come default soon")
         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. The default is False.")
         self.addOption ('saveDetailedSF', True, type=bool,
             info="save all the independent detailed object scale factors. "
             "The default is True.")
         self.addOption ('saveCombinedSF', False, type=bool,
             info="save the combined object scale factor. "
             "The default is False.")
         self.addOption ('addSelectionToPreselection', True, type=bool,
             info="whether to retain only tau-jets satisfying the working point "
             "requirements. The default is True.")
  

Member Function Documentation

◆ makeAlgs()

def python.TauAnalysisConfig.TauWorkingPointConfig.makeAlgs	(	self,
		config
	)

Definition at line 145 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.useGNTau:
             nameFormat = 'TauAnalysisAlgorithms/tau_selection_gntau_{}_eleid.conf'
             if not self.use_eVeto:
                 nameFormat = 'TauAnalysisAlgorithms/tau_selection_gntau_{}_noeleid.conf'
         else:
             nameFormat = 'TauAnalysisAlgorithms/tau_selection_{}_eleid.conf'
             if not self.use_eVeto:
                 nameFormat = 'TauAnalysisAlgorithms/tau_selection_{}_noeleid.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")
         inputfile = nameFormat.format(self.quality.lower())
  
         # Set up the algorithm selecting taus:
         alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'TauSelectionAlg' + postfix )
         config.addPrivateTool( 'selectionTool', 'TauAnalysisTools::TauSelectionTool' )
         alg.selectionTool.ConfigPath = inputfile
         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 and not self.useGNTau:
             # 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' + postfix )
             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'):
  
                 alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                    'TauEfficiencyCorrectionsAlgID' + postfix )
                 config.addPrivateTool( 'efficiencyCorrectionsTool',
                                 'TauAnalysisTools::TauEfficiencyCorrectionsTool' )
                 alg.efficiencyCorrectionsTool.EfficiencyCorrectionTypes = [4]
                 if self.quality=="Loose":
                     JetIDLevel = 7
                 elif self.quality=="Medium":
                     JetIDLevel = 8
                 elif self.quality=="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:
  
                 # correction for fake tau
                 alg = config.createAlgorithm( 'CP::TauEfficiencyCorrectionsAlg',
                                    'TauEfficiencyCorrectionsAlgEvetoFakeTau' + postfix )
                 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
                 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%'
                 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' + postfix )
                 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' + postfix )
                 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

◆ quality

python.TauAnalysisConfig.TauWorkingPointConfig.quality

Definition at line 216 of file TauAnalysisConfig.py.

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

TauAnalysisConfig.py

Public Member Functions

Public Attributes