python.PhotonAnalysisConfig.PhotonCalibrationConfig Class Reference

Inheritance diagram for python.PhotonAnalysisConfig.PhotonCalibrationConfig:

Collaboration diagram for python.PhotonAnalysisConfig.PhotonCalibrationConfig:

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

Public Attributes
	ESModel
	forceFullSimConfigForP4
	containerName
	decorateCaloClusterEta
	addGlobalFELinksDep
	crackVeto
	enableCleaning
	splitCalibrationAndSmearing
	recalibratePhyslite
	applyIsolationCorrection
	forceFullSimConfigForIso

Detailed Description

the ConfigBlock for the photon four-momentum correction

Definition at line 19 of file PhotonAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.PhotonAnalysisConfig.PhotonCalibrationConfig.__init__

(

self

)

Definition at line 22 of file PhotonAnalysisConfig.py.

    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.")
        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`.")
        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)
 

Member Function Documentation

instanceName()

python.PhotonAnalysisConfig.PhotonCalibrationConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 80 of file PhotonAnalysisConfig.py.

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

makeAlgs()

python.PhotonAnalysisConfig.PhotonCalibrationConfig.makeAlgs	(		self,
			config )

Definition at line 123 of file PhotonAnalysisConfig.py.

    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',
                                          'ElectronEgammaCaloClusterEtaAlg',
                                           reentrant=True )
            alg.particles = config.readName(self.containerName)
            config.addOutputVar (self.containerName, 'caloEta2', 'caloEta2', noSys=True)
 
        # 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:
                alg.showerShapeFudgeTool.ConfigFile = \
              'EGammaVariableCorrection/TUNE23/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,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,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)
            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')
        config.addOutputVar (self.containerName, 'eta', 'eta', noSys=True)
        config.addOutputVar (self.containerName, 'phi', 'phi', noSys=True)
        config.addOutputVar (self.containerName, 'e_%SYS%', 'e')
        config.addOutputVar (self.containerName, 'caloClusterEnergyReso_%SYS%', 'caloClusterEnergyReso', noSys=True)
 
        # 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)
            config.addOutputVar (self.containerName, "truthOrigin", "truth_origin", noSys=True)
 
 

makeCalibrationAndSmearingAlg()

python.PhotonAnalysisConfig.PhotonCalibrationConfig.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

Definition at line 85 of file PhotonAnalysisConfig.py.

    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 ElectronCalibrationConfig 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
        alg.egammas = config.readName (self.containerName)
        alg.egammasOut = config.copyName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
        return alg
 
 

Member Data Documentation

addGlobalFELinksDep

python.PhotonAnalysisConfig.PhotonCalibrationConfig.addGlobalFELinksDep

Definition at line 161 of file PhotonAnalysisConfig.py.

applyIsolationCorrection

python.PhotonAnalysisConfig.PhotonCalibrationConfig.applyIsolationCorrection

Definition at line 262 of file PhotonAnalysisConfig.py.

containerName

python.PhotonAnalysisConfig.PhotonCalibrationConfig.containerName

Definition at line 137 of file PhotonAnalysisConfig.py.

crackVeto

python.PhotonAnalysisConfig.PhotonCalibrationConfig.crackVeto

Definition at line 172 of file PhotonAnalysisConfig.py.

decorateCaloClusterEta

python.PhotonAnalysisConfig.PhotonCalibrationConfig.decorateCaloClusterEta

Definition at line 144 of file PhotonAnalysisConfig.py.

enableCleaning

python.PhotonAnalysisConfig.PhotonCalibrationConfig.enableCleaning

Definition at line 207 of file PhotonAnalysisConfig.py.

ESModel

python.PhotonAnalysisConfig.PhotonCalibrationConfig.ESModel

Definition at line 96 of file PhotonAnalysisConfig.py.

forceFullSimConfigForIso

python.PhotonAnalysisConfig.PhotonCalibrationConfig.forceFullSimConfigForIso

Definition at line 283 of file PhotonAnalysisConfig.py.

forceFullSimConfigForP4

python.PhotonAnalysisConfig.PhotonCalibrationConfig.forceFullSimConfigForP4

Definition at line 129 of file PhotonAnalysisConfig.py.

recalibratePhyslite

python.PhotonAnalysisConfig.PhotonCalibrationConfig.recalibratePhyslite

Definition at line 229 of file PhotonAnalysisConfig.py.

splitCalibrationAndSmearing

python.PhotonAnalysisConfig.PhotonCalibrationConfig.splitCalibrationAndSmearing

Definition at line 226 of file PhotonAnalysisConfig.py.

---

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

• PhotonAnalysisConfig.py