Inheritance diagram for python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig:

Collaboration diagram for python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig:

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

Public Attributes
	noEffSF
	quality
	saveDetailedSF
	containerName
	saveCombinedSF

Detailed Description

the ConfigBlock for the muon working point efficiency computation

Definition at line 355 of file MuonAnalysisConfig.py.

Constructor & Destructor Documentation

◆ init()

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.__init__ ( self )

Definition at line 358 of file MuonAnalysisConfig.py.

    def __init__ (self) :
        super (MuonWorkingPointEfficiencyConfig, self).__init__ ()
        self.setBlockName('MuonWorkingPointEfficiency')
        self.addDependency('MuonWorkingPointSelection', required=True)
        self.addDependency('EventSelection', required=False)
        self.addDependency('EventSelectionMerger', required=False)
        self.addOption ('containerName', '', type=str,
            noneAction='error',
            info="the name of the input container.",
            meta={'role':'containerRef'})
        self.addOption ('selectionName', '', type=str,
            noneAction='error',
            info="the name of the muon selection to define (e.g. `tight` or `loose`).",
            meta={'role':'selection'})
        self.addOption ('postfix', None, type=str,
            info="a postfix to apply to decorations and algorithm names. "
            "Typically not needed here as `selectionName` is used internally.")
        self.addOption ('trackSelection', True, type=bool,
            info="whether or not to set up an instance of "
            "`CP::AsgLeptonTrackSelectionAlg`, with the recommended $d_0$ and "
            r"$z_0\sin\theta$ cuts.")
        self.addOption ('quality', None, type=str,
            info="the ID WP to use. Supported ID WPs: `Tight`, `Medium`, "
            "`Loose`, `LowPt`, `HighPt`.",
            meta={'choices':(['Tight','Medium','Loose','LowPt','HighPt'],1)})
        self.addOption ('isolation', None, type=str,
            info="the isolation WP to use. Supported isolation WPs: "
            "`PflowLoose_VarRad`, `PflowTight_VarRad`, `Loose_VarRad`, "
            "`Tight_VarRad`, `NonIso`.",
            meta={'choices':(['PflowLoose_VarRad','PflowTight_VarRad','Loose_VarRad','Tight_VarRad','NonIso'],1)})
        self.addOption ('systematicBreakdown', False, type=bool,
            info="enables the full breakdown of efficiency SF systematics "
            "(1 NP per uncertainty source, instead of 1 NP in total).")
        self.addOption ('noEffSF', False, type=bool,
            info="disables the calculation of efficiencies and scale factors. "
            "Experimental! Only useful to test a new WP for which scale "
            "factors are not available.",
            expertMode=True)
        self.addOption ('saveDetailedSF', True, type=bool,
            info="save all the independent detailed object scale factors.")
        self.addOption ('saveCombinedSF', False, type=bool,
            info="save the combined object scale factor.")
        self.addOption('useLRT', False, type=bool,
            info="apply the LRT-specific reco/ID efficiency SF treatment. When "
              "set (and quality is Medium, the only WP supported for LRT muons), "
              "the reco SF tool routes per-muon via the isLRT flag and uses the "
              "LRT-specific CalibrationRelease.")
    

Member Function Documentation

◆ instanceName()

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.instanceName ( self )

Definition at line 406 of file MuonAnalysisConfig.py.

    def instanceName (self) :
        if self.postfix is not None:
            return self.containerName + '_' + self.postfix
        else:
            return self.containerName + '_' + self.selectionName
 

◆ makeAlgs()

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

Definition at line 412 of file MuonAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        # The setup below is inappropriate for Run 1
        if config.geometry() is LHCPeriod.Run1:
            raise ValueError ("Can't set up the MuonWorkingPointEfficiencyConfig with %s, there must be something wrong!" % config.geometry().value)
 
        postfix = self.postfix
        if postfix is None :
            postfix = self.selectionName
        if postfix != '' and postfix[0] != '_' :
            postfix = '_' + postfix
 
        sfList = []
        if config.dataType() is not DataType.Data and not self.noEffSF:
            if self.isolation is None :
                raise ValueError ("muon isolation working point not set, "
                                  "use e.g. \"NonIso\" to disable the isolation selection")
            # LRT muons: MCP supports only Medium WP. Enable per-muon isLRT flag and use dedicated LRT reco-sf release.
            if self.useLRT and self.quality != 'Medium':
                raise ValueError ("useLRT is only supported with the Medium quality working point, not '%s'" % self.quality)
 
            isRun3 = config.geometry() >= LHCPeriod.Run3
            if isRun3:
                recoRelease = '250418_Preliminary_r24run3' if self.useLRT else '251211_Preliminary_r24run3'
            else:
                recoRelease = '240620_LRT_r22run2' if self.useLRT else '230213_Preliminary_r22run2_loosefix'
            defaultRelease = '251211_Preliminary_r24run3' if isRun3 else '230213_Preliminary_r22run2_loosefix'
 
            # (enabled, algorithm name suffix, working point, decoration prefix, calibration release)
            sfConfigs = [
                # reco/ID efficiency scale factor
                (True, 'Reco', self.quality, 'reco', recoRelease),
                # HighPt-specific BadMuonVeto efficiency scale factor
                (self.quality == 'HighPt', 'BMVHighPt', 'BadMuonVeto_HighPt', 'BadMuonVeto',
                 # not available as part of '230123_Preliminary_r22run3'!
                 '220817_Preliminary_r22run3' if isRun3 else '230213_Preliminary_r22run2_loosefix'),
                # isolation efficiency scale factor
                (self.isolation != 'NonIso', 'Isol', self.isolation + 'Iso', 'isol', defaultRelease),
                # TTVA scale factor
                (self.trackSelection, 'TTVA', 'TTVA', 'TTVA', defaultRelease),
            ]
 
            for enabled, algSuffix, workingPoint, prefix, release in sfConfigs:
                if not enabled:
                    continue
                alg = config.createAlgorithm( 'CP::MuonEfficiencyScaleFactorAlg',
                                              'MuonEfficiencyScaleFactorAlg' + algSuffix )
                config.addPrivateTool( 'efficiencyScaleFactorTool',
                                       'CP::MuonEfficiencyScaleFactors' )
                config.setExtraInputs ({('xAOD::EventInfo', 'EventInfo.RandomRunNumber')})
                sfDecoration = 'muon_' + prefix + '_effSF' + postfix + "_%SYS%"
                alg.scaleFactorDecoration = sfDecoration
                alg.outOfValidity = 2 #silent
                alg.outOfValidityDeco = 'muon_' + prefix + '_bad_eff' + postfix
                alg.efficiencyScaleFactorTool.WorkingPoint = workingPoint
                alg.efficiencyScaleFactorTool.CalibrationRelease = release
                alg.efficiencyScaleFactorTool.BreakDownSystematics = self.systematicBreakdown
                alg.muons = config.readName (self.containerName)
                alg.preselection = config.getPreselection (self.containerName, self.selectionName)
                if self.saveDetailedSF:
                    config.addOutputVar (self.containerName, sfDecoration,
                                         prefix + '_effSF' + postfix)
                sfList += [sfDecoration]
 
        if config.dataType() is not DataType.Data and not self.noEffSF and self.saveCombinedSF:
            alg = config.createAlgorithm( 'CP::AsgObjectScaleFactorAlg',
                                          'MuonCombinedEfficiencyScaleFactorAlg' )
            alg.particles = config.readName (self.containerName)
            alg.inScaleFactors = sfList
            alg.outScaleFactor = 'effSF' + postfix + '_%SYS%'
            config.addOutputVar (self.containerName, alg.outScaleFactor, 'effSF' + postfix)
 

Member Data Documentation

◆ containerName

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.containerName

Definition at line 472 of file MuonAnalysisConfig.py.

◆ noEffSF

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.noEffSF

Definition at line 425 of file MuonAnalysisConfig.py.

◆ quality

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.quality

Definition at line 431 of file MuonAnalysisConfig.py.

◆ saveCombinedSF

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.saveCombinedSF

Definition at line 476 of file MuonAnalysisConfig.py.

◆ saveDetailedSF

python.MuonAnalysisConfig.MuonWorkingPointEfficiencyConfig.saveDetailedSF

Definition at line 471 of file MuonAnalysisConfig.py.

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

MuonAnalysisConfig.py

Public Member Functions

Public Attributes