python.JetAnalysisConfig.LargeRJetAnalysisConfig Class Reference

Inheritance diagram for python.JetAnalysisConfig.LargeRJetAnalysisConfig:

Collaboration diagram for python.JetAnalysisConfig.LargeRJetAnalysisConfig:

Public Member Functions
	__init__ (self)
	instanceName (self)
	getUncertaintyToolSettings (self, config)
	createUncertaintyTool (self, jetUncertaintiesAlg, config, jetCollectionName, doPseudoData=False)
	createFFSmearingTool (self, jetFFSmearingAlg, config)
	makeAlgs (self, config)

Public Attributes
	systematicsModelJER
	systematicsModelJMS
	runJERsystematicsOnData
	containerName
str	jetCollection = "AnalysisJets") :
	recalibratePhyslite

Detailed Description

the ConfigBlock for the large-r jet sequence

Definition at line 612 of file JetAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.__init__

(

self

)

Definition at line 615 of file JetAnalysisConfig.py.

    def __init__ (self) :
        super (LargeRJetAnalysisConfig, self).__init__ ()
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the output container after calibration.")
        self.addOption ('jetCollection', '', type=str,
            noneAction='error',
            info="the jet container to run on. It is interpreted to determine "
            "the correct config blocks to call for small- or large-R jets.")
        self.addOption ('jetInput', '', type=str,
            noneAction='error',
            info="the type of jet input. Supported options are: `UFO`.")
        self.addOption ('recalibratePhyslite', True, type=bool,
            info="whether to run the CP::JetCalibrationAlg on PHYSLITE "
            "derivations. The default is True.")
        self.addOption ('runUncertainties', True, type=bool,
            info="whether to configure JetUncertaintiesTool.", expertMode=True )
        self.addOption ('systematicsModelJER', "Full", type=str)
        self.addOption ('systematicsModelJMS', "Full", type=str)
        self.addOption ('systematicsModelJMR', "Full", type=str,
            info="the NP reduction scheme to use for JMR: Full, Simple. The default is Full.")
        self.addOption ('runJERsystematicsOnData', False, type=bool,
            info="whether to run the All/Full JER model variations also on data samples. Expert option!",
            expertMode=True)
        # Adding these options to override the jet uncertainty config file when we have new recommendations
        # Calibration tool options
        self.addOption ('calibToolConfigFile', None, type=str,
            info="name of the config file to use for the jet calibration "
            "tool. Expert option to override JetETmiss recommendations.",
            expertMode=True)
        self.addOption ('calibToolCalibArea', None, type=str,
            info="name of the CVMFS area to use for the jet calibration "
            "tool. Expert option to override JetETmiss recommendations.",
            expertMode=True)
        self.addOption ('calibToolCalibSeq', None, type=str,
            info="name of the sequence to use for the jet calibration "
            "tool (e.g. `JetArea_Residual_EtaJES_GSC`). Expert option to override "
            "JetETmiss recommendations.",
            expertMode=True)
        # Uncertainties tool options
        self.addOption ('uncertToolConfigPath', None, type=str,
            info="name of the config file to use for the JES, JER, and JMS uncertainty "
            "tool. Expert option to override JetETmiss recommendations.",
            expertMode=True)
        self.addOption ('uncertToolConfigPathJMR', None, type=str,
            info="name of the config file to use for the JMR uncertainty "
            "tool. Expert option to override JetETmiss recommendations.",
            expertMode=True)
        self.addOption ('uncertToolCalibArea', None, type=str,
            info="name (str) of the CVMFS area to use for the jet uncertainty "
            "tool. Expert option to override JetETmiss recommendations. The "
            "default is None.",
            expertMode=True)
        self.addOption ('uncertToolMCType', None, type=str,
            info="data type (str) to use for the jet uncertainty tool (e.g. "
            "'AF3' or 'MC16'). Expert option to override JetETmiss "
            "recommendations. The default is None.",
            expertMode=True)
        self.addOption ('minPt', 200.*GeV, type=float,
            info=r"the minimum $p_\mathrm{T}$ cut (in MeV) to apply to calibrated large-R jets.")
        self.addOption ('maxPt', 3000.*GeV, type=float,
            info=r"the maximum $p_\mathrm{T}$ cut (in MeV) to apply to calibrated large-R jets.")
        self.addOption ('maxEta', 0., type=float,
            info=r"the maximum $\vert\eta\vert$ cut to apply to calibrated large-R jets.")
        self.addOption ('maxRapidity', 2., type=float,
            info="the maximum rapidity cut to apply to calibrated large-R jets.")
        self.addOption ('minMass', 40.*GeV, type=float,
            info="the minimum mass cut (in MeV) to apply to calibrated large-R jets.")
        self.addOption ('maxMass', 600.*GeV, type=float,
            info="the maximum mass cut (in MeV) to apply to calibrated large-R jets.")
 

Member Function Documentation

createFFSmearingTool()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.createFFSmearingTool	(		self,
			jetFFSmearingAlg,
			config )

Definition at line 779 of file JetAnalysisConfig.py.

    def createFFSmearingTool(self, jetFFSmearingAlg, config):
        # Retrieve appropriate large-R jet mass resolution recommendations for the FFJetSmearingTool.
 
        # Config file:
        if self.systematicsModelJMR in ["Simple", "Full"]:
            config_file = f"R10_{self.systematicsModelJMR}JMR.config"
        else:
            raise ValueError(
                f"Invalid request for systematicsModelJMR settings: {self.systematicsModelJMR}"
            )
 
        # Expert override for config path:
        if self.uncertToolConfigPathJMR is not None:
            config_file = self.uncertToolConfigPathJMR
        else:
            config_file = "rel22/Summer2025_PreRec/" + config_file
            if config.geometry() is LHCPeriod.Run4:
                warnings.warn_explicit(
                    "Uncertainties for UFO jets are not for Run 4!",
                    JetUncertaintyWarning, filename='', lineno=0)
 
        # MC type:
        if config.geometry() is LHCPeriod.Run2:
            if config.dataType() is DataType.FastSim:
                mc_type = "MC20AF3"
            else:
                mc_type = "MC20"
        elif config.geometry() >= LHCPeriod.Run3:
            if config.dataType() is DataType.FastSim:
                mc_type = "MC23AF3"
            else:
                mc_type = "MC23"
 
        # Set up the FF smearing tool
        config.addPrivateTool( 'FFSmearingTool', 'CP::FFJetSmearingTool')
        jetFFSmearingAlg.FFSmearingTool.MassDef = "UFO"
        jetFFSmearingAlg.FFSmearingTool.MCType = mc_type
        jetFFSmearingAlg.FFSmearingTool.ConfigFile = config_file
 

createUncertaintyTool()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.createUncertaintyTool	(		self,
			jetUncertaintiesAlg,
			config,
			jetCollectionName,
			doPseudoData = False )

Create instance(s) of JetUncertaintiesTool following JetETmiss recommendations.

JER uncertainties under the "Full" scheme must be run on MC samples twice:
1. Normal (MC) mode,
2. Pseudodata (PD) mode, as if the events are Data.

Definition at line 741 of file JetAnalysisConfig.py.

    def createUncertaintyTool(self, jetUncertaintiesAlg, config, jetCollectionName, doPseudoData=False):
        '''
        Create instance(s) of JetUncertaintiesTool following JetETmiss recommendations.
 
        JER uncertainties under the "Full" scheme must be run on MC samples twice:
        1. Normal (MC) mode,
        2. Pseudodata (PD) mode, as if the events are Data.
        '''
 
        # Retrieve the common configuration settings
        configFile, calibArea, mcType = self.getUncertaintyToolSettings(config)
 
        # The main tool for all JER combinations
        config.addPrivateTool( 'uncertaintiesTool', 'JetUncertaintiesTool' )
        jetUncertaintiesAlg.uncertaintiesTool.JetDefinition = jetCollectionName[:-4]
        jetUncertaintiesAlg.uncertaintiesTool.ConfigFile = configFile
        if calibArea is not None:
            jetUncertaintiesAlg.uncertaintiesTool.CalibArea = calibArea
        jetUncertaintiesAlg.uncertaintiesTool.MCType = mcType
        jetUncertaintiesAlg.uncertaintiesTool.IsData = (config.dataType() is DataType.Data)
        jetUncertaintiesAlg.uncertaintiesTool.PseudoDataJERsmearingMode = False
 
        # JER smearing on data 
        if config.dataType() is DataType.Data and not (config.isPhyslite() and doPseudoData and self.runJERsystematicsOnData):
            # we don't want any systematics on data if we're not using the right JER model!
            jetUncertaintiesAlg.affectingSystematicsFilter = '.*'
 
        if config.dataType() is not (DataType.Data and config.isPhyslite()) and doPseudoData and not self.runJERsystematicsOnData:
            # The secondary tool for pseudo-data JER smearing
            config.addPrivateTool( 'uncertaintiesToolPD', 'JetUncertaintiesTool' )
            jetUncertaintiesAlg.uncertaintiesToolPD.JetDefinition = jetCollectionName[:-4]
            jetUncertaintiesAlg.uncertaintiesToolPD.ConfigFile = configFile
            if calibArea is not None:
                jetUncertaintiesAlg.uncertaintiesToolPD.CalibArea = calibArea
            jetUncertaintiesAlg.uncertaintiesToolPD.MCType = mcType
            jetUncertaintiesAlg.uncertaintiesToolPD.IsData = True
            jetUncertaintiesAlg.uncertaintiesToolPD.PseudoDataJERsmearingMode = True
 

getUncertaintyToolSettings()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.getUncertaintyToolSettings	(		self,
			config )

Definition at line 690 of file JetAnalysisConfig.py.

    def getUncertaintyToolSettings(self, config):
        # Retrieve appropriate JES/JER recommendations for the JetUncertaintiesTool.
        # We do this separately from the tool declaration, as we may need to set uo
        # two such tools, but they have to be private.
 
 
        # Config file:
        config_file = None
        if self.systematicsModelJER in ["Simple", "Full"] and self.systematicsModelJMS in ["Simple", "Full"]:
            config_file = "R10_CategoryJES_{0}JER_{1}JMS.config".format(self.systematicsModelJER, self.systematicsModelJMS)
        else:
            raise ValueError(
                "Invalid request for systematicsModelJER/JMS settings: "
                "systematicsModelJER = '{0}', "
                "systematicsModelJMS = '{1}'".format(self.systematicsModelJER, self.systematicsModelJMS) )
        if self.uncertToolConfigPath is not None:
            # Expert override
            config_file = self.uncertToolConfigPath
        else:
            if config.geometry() in [LHCPeriod.Run2, LHCPeriod.Run3]:
                config_file = "rel22/Summer2025_PreRec/" + config_file
            else:
                warnings.warn_explicit(
                    "Uncertainties for UFO jets are not for Run 4!"
                    " are deprecated - please use a"
                    " JVTWorkingPoint block instead.",
                    JetUncertaintyWarning, filename='', lineno=0)
 
 
        # Calibration area:
        calib_area = None
        if self.uncertToolCalibArea is not None:
            calib_area = self.uncertToolCalibArea
                
        # MC type:
        if self.uncertToolMCType is not None:
            mc_type = self.uncertToolMCType
        else:
            if config.dataType() is DataType.FastSim:
                if config.geometry() is LHCPeriod.Run2:
                    mc_type = "MC20AF3"
                else:
                    mc_type = "MC23AF3"
            else:
                if config.geometry() is LHCPeriod.Run2:
                    mc_type = "MC20"
                else:
                    mc_type = "MC23"
 
        return config_file, calib_area, mc_type
 

instanceName()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 686 of file JetAnalysisConfig.py.

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

makeAlgs()

python.JetAnalysisConfig.LargeRJetAnalysisConfig.makeAlgs	(		self,
			config )

Definition at line 818 of file JetAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        # Self-select: only run for large-R (radius 10) jets
        if config.getContainerMeta(self.containerName, 'jetRadius', failOnMiss=True) != 10:
            return
 
        configFile = None
        calibSeq = None
        calibArea = None
 
        jetCollectionName=self.jetCollection
        if(self.jetCollection=="AnalysisJets") :
            jetCollectionName="AntiKt4EMPFlowJets"
        if(self.jetCollection=="AnalysisLargeRJets") :
            jetCollectionName="AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets"
 
        jetInput = config.getContainerMeta(self.containerName, 'jetInput', failOnMiss=True)
        trim = config.getContainerMeta(self.containerName, 'jetTrim', failOnMiss=True)
 
        if jetInput not in ["UFO"]:
            raise ValueError("Invalid input type '{0}' for large-R jets!".format(jetInput) )
 
        if not trim:
            raise ValueError("Untrimmed large-R jets are not supported!")
 
        configFile = "JES_MC20PreRecommendation_R10_UFO_CSSK_SoftDrop_JMS_R21Insitu_26Nov2024.config"
        calibArea = "00-04-83"
        if self.calibToolConfigFile is not None:
            configFile = self.calibToolConfigFile
 
        if config.dataType() is not DataType.Data:
            calibSeq = "EtaJES_JMS"
        elif config.dataType() is DataType.Data:
            calibSeq = "EtaJES_JMS_Insitu"
        if self.calibToolCalibSeq is not None:
            calibSeq = self.calibToolCalibSeq
 
        if self.calibToolCalibArea is not None:
            calibArea = self.calibToolCalibArea
 
        if not config.isPhyslite() or self.recalibratePhyslite:
            # Create calibration tool before algorithm (EventLoop ordering)
            calibToolName = 'JetCalibTool_' + jetCollectionName[:-4]
            calibTool = config.createPublicTool( 'JetCalibrationTool', calibToolName )
 
            calibTool.JetCollection = jetCollectionName[:-4]
 
            if configFile is None:
                raise ValueError(f'Unsupported: {jetInput=}, {config.dataType()=}')
            calibTool.ConfigFile = configFile
 
            if calibSeq is None:
                raise ValueError(f'Unsupported: {jetInput=}, {config.dataType()=}')
            calibTool.CalibSequence = calibSeq
 
            if calibArea is not None:
                calibTool.CalibArea = calibArea
 
            calibTool.IsData = (config.dataType() is DataType.Data)
            # Prepare the jet calibration algorithm
            alg = config.createAlgorithm( 'CP::JetCalibrationAlg', 'JetCalibrationAlg' )
            alg.calibrationTool = f'{calibTool.getType()}/{calibTool.getName()}'
            alg.jets = config.readName(self.containerName)
            alg.jetsOut = config.copyName(self.containerName)
 
        # Jet uncertainties
        if jetInput == "UFO" and config.dataType() in [DataType.FullSim, DataType.FastSim] and self.runUncertainties:
            alg = config.createAlgorithm( 'CP::JetUncertaintiesAlg', 'JetUncertaintiesAlg' )
            self.createUncertaintyTool(alg, config, jetCollectionName, doPseudoData=( self.systematicsModelJER in ["Full","All"] ))
 
            alg.uncertaintiesTool.JetDefinition = jetCollectionName[:-4]
 
            # R=1.0 jets have a validity range
            alg.outOfValidity = 2 # SILENT
            alg.outOfValidityDeco = 'outOfValidity'
 
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        if jetInput != "UFO" and self.runUncertainties:
            alg = config.createAlgorithm( 'CP::JetUncertaintiesAlg', 'JetUncertaintiesAlg' )
 
            # R=1.0 jets have a validity range
            alg.outOfValidity = 2 # SILENT
            alg.outOfValidityDeco = 'outOfValidity'
            config.addPrivateTool( 'uncertaintiesTool', 'JetUncertaintiesTool' )
 
            alg.uncertaintiesTool.JetDefinition = jetCollectionName[:-4]
            alg.uncertaintiesTool.ConfigFile = \
                "rel21/Moriond2018/R10_{0}Mass_all.config".format(self.largeRMass)
            alg.uncertaintiesTool.MCType = "MC16a"
            alg.uncertaintiesTool.IsData = (config.dataType() is DataType.Data)
 
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, '', 'outOfValidity')
 
        if jetInput == "UFO" and config.dataType() is not DataType.Data:
            # set up the FF smearing algorithm
            alg = config.createAlgorithm( 'CP::JetFFSmearingAlg', 'JetFFSmearingAlg' )
            self.createFFSmearingTool(alg, config)
            alg.outOfValidity = 2 # SILENT
            alg.outOfValidityDeco = 'outOfValidityJMR'
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        if self.minPt > 0 or self.maxPt > 0 or self.maxEta > 0 or self.maxRapidity > 0:
            # Set up the the pt-eta selection
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'JetPtEtaCutAlg' )
            alg.selectionDecoration = 'selectPtEta,as_bits'
            config.addPrivateTool( 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
            alg.selectionTool.minPt = self.minPt
            alg.selectionTool.maxPt = self.maxPt
            alg.selectionTool.maxEta = self.maxEta
            alg.selectionTool.maxRapidity = self.maxRapidity
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, '', alg.selectionDecoration,
                                 preselection=True)
 
        if self.minMass > 0 or self.maxMass > 0:
            # Set up the the mass selection
            alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'JetMassCutAlg' )
            alg.selectionDecoration = 'selectMass,as_bits'
            config.addPrivateTool( 'selectionTool', 'CP::AsgMassSelectionTool' )
            alg.selectionTool.minM = self.minMass
            alg.selectionTool.maxM = self.maxMass
            alg.particles = config.readName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
            config.addSelection (self.containerName, '', alg.selectionDecoration,
                                 preselection=True)
 
        config.addOutputVar (self.containerName, 'm', 'm')
 

Member Data Documentation

containerName

python.JetAnalysisConfig.LargeRJetAnalysisConfig.containerName

Definition at line 821 of file JetAnalysisConfig.py.

jetCollection

str python.JetAnalysisConfig.LargeRJetAnalysisConfig.jetCollection = "AnalysisJets") :

Definition at line 829 of file JetAnalysisConfig.py.

recalibratePhyslite

python.JetAnalysisConfig.LargeRJetAnalysisConfig.recalibratePhyslite

Definition at line 858 of file JetAnalysisConfig.py.

runJERsystematicsOnData

python.JetAnalysisConfig.LargeRJetAnalysisConfig.runJERsystematicsOnData

Definition at line 764 of file JetAnalysisConfig.py.

systematicsModelJER

python.JetAnalysisConfig.LargeRJetAnalysisConfig.systematicsModelJER

Definition at line 704 of file JetAnalysisConfig.py.

systematicsModelJMS

python.JetAnalysisConfig.LargeRJetAnalysisConfig.systematicsModelJMS

Definition at line 704 of file JetAnalysisConfig.py.

---

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

• JetAnalysisConfig.py