python.JetAnalysisConfig.SmallRJetAnalysisConfig Class Reference

Inheritance diagram for python.JetAnalysisConfig.SmallRJetAnalysisConfig:

Collaboration diagram for python.JetAnalysisConfig.SmallRJetAnalysisConfig:

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

Public Attributes
str	systematicsModelJES = "All":
	uncertaintyAnalysisFiles
	runJERsystematicsOnData
	containerName
	recalibratePhyslite
	runUncertainties
	runJvtUpdate
	runNNJvtUpdate
	runJvtSelection
	runFJvtSelection

Detailed Description

the ConfigBlock for the small-r jet sequence

Definition at line 190 of file JetAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.JetAnalysisConfig.SmallRJetAnalysisConfig.__init__

(

self

)

Definition at line 193 of file JetAnalysisConfig.py.

    def __init__ (self) :
        super().__init__()
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the output container after calibration.",
            meta={'role':'container'})
        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 ('runJvtUpdate', False, type=bool,
            info="whether to update the JVT.")
        self.addOption ('runNNJvtUpdate', False, type=bool,
            info="whether to update the NN-JVT.")
        self.addOption ('runJvtSelection', True, type=bool,
            info="whether to run JVT selection.")
        self.addOption ('runFJvtSelection', False, type=bool,
            info="whether to run forward JVT selection.")
        self.addOption ('jvtWP', "FixedEffPt", type=str,
            info="which Jvt WP to apply.",
            meta={'choices':(['FixedEffPt'],1)})
        self.addOption ('fJvtWP', "Loose", type=str,
            info="which fJvt WP to apply.",
            meta={'choices':(['Loose','Tight','Tighter'],1)})
        self.addOption ('runJvtEfficiency', True, type=bool,
            info="whether to calculate the JVT efficiency.")
        self.addOption ('runFJvtEfficiency', False, type=bool,
            info="whether to calculate the forward JVT efficiency.")
        self.addOption ('runUncertainties', True, type=bool,
            info="whether to configure JetUncertaintiesTool.", expertMode=True)
        self.addOption('uncertaintyAnalysisFiles', None, type=dict,
            info="dictionary of dsids with entry corresponding to file containing gluon fraction histograms needed to calculate an analysis specific "
            "jet flavor composition uncertainty.")
        self.addOption ('systematicsModelJES', "Category", type=str,
            info="the NP reduction scheme to use for JES: All, Global, Category, "
            "Scenario. The default is Category.")
        self.addOption ('systematicsModelJER', "Full", type=str,
            info="the NP reduction scheme to use for JER: All, Full, Simple. The "
            "default is Full.",
            meta={'choices':(['All','Full','Simple'],1)})
        self.addOption ('runJERsystematicsOnData', False, type=bool,
            info="whether to run the All/Full JER model variations also on data samples. Expert option!",
            expertMode=True)
        self.addOption ('recalibratePhyslite', True, type=bool,
            info="whether to run the `CP::JetCalibrationAlg` on PHYSLITE derivations.")
        # Calibration tool options
        self.addOption ('calibToolConfigFile', None, type=str,
            info="the 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 (str) of the config file to use for the jet uncertainty "
            "tool. Expert option to override JetETmiss recommendations. The "
            "default is None.",
            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)
 

Member Function Documentation

createUncertaintyTool()

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

Definition at line 345 of file JetAnalysisConfig.py.

    def createUncertaintyTool(self, jetUncertaintiesAlg, config, jetCollectionName, doPseudoData=False):
 
        # Create an instance of JetUncertaintiesTool, following JetETmiss recommendations.
        # To run Jet Energy Resolution (JER) uncertainties in the "Full" or "All" schemes,
        # we need two sets of tools: one configured as normal (MC), the other with the
        # exact same settings but pretending to run on data (pseudo-data).
        # This is achieved by passing "isPseudoData=True" to the arguments.
 
        # Retrieve the common configuration settings
        configFile, calibArea, mcType = self.getUncertaintyToolSettings(config)
 
        # The main tool for all JES+JER combinations
        tool = _addJetUncertaintiesTool(config, jetUncertaintiesAlg, 'uncertaintiesTool',
                                        jetCollectionName, configFile, calibArea, mcType,
                                        isData=(config.dataType() is DataType.Data),
                                        pseudoData=False)
        from PathResolver import PathResolver
        if self.uncertaintyAnalysisFiles is not None:
          if config.dsid() in self.uncertaintyAnalysisFiles:
            tool.AnalysisFile = PathResolver.FindCalibFile(self.uncertaintyAnalysisFiles[config.dsid()])
 
        if config.dataType() is DataType.Data and not (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 doPseudoData and not self.runJERsystematicsOnData:
            # The secondary tool for pseudo-data JER smearing
            _addJetUncertaintiesTool(config, jetUncertaintiesAlg, 'uncertaintiesToolPD',
                                     jetCollectionName, configFile, calibArea, mcType,
                                     isData=True, pseudoData=True)
 
 

getUncertaintyToolSettings()

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

Definition at line 273 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.
 
        jetInput = config.getContainerMeta(self.containerName, 'jetInput', failOnMiss=True)
        # Config file:
        config_file = None
        if self.systematicsModelJES == "All" and self.systematicsModelJER == "All":
            config_file = "R4_AllNuisanceParameters_AllJERNP.config"
        elif "Scenario" in self.systematicsModelJES:
            if self.systematicsModelJER != "Simple":
                raise ValueError(
                    "Invalid uncertainty configuration - Scenario* systematicsModelJESs can "
                    "only be used together with the Simple systematicsModelJER")
            config_file = f"R4_{self.systematicsModelJES}_SimpleJER.config"
        elif self.systematicsModelJES in ["Global", "Category"] and self.systematicsModelJER in ["Simple", "Full"]:
            config_file = f"R4_{self.systematicsModelJES}Reduction_{self.systematicsModelJER}JER.config"
        else:
            raise ValueError(
                "Invalid combination of systematicsModelJES and systematicsModelJER settings: "
                f"systematicsModelJES: {self.systematicsModelJES}, systematicsModelJER: {self.systematicsModelJER}" )
 
        # Calibration area:
        calib_area = None
        if self.uncertToolCalibArea is not None:
            calib_area = self.uncertToolCalibArea
 
        # Expert override for config path:
        if self.uncertToolConfigPath is not None:
            config_file = self.uncertToolConfigPath
        else:
            if config.geometry() is LHCPeriod.Run2:
                if config.dataType() is DataType.FastSim:
                    config_file = "rel22/Fall2024_PreRec/" + config_file
                else:
                    if jetInput == "HI":
                        config_file = "HIJetUncertainties/Spring2023/HI" + config_file
                    else:
                        config_file = "rel22/Summer2023_PreRec/" + config_file
            else:
                if config.dataType() is DataType.FastSim:
                    config_file = "rel22/Winter2025_AF3_PreRec/" + config_file
                else:
                    if jetInput == "HI":
                        config_file = "HIJetUncertainties/Spring2023/HI" + config_file
                    else:
                        config_file = "rel22/Winter2025_PreRec/" + config_file
 
        # MC type:
        mc_type = None
        if self.uncertToolMCType is not None:
            mc_type = self.uncertToolMCType
        else:
            if config.geometry() is LHCPeriod.Run2:
                if config.dataType() is DataType.FastSim:
                    mc_type = "AF3"
                else:
                    mc_type = "MC20"
            else:
                if config.dataType() is DataType.FastSim:
                    mc_type = "MC23AF3"
                else:
                    if jetInput == "HI":
                        mc_type = "MC16"
                    else:
                        mc_type = "MC23"
 
        return config_file, calib_area, mc_type
 
 

instanceName()

python.JetAnalysisConfig.SmallRJetAnalysisConfig.instanceName

(

self

)

Return the instance name for this block

Definition at line 269 of file JetAnalysisConfig.py.

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

makeAlgs()

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

Definition at line 376 of file JetAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        # Self-select: only run for radius-4 jets
        if config.getContainerMeta(self.containerName, 'jetRadius', failOnMiss=True) != 4:
            return
 
 
        jetCollectionName = config.getContainerMeta(self.containerName, 'jetCollectionName', failOnMiss=True)
 
        jetInput = config.getContainerMeta(self.containerName, 'jetInput', failOnMiss=True)
 
        if jetInput not in ["EMTopo", "EMPFlow", "HI"]:
            raise ValueError(
                f"Unsupported input type '{jetInput}' for R=0.4 jets!" )
 
        if self.jvtWP not in ["FixedEffPt"]:
            raise ValueError(
                f"Unsupported NNJvt WP '{self.jvtWP}'" )
 
        if self.fJvtWP not in ["Loose", "Tight", "Tighter"]:
            raise ValueError(
                f"Unsupported fJvt WP '{self.fJvtWP}'" )
 
        if not config.isPhyslite() or self.recalibratePhyslite:
            # Create calibration tool as public so it can be shared
            # (e.g. with FTAG1LITE's JetCalibratedPtDecoratorAlg).
            # Must be created before the algorithm so EventLoop
            # initialises the tool first.
            calibToolName = 'JetCalibTool_' + jetCollectionName[:-4]
            calibTool = config.createPublicTool( 'JetCalibrationTool', calibToolName )
            calibTool.JetCollection = jetCollectionName[:-4]
            # Get the correct string to use in the config file name
            if jetInput == "EMPFlow":
                if config.geometry() is LHCPeriod.Run2:
                    configFile = "PreRec_R22_PFlow_ResPU_EtaJES_GSC_February23_230215.config"
                    calibTool.CalibArea = "00-04-82"
                elif config.geometry() >= LHCPeriod.Run3:
                    configFile = "AntiKt4EMPFlow_MC23a_PreRecR22_Phase2_CalibConfig_ResPU_EtaJES_GSC_241208_InSitu.config"
                    calibTool.CalibArea = "00-04-83"
            elif jetInput == "HI":
                if config.geometry() is LHCPeriod.Run2:
                    configFile = "JES_MC16_HI_Jan2021_5TeV.config"
                elif config.geometry() is LHCPeriod.Run3:
                    configFile = "AntiKt4HI_MC23_EtaJES_Run3PreRec_Run2VJet_Run3EtaInt_5p36TeV.config"
                    calibTool.CalibArea = "00-04-83"
                else:
                    raise ValueError(
                        f"Unsupported geometry '{config.geometry()}' for HI jet calibration!")
            else:
                if config.dataType() is DataType.FastSim:
                    configFile = f"JES_MC16Recommendation_AFII_{jetInput}_Apr2019_Rel21.config"
                else:
                    configFile = f"JES_MC16Recommendation_Consolidated_{jetInput}_Apr2019_Rel21.config"
            if self.calibToolCalibArea is not None:
                calibTool.CalibArea = self.calibToolCalibArea
            if self.calibToolConfigFile is not None:
                configFile = self.calibToolConfigFile
            calibTool.ConfigFile = configFile
            if config.dataType() is DataType.Data:
                if jetInput == "HI":
                    calibTool.CalibSequence = 'EtaJES_Insitu'
                else:
                    calibTool.CalibSequence = 'JetArea_Residual_EtaJES_GSC_Insitu'
            else:
                if jetInput == "EMPFlow":
                    calibTool.CalibSequence = 'JetArea_Residual_EtaJES_GSC'
                elif jetInput == "HI":
                    calibTool.CalibSequence = 'EtaJES'
                else:
                    calibTool.CalibSequence = 'JetArea_Residual_EtaJES_GSC_Smear'
            if self.calibToolCalibSeq is not None:
                calibTool.CalibSequence = self.calibToolCalibSeq
            calibTool.IsData = (config.dataType() is DataType.Data)
            # Prepare the jet calibration algorithm
            alg = config.createAlgorithm( 'CP::JetCalibrationAlg', 'JetCalibrationAlg' )
            alg.HIsetup = jetInput == "HI"
            alg.calibrationTool = f'{calibTool.getType()}/{calibTool.getName()}'
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
 
        # Jet uncertainties
        if self.runUncertainties:
            alg = config.createAlgorithm( 'CP::JetUncertaintiesAlg', 'JetUncertaintiesAlg' )
            self.createUncertaintyTool(alg, config, jetCollectionName, doPseudoData=( self.systematicsModelJER in ["Full","All"] ))
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        # Set up the JVT update algorithm:
        if self.runJvtUpdate :
            alg = config.createAlgorithm( 'CP::JvtUpdateAlg', 'JvtUpdateAlg' )
            config.addPrivateTool( 'jvtTool', 'JetVertexTaggerTool' )
            alg.jvtTool.JetContainer = self.jetCollection
            alg.jvtTool.SuppressInputDependence=True
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            alg.preselection = config.getPreselection (self.containerName, '')
 
        if self.runNNJvtUpdate:
            assert jetInput=="EMPFlow", "NN JVT only defined for PFlow jets"
            alg = config.createAlgorithm( 'CP::JetDecoratorAlg', 'NNJvtUpdateAlg' )
            config.addPrivateTool( 'decorator', 'JetPileupTag::JetVertexNNTagger' )
            alg.jets = config.readName (self.containerName)
            alg.jetsOut = config.copyName (self.containerName)
            # Set this actually to the *output* collection
            alg.decorator.JetContainer = alg.jetsOut.replace ('%SYS%', 'NOSYS')
            alg.decorator.SuppressInputDependence=True
            alg.decorator.SuppressOutputDependence=True
 
        # Set up the jet efficiency scale factor calculation algorithm
        # Change the truthJetCollection property to AntiKt4TruthWZJets if preferred
        if self.runJvtSelection :
            assert jetInput=="EMPFlow", "NNJvt WPs and SFs only valid for PFlow jets"
            warnings.warn_explicit(
                "jvtWP, runJvtSelection and runJvtEfficiency"
                " are deprecated - please use a"
                " JVTWorkingPoint block instead.",
                ConfigDeprecationWarning, filename='', lineno=0)
 
            alg = config.createAlgorithm('CP::AsgSelectionAlg', 'JvtSelectionAlg')
            config.addPrivateTool('selectionTool', 'CP::NNJvtSelectionTool')
            alg.selectionTool.JetContainer = config.readName(self.containerName)
            alg.selectionTool.JvtMomentName = "NNJvt"
            alg.selectionTool.WorkingPoint = self.jvtWP
            alg.selectionTool.MaxPtForJvt = 60*GeV
            alg.selectionDecoration = "jvt_selection,as_char"
            alg.particles = config.readName(self.containerName)
 
            if self.runJvtEfficiency and config.dataType() is not DataType.Data:
                alg = config.createAlgorithm( 'CP::JvtEfficiencyAlg', 'JvtEfficiencyAlg' )
                config.addPrivateTool( 'efficiencyTool', 'CP::NNJvtEfficiencyTool' )
                alg.efficiencyTool.JetContainer = config.readName(self.containerName)
                alg.efficiencyTool.MaxPtForJvt = 60*GeV
                alg.efficiencyTool.WorkingPoint = self.jvtWP
                if config.geometry() is LHCPeriod.Run2:
                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/NNJvtSFFile_Run2_EMPFlow.root"
                else:
                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/NNJvtSFFile_Run3_EMPFlow.root"
                alg.selection = 'jvt_selection,as_char'
                alg.scaleFactorDecoration = 'jvt_effSF_%SYS%'
                alg.outOfValidity = 2
                alg.outOfValidityDeco = 'no_jvt'
                alg.skipBadEfficiency = False
                alg.jets = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, '')
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'jvtEfficiency')
            config.addSelection (self.containerName, 'baselineJvt', 'jvt_selection,as_char', preselection=False)
 
        if self.runFJvtSelection :
            assert jetInput=="EMPFlow", "fJvt WPs and SFs only valid for PFlow jets"
            warnings.warn_explicit(
                "fJvtWP, runFJvtSelection and runFJvtEfficiency"
                " are deprecated - please use a"
                " FJVTWorkingPoint block instead.",
                ConfigDeprecationWarning, filename='', lineno=0)
 
            alg = config.createAlgorithm('CP::AsgSelectionAlg', 'FJvtSelectionAlg')
            config.addPrivateTool('selectionTool', 'CP::FJvtSelectionTool')
            alg.selectionTool.JetContainer = config.readName(self.containerName)
            alg.selectionTool.JvtMomentName = "DFCommonJets_fJvt"
            alg.selectionTool.WorkingPoint = self.fJvtWP
            alg.selectionDecoration = "fjvt_selection,as_char"
            alg.particles = config.readName(self.containerName)
 
            if self.runFJvtEfficiency and config.dataType() is not DataType.Data:
                alg = config.createAlgorithm( 'CP::JvtEfficiencyAlg', 'FJvtEfficiencyAlg' )
                config.addPrivateTool( 'efficiencyTool', 'CP::FJvtEfficiencyTool' )
                alg.efficiencyTool.JetContainer = config.readName(self.containerName)
                alg.efficiencyTool.WorkingPoint = self.fJvtWP
                if config.geometry() is LHCPeriod.Run2:
                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/fJvtSFFile_Run2_EMPFlow.root"
                else:
                    alg.efficiencyTool.SFFile = "JetJvtEfficiency/May2024/fJvtSFFile_Run3_EMPFlow.root"
                alg.selection = 'fjvt_selection,as_char'
                alg.scaleFactorDecoration = 'fjvt_effSF_%SYS%'
                alg.outOfValidity = 2
                alg.outOfValidityDeco = 'no_fjvt'
                alg.skipBadEfficiency = False
                alg.jets = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, '')
                config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'fjvtEfficiency')
            config.addSelection (self.containerName, 'baselineFJvt', 'fjvt_selection,as_char', preselection=False)
 
        # Additional decorations
        alg = config.createAlgorithm( 'CP::AsgEnergyDecoratorAlg', 'AsgEnergyDecoratorAlg' )
        alg.particles = config.readName (self.containerName)
 
        config.addOutputVar (self.containerName, 'e_%SYS%', 'e')
 
 

Member Data Documentation

containerName

python.JetAnalysisConfig.SmallRJetAnalysisConfig.containerName

Definition at line 379 of file JetAnalysisConfig.py.

recalibratePhyslite

python.JetAnalysisConfig.SmallRJetAnalysisConfig.recalibratePhyslite

Definition at line 399 of file JetAnalysisConfig.py.

runFJvtSelection

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runFJvtSelection

Definition at line 524 of file JetAnalysisConfig.py.

runJERsystematicsOnData

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runJERsystematicsOnData

Definition at line 366 of file JetAnalysisConfig.py.

runJvtSelection

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runJvtSelection

Definition at line 487 of file JetAnalysisConfig.py.

runJvtUpdate

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runJvtUpdate

Definition at line 465 of file JetAnalysisConfig.py.

runNNJvtUpdate

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runNNJvtUpdate

Definition at line 474 of file JetAnalysisConfig.py.

runUncertainties

python.JetAnalysisConfig.SmallRJetAnalysisConfig.runUncertainties

Definition at line 457 of file JetAnalysisConfig.py.

systematicsModelJES

str python.JetAnalysisConfig.SmallRJetAnalysisConfig.systematicsModelJES = "All":

Definition at line 282 of file JetAnalysisConfig.py.

uncertaintyAnalysisFiles

python.JetAnalysisConfig.SmallRJetAnalysisConfig.uncertaintyAnalysisFiles

Definition at line 363 of file JetAnalysisConfig.py.

---

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

• JetAnalysisConfig.py