python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock Class Reference

Inheritance diagram for python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock:

Collaboration diagram for python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock:

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

Detailed Description

Definition at line 387 of file MuonAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

def python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.__init__

(

self

)

Definition at line 389 of file MuonAnalysisConfig.py.

    def __init__ (self) :
        super (MuonTriggerAnalysisSFBlock, self).__init__ ()
 
        self.addOption ('triggerChainsPerYear', {}, type=None,
                        info="a dictionary with key (string) the year and value (list of "
                        "strings) the trigger chains. The default is {} (empty dictionary).")
        self.addOption ('muonID', '', type=str,
                        info="the muon quality WP (string) to use.")
        self.addOption ('saveSF', True, type=bool,
                        info="define whether we decorate the trigger scale factor "
                        "The default is True.")
        self.addOption ('saveEff', False, type=bool,
                        info="define whether we decorate the trigger MC efficiencies "
                        "The default is False.")
        self.addOption ('saveEffData', False, type=bool,
                        info="define whether we decorate the trigger data efficiencies "
                        "The default is False.")
        self.addOption ('prefixSF', 'trigEffSF', type=str,
                        info="the decoration prefix for trigger scale factors, "
                        "the default is 'trigEffSF'")
        self.addOption ('prefixEff', 'trigEff', type=str,
                        info="the decoration prefix for MC trigger efficiencies, "
                        "the default is 'trigEff'")
        self.addOption ('prefixEffData', 'trigEffData', type=str,
                        info="the decoration prefix for data trigger efficiencies, "
                        "the default is 'trigEffData'")
        self.addOption ('includeAllYearsPerRun', False, type=bool,
                        info="if True, all configured years in the LHC run will "
                        "be included in all jobs. The default is False.")
        self.addOption ('removeHLTPrefix', True, type=bool,
                        info="remove the HLT prefix from trigger chain names, "
                        "The default is True.")
        self.addOption ('containerName', '', type=str,
                        info="the input muon container, with a possible selection, in "
                        "the format container or container.selection.")
 

Member Function Documentation

instanceName()

def python.MuonAnalysisConfig.MuonTriggerAnalysisSFBlock.instanceName

(

self

)

Definition at line 425 of file MuonAnalysisConfig.py.

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

makeAlgs()

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

Definition at line 428 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,
            }
 
            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]
 
            for trig_short, trig in triggerConfigs.items():
                alg = config.createAlgorithm('CP::MuonTriggerEfficiencyScaleFactorAlg',
                                             'MuonTrigEfficiencyCorrectionsAlg_' + trig_short)
                config.addPrivateTool( 'efficiencyScaleFactorTool',
                                       'CP::MuonTriggerScaleFactors' )
 
                # Reproduce config from TrigGlobalEfficiencyAlg
                alg.efficiencyScaleFactorTool.MuonQuality = self.muonID
                alg.efficiencyScaleFactorTool.AllowZeroSF = True
 
                # 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
                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}")
 
 

---

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

• MuonAnalysisConfig.py