Move FTagEventSF to standalone analysis config

Move FTagEventSF to standalone analysis config

PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigFactory.py

@@ -220,6 +220,11 @@ class ConfigFactory():
         self.addAlgConfigBlock(algName="FlavourTagging", alg=makeFTagAnalysisConfig,
             defaults={'selectionName': ''},
             superBlocks="Jets")
+        from FTagAnalysisAlgorithms.FTagEventSFAnalysisConfig import makeFTagEventSFConfig
+        self.addAlgConfigBlock(algName="FlavourTaggingEventSF",
+                               alg=makeFTagEventSFConfig,
+                               defaults={'selectionName': ''},
+                               superBlocks="Jets")
 
         # electrons
         from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import ElectronCalibrationConfig 

PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py

@@ -717,10 +717,17 @@ def makeSequenceBlocks (dataType, algSeq, forCompare, isPhyslite,
     configSeq.setOptionValue ('.btagger', btagger)
     configSeq.setOptionValue ('.btagWP', btagWP)
     configSeq.setOptionValue ('.kinematicSelection', True )
-
+    
     configSeq += config.makeConfig( 'Jets.JVT',
         containerName='AnaJets' )
 
+    if not forCompare:
+        configSeq += config.makeConfig( 'Jets.FlavourTaggingEventSF',
+            containerName='AnaJets',
+            selectionName='ftag')
+        configSeq.setOptionValue ('.btagger', btagger)
+        configSeq.setOptionValue ('.btagWP', btagWP)
+
     if largeRJets :
         configSeq += config.makeConfig( 'Jets',
             containerName='AnaLargeRJets',
@@ -959,7 +966,7 @@ def makeSequenceBlocks (dataType, algSeq, forCompare, isPhyslite,
         configSeq += config.makeConfig ('Thinning',
             containerName='AnaTrackJets')
         configSeq.setOptionValue ('.outputName', 'OutTrackJets')
-
+        
     # disabling comparisons for triggers, because the config blocks do a lot
     # more than the sequences
     if not forCompare :

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/python/OverlapAnalysisConfig.py

-# Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # AnaAlgorithm import(s):
 from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
 
 
 class OverlapAnalysisConfig (ConfigBlock):
-    """the ConfigBlock for the MET configuration"""
+    """the ConfigBlock for the OverlapRemoval configuration"""
 
     def __init__ (self) :
         super (OverlapAnalysisConfig, self).__init__ ()
+        self.setBlockName('OverlapRemoval')
         self.addOption ('inputLabel', '', type=str)
         self.addOption ('outputLabel', 'passesOR', type=str)
         self.addOption ('selectionName', None, type=str)

PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisConfig.py

@@ -35,7 +35,6 @@ class FTagConfig (ConfigBlock):
         self.addOption ('generator', "autoconfig", type=str)
         self.addOption ('kinematicSelection', True, type=bool)
         self.addOption ('noEffSF', False, type=bool)
-        self.addOption ('globalSF', True, type=bool)
         self.addOption ('minPt', None, type=float)
         self.addOption ('bTagCalibFile', None, type=str,
                         info='calibration file for CDI')
@@ -276,19 +275,6 @@ class FTagConfig (ConfigBlock):
             alg.jets = config.readName (self.containerName)
             config.addOutputVar (self.containerName, alg.scaleFactorDecoration, selectionName + '_eff')
 
-            if self.globalSF:
-                alg = config.createAlgorithm('CP::AsgEventScaleFactorAlg',
-                                             'FTagEventScaleFactorAlg' + postfix)
-                preselection = config.getFullSelection(self.containerName, '')
-                alg.preselection = ((preselection + '&&' if preselection else '')
-                                    + 'ftag_kin_select_' + selectionName + ',as_char')
-                alg.scaleFactorInputDecoration = 'ftag_effSF_' + selectionName + '_%SYS%'
-                alg.scaleFactorOutputDecoration = 'ftag_effSF_' + selectionName + '_%SYS%'
-                alg.particles = config.readName(self.containerName)
-
-                config.addOutputVar('EventInfo', alg.scaleFactorOutputDecoration,
-                                    'weight_ftag_effSF_' + selectionName)
-
 
 def makeFTagAnalysisConfig( seq, containerName,
                             selectionName,
@@ -297,7 +283,6 @@ def makeFTagAnalysisConfig( seq, containerName,
                             generator = None,
                             kinematicSelection = None,
                             noEffSF = None,
-                            globalSF = None,
                             minPt = None ):
     """Create a ftag analysis algorithm config
 
@@ -307,7 +292,6 @@ def makeFTagAnalysisConfig( seq, containerName,
       generator -- Generator for MC/MC scale factors
       kinematicSelection -- Wether to run kinematic selection
       noEffSF -- Disables efficiency and scale factor calculations
-      globalSF -- Compute event level FTAG scale factor
       minPt -- Kinematic selection for jet calibration validity (depending on jet collection)
     """
 
@@ -317,6 +301,5 @@ def makeFTagAnalysisConfig( seq, containerName,
     config.setOptionValue ('generator', generator)
     config.setOptionValue ('kinematicSelection', kinematicSelection)
     config.setOptionValue ('noEffSF', noEffSF)
-    config.setOptionValue ('globalSF', globalSF)
     config.setOptionValue ('minPt', minPt)
     seq.append (config)

PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagEventSFAnalysisConfig.py

+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
+
+# AnaAlgorithm import(s):
+from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
+from AnalysisAlgorithmsConfig.ConfigAccumulator import DataType
+
+
+class FTagEventSFConfig(ConfigBlock):
+    """the ConfigBlock for the event-level FTAG scale factor"""
+
+    def __init__(self, containerName, selectionName):
+        super(FTagEventSFConfig, self).__init__()
+        self.addDependency('OverlapRemoval', required=True)
+        self.containerName = containerName
+        self.postfix = selectionName
+        self.addOption('btagWP', "FixedCutBEff_77", type=str)
+        self.addOption('btagger', "DL1r", type=str)
+
+    def makeAlgs(self, config):
+
+        selectionName = self.postfix
+        if selectionName is None or selectionName == '':
+            selectionName = self.btagger + '_' + self.btagWP
+
+        postfix = selectionName
+        if postfix != "" and postfix[0] != '_':
+            postfix = '_' + postfix
+
+        # Set up the per-event FTAG efficiency scale factor calculation algorithm
+        if config.dataType() is not DataType.Data:
+            alg = config.createAlgorithm('CP::AsgEventScaleFactorAlg',
+                                         'FTagEventScaleFactorAlg' + postfix)
+            preselection = config.getFullSelection(self.containerName, '')
+            alg.preselection = ((preselection + '&&' if preselection else '')
+                                + 'ftag_kin_select_' + selectionName + ',as_char')
+            alg.scaleFactorInputDecoration = 'ftag_effSF_' + selectionName + '_%SYS%'
+            alg.scaleFactorOutputDecoration = 'ftag_effSF_' + selectionName + '_%SYS%'
+            alg.particles = config.readName(self.containerName)
+
+            config.addOutputVar('EventInfo', alg.scaleFactorOutputDecoration,
+                                'weight_ftag_effSF_' + selectionName)
+
+
+def makeFTagEventSFConfig(seq, containerName,
+                          selectionName,
+                          btagWP=None,
+                          btagger=None):
+
+    config = FTagEventSFConfig(containerName, selectionName)
+    if btagWP is not None:
+        config.setOptionValue('btagWP', btagWP)
+    if btagger is not None:
+        config.setOptionValue('btagger', btagger)
+    seq.append(config)