PhotonAnalysisConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
# AnaAlgorithm import(s):
from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
from AnalysisAlgorithmsConfig.ConfigSequence import groupBlocks
from AthenaCommon.SystemOfUnits import GeV
from AthenaConfiguration.Enums import LHCPeriod
from Campaigns.Utils import Campaign
from AnalysisAlgorithmsConfig.ConfigAccumulator import (
    DataType, Run4FallbackWarning, TestingOnlyWarning)
import warnings
 
import ROOT
 
# E/gamma import(s).
from xAODEgamma.xAODEgammaParameters import xAOD
 
import PATCore.ParticleDataType
 
class PhotonCalibrationConfig (ConfigBlock) :
    """the ConfigBlock for the photon four-momentum correction"""
 
    def __init__ (self) :
        super (PhotonCalibrationConfig, self).__init__ ()
        self.setBlockName('Photons')
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the output container after calibration.",
            meta={'role':'container'})
        self.addOption ('ESModel', '', type=str,
            info="flag for EGamma calibration. If left empty, uses the current recommendations.")
        self.addOption ('decorrelationModel', '1NP_v1', type=str,
            info="decorrelation model for the EGamma energy scale. Supported choices are: `FULL_v1`, `1NP_v1`.",
            meta={'choices':(['FULL_v1','1NP_v1'],1)})
        self.addOption ('postfix', '', type=str,
            info="a postfix to apply to decorations and algorithm names. "
            "Typically not needed here since the calibration is common to "
            "all photons.")
        self.addOption ('crackVeto', False, type=bool,
            info=r"whether to perform LAr crack veto based on the cluster $\eta$, "
            r"i.e. remove photons within $1.37<\vert\eta\vert<1.52$.")
        self.addOption ('enableCleaning', True, type=bool,
            info="whether to enable photon cleaning (`DFCommonPhotonsCleaning`).")
        self.addOption ('cleaningAllowLate', False, type=bool,
            info="whether to ignore timing information in cleaning "
            "(`DFCommonPhotonsCleaningNoTime`).")
        self.addOption ('recomputeIsEM', False, type=bool,
            info="whether to recompute the photon shower shape fudge "
            "corrections (sets up an instance of `CP::PhotonShowerShapeFudgeAlg`) or rely on derivation flags.")
        self.addOption ('recalibratePhyslite', True, type=bool,
            info="whether to run the `CP::EgammaCalibrationAndSmearingAlg` on "
            "PHYSLITE derivations.")
        self.addOption ('minPt', 10*GeV, type=float,
            info=r"the minimum $p_\mathrm{T}$ cut (in MeV) to apply to calibrated photons.")
        self.addOption ('maxEta', 2.37, type=float,
            info=r"maximum photon $\vert\eta\vert$.")
        self.addOption ('forceFullSimConfigForP4', False, type=bool,
            info="whether to force the tool to use the configuration meant for "
            "full simulation samples for 4-vector corrections. Only for testing purposes.")
        self.addOption ('forceFullSimConfigForIso', False, type=bool,
            info="whether to force the tool to use the configuration meant for "
            "full simulation samples for isolation corrections. Only for testing purposes.")
        self.addOption ('applyIsolationCorrection', True, type=bool,
            info="whether to apply the isolation corrections.")
        self.addOption ('splitCalibrationAndSmearing', False, type=bool,
            info="EXPERIMENTAL: This splits the `EgammaCalibrationAndSmearingTool` "
            " into two steps. The first step applies a baseline calibration that "
            "is not affected by systematics. The second step then applies the "
            "systematics dependent corrections.  The net effect is that the "
            "slower first step only has to be run once, while the second is run "
            "once per systematic. ATLASG-2358.",
            expertMode=True)
        self.addOption ('decorateTruth', False, type=bool,
            info="decorate the truth particle information on the reconstructed one.")
        self.addOption ('decorateCaloClusterEta', False, type=bool,
            info=r"decorate the calo-cluster $\eta$.")
        self.addOption ('decorateEmva', False, type=bool,
            info="decorate `E_mva_only` on the photons (needed for columnar tools/PHYSLITE).")
        self.addOption ('addGlobalFELinksDep', False, type=bool,
            info="whether to add dependencies for the global FE links (needed for PHYSLITE production)",
            expertMode=True)
 
    def instanceName (self) :
        """Return the instance name for this block"""
        return self.containerName + self.postfix
 
 
    def makeCalibrationAndSmearingAlg (self, config, name) :
        """Create the calibration and smearing algorithm
 
        Factoring this out into its own function, as we want to
        instantiate it in multiple places"""
 
        # Set up the calibration and smearing algorithm:
        alg = config.createAlgorithm( 'CP::EgammaCalibrationAndSmearingAlg', name )
        config.addPrivateTool( 'calibrationAndSmearingTool',
                               'CP::EgammaCalibrationAndSmearingTool' )
        # Set default ESModel per period
        if self.ESModel:
            alg.calibrationAndSmearingTool.ESModel = self.ESModel
        else:
            if config.geometry() is LHCPeriod.Run2:
                alg.calibrationAndSmearingTool.ESModel = 'es2023_R22_Run2_v1'
            elif config.geometry() is LHCPeriod.Run3:
                alg.calibrationAndSmearingTool.ESModel = 'es2024_Run3_v0'
            elif config.geometry() is LHCPeriod.Run4:
                warnings.warn_explicit(
                    "No ESModel set for Run4, using Run3 model",
                    Run4FallbackWarning, filename='', lineno=0)
                alg.calibrationAndSmearingTool.ESModel = 'es2024_Run3_v0'
            else:
                raise ValueError (f"Can't set up the PhotonCalibrationConfig with {config.geometry().value}, "
                                  "there must be something wrong!")
 
        alg.calibrationAndSmearingTool.decorrelationModel = self.decorrelationModel
        alg.calibrationAndSmearingTool.useFastSim = (
            0 if self.forceFullSimConfigForP4
            else int( config.dataType() is DataType.FastSim ))
        alg.calibrationAndSmearingTool.decorateEmva = self.decorateEmva
        # only photons are calibrated here, so skip loading the electron BDTs
        alg.calibrationAndSmearingTool.DoElectronMVACalibration = False
        alg.egammas = config.readName (self.containerName)
        alg.egammasOut = config.copyName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
 
        config.setContainerMeta (self.containerName, 'ESModel', alg.calibrationAndSmearingTool.ESModel, allowOverwrite=True)
        config.setContainerMeta (self.containerName, 'decorrelationModel', alg.calibrationAndSmearingTool.decorrelationModel, allowOverwrite=True)
 
        return alg
 
 
    def makeAlgs (self, config) :
 
        postfix = self.postfix
        if postfix != '' and postfix[0] != '_' :
            postfix = '_' + postfix
 
        if self.forceFullSimConfigForP4:
            warnings.warn_explicit(
                "You are running PhotonCalibrationConfig forcing"
                " full sim config for P4 corrections."
                " This is only intended to be used for testing purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        if config.isPhyslite() :
            config.setSourceName (self.containerName, "AnalysisPhotons")
        else :
            config.setSourceName (self.containerName, "Photons")
 
        cleaningWP = 'NoTime' if self.cleaningAllowLate else ''
 
        # Decorate calo cluster eta if required
        if self.decorateCaloClusterEta:
            alg = config.createAlgorithm( 'CP::EgammaCaloClusterEtaAlg',
                                          'PhotonEgammaCaloClusterEtaAlg',
                                           reentrant=True )
            alg.particles = config.readName(self.containerName)
            config.addOutputVar (self.containerName, 'caloEta2', 'caloEta2', noSys=True, auxType='float')
 
        # Set up a shallow copy to decorate
        if config.wantCopy (self.containerName) :
            alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'PhotonShallowCopyAlg' )
            alg.input = config.readName (self.containerName)
            alg.output = config.copyName (self.containerName)
            alg.outputType = 'xAOD::PhotonContainer'
            decorationList = ['DFCommonPhotonsCleaning',
                              'ptcone20_CloseByCorr',
                              'topoetcone20_CloseByCorr',
                              'topoetcone40_CloseByCorr']
            if self.addGlobalFELinksDep:
                decorationList += ['neutralGlobalFELinks', 'chargedGlobalFELinks']
            if config.dataType() is not DataType.Data:
                decorationList += ['TruthLink']
            alg.declareDecorations = decorationList
 
        # Set up the eta-cut on all photons prior to everything else
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonEtaCutAlg' )
        alg.selectionDecoration = 'selectEta' + postfix + ',as_bits'
        config.addPrivateTool( 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
        alg.selectionTool.maxEta = self.maxEta
        if self.crackVeto:
            alg.selectionTool.etaGapLow = 1.37
            alg.selectionTool.etaGapHigh = 1.52
        alg.selectionTool.useClusterEta = True
        alg.particles = config.readName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
        config.addSelection (self.containerName, '', alg.selectionDecoration)
 
        # Setup shower shape fudge
        if self.recomputeIsEM and config.dataType() is DataType.FullSim:
            alg = config.createAlgorithm( 'CP::PhotonShowerShapeFudgeAlg',
                                          'PhotonShowerShapeFudgeAlg' )
            config.addPrivateTool( 'showerShapeFudgeTool',
                                    'ElectronPhotonVariableCorrectionTool' )
            if config.geometry() is LHCPeriod.Run2:
                alg.showerShapeFudgeTool.ConfigFile = \
              'EGammaVariableCorrection/TUNE25/ElPhVariableNominalCorrection.conf'
            if config.geometry() is LHCPeriod.Run3:
                if config.campaign() in (Campaign.MC23a, Campaign.MC23d):
                    alg.showerShapeFudgeTool.ConfigFile = \
                    'EGammaVariableCorrection/TUNE28AD/ElPhVariableNominalCorrection.conf'
                else:
                    alg.showerShapeFudgeTool.ConfigFile = \
                    'EGammaVariableCorrection/TUNE28EG/ElPhVariableNominalCorrection.conf'
            alg.photons = config.readName (self.containerName)
            alg.photonsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        # Select photons only with good object quality.
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonObjectQualityAlg' )
        config.setExtraInputs ({('xAOD::EventInfo', 'EventInfo.RandomRunNumber')})
        alg.selectionDecoration = 'goodOQ' + postfix + ',as_bits'
        config.addPrivateTool( 'selectionTool', 'CP::EgammaIsGoodOQSelectionTool' )
        alg.selectionTool.Mask = xAOD.EgammaParameters.BADCLUSPHOTON
        alg.particles = config.readName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
        config.addSelection (self.containerName, '', alg.selectionDecoration)
 
        # Select clean photons
        if self.enableCleaning:
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonCleaningAlg' )
            config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
            alg.selectionDecoration = 'isClean' + postfix + ',as_bits'
            alg.selectionTool.selectionFlags = ['DFCommonPhotonsCleaning' + cleaningWP]
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, '', alg.selectionDecoration)
 
        # Change the origin of Photons from (0,0,0) to (0,0,z)
        # where z comes from the position of a vertex
        # Default the one tagged as Primary
        alg = config.createAlgorithm( 'CP::PhotonOriginCorrectionAlg',
                                      'PhotonOriginCorrectionAlg',
                                       reentrant=True )
        alg.photons = config.readName (self.containerName)
        alg.photonsOut = config.copyName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
 
        if not self.splitCalibrationAndSmearing :
            # Set up the calibration and smearing algorithm:
            alg = self.makeCalibrationAndSmearingAlg (config, 'PhotonCalibrationAndSmearingAlg')
            if config.isPhyslite() and not self.recalibratePhyslite :
                alg.skipNominal = True
        else:
            # This splits the EgammaCalibrationAndSmearingTool into two
            # steps. The first step applies a baseline calibration that
            # is not affected by systematics. The second step then
            # applies the systematics dependent corrections.  The net
            # effect is that the slower first step only has to be run
            # once, while the second is run once per systematic.
            #
            # For now (22 May 24) this has to happen in the same job, as
            # the output of the first step is not part of PHYSLITE, and
            # even for the nominal the output of the first and second
            # step are different.  In the future the plan is to put both
            # the output of the first and second step into PHYSLITE,
            # allowing to skip the first step when running on PHYSLITE.
            #
            # WARNING: All of this is experimental, see: ATLASG-2358
 
            # Set up the calibration algorithm:
            alg = self.makeCalibrationAndSmearingAlg (config, 'PhotonBaseCalibrationAlg')
            # turn off systematics for the calibration step
            alg.noToolSystematics = True
            # turn off smearing for the calibration step
            alg.calibrationAndSmearingTool.doSmearing = False
 
            # Set up the smearing algorithm:
            alg = self.makeCalibrationAndSmearingAlg (config, 'PhotonCalibrationSystematicsAlg')
            # turn off scale corrections for the smearing step
            alg.calibrationAndSmearingTool.doScaleCorrection = False
            alg.calibrationAndSmearingTool.useMVACalibration = False
            alg.calibrationAndSmearingTool.decorateEmva = False
 
        if not self.applyIsolationCorrection:
            warnings.warn_explicit(
                "You are not applying the isolation corrections."
                " This is only intended to be used for testing purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        if self.minPt > 0:
 
            # Set up the the pt selection
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonPtCutAlg' )
            alg.selectionDecoration = 'selectPt' + postfix + ',as_bits'
            config.addPrivateTool( 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
            alg.selectionTool.minPt = self.minPt
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, '', alg.selectionDecoration,
                                preselection=True)
 
        # Set up the isolation correction algorithm.
        if self.applyIsolationCorrection:
 
            if self.forceFullSimConfigForIso:
                warnings.warn_explicit(
                    "You are running PhotonCalibrationConfig forcing"
                    " full sim config for isolation corrections."
                    " This is only intended to be used for testing purposes.",
                    TestingOnlyWarning, filename='', lineno=0)
 
            alg = config.createAlgorithm( 'CP::EgammaIsolationCorrectionAlg',
                                          'PhotonIsolationCorrectionAlg' )
            config.addPrivateTool( 'isolationCorrectionTool',
                                   'CP::IsolationCorrectionTool' )
            alg.isolationCorrectionTool.IsMC = config.dataType() is not DataType.Data
            alg.isolationCorrectionTool.AFII_corr = (
                0 if self.forceFullSimConfigForIso
                else config.dataType() is DataType.FastSim)
            AODfixes = config.flags.Input.AODFixesDone
            if "egammatopoIsoFix" in AODfixes:
                alg.isolationCorrectionTool.FixTimingIssueInCore = False
            else:
                alg.isolationCorrectionTool.FixTimingIssueInCore = True
            alg.egammas = config.readName (self.containerName)
            alg.egammasOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        # Additional decorations
        alg = config.createAlgorithm( 'CP::AsgEnergyDecoratorAlg', 'EnergyDecorator' )
        alg.particles = config.readName (self.containerName)
 
        config.addOutputVar (self.containerName, 'pt', 'pt', auxType='float')
        config.addOutputVar (self.containerName, 'eta', 'eta', noSys=True, auxType='float')
        config.addOutputVar (self.containerName, 'phi', 'phi', noSys=True, auxType='float')
        config.addOutputVar (self.containerName, 'e_%SYS%', 'e', auxType='float')
        if self.splitCalibrationAndSmearing or not (config.isPhyslite() and not self.recalibratePhyslite) :
            config.addOutputVar (self.containerName, 'caloClusterEnergyReso_%SYS%', 'caloClusterEnergyReso', noSys=True, auxType='float')
 
        # decorate truth information on the reconstructed object:
        if self.decorateTruth and config.dataType() is not DataType.Data:
            config.addOutputVar (self.containerName, "truthType", "truth_type", noSys=True, auxType='int')
            config.addOutputVar (self.containerName, "truthOrigin", "truth_origin", noSys=True, auxType='int')
 
 
class PhotonWorkingPointSelectionConfig (ConfigBlock) :
    """the ConfigBlock for the photon working point selection"""
 
    def __init__ (self) :
        super (PhotonWorkingPointSelectionConfig, self).__init__ ()
        self.setBlockName('PhotonWorkingPointSelection')
        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 photon 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 ('qualityWP', None, type=str,
            info="the ID WP to use. Supported ID WPs: `Tight`, `Medium`, `Loose`, `NoID`.",
            expertMode=['NoID'],
            meta={'choices':(['Tight','Medium','Loose','NoID'],1)})
        self.addOption ('isolationWP', None, type=str,
            info="the isolation WP to use. Supported isolation WPs: "
            "`FixedCutLoose`, `FixedCutTight`, `TightCaloOnly`, `NonIso`.",
            meta={'choices':(['FixedCutLoose','FixedCutTight','TightCaloOnly','NonIso'],1)})
        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,
            meta={'role':'containerRef'})
 
    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
 
    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
        elif self.qualityWP == 'NoID':
            quality = None
            if self.recomputeIsEM:
                raise ValueError('NoID WP cannot be recomputed.')
        else :
            raise Exception (f'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/mc23_20260924/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' )
            if quality is not None:
                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.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 (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)
 
 
class PhotonWorkingPointEfficiencyConfig (ConfigBlock) :
    """the ConfigBlock for the photon working point efficiency computation"""
 
    def __init__ (self) :
        super (PhotonWorkingPointEfficiencyConfig, self).__init__ ()
        self.setBlockName('PhotonWorkingPointEfficiency')
        self.addDependency('PhotonWorkingPointSelection', required=True)
        self.addDependency('EventSelection', required=False)
        self.addDependency('EventSelectionMerger', required=False)
        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 photon 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 ('qualityWP', None, type=str,
            info="the ID WP to use. Supported ID WPs: `Tight`, `Medium`, `Loose`, `NoID`.",
            expertMode=['NoID'],
            meta={'choices':(['Tight','Medium','Loose','NoID'],1)})
        self.addOption ('isolationWP', None, type=str,
            info="the isolation WP to use. Supported isolation WPs: "
            "`FixedCutLoose`, `FixedCutTight`, `TightCaloOnly`, `NonIso`.",
            meta={'choices':(['FixedCutLoose','FixedCutTight','TightCaloOnly','NonIso'],1)})
        self.addOption ('noEffSFForID', False, type=bool,
            info="disables the calculation of ID efficiencies and scale factors. "
            "Experimental! only useful to test a new WP for which scale "
            "factors are not available.",
            expertMode=True)
        self.addOption ('noEffSFForIso', False, type=bool,
            info="disables the calculation of isolation efficiencies and scale factors. "
            "Experimental! only useful to test a new WP for which scale "
            "factors are not available.",
            expertMode=True)
        self.addOption ('saveDetailedSF', True, type=bool,
            info="save all the independent detailed object scale factors.")
        self.addOption ('saveCombinedSF', False, type=bool,
            info="save the combined object scale factor.")
        self.addOption ('forceFullSimConfigForID', False, type=bool,
            info="whether to force the ID tool to use the configuration meant "
            "for full simulation samples. Only for testing purposes.")
        self.addOption ('forceFullSimConfigForIso', False, type=bool,
            info="whether to force the isolation tool to use the configuration meant "
            "for full simulation samples. Only for testing purposes.")
 
    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
 
    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)
 
        if self.forceFullSimConfigForID:
            warnings.warn_explicit(
                "You are running PhotonWorkingPointConfig forcing"
                " full sim config for ID."
                " This is only intended to be used for testing purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        if self.forceFullSimConfigForIso:
            warnings.warn_explicit(
                "You are running PhotonWorkingPointConfig forcing"
                " full sim config for Iso."
                " This is only intended to be used for testing purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        postfix = self.postfix
        if postfix is None :
            postfix = self.selectionName
        if postfix != '' and postfix[0] != '_' :
            postfix = '_' + postfix
 
        sfList = []
        # Set up the ID/reco photon efficiency correction algorithm:
        if config.dataType() is not DataType.Data and self.qualityWP != 'NoID' and not self.noEffSFForID:
            alg = config.createAlgorithm( 'CP::PhotonEfficiencyCorrectionAlg',
                                          'PhotonEfficiencyCorrectionAlgID' )
            config.addPrivateTool( 'efficiencyCorrectionTool',
                                   'CP::AsgPhotonEfficiencyCorrectionTool' )
            alg.scaleFactorDecoration = 'ph_id_effSF' + postfix + '_%SYS%'
            if config.dataType() is DataType.FastSim:
                alg.efficiencyCorrectionTool.ForceDataType = (
                    PATCore.ParticleDataType.Full if self.forceFullSimConfigForID else
                    PATCore.ParticleDataType.Fast)
            elif config.dataType() is DataType.FullSim:
                alg.efficiencyCorrectionTool.ForceDataType = \
                    PATCore.ParticleDataType.Full
            alg.efficiencyCorrectionTool.MapFilePath = 'PhotonEfficiencyCorrection/2015_2025/rel22.2/2026_Run3Consolidated_Recommendation_v1/map0.txt'
            alg.outOfValidity = 2 #silent
            alg.outOfValidityDeco = 'ph_id_bad_eff' + postfix
            alg.photons = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, self.selectionName)
            if self.saveDetailedSF:
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                     'id_effSF' + postfix, auxType='float')
            sfList += [alg.scaleFactorDecoration]
 
        # Set up the ISO photon efficiency correction algorithm:
        if config.dataType() is not DataType.Data and self.isolationWP != 'NonIso' and not self.noEffSFForIso:
            alg = config.createAlgorithm( 'CP::PhotonEfficiencyCorrectionAlg',
                                          'PhotonEfficiencyCorrectionAlgIsol' )
            config.addPrivateTool( 'efficiencyCorrectionTool',
                                   'CP::AsgPhotonEfficiencyCorrectionTool' )
            alg.scaleFactorDecoration = 'ph_isol_effSF' + postfix + '_%SYS%'
            if config.dataType() is DataType.FastSim:
                alg.efficiencyCorrectionTool.ForceDataType = (
                    PATCore.ParticleDataType.Full if self.forceFullSimConfigForIso else
                    PATCore.ParticleDataType.Fast)
            elif config.dataType() is DataType.FullSim:
                alg.efficiencyCorrectionTool.ForceDataType = \
                    PATCore.ParticleDataType.Full
            alg.efficiencyCorrectionTool.IsoKey = self.isolationWP.replace("FixedCut","")
            alg.efficiencyCorrectionTool.MapFilePath = 'PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map1.txt'
            alg.outOfValidity = 2 #silent
            alg.outOfValidityDeco = 'ph_isol_bad_eff' + postfix
            alg.photons = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, self.selectionName)
            if self.saveDetailedSF:
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration,
                                     'isol_effSF' + postfix, auxType='float')
            sfList += [alg.scaleFactorDecoration]
 
        doCombEffSF = not self.noEffSFForID or not self.noEffSFForIso
        if config.dataType() is not DataType.Data and doCombEffSF and self.saveCombinedSF:
            alg = config.createAlgorithm( 'CP::AsgObjectScaleFactorAlg',
                                          'PhotonCombinedEfficiencyScaleFactorAlg' )
            alg.particles = config.readName (self.containerName)
            alg.inScaleFactors = sfList
            alg.outScaleFactor = 'effSF' + postfix + '_%SYS%'
            config.addOutputVar (self.containerName, alg.outScaleFactor, 'effSF' + postfix, auxType='float')
 
 
@groupBlocks
def PhotonWorkingPoint(seq):
    seq.append(PhotonWorkingPointSelectionConfig())
    seq.append(PhotonWorkingPointEfficiencyConfig())