KLFitterConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
 
from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
from FTagAnalysisAlgorithms.FTagHelpers import getRecommendedBTagCalib
 
 
class KLFitterBlock(ConfigBlock):
    """ConfigBlock for KLFitter algorithms"""
 
    def __init__(self):
        super(KLFitterBlock, self).__init__()
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the input container.",
            meta={'role':'container'})
        self.addOption(
            "electrons",
            "",
            type=str,
            info="the input electron container, with a possible selection, in the format `container` or `container.selection`.",
            meta={'role':'containerRef'},
        )
        self.addOption(
            "muons",
            "",
            type=str,
            info="the input muon container, with a possible selection, in the format `container` or `container.selection`.",
            meta={'role':'containerRef'},
        )
        self.addOption(
            "jets",
            "",
            type=str,
            info="the input jet container, with a possible selection, in the format `container` or `container.selection`.",
            meta={'role':'containerRef'},
        )
        self.addOption(
            "met",
            "",
            type=str,
            info="the input MET container.",
            meta={'role':'containerRef'},
        )
        self.addOption(
            "likelihoodType",
            "",
            type=str,
            info="KLFitter likelihood, if only one is needed. See `KLFitterEnums.h` for possible values.",
        )
        self.addOption(
            "leptonType",
            "",
            type=str,
            info="type of lepton to use (only relevant to certain likelihood types), if only one is needed. See `KLFitterEnums.h` for possible values.",
        )
        self.addOption(
            "jetSelectionMode",
            "",
            type=str,
            info="jet selection mode to use, if only one is needed. See `KLFitterEnums.h` for possible values.",
        )
        self.addOption(
            "btaggingMethod",
            "kNotag",
            type=str,
            info="strategy to handle b-jets, if only one is needed. See `KLFitterEnums.h` for possible values.",
        )
        self.addOption(
            "bTagCDIFile",
            None,
            type=str,
            info="CDI file to pass to the b-tagging efficiency tool.",
        )
        self.addOption(
            "btagger",
            "GN2v01",
            type=str,
            info="b-tagging algorithm to use, if only one is needed.",
        )
        self.addOption(
            "btagWP",
            "",
            type=str,
            info="b-tagging efficiency WP to use, if only one is needed.",
        )
        self.addOption(
            "btagIgnoreOutOfValidityRange",
            False,
            type=bool,
            info="whether or not the b-tagger should ignore (and not fail) when a jet is outside the calibration range.",
        )
        self.addOption(
            "selectionRegionsConfig",
            "",
            type=str,
            info="string of the form `selectionName: sel1, optionA: opA, optionB: opB; selectionName: sel2, ...` where options can be `likelihoodType`, `leptonType`, `jetSelectionMode`, `btaggingMethod`, `btagger` or `btagWP`.",
        )
        self.addOption(
            "saveAllPermutations",
            False,
            type=bool,
            info="whether to save all permutations, or just the best one.",
        )
        # list of dictionaries for the per-region config options
        self.perRegionConfiguration = list()
 
    def instanceName (self) :
        """Return the instance name for this block"""
        return self.containerName
 
    def parseSelectionRegionsConfig(self):
        if not self.selectionRegionsConfig.strip():
            raise ValueError(
                "KLFitterConfig: Could not determine any regions in your selectionRegionsConfig (empty string)"
            )
        regions = self.selectionRegionsConfig.split(";")
        for reg in regions:
            regionopts = {}
            for option in reg.replace(" ", "").split(","):
                keyval = option.split(":")
                if len(keyval) != 2 or not keyval[0] or not keyval[1]:
                    raise ValueError(
                        f"KLFitterConfig: malformed option '{option}' in selectionRegionsConfig region '{reg}', expected 'key: value'"
                    )
                regionopts[keyval[0]] = keyval[1]
            if "selectionName" not in regionopts:
                raise ValueError(
                    f"KLFitterConfig: Could not parse selectionRegionsConfig selectionName for region '{reg}'"
                )
            if "likelihoodType" in regionopts:
                raise ValueError(
                    "KLFitterConfig: likelihoodType cannot be overriden per region. Create a separate instance of KLFitter block with different likelihoodType instead."
                )
 
            self.perRegionConfiguration.append(regionopts)
 
    def makeAlgs(self, config):
        if not self.likelihoodType:
            raise ValueError("KLFitterConfig: the likelihoodType option must be set")
        self.parseSelectionRegionsConfig()
        for perRegionConfig in self.perRegionConfiguration:
            selectionName = perRegionConfig["selectionName"]
            alg = config.createAlgorithm(
                "EventReco::RunKLFitterAlg",
                f"RunKLFitterAlg_{selectionName}",
            )
            # input objects and their object selections
            alg.electrons, alg.electronSelection = config.readNameAndSelection(
                self.electrons
            )
            alg.muons, alg.muonSelection = config.readNameAndSelection(self.muons)
            alg.jets, alg.jetSelection = config.readNameAndSelection(self.jets)
            alg.met = config.readName(self.met)
            alg.result = self.containerName + "_%SYS%"
 
            # global settings, in future expect to expose more options for configuration
            alg.SaveAllPermutations = self.saveAllPermutations
 
            # these settings can be defined per-region, but if not, we fallback to global setting
            alg.selectionDecorationName = selectionName + "_%SYS%,as_char"
            alg.LHType = self.likelihoodType
            alg.LeptonType = perRegionConfig.get("leptonType", self.leptonType)
            alg.JetSelectionMode = perRegionConfig.get(
                "jetSelectionMode", self.jetSelectionMode
            )
            btagAlgo = perRegionConfig.get("btagger", self.btagger)
            btagWP = perRegionConfig.get("btagWP", self.btagWP)
            alg.BTaggingDecoration = f"ftag_select_{btagAlgo}_{btagWP}"
 
            alg.BTaggingMethod = perRegionConfig.get(
                "btaggingMethod", self.btaggingMethod
            )
            if alg.BTaggingMethod == "kWorkingPoint":
                config.addPrivateTool("btagEffTool", "BTaggingEfficiencyTool")
                alg.btagEffTool.TaggerName = btagAlgo
                alg.btagEffTool.OperatingPoint = btagWP
                jetCollection = config.originalName(self.jets.split(".")[0])
                alg.btagEffTool.JetAuthor = jetCollection
                alg.btagEffTool.ScaleFactorFileName = (
                    getRecommendedBTagCalib(config.geometry(), btagWP)
                    if self.bTagCDIFile is None
                    else self.bTagCDIFile
                )
                alg.btagEffTool.IgnoreOutOfValidityRange = (
                    self.btagIgnoreOutOfValidityRange
                )
                alg.btagEffTool.MinPt = (
                    20e3  # hardcoded to the recommendation for EMPFlow at the moment
                )
                # NOTE the efficiency tool is simply set to the default generator,
                # meaning the results are not correct for alternative showering generators!!
 
        finalizeAlg = config.createAlgorithm(
            "EventReco::KLFitterFinalizeOutputAlg",
            "KLFitterFinalizeOutputAlg",
        )
        finalizeAlg.resultContainerToCheck = self.containerName + "_%SYS%"
        finalizeAlg.resultContainerToWrite = self.containerName + "_%SYS%"
 
        config.writeName(self.containerName)
 
        config.addOutputVar(self.containerName, "eventProbability", "eventProbability", auxType="float")
        config.addOutputVar(self.containerName, "logLikelihood", "logLikelihood", auxType="float")
        if self.saveAllPermutations:
            config.addOutputVar(self.containerName, "bestPermutation", "bestPermutation", auxType="unsigned_int")
 
        if self.likelihoodType != "ttbar_AllHad":
            config.addOutputVar(
                self.containerName, "model_bhad_jetIndex", "bhad_jetIndex", auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName, "model_blep_jetIndex", "blep_jetIndex", auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName, "model_lq1_jetIndex", "lq1_jetIndex", auxType="unsigned_int"
            )
            if self.likelihoodType != "ttbar_BoostedLJets":
                config.addOutputVar(
                    self.containerName, "model_lq2_jetIndex", "lq2_jetIndex", auxType="unsigned_int"
                )
            if self.likelihoodType == "ttH":
                config.addOutputVar(
                    self.containerName, "model_Higgs_b1_jetIndex", "Higgs_b1_jetIndex", auxType="unsigned_int"
                )
                config.addOutputVar(
                    self.containerName, "model_Higgs_b2_jetIndex", "Higgs_b2_jetIndex", auxType="unsigned_int"
                )
 
            config.addOutputVar(self.containerName, "model_nu_pt", "nu_pt", auxType="float")
            config.addOutputVar(self.containerName, "model_nu_eta", "nu_eta", auxType="float")
            config.addOutputVar(self.containerName, "model_nu_phi", "nu_phi", auxType="float")
            config.addOutputVar(self.containerName, "model_nu_E", "nu_E", auxType="float")
 
            if self.likelihoodType == "ttZTrilepton":
                config.addOutputVar(self.containerName, "model_lep_index", "lep_index", auxType="unsigned_int")
                config.addOutputVar(
                    self.containerName, "model_lepZ1_index", "lepZ1_index", auxType="unsigned_int"
                )
                config.addOutputVar(
                    self.containerName, "model_lepZ2_index", "lepZ2_index", auxType="unsigned_int"
                )
        else:
            config.addOutputVar(
                self.containerName, "model_b_from_top1_jetIndex", "b_from_top1_jetIndex", auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName, "model_b_from_top2_jetIndex", "b_from_top2_jetIndex", auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName,
                "model_lj1_from_top1_jetIndex",
                "lj1_from_top1_jetIndex",
                auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName,
                "model_lj2_from_top1_jetIndex",
                "lj2_from_top1_jetIndex",
                auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName,
                "model_lj1_from_top2_jetIndex",
                "lj1_from_top2_jetIndex",
                auxType="unsigned_int"
            )
            config.addOutputVar(
                self.containerName,
                "model_lj2_from_top2_jetIndex",
                "lj2_from_top2_jetIndex",
                auxType="unsigned_int"
            )