Inheritance diagram for python.PhotonAnalysisConfig.PhotonWorkingPointConfig:

Collaboration diagram for python.PhotonAnalysisConfig.PhotonWorkingPointConfig:

Public Member Functions
def	__init__ (self, containerName='', selectionName='')

def	makeAlgs (self, config)

Public Attributes
	qualityWP

Detailed Description

the ConfigBlock for the photon working point

This may at some point be split into multiple blocks (29 Aug 22).

Definition at line 254 of file PhotonAnalysisConfig.py.

Constructor & Destructor Documentation

◆ init()

def python.PhotonAnalysisConfig.PhotonWorkingPointConfig.__init__	(	self,
		containerName = `''`,
		selectionName = `''`
	)

Definition at line 259 of file PhotonAnalysisConfig.py.

     def __init__ (self, containerName='', selectionName='') :
         super (PhotonWorkingPointConfig, self).__init__ ()
         self.addOption ('containerName', containerName, type=str,
             noneAction='error',
             info="the name of the input container.")
         self.addOption ('selectionName', selectionName, type=str,
             noneAction='error',
             info="the name of the photon selection to define (e.g. tight or "
             "loose).")
         self.addOption ('postfix', selectionName, type=str,
             info="a postfix to apply to decorations and algorithm names. "
             "Typically not needed here as selectionName is used internally.")
         self.addOption ('qualityWP', None, type=str,
             info="the ID WP (string) to use. Supported ID WPs: Tight, Medium and Loose.")
         self.addOption ('isolationWP', None, type=str,
             info="the ID WP (string) to use. Supported isolation WPs: "
             "FixedCutLoose, FixedCutTight, TightCaloOnly, NonIso.")
         self.addOption ('closeByCorrection', False, type=bool,
             info="whether to use close-by-corrected isolation working points")
         self.addOption ('recomputeIsEM', False, type=bool,
             info="whether to rerun the cut-based selection. The default is "
             "False, i.e. to use derivation flags.")
         self.addOption ('doFSRSelection', False, type=bool,
             info="whether to accept additional photons close to muons for the "
             "purpose of FSR corrections to these muons. Expert feature "
             "requested by the H4l analysis running on PHYSLITE. "
             "The default is False.")
         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. The default is False.")
         self.addOption ('forceFullSimConfig', False, type=bool,
             info="whether to force the tool to use the configuration meant "
             "for full simulation samples. Only for testing purposes. "
             "The default is False.")
  

Member Function Documentation

◆ makeAlgs()

def python.PhotonAnalysisConfig.PhotonWorkingPointConfig.makeAlgs	(	self,
		config
	)

Definition at line 295 of file PhotonAnalysisConfig.py.

     def makeAlgs (self, config) :
  
         log = logging.getLogger('PhotonWorkingPointConfig')
  
         # The setup below is inappropriate for Run 1
         if config.geometry() is LHCPeriod.Run1:
             raise ValueError ("Can't set up the PhotonWorkingPointConfig with %s, there must be something wrong!" % config.geometry().value)
  
         if self.forceFullSimConfig:
             log.warning("You are running PhotonWorkingPointConfig forcing full sim config")
             log.warning("This is only intended to be used for testing purposes")
  
         postfix = self.postfix
         if postfix != '' and postfix[0] != '_' :
             postfix = '_' + postfix
  
         if self.qualityWP == 'Tight' :
             quality = ROOT.egammaPID.PhotonTight
         elif self.qualityWP == 'Medium' :
             quality = ROOT.egammaPID.PhotonMedium
         elif self.qualityWP == 'Loose' :
             quality = ROOT.egammaPID.PhotonLoose
         else :
             raise Exception ('unknown photon quality working point "' + self.qualityWP + '" should be Tight, Medium or Loose')
  
         # Set up the photon selection algorithm:
         alg = config.createAlgorithm( 'CP::AsgSelectionAlg', 'PhotonIsEMSelectorAlg' + postfix )
         alg.selectionDecoration = 'selectEM' + postfix + ',as_bits'
         if self.recomputeIsEM:
             # Rerun the cut-based ID
             config.addPrivateTool( 'selectionTool', 'AsgPhotonIsEMSelector' )
             alg.selectionTool.isEMMask = quality
             if config.geometry() is LHCPeriod.Run2:
                 if self.qualityWP == 'Tight':
                     alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc20_20240510/PhotonIsEMTightSelectorCutDefs_pTdep_mc20_smooth.conf'
                 elif self.qualityWP == 'Loose':
                     alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf'
                 elif self.qualityWP == 'Medium':
                     alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc20_20240510/PhotonIsEMMediumSelectorCutDefs_pTdep_smooth.conf'
             if config.geometry() is LHCPeriod.Run3:
                 if self.qualityWP == 'Tight':
                     alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/20180825/PhotonIsEMTightSelectorCutDefs.conf'
                 elif self.qualityWP == 'Loose':
                     alg.selectionTool.ConfigFile = 'ElectronPhotonSelectorTools/offline/mc15_20150712/PhotonIsEMLooseSelectorCutDefs.conf'
                 elif self.qualityWP == 'Medium':
                     raise ValueError('No Medium menu available for Run-3. Please get in contact with egamma')
         else:
             # Select from Derivation Framework flags
             config.addPrivateTool( 'selectionTool', 'CP::AsgFlagSelectionTool' )
             dfFlag = 'DFCommonPhotonsIsEM' + self.qualityWP
             alg.selectionTool.selectionFlags = [ dfFlag ]
         alg.particles = config.readName (self.containerName)
         alg.preselection = config.getPreselection (self.containerName, self.selectionName)
         config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
  
         # Set up the FSR selection
         if self.doFSRSelection :
             # save the flag set for the WP
             wpFlag = alg.selectionDecoration.split(",")[0]
             alg = config.createAlgorithm( 'CP::EgammaFSRForMuonsCollectorAlg', 'EgammaFSRForMuonsCollectorAlg' + postfix + '_ph') # added extra postfix to avoid name clash with electrons
             alg.selectionDecoration = wpFlag
             alg.ElectronOrPhotonContKey = config.readName (self.containerName)
  
         # Set up the isolation selection algorithm:
         if self.isolationWP != 'NonIso' :
             alg = config.createAlgorithm( 'CP::EgammaIsolationSelectionAlg',
                                           'PhotonIsolationSelectionAlg' + postfix )
             alg.selectionDecoration = 'isolated' + postfix + ',as_bits'
             config.addPrivateTool( 'selectionTool', 'CP::IsolationSelectionTool' )
             alg.selectionTool.PhotonWP = self.isolationWP
             if self.closeByCorrection:
               alg.selectionTool.IsoDecSuffix = "CloseByCorr"
             alg.isPhoton = True
             alg.egammas = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addSelection (self.containerName, self.selectionName, alg.selectionDecoration)
  
         # Set up the ID/reco photon efficiency correction algorithm:
         if config.dataType() is not DataType.Data and not self.noEffSF:
             alg = config.createAlgorithm( 'CP::PhotonEfficiencyCorrectionAlg',
                                           'PhotonEfficiencyCorrectionAlgID' + postfix )
             config.addPrivateTool( 'efficiencyCorrectionTool',
                                    'AsgPhotonEfficiencyCorrectionTool' )
             alg.scaleFactorDecoration = 'ph_id_effSF' + postfix + '_%SYS%'
             if config.dataType() is DataType.FastSim:
                 alg.efficiencyCorrectionTool.ForceDataType = (
                     PATCore.ParticleDataType.Full if self.forceFullSimConfig else
                     PATCore.ParticleDataType.Fast)
             elif config.dataType() is DataType.FullSim:
                 alg.efficiencyCorrectionTool.ForceDataType = \
                     PATCore.ParticleDataType.Full
             if config.geometry() >= LHCPeriod.Run2:
                 alg.efficiencyCorrectionTool.MapFilePath = 'PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt'
             alg.outOfValidity = 2 #silent
             alg.outOfValidityDeco = 'ph_id_bad_eff' + postfix
             alg.photons = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'id_effSF' + postfix)
  
         # Set up the ISO photon efficiency correction algorithm:
         if config.dataType() is not DataType.Data and self.isolationWP != 'NonIso' and not self.noEffSF:
             alg = config.createAlgorithm( 'CP::PhotonEfficiencyCorrectionAlg',
                                           'PhotonEfficiencyCorrectionAlgIsol' + postfix )
             config.addPrivateTool( 'efficiencyCorrectionTool',
                                    'AsgPhotonEfficiencyCorrectionTool' )
             alg.scaleFactorDecoration = 'ph_isol_effSF' + postfix + '_%SYS%'
             if config.dataType() is DataType.FastSim:
                 alg.efficiencyCorrectionTool.ForceDataType = (
                     PATCore.ParticleDataType.Full if self.forceFullSimConfig else
                     PATCore.ParticleDataType.Fast)
             elif config.dataType() is DataType.FullSim:
                 alg.efficiencyCorrectionTool.ForceDataType = \
                     PATCore.ParticleDataType.Full
             alg.efficiencyCorrectionTool.IsoKey = self.isolationWP.replace("FixedCut","")
             if config.geometry() >= LHCPeriod.Run2:
                 alg.efficiencyCorrectionTool.MapFilePath = 'PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt'
             alg.outOfValidity = 2 #silent
             alg.outOfValidityDeco = 'ph_isol_bad_eff' + postfix
             alg.photons = config.readName (self.containerName)
             alg.preselection = config.getPreselection (self.containerName, self.selectionName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, 'isol_effSF' + postfix)
  
  
  
  
  

Member Data Documentation

◆ qualityWP

python.PhotonAnalysisConfig.PhotonWorkingPointConfig.qualityWP

Definition at line 311 of file PhotonAnalysisConfig.py.

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

PhotonAnalysisConfig.py

Public Member Functions

Public Attributes