Inheritance diagram for python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig:

Collaboration diagram for python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig:

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

Public Attributes
str	qualityWP = 'Tight' :
	recomputeIsEM
	doFSRSelection
	containerName
	selectionName
	closeByCorrection

Detailed Description

the ConfigBlock for the photon working point selection

Definition at line 311 of file PhotonAnalysisConfig.py.

Constructor & Destructor Documentation

◆ init()

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.__init__ ( self )

Definition at line 314 of file PhotonAnalysisConfig.py.

    def __init__ (self) :
        super (PhotonWorkingPointSelectionConfig, self).__init__ ()
        self.setBlockName('PhotonWorkingPointSelection')
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the input container.")
        self.addOption ('selectionName', '', type=str,
            noneAction='error',
            info="the name of the photon 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 ('qualityWP', None, type=str,
            info="the ID WP to use. Supported ID WPs: `Tight`, `Medium`, `Loose`.")
        self.addOption ('isolationWP', None, type=str,
            info="the isolation WP to use. Supported isolation WPs: "
            "`FixedCutLoose`, `FixedCutTight`, `TightCaloOnly`, `NonIso`.")
        self.addOption ('addSelectionToPreselection', True, type=bool,
            info="whether to retain only photons satisfying the working point "
            "requirements.")
        self.addOption ('closeByCorrection', False, type=bool,
            info="whether to use close-by-corrected isolation working points.")
        self.addOption ('recomputeIsEM', False, type=bool,
            info="whether to rerun the cut-based selection (`True`), or rely on derivation flags (`False`).")
        self.addOption ('doFSRSelection', False, type=bool,
            info="whether to accept additional photons 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)
 

Member Function Documentation

◆ instanceName()

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.instanceName ( self )

Return the instance name for this block

Definition at line 349 of file PhotonAnalysisConfig.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.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.makeAlgs	(		self,
			config )

Definition at line 355 of file PhotonAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        # The setup below is inappropriate for Run 1
        if config.geometry() is LHCPeriod.Run1:
            raise ValueError ("Can't set up the PhotonWorkingPointConfig 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
 
        if self.qualityWP == 'Tight' :
            quality = ROOT.egammaPID.PhotonTight
        elif self.qualityWP == 'Medium' :
            quality = ROOT.egammaPID.PhotonMedium
        elif self.qualityWP == 'Loose' :
            quality = ROOT.egammaPID.PhotonLoose
        else :
            raise Exception ('unknown photon quality working point "' + self.qualityWP + '" should be Tight, Medium or Loose')
 
        # Set up the photon selection algorithm:
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonIsEMSelectorAlg' )
        alg.selectionDecoration = 'selectEM' + postfix + ',as_char'
        if self.recomputeIsEM:
            # Rerun the cut-based ID
            config.addPrivateTool( 'selectionTool', 'AsgPhotonIsEMSelector' )
            alg.selectionTool.isEMMask = quality
            if config.geometry() is LHCPeriod.Run2:
                if self.qualityWP == 'Tight':
                    alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc20_20240510/PhotonIsEMTightSelectorCutDefs_pTdep_mc20_smooth.conf'
                elif self.qualityWP == 'Loose':
                    alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf'
                elif self.qualityWP == 'Medium':
                    alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc20_20240510/PhotonIsEMMediumSelectorCutDefs_pTdep_smooth.conf'
            if config.geometry() is LHCPeriod.Run3:
                if self.qualityWP == 'Tight':
                    alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/20180825/PhotonIsEMTightSelectorCutDefs.conf'
                elif self.qualityWP == 'Loose':
                    alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf'
                elif self.qualityWP == 'Medium':
                    raise ValueError('No Medium menu available for Run-3. Please get in contact with egamma')
        else:
            # Select from Derivation Framework flags
            config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
            dfFlag = 'DFCommonPhotonsIsEM' + self.qualityWP
            alg.selectionTool.selectionFlags = [ dfFlag ]
        alg.particles = config.readName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, self.selectionName)
 
        # Set up the FSR selection
        if self.doFSRSelection :
            # wpSelection needs the ',as_char' suffix so SysReadSelectionHandle knows the type
            wpDecoration = alg.selectionDecoration
            wpDecorationName = wpDecoration.split(',')[0]
            # Insert FSR before the postfix (e.g., selectEM_loose -> selectEMFSR_loose)
            underscorePos = wpDecorationName.index('_')
            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 (name only for SysWriteDecorHandle)
            alg.ElectronOrPhotonContKey = config.readName (self.containerName)
            if self.muonsForFSRSelection is not None:
                alg.MuonContKey = config.readName (self.muonsForFSRSelection)
 
            # Register the FSR COMBINED selection
            config.addSelection (self.containerName, self.selectionName,
                                 alg.selectionDecoration + ',as_char',
                                 preselection=self.addSelectionToPreselection)
        else:
            # No FSR - register the WP selection directly
            config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration,
                                 preselection=self.addSelectionToPreselection)
 
        # Set up the isolation selection algorithm:
        if self.isolationWP != 'NonIso' :
            alg = config.createAlgorithm( 'CP::EgammaIsolationSelectionAlg',
                                          'PhotonIsolationSelectionAlg' )
            alg.selectionDecoration = 'isolated' + postfix + ',as_char'
            config.addPrivateTool( 'selectionTool', 'CP::IsolationSelectionTool' )
            alg.selectionTool.PhotonWP = self.isolationWP
            if self.closeByCorrection:
              alg.selectionTool.IsoDecSuffix = "CloseByCorr"
            alg.isPhoton = True
            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)
 
 

Member Data Documentation

◆ closeByCorrection

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.closeByCorrection

Definition at line 437 of file PhotonAnalysisConfig.py.

◆ containerName

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.containerName

Definition at line 422 of file PhotonAnalysisConfig.py.

◆ doFSRSelection

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.doFSRSelection

Definition at line 406 of file PhotonAnalysisConfig.py.

◆ qualityWP

str python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.qualityWP = 'Tight' :

Definition at line 367 of file PhotonAnalysisConfig.py.

◆ recomputeIsEM

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.recomputeIsEM

Definition at line 379 of file PhotonAnalysisConfig.py.

◆ selectionName

python.PhotonAnalysisConfig.PhotonWorkingPointSelectionConfig.selectionName