Inheritance diagram for python.LeptonSFCalculatorConfig.LeptonSFCalculatorBlock:

Collaboration diagram for python.LeptonSFCalculatorConfig.LeptonSFCalculatorBlock:

Public Member Functions
def	__init__ (self)

def	instanceName (self)

def	makeAlgs (self, config)

Detailed Description

ConfigBlock for the common electron-muon-photon-tau SF calculator

--> combine all the per-object SFs into a single per-event SF

Definition at line 7 of file LeptonSFCalculatorConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.LeptonSFCalculatorConfig.LeptonSFCalculatorBlock.__init__ ( self )

Definition at line 11 of file LeptonSFCalculatorConfig.py.

     def __init__(self):
         super(LeptonSFCalculatorBlock, self).__init__()
         self.addOption('electrons', None, type=str,
                        info='the input electron container, with a possible selection, in the format `container` or `container.selection`.')
         self.addOption('electronSFs', None, type=list,
                        info='list of decorated electron SFs to use in the computation. If not set, will use reconstruction x ID x isolation, also ECIDS (charge ID) if available.')
         self.addOption('muons', None, type=str,
                        info='the input muon container, with a possible selection, in the format `container` or `container.selection`.')
         self.addOption('muonSFs', None, type=list,
                        info='list of decorated muon SFs to use in the computation. If not set, will use reconstruction x isolation x TTVA.')
         self.addOption('photons', None, type=str,
                        info='the input photon container, with a possible selection, in the format `container` or `container.selection`.')
         self.addOption('photonSFs', None, type=list,
                        info='list of decorated photon SFs to use in the computation. If not set, will use ID x isolation.')
         self.addOption('taus', None, type=str,
                        info='the input tau container, with a possible selection, in the format `container` or `container.selection`.')
         self.addOption('tauSFs', None, type=list,
                        info='list of decorated tau SFs to use in the computation. If not set, will use reconstruction x ID x eVeto.')
         self.addOption('lepton_postfix', None, type=str,
                        info='the name of the common lepton SF, e.g. `tight`.')
         self.addOption('includeElectronChargeMisID', False, type=str,
                        info='whether to include the electron charge mis-ID SFs in the computation. The user is responsible for determining whether these are available.')
         self.addOption('includeMuonBadVeto', False, type=str,
                        info='whether to include the muon bad veto SFs in the computation. The user is responsible for determining whether these are available.')
  

Member Function Documentation

◆ instanceName()

def python.LeptonSFCalculatorConfig.LeptonSFCalculatorBlock.instanceName ( self )

Return the instance name for this block

Definition at line 36 of file LeptonSFCalculatorConfig.py.

     def instanceName (self) :
         """Return the instance name for this block"""
         return self.lepton_postfix
  

◆ makeAlgs()

def python.LeptonSFCalculatorConfig.LeptonSFCalculatorBlock.makeAlgs	(	self,
		config
	)

Definition at line 40 of file LeptonSFCalculatorConfig.py.

     def makeAlgs(self, config):
         if config.dataType() is DataType.Data: return
  
         alg = config.createAlgorithm('CP::LeptonSFCalculatorAlg',
                                      'leptonSFCalculator')
  
         if self.electrons:
             electrons, electronSelection = config.readNameAndSelection(self.electrons)
             alg.electrons                = electrons
             alg.electronSelection        = electronSelection
             if self.electronSFs:
                 alg.electronSFs = self.electronSFs
             else:
                 alg.electronSFs = [ f'el_reco_effSF_{self.electrons.split(".")[1]}_%SYS%',
                                     f'el_id_effSF_{self.electrons.split(".")[1]}_%SYS%' ]
                 if 'isolated' in alg.electronSelection:
                     alg.electronSFs += [ f'el_isol_effSF_{self.electrons.split(".")[1]}_%SYS%' ]
                 if 'chargeID' in  alg.electronSelection:
                     alg.electronSFs += [ f'el_ecids_effSF_{self.electrons.split(".")[1]}_%SYS%' ]
                 if self.includeElectronChargeMisID:
                     alg.electronSFs += [ f'el_charge_misid_effSF_{self.electrons.split(".")[1]}_%SYS%' ]
  
         if self.muons:
             muons, muonSelection         = config.readNameAndSelection(self.muons)
             alg.muons                    = muons
             alg.muonSelection            = muonSelection
             if self.muonSFs:
                 alg.muonSFs = self.muonSFs
             else:
                 alg.muonSFs = [ f'muon_reco_effSF_{self.muons.split(".")[1]}_%SYS%']
                 if 'trackSelection' in alg.muonSelection:
                     alg.muonSFs += [ f'muon_TTVA_effSF_{self.muons.split(".")[1]}_%SYS%' ]
                 if 'isolated' in alg.muonSelection:
                     alg.muonSFs += [ f'muon_isol_effSF_{self.muons.split(".")[1]}_%SYS%' ]
                 if self.includeMuonBadVeto:
                     alg.muonSFs += [ f'muon_BadMuonVeto_effSF_{self.muons.split(".")[1]}_%SYS%' ]
  
         if self.photons:
             photons, photonSelection     = config.readNameAndSelection(self.photons)
             alg.photons                  = photons
             alg.photonSelection          = photonSelection
             if self.photonSFs:
                 alg.photonSFs = self.photonSFs
             else:
                 alg.photonSFs = [ f'ph_id_effSF_{self.photons.split(".")[1]}_%SYS%' ]
                 if 'isolated' in alg.photonSelection:
                     alg.photonSFs += [ f'ph_isol_effSF_{self.photons.split(".")[1]}_%SYS%' ]
  
         if self.taus:
             taus, tauSelection           = config.readNameAndSelection(self.taus)
             alg.taus                     = taus
             alg.tauSelection             = tauSelection
             if self.tauSFs:
                 alg.tauSFs = self.tauSFs
             else:
                 alg.tauSFs = [ f'tau_Reco_effSF_{self.taus.split(".")[1]}_%SYS%',
                                f'tau_ID_effSF_{self.taus.split(".")[1]}_%SYS%']
                 if 'eVeto' in alg.tauSelection:
                     alg.tauSFs += [ f'tau_EvetoFakeTau_effSF_{self.taus.split(".")[1]}_%SYS%',
                                     f'tau_EvetoTrueTau_effSF_{self.taus.split(".")[1]}_%SYS%']
  
         alg.event_leptonSF = f'leptonSF_{self.lepton_postfix}_%SYS%'
  
         config.addOutputVar('EventInfo', alg.event_leptonSF, f'weight_leptonSF_{self.lepton_postfix}')

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

LeptonSFCalculatorConfig.py