python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig Class Reference

Inheritance diagram for python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig:

Collaboration diagram for python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig:

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

Public Attributes
str	identificationWP = 'NoID' and self.doFSRSelection:
	trackSelection
	containerName
	selectionName
	recomputeID
	chargeIDSelectionRun2
	doFSRSelection
str	convSelection = "Veto":
	closeByCorrection
	recomputeChargeID

Detailed Description

the ConfigBlock for the electron working point selection

Definition at line 340 of file ElectronAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.__init__

(

self

)

Definition at line 343 of file ElectronAnalysisConfig.py.

    def __init__ (self) :
        super (ElectronWorkingPointSelectionConfig, self).__init__ ()
        self.setBlockName('ElectronWorkingPointSelection')
        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 electron 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 ('trackSelection', True, type=bool,
            info="whether or not to set up an instance of "
            "`CP::AsgLeptonTrackSelectionAlg`, with the recommended $d_0$ and "
            r"$z_0\sin\theta$ cuts.")
        self.addOption ('maxD0Significance', 5, type=float,
            info="maximum $d_0$ significance used for the track selection.")
        self.addOption ('maxDeltaZ0SinTheta', 0.5, type=float,
            info=r"maximum $z_0\sin\theta$ (in mm) used for the track selection.")
        self.addOption ('identificationWP', None, type=str,
            info="the ID WP to use. Supported ID WPs: `TightLH`, "
            "`MediumLH`, `LooseBLayerLH`, `TightDNN`, `MediumDNN`, `LooseDNN`, "
            "`TightNoCFDNN`, `MediumNoCFDNN`, `VeryLooseNoCF97DNN`, `NoID`.",
            expertMode=["NoID"],
            meta={'choices':(['MediumLH', 'LooseBLayerLH', 'TightDNN', 'MediumDNN', 'LooseDNN',
                              'TightNoCFDNN', 'MediumNoCFDNN', 'VeryLooseNoCF97DNN', 'NoID'],1)})
        self.addOption ('isolationWP', None, type=str,
            info="the isolation WP to use. Supported isolation WPs: "
            "`HighPtCaloOnly`, `Loose_VarRad`, `Tight_VarRad`, `TightTrackOnly_"
            "VarRad`, `TightTrackOnly_FixedRad`, `NonIso`.",
            meta={'choices':(['HighPtCaloOnly', 'Loose_VarRad', 'Tight_VarRad', 'TightTrackOnly_VarRad',
                              'TightTrackOnly_FixedRad', 'NonIso'],1)})
        self.addOption ('convSelection', None, type=str,
            info="enter additional selection to use for conversions. To be used with "
            "`TightLH` or will crash. Supported keywords:"
            "`Veto`, `MatConv`, `GammaStar`.",
            meta={'choices':(['Veto', 'MatConv', 'GammaStar'],1)})
        self.addOption ('addSelectionToPreselection', True, type=bool,
            info="whether to retain only electrons satisfying the working point "
            "requirements.")
        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, or rely on derivation flags.")
        self.addOption ('chargeIDSelectionRun2', False, type=bool,
            info="whether to run the ECIDS tool. Only available for Run 2.")
        self.addOption ('recomputeChargeID', False, type=bool,
            info="whether to rerun the ECIDS, or rely on 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.",
            expertMode=True)
        self.addOption ('muonsForFSRSelection', None, type=str,
            info="the name of the muon container to use for the FSR selection. "
            "If not specified, AnalysisMuons is used.",
            expertMode=True)
        self.addOption ('mainElectronContainer', None, type=str,
            info="the name of the main electron container to use for the SiHit selection. "
            "If not specified, this defaults to AnalysisElectrons.",
            expertMode=True)
 

Member Function Documentation

instanceName()

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 409 of file ElectronAnalysisConfig.py.

    def instanceName (self) :
        """Return the instance name for this block"""
        if self.postfix is not None :
            return self.containerName + '_' + self.selectionName + self.postfix
        return self.containerName + '_' + self.selectionName
 

makeAlgs()

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.makeAlgs	(		self,
			config )

Definition at line 415 of file ElectronAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        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 ElectronWorkingPointSelectionConfig with %s, there must be something wrong!" % config.geometry().value)
 
        if self.identificationWP is None:
            raise ValueError ("ElectronWorkingPointSelectionConfig: the identificationWP option must be set")
        if self.identificationWP == 'NoID' and self.doFSRSelection:
            raise ValueError ("ElectronWorkingPointSelectionConfig: doFSRSelection requires an ID working point, "
                              "it can't be used with identificationWP='NoID'")
 
        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.trackSelection :
            alg = config.createAlgorithm( 'CP::AsgLeptonTrackSelectionAlg',
                                          'ElectronTrackSelectionAlg',
                                          reentrant=True )
            alg.selectionDecoration = 'trackSelection' + postfix + ',as_bits'
            alg.maxD0Significance = self.maxD0Significance
            alg.maxDeltaZ0SinTheta = self.maxDeltaZ0SinTheta
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration,
                                 preselection=self.addSelectionToPreselection)
 
        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' )
            alg.selectionDecoration = 'selectLikelihood' + selectionPostfix + ',as_char'
            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:
                    if 'HI' not in self.identificationWP:
                        alg.selectionTool.WorkingPoint = self.identificationWP.replace("BLayer","BL") + 'Electron'
                    else:
                        alg.selectionTool.WorkingPoint = self.identificationWP.replace('_HI', 'Electron_HI')
                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')
            algVeto.selectionDecoration = 'selectLikelihoodVeto' + postfix + ',as_char'
            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 the veto as a selection
            config.addSelection (self.containerName, self.selectionName, algVeto.selectionDecoration,
                                 preselection=self.addSelectionToPreselection)
 
            # Select SiHit electrons using IsEM bits
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronLikelihoodAlg' )
            alg.selectionDecoration = 'selectSiHit' + selectionPostfix + ',as_char'
            # Select from Derivation Framework IsEM bits
            config.addPrivateTool( 'selectionTool', 'CP::AsgMaskSelectionTool' )
            dfVar = "DFCommonElectronsLHLooseBLIsEMValue"
            alg.selectionTool.selectionVars = [dfVar]
            mask = 0x6  # IsEM bits 1 and 2
            alg.selectionTool.selectionMasks = [mask]
        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' )
            alg.selectionDecoration = 'selectDNN' + selectionPostfix + ',as_char'
            if self.recomputeID:
                # Rerun the DNN ID
                config.addPrivateTool( 'selectionTool', 'AsgElectronSelectorTool' )
                # Here we have to match the naming convention of ElectronPhotonSelectorTools/Root/EGSelectorConfigurationMapping.h
                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]
        elif self.identificationWP == 'NoID':
            alg = None
        else:
            raise ValueError (f"Electron ID working point '{self.identificationWP}' is not recognised!")
 
        wpDecoration = None
        if alg is not None:
            wpDecoration = alg.selectionDecoration
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, self.selectionName)
            # Don't register WP selection here if FSR enabled - FSR algorithm will create combined selection
            if not self.doFSRSelection:
                config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration,
                                     preselection=self.addSelectionToPreselection)
 
        # maintain order of selections
        if 'SiHit' in self.identificationWP:
            # Set up the ElectronSiHitDecAlg algorithm to decorate SiHit electrons with a minimal amount of information:
            algDec = config.createAlgorithm( 'CP::ElectronSiHitDecAlg', 'ElectronSiHitDecAlg' )
            selDec = 'siHitEvtHasLeptonPair' + selectionPostfix + ',as_char'
            algDec.selectionName     = selDec.split(",")[0]
            algDec.ElectronContainer = config.readName (self.containerName)
            if self.muonsForFSRSelection is not None:
                algDec.AnalMuonContKey = config.readName (self.muonsForFSRSelection)
            if self.mainElectronContainer is not None:
                algDec.AnalElectronContKey = config.readName (self.mainElectronContainer)
            # 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,
                                 preselection=self.addSelectionToPreselection)
 
        # Additional selection for conversions and gamma*
        if self.convSelection is not None:
            # skip if not applied together with TightLH
            if self.identificationWP != 'TightLH':
                raise ValueError(f"convSelection can only be used with TightLH ID, "
                                 f"whereas {self.identificationWP} has been selected. convSelection option will be ignored.")
            # check if allowed value
            allowedValues = ["Veto", "GammaStar", "MatConv"]
            if self.convSelection not in allowedValues:
                raise ValueError(f"convSelection has been set to {self.convSelection}, which is not a valid option. "
                                 f"convSelection option must be one of {allowedValues}.")
 
            # ambiguityType == 0
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronAmbiguityTypeAlg' )
            alg.selectionDecoration = 'selectAmbiguityType' + selectionPostfix + ',as_char'
            config.addPrivateTool( 'selectionTool', 'CP::AsgNumDecorationSelectionToolUInt8' )
            alg.selectionTool.decorationName = "ambiguityType"
            alg.selectionTool.doEqual = True
            alg.selectionTool.equal = 0
            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)
 
            # DFCommonAddAmbiguity selection
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronDFCommonAddAmbiguityAlg' )
            alg.selectionDecoration = 'selectDFCommonAddAmbiguity' + selectionPostfix + ',as_char'
            config.addPrivateTool( 'selectionTool', 'CP::AsgNumDecorationSelectionToolInt' )
            alg.selectionTool.decorationName = "DFCommonAddAmbiguity"
            if self.convSelection == "Veto":
                alg.selectionTool.doMax = True
                alg.selectionTool.max = 1
            elif self.convSelection == "GammaStar":
                alg.selectionTool.doEqual = True
                alg.selectionTool.equal = 1
            elif self.convSelection == "MatConv":
                alg.selectionTool.doEqual = True
                alg.selectionTool.equal = 2
            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)
 
        # Set up the FSR selection
        if self.doFSRSelection :
            # wpSelection needs the type suffix so SysReadSelectionHandle knows the type
            # selectionDecoration needs name only for SysWriteDecorHandle
            wpDecorationName = wpDecoration.split(',')[0]
            # Insert FSR before the postfix (e.g., selectSiHit_SiHits -> selectSiHitFSR_SiHits)
            underscorePos = wpDecorationName.find('_')
            if underscorePos < 0:
                underscorePos = len(wpDecorationName)
            outputDecorationName = wpDecorationName[:underscorePos] + 'FSR' + wpDecorationName[underscorePos:]
            alg = config.createAlgorithm( 'CP::EgammaFSRForMuonsCollectorAlg', 'EgammaFSRForMuonsCollectorAlg' )
            alg.wpSelection = wpDecoration  # Input: read the WP selection (with type suffix)
            alg.selectionDecoration = outputDecorationName  # Output: combined WP||FSR (or WP&&!FSR for vetoFSR) (name only)
            alg.ElectronOrPhotonContKey = config.readName (self.containerName)
            if self.muonsForFSRSelection is not None:
                alg.MuonContKey = config.readName (self.muonsForFSRSelection)
            # 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
 
            # Register the FSR COMBINED selection
            config.addSelection (self.containerName, self.selectionName,
                                 alg.selectionDecoration + ',as_char',
                                 preselection=self.addSelectionToPreselection)
 
        # Set up the isolation selection algorithm:
        if self.isolationWP != 'NonIso' :
            alg = config.createAlgorithm( 'CP::EgammaIsolationSelectionAlg',
                                          'ElectronIsolationSelectionAlg' )
            alg.selectionDecoration = 'isolated' + selectionPostfix + ',as_char'
            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,
                                 preselection=self.addSelectionToPreselection)
 
        if self.chargeIDSelectionRun2 and config.geometry() >= LHCPeriod.Run3:
            warnings.warn_explicit(
                "ECIDS is only available for Run 2 and will not have any"
                " effect in Run 3.",
                Run2OnlyFeatureWarning, filename='', lineno=0)
 
        # 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' )
            alg.selectionDecoration = 'chargeID' + selectionPostfix + ',as_char'
            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,
                                 preselection=self.addSelectionToPreselection)
 
 

Member Data Documentation

chargeIDSelectionRun2

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.chargeIDSelectionRun2

Definition at line 497 of file ElectronAnalysisConfig.py.

closeByCorrection

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.closeByCorrection

Definition at line 622 of file ElectronAnalysisConfig.py.

containerName

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.containerName

Definition at line 447 of file ElectronAnalysisConfig.py.

convSelection

str python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.convSelection = "Veto":

Definition at line 574 of file ElectronAnalysisConfig.py.

doFSRSelection

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.doFSRSelection

Definition at line 525 of file ElectronAnalysisConfig.py.

identificationWP

str python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.identificationWP = 'NoID' and self.doFSRSelection:

Definition at line 427 of file ElectronAnalysisConfig.py.

recomputeChargeID

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.recomputeChargeID

Definition at line 640 of file ElectronAnalysisConfig.py.

recomputeID

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.recomputeID

Definition at line 455 of file ElectronAnalysisConfig.py.

selectionName

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.selectionName

Definition at line 447 of file ElectronAnalysisConfig.py.

trackSelection

python.ElectronAnalysisConfig.ElectronWorkingPointSelectionConfig.trackSelection

Definition at line 438 of file ElectronAnalysisConfig.py.

---

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

• ElectronAnalysisConfig.py