JetCalibStepsConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration

from AnaAlgorithm.DualUseConfig import isAthena
if not isAthena:
    
    import AnaAlgorithm.AlgSequence # noqa: F401
    import JetRecConfig.JetAnalysisCommon # noqa: F401

from AthenaCommon import Logging
jcslog = Logging.logging.getLogger('JetCalibStepsConfig')
 
from JetToolHelpers.HelperConfig import VarToolCfg, HistoInputCfg
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.AutoConfigFlags import GetFileMD
from AthenaConfiguration.Enums import LHCPeriod
from PathResolver import PathResolver
import json
 
def smearingStep(flags, **configDict):
    """ Configuration of the Smearing step. """
 
    configDict.setdefault('OutScale', 'JetSmearedMomentum')
 
    # HistoReaderMC and HistoReaderData can be specified simultaneously using a single "HistoReader" YAML block.
    # This should contain the common configuration for both and histNameMC/histNameData entries for the histogram names.
    # This cannot be used simultaneously with a HistoReaderMC or HistoReaderData block
    if "HistoReader" in configDict:
        if "HistoReaderMC" in configDict:
            raise JetCalibConfigError("Both HistoReader and HistoReaderMC blocks included in YAML config")
        if "HistoReaderData" in configDict:
            raise JetCalibConfigError("Both HistoReader and HistoReaderData blocks included in YAML config")
        
        # Build the HistoReaderMC and HistoReaderData blocks from the HistoReader block
        histoReader = configDict.pop("HistoReader")
        histNameMC = histoReader.pop("histNameMC")
        histNameData = histoReader.pop("histNameData")
        configDict["HistoReaderMC"] = dict(histoReader)
        configDict["HistoReaderData"] = dict(histoReader)
        configDict["HistoReaderMC"]["histName"] = histNameMC
        configDict["HistoReaderData"]["histName"] = histNameData
 
    configDict["HistoReaderMC"]["inputFile"] = PathResolver.FindCalibFile(configDict["HistoReaderMC"]["inputFile"])
    configDict["HistoReaderData"]["inputFile"] = PathResolver.FindCalibFile(configDict["HistoReaderData"]["inputFile"])
 
    histToolMC = HistoInputCfg(flags, "HistToolMC", **configDict["HistoReaderMC"])
    histToolData = HistoInputCfg(flags, "HistToolData", **configDict["HistoReaderData"])
    configDict["HistoReaderMC"] = histToolMC
    configDict["HistoReaderData"] = histToolData
 
    smearStep = CompFactory.SmearingCalibStep("SmearingCalibStep", **configDict)
 
    return [smearStep]
 
def puresidualStep(flags, **configDict):
    configDict.setdefault('OutScale', 'JetPileupScaleMomentum')
    configDict.setdefault('IsData', not flags.Input.isMC)
    PU_step = CompFactory.Pileup1DResidualCalibStep("PUResid", **configDict)
    return [PU_step]
 
def puCorrectionStep(flags, **configDict):
    # rho * area and histogram-based 1D residual correction
    configDict.setdefault('OutScale', 'JetPileupScaleMomentum')
    configDict.setdefault('IsData', not flags.Input.isMC)
 
    histoParamsMu = configDict.pop('histoParamsMu')
    inputFile = PathResolver.FindCalibFile(configDict.pop('calibFile'))
    histoParamsMu['inputFile'] = inputFile
 
    histoParamsNPV = configDict.pop('histoParamsNPV')
    histoParamsNPV['inputFile'] = inputFile
 
    histToolMu = HistoInputCfg(flags, "HistToolMu", **histoParamsMu)
    histToolNPV = HistoInputCfg(flags, "HistToolNPV", **histoParamsNPV)
    configDict["histTool_mu"] = histToolMu
    configDict["histTool_NPV"] = histToolNPV
 
    PU_step = CompFactory.PileupCalibStep("PileUpCorrection", **configDict)
    return [PU_step]
 
def gscStep(flags, **configDict):
 
    configDict.setdefault('OutScale', 'JetGSCScaleMomentum')
 
    defaultFileGSC = PathResolver.FindCalibFile(configDict.pop('fileGSC'))
 
    # These HistoInput2D defaults can't be set in the C++, so are set here:
    defaultHistTools = dict(
        histTool_EM3 = [dict(varX = "pt", varY = "EM3", histName=f"AntiKt4EMPFlow_EM3_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(35)],
        histTool_CharFrac = [dict(varX = "pt", varY = "ChargedFraction", histName = f"AntiKt4EMPFlow_chargedFraction_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(25)],
        histTool_Tile0 = [dict(varX = "pt", varY = "Tile0", histName=f"AntiKt4EMPFlow_Tile0_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(18)],
        histTool_nTrk=[dict(varX = "pt", varY = dict(Name="nTrk", Type="int",), histName=f"AntiKt4EMPFlow_nTrk_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(25)],
        histTool_trackWIDTH=[dict(varX = "pt", varY = "trackWIDTH", histName=f"AntiKt4EMPFlow_trackWIDTH_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(25)],
        histTool_PunchThrough=[dict(varX = "e", varY = dict(Name="Nsegments", Type="int",), histName=f"AntiKt4EMPFlow_PunchThrough_interpolation_resp_eta_{j}", inputFile=defaultFileGSC) for j in range(2)],
    )
 
    gsc_steps = []
    if configDict.get('applyChargedFraction', True):
        gsc_steps.append('histTool_CharFrac')
    if configDict.get('applyEM3', True):
        gsc_steps.append('histTool_EM3')
    if configDict.get('applyTile0', True):
        gsc_steps.append('histTool_Tile0')
    if configDict.get('applyNtrk', True):
        gsc_steps.append('histTool_nTrk')
    if configDict.get('applyTrackWidth', True):
        gsc_steps.append('histTool_trackWIDTH')
    if configDict.get('applyPunchThrough',False):
        gsc_steps.append('histTool_PunchThrough')
 
    # Build the hist tools
    for key in gsc_steps:
        # Use defaultHistTools by default
        if key not in configDict:
            toolArray = defaultHistTools[key]
 
        # In this case the full list of sub-tools has been specified in the YAML
        # and the defaultDict will be fully overwritten (ie. all parameters must be specified)
        elif isinstance(configDict[key],list):
            toolArray = configDict[key]
            for subDict in toolArray:
                subDict.setdefault('inputFile',defaultFileGSC)
 
        # Functionality to build the arrays of histogram reader from a shorter block in the YAML file
        # Fall back on defaultHistTools for defaults
        else:
            baseDict = dict(configDict[key])
            N_hist = baseDict.pop('N_hist')
            histNameBase = baseDict.pop('histNameBase')
            inputFile = baseDict.pop('inputFile', defaultFileGSC)
            varX = baseDict.pop('varX',defaultHistTools[key][0]['varX'])
            varY = baseDict.pop('varY', defaultHistTools[key][0]['varY'])
            toolArray = [dict(varX = varX, varY = varY, histName=f'{histNameBase}_{j}', inputFile = inputFile) for j in range(N_hist)]
 
        # Convert array of properties to HistoInput tools
        configDict[key] = [HistoInputCfg(flags, Tname=f"{key.split('_')[1]}_{j}", **toolConfig) for j, toolConfig in enumerate(toolArray)]
 
    GSCstep = CompFactory.GSCCalibStep("gsccalibstep", **configDict)
 
    return [GSCstep]
 
def etajesStep(flags, **configDic):
    configDic.setdefault('OutScale', 'JetEtaJESScaleMomentum')
    pVars = configDic.pop("ParametrizedVars")
 
    jesstep = CompFactory.EtaJESCalibStep("EtaJESCalib",
                                              VarToolE= VarToolCfg(flags,  var=pVars['varE']),
                                              VarToolEta= VarToolCfg(flags, var=pVars["varEta"]),
                                              **configDic
                                              )
    return [jesstep]
 
def jmsStep(flags, **configDic):
 
    configDic.setdefault('OutScale', 'JetJMSScaleMomentum')
    histoParams = configDic.pop('histoParams')
    histoParams['inputFile'] = PathResolver.FindCalibFile(configDic.pop('HistoFile'))
 
    configDic["histoReaderJMS"] = HistoInputCfg(flags, "HistToolJMS", **histoParams)
    configDic['varToolX'] = VarToolCfg(flags, var=histoParams['varX'], Tname="VarToolX_JMS")
    configDic['varToolZ'] = VarToolCfg(flags, var=histoParams['varZ'], Tname="VarToolZ_JMS")
 
    jmsstep = CompFactory.JMSCalibStep("JMSCalib",
                                       **configDic
                                       )
    return [jmsstep]
 
def insituStep(flags, **configDic):
    configDic.setdefault('OutScale', 'JetInsituScaleMomentum')
    histEtaInterCalib = configDic.pop('histEtaInterCalib')
    histAbsCalib = configDic.pop('histAbsCalib')
 
    histAbsJMSCalib = configDic.pop('JMS',None)
 
    histoReaderEta_vec, histoReaderAbs_vec = [], []
 
    for infile in configDic.pop('fileInsitu'):
        histoReaderEta_vec.append(dict(inputFile = PathResolver.FindCalibFile(infile), **histEtaInterCalib))
        histoReaderAbs_vec.append(dict(inputFile = PathResolver.FindCalibFile(infile), **histAbsCalib))
 
    configDic['HistoReaderEtaInter'] = [HistoInputCfg(flags, "HistToolEtaInter"+str(j), **etaDic) for j, etaDic in enumerate(histoReaderEta_vec)]
    configDic['HistoReaderAbs'] = [HistoInputCfg(flags, "HistToolAbs"+str(j), **absDic) for j, absDic in enumerate(histoReaderAbs_vec)]
 
    configDic['isMC'] = flags.Input.isMC
 
    insituSteps = [CompFactory.InSituCalibStep("insitucalibstep", **configDic)]
 
    # JMS
    if histAbsJMSCalib:
        histAbsJMSCalib['inputFile'] = PathResolver.FindCalibFile(histAbsJMSCalib['inputFile'])
        insituSteps.append(
            CompFactory.InSituJMSCalibStep("insitujmscalibstep", 
                CalibrateMC = configDic.get("CalibrateMC",False),
                isMC = flags.Input.isMC,
                # modifying insitu scale rather than defining a new scale
                InScale = "JetInsituScaleMomentum",
                OutScale = "JetInsituScaleMomentum",
                HistoReaderAbsJMS = HistoInputCfg(flags, "HistoToolAbsJMS", **histAbsJMSCalib),
                ))
 
    return insituSteps
 
def af3Step(flags, **configDic):
    configDic.setdefault('OutScale','JetFastSimScaleMomentum')
    # Get the settings for the histograms:
    histoParams = configDic.pop('histoParams')
    histoParams['inputFile'] = PathResolver.FindCalibFile(configDic.pop('CalibConstantFile'))
    configDic["histoTool"] = HistoInputCfg(flags, "histoTool", **histoParams)
 
    return [CompFactory.Generic4VecCorrectionStep("AF3", **configDic)]
 
def ptResidualStep(flags, **configDic):
    configDic.setdefault('OutScale','JetPtResidualScaleMomentum')
    # Get the settings for the histograms:
    histoParams = configDic.pop('histoParams')
 
    # Define varTool to switch to bin centers
    if configDic['useBinCenter']:
        varYHisto = histoParams.pop('varYHisto')
        configDic['varTool'] = VarToolCfg(flags, var=varYHisto, Tname="VarTool_for_binCenter")
 
    histoParams['inputFile'] = PathResolver.FindCalibFile(configDic.pop('CalibConstantFile'))
    # 2D histogram with correction factors
    configDic["histoTool"] = HistoInputCfg(flags, "histoTool", **histoParams)
 
    return [CompFactory.Generic4VecCorrectionStep("PtResidual", **configDic)]
 
def mc2mcStep(flags, **configDic):
    configDic.setdefault('OutScale','JetMC2MCScaleMomentum')
    # Generator and version are the first item
    for key, value in flags.Input.GeneratorsInfo.items():
        generator = key
        generator_version = value
        break
 
    # Get the shower model:
    showerModel = ''
    # Check first if the DSID is on the exceptions list
    mcDSID = flags.Input.MCChannelNumber
    with open(PathResolver.FindCalibFile("JetCalibTools/MC2MC_exceptions_DSID.json")) as read_file:
        data = json.load(read_file)
        for key, value in data.items():
            if key == mcDSID:
                showerModel = value
 
    if showerModel == '':
        genType, psType, hadType = generatorDic[generator]
        version = generator_version.replace('.','')[:3]
        if (generator == 'Pythia8' or generator == 'Pythia8B') and not version.startswith('8'):
            version = '8'+version
        showerModel = genType+"-"+version+"-"+psType+"-"+hadType
 
        with open(PathResolver.FindCalibFile("JetCalibTools/MC2MC_showerRemap.json")) as read_file:
            data = json.load(read_file)
            foundMatch = False
            for key, value in data.items():
                if key == showerModel:
                    showerModel = value
                    foundMatch = True
                    break
            if not foundMatch:
                for key, value in data.items():
                    if key == genType+"-"+version:
                        showerModel = value+"-"+psType+"-"+hadType
                        break
 
    jcslog.info(f'Using shower model {showerModel} for the MC-to-MC correction')
 
    # Get the settings for the histograms:
    baseHistoParams = configDic.pop('histoParams')
    baseHistoParams['inputFile'] = PathResolver.FindCalibFile(configDic.pop('CalibConstantFileName')+'_'+showerModel+'.root')
 
    histNameBase = baseHistoParams.pop('histNameBase')
    for flav in configDic.pop('flavours'):
        if flav == 'c':
            configDic['doCjetCorrection'] = True
        elif flav == 'b':
            configDic['doBjetCorrection'] = True
        histoParams = dict(varX = baseHistoParams['varX'],varY = baseHistoParams['varY'],
                           histName=f'{histNameBase}_{flav}',
                           inputFile=baseHistoParams['inputFile'])
        configDic['mc2mcHist_'+flav] = HistoInputCfg(flags,Tname='HistoTool_MC2MC_'+flav,**histoParams)
 
    configDic['isMC2MCCorr'] = True
 
    return [CompFactory.Generic4VecCorrectionStep("MC2MC", **configDic)]
 
def jetDNNCalibStep(flags, **configDic):
    configDic.setdefault('OutScale', 'JetDNNScaleMomentum')
 
    onnxModelPath = PathResolver.FindCalibFile(configDic.pop('ONNXInput'))
 
    #Retrieving variables from YAML
    inputVarArray = configDic.pop('InputVars')
    eScales = configDic.pop('EScales')
 
    list_of_inputVarTools = []
 
    for i, v in enumerate(inputVarArray):
        if v in ["NPV", "mu"]:
            list_of_inputVarTools.append(VarToolCfg(flags, v, f'{v}', isJetVar=False))
        elif v in ["log_e", "log_m"]:
            # InputVariable.cpp's log_e/log_m already compute log(e*scale)/log(m*scale) with the
            # right scale-before-log semantics, so just pass eScale through as this VarTool's Scale.
            list_of_inputVarTools.append(VarToolCfg(flags, v, f'{v}', isJetVar=True, Scale=eScales[i]))
        else:
            list_of_inputVarTools.append(VarToolCfg(flags, v, f'{v}', isJetVar=True))
 
    #Add to configDic
    configDic["InputVarTool"] = list_of_inputVarTools
    configDic["EScales"] = eScales
    configDic["NormOffsets"] = configDic.pop('NormOffsets')
    configDic["NormScales"] = configDic.pop('NormScales')
    configDic["onnxInputShape"] = configDic.pop('onnxInputShape')
    configDic["onnxOutputShape"] = configDic.pop('onnxOutputShape')
 
    # Set-up the ONNX inference tool, pointing its session at the calibration model from the YAML.
    # OnnxRuntimeInferenceToolCfg is ComponentAccumulator-based (picks CPU/CUDA via
    # flags.AthOnnx.ExecutionProvider), but this file builds plain Configurables throughout with no
    # accumulator to merge into, so we use a throwaway local one and keep only the tool. Its
    # OnnxRuntimeSvc registration is discarded here; the service still resolves via Gaudi's
    # auto-create-by-name behaviour, same as before this change.
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    from AthOnnxComps.OnnxRuntimeInferenceConfig import OnnxRuntimeInferenceToolCfg
    onnxAcc = ComponentAccumulator()
    configDic["ORTInferenceTool"] = onnxAcc.popToolsAndMerge(
        OnnxRuntimeInferenceToolCfg(flags, model_fname=onnxModelPath, name="ORTInferenceTool_DNN")
    )
 
    # Set-up the calibration step
    DNNCalibStep = CompFactory.JetDNNCalibStep("JetDNNCalib", **configDic)
    return [DNNCalibStep]
 
 

    
calibStepDic = dict(
    Residual = puresidualStep,
    Pileup = puCorrectionStep,
    EtaJES = etajesStep,
    JMS = jmsStep,
    GSC = gscStep,
    Insitu = insituStep,
    Smear = smearingStep,
    AF3 = af3Step,
    PtResidual = ptResidualStep,
    MC2MC = mc2mcStep,
    DNNCalib = jetDNNCalibStep
 
)
 

generatorDic = {
    "Herwigpp": ["Herwigpp", "angular", "cluster"],
    "Herwig7": ["Herwig", "angular", "cluster"],
    "Sherpa": ["Sherpa", "dipole", "cluster"],
    "Pythia8B": ["PythiaB", "dipole", "cluster"],
    "Pythia8": ["Pythia", "dipole", "cluster"]
}
 
def getSampleMetadata(flags):
    ''' Returns sample type (AF3/FullSim/Data) and run (Run2/Run3/Run4) '''
    # Identify type of sample
    if flags.Input.isMC:
        metaData = GetFileMD(flags.Input.Files[0])
        simFlavour = metaData.get('Simulator','') # ATLFAST3 or FullG4
        if 'ATLFAST3' in simFlavour:
            sampleType = 'AF3'
        else:
            sampleType = 'FullSim'
    else:
        sampleType = 'Data'
 
    if flags.GeoModel.Run == LHCPeriod.Run2:
        run = 'Run2'
    elif flags.GeoModel.Run == LHCPeriod.Run3:
        run = 'Run3'
    elif flags.GeoModel.Run >= LHCPeriod.Run4:
        run = 'Run4'
    else:
        jcslog.warning('LHCPeriod not recognised')
        run = None
 
    return sampleType, run
 
def sequenceForSample(seqBlock, sampleKeys):
    """
    Returns (sequence, matched sample key) for a Sequence sub-block, which is either a plain
    list of steps (matched key None) or a dict keyed by sample type. sampleKeys is the list of
    accepted sample keys, in order of preference. Returns (None, None) if nothing matches.
    """
    if isinstance(seqBlock, list):
        return seqBlock, None
    if isinstance(seqBlock, dict):
        for key in sampleKeys:
            if key in seqBlock:
                return seqBlock[key], key
    return None, None
 
def calibConfigToToolList(flags, calibSeqKey = None, **configDict):
    """
    Returns a list of instantiated tools for each of the calibration steps. 
    Tools are instantiated by calling functions declared in the calibStepDic dictionary.
    The order of the steps is determined by the Sequence block of the config.
 
    Parameters:
    -----------
    calibSeqKey: str
        Specifies which sub-block of Sequence to take the calibration sequence from (e.g. Default/T0/Run3 etc.).
        If not set, Default is used unless a "RunX" sub-block exists matching the metadata of the sample.
        Default is also used if the requested sub-block has no entry for this sample type.
    configDict: dict
        A dictionary of config options (usually extracted from a YAML config file).
    """
 
    sampleKey, runKey = getSampleMetadata(flags)
    
    # 'MC' can be used in the YAML as a shorthand covering both FullSim and AF3
    sampleKeys = [sampleKey] if sampleKey=='Data' else [sampleKey, 'MC']
 
    # Ordering of calib steps based on Sequence block and type of sample
    if 'Sequence' not in configDict:
        raise JetCalibConfigError("Sequence block not found in YAML file.")
    seqDict = configDict.pop('Sequence')
 
    # Use the run-specific sequence if one is supplied for this sample, otherwise Default
    if calibSeqKey is None:
        calibSeqKey = runKey if sequenceForSample(seqDict.get(runKey), sampleKeys)[0] else 'Default'
 
    if calibSeqKey not in seqDict:
        raise JetCalibConfigError(f"{calibSeqKey} key not found in YAML Sequence block")
 
    # Extract the step sequence for this sample type
    sequence, matchedKey = sequenceForSample(seqDict[calibSeqKey], sampleKeys)
 
    # Fall back on Default if the requested sub-block has no entry for this sample type
    if sequence is None and calibSeqKey!='Default':
        jcslog.warning(f'No {sampleKey} sequence in Sequence[{calibSeqKey}] - falling back on Default')
        calibSeqKey = 'Default'
        sequence, matchedKey = sequenceForSample(seqDict.get('Default'), sampleKeys)
 
    # Raise an error if the sequence for this sample could not be identified
    if sequence is None:
        raise JetCalibConfigError(f'No sequence for sample type "{sampleKey}" found in Sequence[{calibSeqKey}] YAML sub-block')
 
    jcslog.info(f'Using {calibSeqKey} step sequence' + (f' for {matchedKey}' if matchedKey else ''))
 
    toolList = []
    jcslog.debug('Configuring jet calib steps:')
    for step in sequence:
 
        if step not in configDict:
            raise JetCalibConfigError(f'Sequence includes step {step} but no YAML block is provided.')
 
        calibConfig = configDict[step]
        calibConfig.pop('prereqs',{}) # removes the 'prereqs' entry not refined in steps
 
        # expert option to skip a step
        if calibConfig.pop('noRun',False):
            jcslog.warning(f'Expert option: Skipping calib step {step}')
            continue
 
        # Warning: Insitu for MC
        if step=="Insitu" and flags.Input.isMC and not calibConfig.get("CalibrateMC",False):
            jcslog.warning('Insitu step included for MC but CalibrateMC is False - no calibration will be run')
 
        if step=="MC2MC":
            # Print warning if running MC2MC calibration for data
            if not flags.Input.isMC:
                jcslog.warning('Running MC2MC calibration for data')
 
            # Skip MC to MC calibration for Pythia8
            generator = next(iter(flags.Input.GeneratorsInfo), '')
            if 'Pythia' in generator:
                jcslog.debug('Skipping MC2MC calibration for Pythia8')
                continue
 
        # Warning if running AF3 calibration for data or FullSim
        if step=="AF3":
            if not flags.Input.isMC:
                jcslog.warning('Running FastSimulation calibration for data')
 
            if sampleKey=='FullSim':
                jcslog.warning('Running FastSimulation calibration for full sim')
 
        calibFunc = calibStepDic.get(step,None)
 
        if calibFunc is None:
            raise NotImplementedError(f'Calibration step {step} is not found in calibStepDic')
 
        # Config can contain run-specific settings in 'RunX:' sub-blocks. All are removed from
        # the configDict, but only the block matching this sample's Run is applied.
        runOverrides = {key: calibConfig.pop(key) for key in ['Run2', 'Run3', 'Run4'] if key in calibConfig}
        for key, value in runOverrides.get(runKey,{}).items():
            jcslog.debug(f'{step}: Applying {runKey} override for {key}')
            if key in calibConfig:
                jcslog.warning(f'{key} will be overwritten by {runKey} settings')
            calibConfig[key] = value
 
        # Start from ConstitScale. For subsequent steps set InScale to OutScale of previous step
        if len(toolList)==0:
            inScale = 'JetConstitScaleMomentum'
        else:
            inScale = toolList[-1].OutScale
 
        configInScale = calibConfig.setdefault('InScale', inScale)
 
        if configInScale!=inScale:
            jcslog.warning(f'InScale set to {configInScale} in YAML config, but expected {inScale} from Sequence ordering -- is this intentional?')
 
 
        # each func returns a list (to allow one YAML block to configure multiple steps run in order)
        newToolList = calibFunc(flags, **calibConfig)
        jcslog.debug(f'{step}: InScale = {newToolList[0].InScale}, OutScale = {newToolList[-1].OutScale}')
 
        toolList += newToolList
 
    return toolList
 
def calibToolFromConfigFile(flags, configFile, name = "jetcalib", calibSeqKey = None):
    """
    Returns a list of instantiated tools for each of the calibration steps. 
    The order of the steps is determined by the Sequence block of the config.
 
    Parameters:
    -----------
    configFile: str
        Path to YAML configuration file
    name: str
        Internal name of the configured jet calib tool
    calibSeqKey: str
        Specifies which sub-block of Sequence to take the calibration sequence from (e.g. Default/T0/Run3 etc.).
        If not set, Default is used unless a "RunX" sub-block exists matching the metadata of the sample.
        Default is also used if the requested sub-block has no entry for this sample type.
    """
    infoMsg = f'Configuring JetCalibTools with {configFile}'
    jcslog.info(infoMsg)
 
    configDic = load_yaml_cfg(configFile)
 
    globalSettings = configDic.pop('Global',{})
 
    calibTool = CompFactory.JetCalibTool(name, CalibSteps=calibConfigToToolList(flags, calibSeqKey, **configDic), **globalSettings)
    return calibTool
 
def combine(baseDict, extendDict):
    ''' Return baseDict with keys recursively overwritten by extendDict '''
    merged = dict(baseDict)
    for key, value in extendDict.items():
        if isinstance(merged.get(key), dict) and isinstance(value, dict):
            merged[key] = combine(merged[key], value)
        else:
            merged[key] = value
    return merged
 
 
def load_yaml_cfg(configFile):
    from yaml import safe_load
 
    path_configFile = PathResolver.FindCalibFile(configFile)
    configDic = safe_load(open(path_configFile))
    
    # If configDic includes the 'BaseConfig' keyword, it will be combined with the specified base config file
    baseConfigFile = configDic.pop('BaseConfig',None)
    if not baseConfigFile:
        return configDic
    else:
        jcslog.info(f'Extending base config file {baseConfigFile} with supplied overrides')
        # Combine config files recursively
        baseConfigDic = load_yaml_cfg(baseConfigFile)
        combinedConfig = combine(baseConfigDic, configDic)
        return combinedConfig
 
class JetCalibConfigError(Exception):
    """ Exception raised for invalid jet calibration config """
 
    def __init__(self, message):
        super().__init__(message)
        self.message = message
 
    def __str__(self):
        return self.message