Inheritance diagram for python.ElectronAnalysisConfig.ElectronWorkingPointConfig:

Collaboration diagram for python.ElectronAnalysisConfig.ElectronWorkingPointConfig:

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

def	makeAlgs (self, config)

Detailed Description

the ConfigBlock for the electron working point

This may at some point be split into multiple blocks (29 Aug 22).

Definition at line 211 of file ElectronAnalysisConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.ElectronAnalysisConfig.ElectronWorkingPointConfig.__init__	(	self,
		containerName = `''`,
		selectionName = `''`
	)

Definition at line 216 of file ElectronAnalysisConfig.py.

     def __init__ (self, containerName='', selectionName='') :
         super (ElectronWorkingPointConfig, 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 electron 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 ('trackSelection', True, type=bool,
             info="whether or not to set up an instance of "
             "CP::AsgLeptonTrackSelectionAlg, with the recommended d_0 and "
             "z_0 sin(theta) cuts. The default is True.")
         self.addOption ('maxD0Significance', 5, type=float,
             info="maximum d0 significance used for the trackSelection"
             "The default is 5")
         self.addOption ('maxDeltaZ0SinTheta', 0.5, type=float,
             info="maximum z0sinTheta in mm used for the trackSelection"
             "The default is 0.5 mm")
         self.addOption ('writeTrackD0Z0', False, type = bool,
             info="save the d0 significance and z0sinTheta variables so they can be written out")
         self.addOption ('identificationWP', None, type=str,
             info="the ID WP (string) to use. Supported ID WPs: TightLH, "
             "MediumLH, LooseBLayerLH, TightDNN, MediumDNN, LooseDNN, "
             "TightDNNnoCF, MediumDNNnoCF, VeryLooseDNNnoCF97.")
         self.addOption ('isolationWP', None, type=str,
             info="the isolation WP (string) to use. Supported isolation WPs: "
             "HighPtCaloOnly, Loose_VarRad, Tight_VarRad, TightTrackOnly_"
             "VarRad, TightTrackOnly_FixedRad, NonIso.")
         self.addOption ('closeByCorrection', False, type=bool,
             info="whether to use close-by-corrected isolation working points")
         self.addOption ('recomputeID', False, type=bool,
             info="whether to rerun the ID LH/DNN. The default is False, i.e. to use "
             "derivation flags.")
         self.addOption ('chargeIDSelectionRun2', False, type=bool,
             info="whether to run the ECIDS tool. Only available for run 2. "
             "The default is False.")
         self.addOption ('recomputeChargeID', False, type=bool,
             info="whether to rerun the ECIDS. The default is False, i.e. to use "
             "derivation flags.")
         self.addOption ('doFSRSelection', False, type=bool,
             info="whether to accept additional electrons close to muons for "
             "the purpose of FSR corrections to these muons. Expert feature "
             "requested by the H4l analysis running on PHYSLITE. "
             "The default is 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. The default is False.")
         self.addOption ('forceFullSimConfig', False, type=bool,
             info="whether to force the tool to use the configuration meant for "
             "full simulation samples. Only for testing purposes. "
             "The default is False.")
         self.addOption ('correlationModelId', 'SIMPLIFIED', type=str,
             info="the correlation model (string) to use for ID scale factors "
             "Supported models: SIMPLIFIED (default), FULL, TOTAL, TOYS")
         self.addOption ('correlationModelIso', 'SIMPLIFIED', type=str,
             info="the correlation model (string) to use for isolation scale factors "
             "Supported models: SIMPLIFIED (default), FULL, TOTAL, TOYS")
         self.addOption ('correlationModelReco', 'SIMPLIFIED', type=str,
             info="the correlation model (string) to use for reconstruction scale factors "
             "Supported models: SIMPLIFIED (default), FULL, TOTAL, TOYS")
  
  

Member Function Documentation

◆ makeAlgs()

def python.ElectronAnalysisConfig.ElectronWorkingPointConfig.makeAlgs	(	self,
		config
	)

Definition at line 283 of file ElectronAnalysisConfig.py.

     def makeAlgs (self, config) :
  
         log = logging.getLogger('ElectronWorkingPointConfig')
  
         if self.forceFullSimConfig:
             log.warning("You are running ElectronWorkingPointConfig forcing full sim config")
             log.warning("This is only intended to be used for testing purposes")
  
         selectionPostfix = self.selectionName
         if selectionPostfix != '' and selectionPostfix[0] != '_' :
             selectionPostfix = '_' + selectionPostfix
  
         # The setup below is inappropriate for Run 1
         if config.geometry() is LHCPeriod.Run1:
             raise ValueError ("Can't set up the ElectronWorkingPointConfig with %s, there must be something wrong!" % config.geometry().value)
  
         postfix = self.postfix
         if postfix is None :
             postfix = self.selectionName
         if postfix != '' and postfix[0] != '_' :
             postfix = '_' + postfix
  
         # Set up the track selection algorithm:
         if self.writeTrackD0Z0 or self.trackSelection :
             alg = config.createAlgorithm( 'CP::AsgLeptonTrackSelectionAlg',
                                         'ElectronTrackSelectionAlg' + postfix )
             alg.selectionDecoration = 'trackSelection' + postfix + ',as_bits'
             alg.maxD0Significance = self.maxD0Significance
             alg.maxDeltaZ0SinTheta = self.maxDeltaZ0SinTheta
             alg.decorateTTVAVars = self.writeTrackD0Z0
             alg.particles = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, '')
             if self.trackSelection :
                 config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
             if self.writeTrackD0Z0 :
                 alg.d0sigDecoration = 'd0sig' + postfix
                 alg.z0sinthetaDecoration = 'z0sintheta' + postfix
                 config.addOutputVar (self.containerName, alg.d0sigDecoration, alg.d0sigDecoration,noSys=True)
                 config.addOutputVar (self.containerName, alg.z0sinthetaDecoration, alg.z0sinthetaDecoration,noSys=True)
  
         if 'LH' in self.identificationWP:
             # Set up the likelihood ID selection algorithm
             # It is safe to do this before calibration, as the cluster E is used
             alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronLikelihoodAlg' + postfix )
             alg.selectionDecoration = 'selectLikelihood' + selectionPostfix + ',as_bits'
             if self.recomputeID:
                 # Rerun the likelihood ID
                 config.addPrivateTool( 'selectionTool', 'AsgElectronLikelihoodTool' )
                 alg.selectionTool.primaryVertexContainer = 'PrimaryVertices'
                 # Here we have to match the naming convention of EGSelectorConfigurationMapping.h
                 # which differ from the one used for scale factors
                 if config.geometry() >= LHCPeriod.Run3:
                     alg.selectionTool.WorkingPoint = self.identificationWP.replace("BLayer","BL") + 'Electron'
                 elif config.geometry() is LHCPeriod.Run2:
                     alg.selectionTool.WorkingPoint = self.identificationWP.replace("BLayer","BL") + 'Electron_Run2'
             else:
                 # Select from Derivation Framework flags
                 config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
                 dfFlag = "DFCommonElectronsLH" + self.identificationWP.split('LH')[0]
                 dfFlag = dfFlag.replace("BLayer","BL")
                 alg.selectionTool.selectionFlags = [dfFlag]
         elif 'SiHit' in self.identificationWP:
             # Only want SiHit electrons, so veto loose LH electrons
             algVeto = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronLikelihoodAlgVeto' + postfix + 'Veto')
             algVeto.selectionDecoration = 'selectLikelihoodVeto' + postfix + ',as_bits'
             config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
             algVeto.selectionTool.selectionFlags = ["DFCommonElectronsLHLoose"]
             algVeto.selectionTool.invertFlags    = [True]
             algVeto.particles = config.readName (self.containerName)
             algVeto.preselection = config.getPreselection (self.containerName, self.selectionName)
             # add in as preselection a veto
             config.addSelection (self.containerName, self.selectionName, algVeto.selectionDecoration)
  
             # Select SiHit electrons using IsEM bits
             alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronLikelihoodAlg' + postfix )
             alg.selectionDecoration = 'selectSiHit' + selectionPostfix + ',as_bits'
             # Select from Derivation Framework IsEM bits
             config.addPrivateTool( 'selectionTool', 'CP::AsgMaskSelectionTool' )
             dfVar = "DFCommonElectronsLHLooseBLIsEMValue"
             alg.selectionTool.selectionVars = [dfVar]
             mask = int( 0 | 0x1 << 1 | 0x1 << 2)
             alg.selectionTool.selectionMasks = [mask]
  
             # Set up the ElectronSiHitDecAlg algorithm to decorate SiHit electrons with a minimal amount of information:
             algDec = config.createAlgorithm( 'CP::ElectronSiHitDecAlg', 'ElectronSiHitDecAlg' + postfix )
             selDec = 'siHitEvtHasLeptonPair' + selectionPostfix + ',as_bits'
             algDec.selectionName     = selDec.split(",")[0]
             algDec.ElectronContainer = config.readName (self.containerName)
             # Set flag to only collect SiHit electrons for events with an electron or muon pair to minimize size increase from SiHit electrons
             algDec.RequireTwoLeptons = True
             config.addSelection (self.containerName, self.selectionName, selDec)
         elif 'DNN' in self.identificationWP:
             if self.chargeIDSelectionRun2:
                 raise ValueError('DNN is not intended to be used with '
                                  '`chargeIDSelectionRun2` option as there are '
                                  'DNN WPs containing charge flip rejection.')
             # Set up the DNN ID selection algorithm
             alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronDNNAlg' + postfix )
             alg.selectionDecoration = 'selectDNN' + selectionPostfix + ',as_bits'
             if self.recomputeID:
                 # Rerun the DNN ID
                 config.addPrivateTool( 'selectionTool', 'AsgElectronSelectorTool' )
                 # Here we have to match the naming convention of EGSelectorConfigurationMapping.h
                 if config.geometry() is LHCPeriod.Run3:
                     raise ValueError ( "DNN working points are not available for Run 3 yet.")
                 else:
                     alg.selectionTool.WorkingPoint = self.identificationWP + 'Electron'
             else:
                 # Select from Derivation Framework flags
                 config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
                 dfFlag = "DFCommonElectronsDNN" + self.identificationWP.split('DNN')[0]
                 alg.selectionTool.selectionFlags = [dfFlag]
  
         alg.particles = config.readName (self.containerName)
         alg.preselection = config.getPreselection (self.containerName, self.selectionName)
         config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
  
         # Set up the FSR selection
         if self.doFSRSelection :
             # save the flag set for the WP
             wpFlag = alg.selectionDecoration.split(",")[0]
             alg = config.createAlgorithm( 'CP::EgammaFSRForMuonsCollectorAlg', 'EgammaFSRForMuonsCollectorAlg' + postfix )
             alg.selectionDecoration = wpFlag
             alg.ElectronOrPhotonContKey = config.readName (self.containerName)
             # For SiHit electrons, set flag to remove FSR electrons.
             # For standard electrons, FSR electrons need to be added as they may be missed by the standard selection.
             # For SiHit electrons FSR electrons are generally always selected, so they should be removed since they will be in the standard electron container.
             if 'SiHit' in self.identificationWP:
                 alg.vetoFSR = True
  
         # Set up the isolation selection algorithm:
         if self.isolationWP != 'NonIso' :
             alg = config.createAlgorithm( 'CP::EgammaIsolationSelectionAlg',
                                           'ElectronIsolationSelectionAlg' + postfix )
             alg.selectionDecoration = 'isolated' + selectionPostfix + ',as_bits'
             config.addPrivateTool( 'selectionTool', 'CP::IsolationSelectionTool' )
             alg.selectionTool.ElectronWP = self.isolationWP
             if self.closeByCorrection:
               alg.selectionTool.IsoDecSuffix = "CloseByCorr"
             alg.egammas = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
  
         if self.chargeIDSelectionRun2 and config.geometry() >= LHCPeriod.Run3:
             log.warning("ECIDS is only available for Run 2 and will not have effect in run 3.")
  
         # Select electrons only if they don't appear to have flipped their charge.
         if self.chargeIDSelectionRun2 and config.geometry() < LHCPeriod.Run3:
             alg = config.createAlgorithm( 'CP::AsgSelectionAlg',
                                           'ElectronChargeIDSelectionAlg' + postfix )
             alg.selectionDecoration = 'chargeID' + selectionPostfix + ',as_bits'
             if self.recomputeChargeID:
                 # Rerun the ECIDS BDT
                 config.addPrivateTool( 'selectionTool',
                                        'AsgElectronChargeIDSelectorTool' )
                 alg.selectionTool.TrainingFile = \
                     'ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root'
                 alg.selectionTool.WorkingPoint = 'Loose'
                 alg.selectionTool.CutOnBDT = -0.337671 # Loose 97%
             else:
                 # Select from Derivation Framework flags
                 config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
                 alg.selectionTool.selectionFlags = ["DFCommonElectronsECIDS"]
  
             alg.particles = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
  
         correlationModels = ["SIMPLIFIED", "FULL", "TOTAL", "TOYS"]
  
         # Set up the RECO electron efficiency correction algorithm:
         if config.dataType() is not DataType.Data and not self.noEffSF:
  
             if config.geometry() is LHCPeriod.Run2:
                 raise ValueError('Run 2 does not yet have efficiency correction, '
                                  'please disable it by setting `noEffSF` to True.')
             if 'DNN' in self.identificationWP:
                 raise ValueError('DNN does not yet have efficiency correction, '
                                  'please disable it by setting `noEffSF` to True.')
  
             alg = config.createAlgorithm( 'CP::ElectronEfficiencyCorrectionAlg',
                                           'ElectronEfficiencyCorrectionAlgReco' + postfix )
             config.addPrivateTool( 'efficiencyCorrectionTool',
                                    'AsgElectronEfficiencyCorrectionTool' )
             alg.scaleFactorDecoration = 'el_reco_effSF' + selectionPostfix + '_%SYS%'
             alg.efficiencyCorrectionTool.RecoKey = "Reconstruction"
             if self.correlationModelReco not in correlationModels:
                 raise ValueError('Invalid correlation model for reconstruction efficiency, '
                                  f'has to be one of: {", ".join(correlationModels)}')
             if config.geometry() >= LHCPeriod.Run3 and self.correlationModelReco != "TOTAL":
                 log.warning("Only TOTAL correlation model is currently supported "
                             "for reconstruction efficiency correction in Run 3.")
                 alg.efficiencyCorrectionTool.CorrelationModel = "TOTAL"
             else:
                 alg.efficiencyCorrectionTool.CorrelationModel = self.correlationModelReco
             if config.dataType() is DataType.FastSim:
                 alg.efficiencyCorrectionTool.ForceDataType = (
                     PATCore.ParticleDataType.Full if self.forceFullSimConfig
                     else PATCore.ParticleDataType.Fast)
             elif config.dataType() is DataType.FullSim:
                 alg.efficiencyCorrectionTool.ForceDataType = \
                     PATCore.ParticleDataType.Full
             alg.outOfValidity = 2 #silent
             alg.outOfValidityDeco = 'el_reco_bad_eff' + selectionPostfix
             alg.electrons = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'reco_effSF' + postfix)
  
         # Set up the ID electron efficiency correction algorithm:
         if config.dataType() is not DataType.Data and not self.noEffSF:
             alg = config.createAlgorithm( 'CP::ElectronEfficiencyCorrectionAlg',
                                           'ElectronEfficiencyCorrectionAlgID' + postfix )
             config.addPrivateTool( 'efficiencyCorrectionTool',
                                    'AsgElectronEfficiencyCorrectionTool' )
             alg.scaleFactorDecoration = 'el_id_effSF' + selectionPostfix + '_%SYS%'
             alg.efficiencyCorrectionTool.IdKey = self.identificationWP.replace("LH","")
             if self.correlationModelId not in correlationModels:
                 raise ValueError('Invalid correlation model for identification efficiency, '
                                  f'has to be one of: {", ".join(correlationModels)}')
             alg.efficiencyCorrectionTool.CorrelationModel = self.correlationModelId
             if config.dataType() is DataType.FastSim:
                 alg.efficiencyCorrectionTool.ForceDataType = (
                     PATCore.ParticleDataType.Full if self.forceFullSimConfig
                     else PATCore.ParticleDataType.Fast)
             elif config.dataType() is DataType.FullSim:
                 alg.efficiencyCorrectionTool.ForceDataType = \
                     PATCore.ParticleDataType.Full
             alg.outOfValidity = 2 #silent
             alg.outOfValidityDeco = 'el_id_bad_eff' + selectionPostfix
             alg.electrons = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'id_effSF' + postfix)
  
         # Set up the ISO electron efficiency correction algorithm:
         if config.dataType() is not DataType.Data and self.isolationWP != 'NonIso' and not self.noEffSF:
             alg = config.createAlgorithm( 'CP::ElectronEfficiencyCorrectionAlg',
                                           'ElectronEfficiencyCorrectionAlgIsol' + postfix )
             config.addPrivateTool( 'efficiencyCorrectionTool',
                                    'AsgElectronEfficiencyCorrectionTool' )
             alg.scaleFactorDecoration = 'el_isol_effSF' + selectionPostfix + '_%SYS%'
             alg.efficiencyCorrectionTool.IdKey = self.identificationWP.replace("LH","")
             alg.efficiencyCorrectionTool.IsoKey = self.isolationWP
             if self.correlationModelIso not in correlationModels:
                 raise ValueError('Invalid correlation model for isolation efficiency, '
                                  f'has to be one of: {", ".join(correlationModels)}')
             if config.geometry() >= LHCPeriod.Run3:
                 log.warning("Only TOTAL correlation model is currently supported "
                       "for isolation efficiency correction in Run 3.")
                 alg.efficiencyCorrectionTool.CorrelationModel = "TOTAL"
             else:
                 alg.efficiencyCorrectionTool.CorrelationModel = self.correlationModelIso
             if config.dataType() is DataType.FastSim:
                 alg.efficiencyCorrectionTool.ForceDataType = (
                     PATCore.ParticleDataType.Full if self.forceFullSimConfig
                     else PATCore.ParticleDataType.Fast)
             elif config.dataType() is DataType.FullSim:
                 alg.efficiencyCorrectionTool.ForceDataType = \
                     PATCore.ParticleDataType.Full
             alg.outOfValidity = 2 #silent
             alg.outOfValidityDeco = 'el_isol_bad_eff' + selectionPostfix
             alg.electrons = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'isol_effSF' + postfix)
  
         # TO-DO: add trigger SFs, for which we need ID key + ISO key + Trigger key !
  
         if self.chargeIDSelectionRun2:
             # ECIDS is currently not supported in R22.
             # SFs might become available or it will be part of the DNN ID.
             pass
  
  

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

ElectronAnalysisConfig.py

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ makeAlgs()

◆ init()