python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock Class Reference

Inheritance diagram for python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock:

Collaboration diagram for python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock:

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

Public Attributes
	includeAllYearsPerRun
	saveSF
	saveEff
	saveEffData
	containerName

Detailed Description

Definition at line 503 of file MuonAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.__init__

(

self

)

Definition at line 505 of file MuonAnalysisConfig.py.

    def __init__ (self) :
        super (MuonTriggerAnalysisSFBlock, self).__init__ ()
        self.addDependency('EventSelection', required=False)
        self.addDependency('EventSelectionMerger', required=False)
        self.addOption ('triggerChainsPerYear', {}, type=dict,
                        info="a dictionary with key (string) the year and value (list of "
                        "strings) the trigger chains.")
        self.addOption ('muonID', '', type=str,
                        info="the muon quality WP to use.")
        self.addOption ('saveSF', True, type=bool,
                        info="whether to decorate the trigger scale factor.")
        self.addOption ('saveEff', False, type=bool,
                        info="whether to decorate the trigger MC efficiencies.")
        self.addOption ('saveEffData', False, type=bool,
                        info="whether to decorate the trigger data efficiencies.")
        self.addOption ('prefixSF', 'trigEffSF', type=str,
                        info="the decoration prefix for trigger scale factors.")
        self.addOption ('prefixEff', 'trigEff', type=str,
                        info="the decoration prefix for MC trigger efficiencies.")
        self.addOption ('prefixEffData', 'trigEffData', type=str,
                        info="the decoration prefix for data trigger efficiencies.")
        self.addOption ('includeAllYearsPerRun', False, type=bool,
                        info="all configured years in the LHC run will "
                        "be included in all jobs.")
        self.addOption ('removeHLTPrefix', True, type=bool,
                        info="remove the HLT prefix from trigger chain names.")
        self.addOption ('containerName', '', type=str,
                        info="the input muon container, with a possible selection, in "
                        "the format `container` or `container.selection`.")
        self.addOption ('customToolSuffix', '', type=str,
                        expertMode=True, info="EXPERIMENTAL: specify custom suffix for the public tool name")
        self.addOption ('customInputFolder', '', type=str,
                        expertMode=True, info="EXPERIMENTAL: specify custom input folder")
        self.addOption ('customInputFilePerYear', {}, type=dict,
                        expertMode=True, info="EXPERIMENTAL: specify custom input file per year")
 

Member Function Documentation

instanceName()

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.instanceName

(

self

)

Definition at line 541 of file MuonAnalysisConfig.py.

    def instanceName (self) :
        return self.containerName + '_' + self.muonID
 

makeAlgs()

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.makeAlgs	(		self,
			config )

Definition at line 544 of file MuonAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        if config.dataType() is not DataType.Data:
 
            # Dictionary from TrigGlobalEfficiencyCorrection/Triggers.cfg
            # Key is trigger chain (w/o HLT prefix)
            # Value is empty for single leg trigger or list of legs
            triggerDict = TriggerDict()
 
            if self.includeAllYearsPerRun:
                years = [int(year) for year in self.triggerChainsPerYear.keys()]
            else:
                from TriggerAnalysisAlgorithms.TriggerAnalysisSFConfig import (
                    get_input_years)
                years = get_input_years(config)
 
            triggerYearStartBoundaries = {
                2015: 260000,
                2016: 290000,
                2017: 324000,
                2018: 348000,
                2022: 410000,
                2023: 450000,
                2024: 470000,
                2025: 495000,
                2026: 516000,
            }
 
            triggerConfigs = {}
            triggerConfigYears = {}
            from TriggerAnalysisAlgorithms.TriggerAnalysisConfig import is_year_in_current_period
            for year in years:
                if not is_year_in_current_period(config, year):
                    continue
 
                triggerChains = self.triggerChainsPerYear.get(int(year), self.triggerChainsPerYear.get(str(year), []))
                for chain in triggerChains:
                    chain = chain.replace(" || ", "_OR_")
                    chain_noHLT = chain.replace("HLT_", "")
                    chain_out = chain_noHLT if self.removeHLTPrefix else chain
                    legs = triggerDict[chain_noHLT]
                    if not legs:
                        if chain_noHLT.startswith('mu') and chain_noHLT[2].isdigit:
                            # Need to support HLT_mu26_ivarmedium_OR_HLT_mu50
                            triggerConfigs[chain_out] = chain
                            if chain_out in triggerConfigYears.keys():
                                triggerConfigYears[chain_out].append(year)
                            else:
                                triggerConfigYears[chain_out] = [year]
                    else:
                        for leg in legs:
                            if leg.startswith('mu') and leg[2].isdigit:
                                # Need to support HLT_mu14_ivarloose
                                leg_out = leg if self.removeHLTPrefix else f"HLT_{leg}"
                                triggerConfigs[leg_out] = f"HLT_{leg}"
                                if leg_out in triggerConfigYears.keys():
                                    triggerConfigYears[leg_out].append(year)
                                else:
                                    triggerConfigYears[leg_out] = [year]
 
            if not triggerConfigs:
                return
 
            # Make the public tool for this configuration
            sfTool = config.createPublicTool("CP::MuonTriggerScaleFactors", f"{self.instanceName()}_SFTool{self.customToolSuffix}")
            # Reproduce config from TrigGlobalEfficiencyAlg
            sfTool.MuonQuality = self.muonID
            sfTool.AllowZeroSF = True
            sfTool.CustomInputFolder = self.customInputFolder
            sfTool.CustomInputFilePerYear = self.customInputFilePerYear
            sfTool.Campaign = config.campaign().value
 
            for trig_short, trig in triggerConfigs.items():
                alg = config.createAlgorithm('CP::MuonTriggerEfficiencyScaleFactorAlg',
                                             'MuonTrigEfficiencyCorrectionsAlg_' + trig_short)
                alg.efficiencyScaleFactorTool = f"{sfTool.getType()}/{sfTool.getName()}"
 
                # Avoid warnings for missing triggers
                if self.includeAllYearsPerRun:
                    alg.minRunNumber = 0
                    alg.maxRunNumber = 999999
 
                    if triggerConfigYears[trig_short][0] != years[0]:
                        alg.minRunNumber = triggerYearStartBoundaries.get(triggerConfigYears[trig_short][0], 999999)
                    if triggerConfigYears[trig_short][-1] != years[-1]:
                        alg.maxRunNumber = triggerYearStartBoundaries.get(triggerConfigYears[trig_short][-1] + 1, 999999)
                elif config.campaign() is Campaign.MC20a:  # to avoid potential corner-cases keep the default config unchanged
                    if triggerConfigYears[trig_short] == [2015]:
                        alg.maxRunNumber = 290000
                    elif triggerConfigYears[trig_short] == [2016]:
                        alg.minRunNumber = 290000
 
                alg.trigger = trig
 
                # Some triggers in `250731_SummerUpdate` recommendations are not supported in 2022 period F
                if config.campaign() is Campaign.MC23a and (trig_short == "HLT_mu8noL1_FSNOSEED" or trig_short == "HLT_mu22_L1MU14FCH"):
                    alg.minRunNumber = 435816  # Start of 2022 period H
 
                if self.saveSF:
                    alg.scaleFactorDecoration = f"muon_{self.prefixSF}_{trig_short}_%SYS%"
                if self.saveEff:
                    alg.mcEfficiencyDecoration = f"muon_{self.prefixEff}_{trig_short}_%SYS%"
                if self.saveEffData:
                    alg.dataEfficiencyDecoration = f"muon_{self.prefixEffData}_{trig_short}_%SYS%"
                alg.outOfValidity = 2 #silent
                alg.outOfValidityDeco = f"bad_eff_muontrig_{trig_short}"
                alg.muons = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, '')
                if self.saveSF:
                    config.addOutputVar (self.containerName, alg.scaleFactorDecoration, f"{self.prefixSF}_{trig_short}")
                if self.saveEff:
                    config.addOutputVar (self.containerName, alg.mcEfficiencyDecoration, f"{self.prefixEff}_{trig_short}")
                if self.saveEffData:
                    config.addOutputVar (self.containerName, alg.dataEfficiencyDecoration, f"{self.prefixEffData}_{trig_short}")
 
 

Member Data Documentation

containerName

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.containerName

Definition at line 653 of file MuonAnalysisConfig.py.

includeAllYearsPerRun

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.includeAllYearsPerRun

Definition at line 553 of file MuonAnalysisConfig.py.

saveEff

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.saveEff

Definition at line 644 of file MuonAnalysisConfig.py.

saveEffData

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.saveEffData

Definition at line 646 of file MuonAnalysisConfig.py.

saveSF

python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.saveSF

Definition at line 642 of file MuonAnalysisConfig.py.

---

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

• MuonAnalysisConfig.py