python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig Class Reference

Inheritance diagram for python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig:

Collaboration diagram for python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig:

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

Public Attributes
	ESModel
	containerName
	forceFullSimConfigForP4
	inputContainer
	decorateCaloClusterEta
	decorateSamplingPattern
	addGlobalFELinksDep
	crackVeto
	splitCalibrationAndSmearing
	recalibratePhyslite
	isolationCorrection

Detailed Description

the ConfigBlock for the electron four-momentum correction

Definition at line 23 of file ElectronAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.__init__

(

self

)

Definition at line 26 of file ElectronAnalysisConfig.py.

    def __init__ (self) :
        super (ElectronMomentumCalibrationConfig, self).__init__ ()
        self.setBlockName('Electrons')
        self.addOption ('inputContainer', '', type=str,
            info="the name of the input electron container. If left empty, automatically defaults "
            "to `AnalysisElectrons` for PHYSLITE or `Electrons` otherwise.")
        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, use the current recommendations.")
        self.addOption ('decorrelationModel', '1NP_v1', type=str,
            info="decorrelation model for the EGamma energy scale. Supported choices are: `1NP_v1`, `FULL_v1`.",
            meta={'choices':(['1NP_v1','FULL_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 electrons.")
        self.addOption ('crackVeto', False, type=bool,
            info=r"whether to perform LAr crack veto based on the cluster $\eta$, "
            r"i.e. remove electrons within $1.37<\vert\eta\vert<1.52$.")
        self.addOption ('isolationCorrection', True, type=bool,
            info="whether or not to perform isolation corrections (leakage "
            "corrections), i.e. set up an instance of "
            "`CP::EgammaIsolationCorrectionAlg`.",
            expertMode=True)
        self.addOption ('recalibratePhyslite', True, type=bool,
            info="whether to run the `CP::EgammaCalibrationAndSmearingAlg` on "
            "PHYSLITE derivations.")
        self.addOption ('minPt', 4.5*GeV, type=float,
            info=r"the minimum $p_\mathrm{T}$ cut (in MeV) to apply to calibrated electrons.")
        self.addOption ('maxEta', 2.47, type=float,
            info=r"maximum electron $\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 ('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 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 electrons (needed for columnar tools/PHYSLITE).")
        self.addOption ('decorateSamplingPattern', False, type=bool,
            info="decorate `samplingPattern` on the clusters (meant for 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.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 85 of file ElectronAnalysisConfig.py.

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

makeAlgs()

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

Definition at line 133 of file ElectronAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        if self.forceFullSimConfigForP4:
            warnings.warn_explicit(
                "You are running ElectronCalibrationConfig forcing full sim"
                " config. This is only intended to be used for testing"
                " purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        inputContainer = "AnalysisElectrons" if config.isPhyslite() else "Electrons"
        if self.inputContainer:
            inputContainer = self.inputContainer
        config.setSourceName (self.containerName, inputContainer)
 
        # 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, auxType='float')
 
        if self.decorateSamplingPattern:
            config.createAlgorithm( 'CP::EgammaSamplingPatternDecoratorAlg', 'EgammaSamplingPatternDecoratorAlg' )
 
        # Set up a shallow copy to decorate
        if config.wantCopy (self.containerName) :
            alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'ElectronShallowCopyAlg' )
            alg.input = config.readName (self.containerName)
            alg.output = config.copyName (self.containerName)
            alg.outputType = 'xAOD::ElectronContainer'
            decorationList = ['DFCommonElectronsLHLoose',
                              'neflowisol20',
                              'ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500',
                              'ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500',
                              'ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000_CloseByCorr',
                              'ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000_CloseByCorr',
                              'topoetcone20_CloseByCorr','DFCommonAddAmbiguity',
                              'PLIT_PLITel_pelxpromp', 'PLIT_PLITel_pnpxall']
            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 electrons prior to everything else
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronEtaCutAlg' )
        alg.selectionDecoration = 'selectEta' + self.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)
 
        # Select electrons only with good object quality.
        alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronObjectQualityAlg' )
        config.setExtraInputs ({('xAOD::EventInfo', 'EventInfo.RandomRunNumber')})
        alg.selectionDecoration = 'goodOQ' + self.postfix + ',as_bits'
        config.addPrivateTool( 'selectionTool', 'CP::EgammaIsGoodOQSelectionTool' )
        alg.selectionTool.Mask = xAOD.EgammaParameters.BADCLUSELECTRON
        alg.particles = config.readName (self.containerName)
        alg.preselection = config.getPreselection (self.containerName, '')
        config.addSelection (self.containerName, '', alg.selectionDecoration)
 
        if not self.splitCalibrationAndSmearing :
            # Set up the calibration and smearing algorithm:
            alg = self.makeCalibrationAndSmearingAlg (config, 'ElectronCalibrationAndSmearingAlg')
            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, 'ElectronBaseCalibrationAlg')
            # 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, 'ElectronCalibrationSystematicsAlg')
            # turn off scale corrections for the smearing step
            alg.calibrationAndSmearingTool.doScaleCorrection = False
            alg.calibrationAndSmearingTool.useMVACalibration = False
            alg.calibrationAndSmearingTool.decorateEmva = False
 
        if self.minPt > 0 :
            # Set up the the pt selection
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'ElectronPtCutAlg' )
            alg.selectionDecoration = 'selectPt' + self.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.isolationCorrection:
            alg = config.createAlgorithm( 'CP::EgammaIsolationCorrectionAlg',
                                          'ElectronIsolationCorrectionAlg' )
            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.isolationCorrectionTool.ToolVer = "REL22"
            alg.isolationCorrectionTool.CorrFile = "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root"
            alg.egammas = config.readName (self.containerName)
            alg.egammasOut = config.copyName (self.containerName)
            alg.egammasType = 'xAOD::ElectronContainer'
            alg.preselection = config.getPreselection (self.containerName, '')
        else:
            warnings.warn_explicit(
                "You are not applying the isolation corrections."
                " This is only intended to be used for testing purposes.",
                TestingOnlyWarning, filename='', lineno=0)
 
        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')
        config.addOutputVar (self.containerName, 'charge', 'charge', noSys=True, 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')
 
            config.addOutputVar (self.containerName, "firstEgMotherPdgId", "truth_firstEgMotherPdgId", noSys=True, auxType='int')
            config.addOutputVar (self.containerName, "firstEgMotherTruthOrigin", "truth_firstEgMotherTruthOrigin", noSys=True, auxType='int')
            config.addOutputVar (self.containerName, "firstEgMotherTruthType", "truth_firstEgMotherTruthType", noSys=True, auxType='int')
 
 

makeCalibrationAndSmearingAlg()

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.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 89 of file ElectronAnalysisConfig.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 Run 3 model instead",
                    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
        # only electrons are calibrated here, so skip loading the photon BDTs
        alg.calibrationAndSmearingTool.DoPhotonMVACalibration = 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)
        config.setContainerMeta (self.containerName, 'decorrelationModel', alg.calibrationAndSmearingTool.decorrelationModel)
 
        return alg
 
 

Member Data Documentation

addGlobalFELinksDep

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.addGlobalFELinksDep

Definition at line 172 of file ElectronAnalysisConfig.py.

containerName

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.containerName

Definition at line 127 of file ElectronAnalysisConfig.py.

crackVeto

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.crackVeto

Definition at line 183 of file ElectronAnalysisConfig.py.

decorateCaloClusterEta

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.decorateCaloClusterEta

Definition at line 148 of file ElectronAnalysisConfig.py.

decorateSamplingPattern

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.decorateSamplingPattern

Definition at line 155 of file ElectronAnalysisConfig.py.

ESModel

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.ESModel

Definition at line 100 of file ElectronAnalysisConfig.py.

forceFullSimConfigForP4

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.forceFullSimConfigForP4

Definition at line 135 of file ElectronAnalysisConfig.py.

inputContainer

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.inputContainer

Definition at line 143 of file ElectronAnalysisConfig.py.

isolationCorrection

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.isolationCorrection

Definition at line 249 of file ElectronAnalysisConfig.py.

recalibratePhyslite

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.recalibratePhyslite

Definition at line 204 of file ElectronAnalysisConfig.py.

splitCalibrationAndSmearing

python.ElectronAnalysisConfig.ElectronMomentumCalibrationConfig.splitCalibrationAndSmearing

Definition at line 201 of file ElectronAnalysisConfig.py.

---

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

• ElectronAnalysisConfig.py