introduce a configuration block for PRW

PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py

@@ -471,30 +471,23 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare, isPhyslite, noPhysliteB
 
 def makeSequenceBlocks (dataType, algSeq, vars, forCompare, isPhyslite, noPhysliteBroken) :
 
+    configSeq = ConfigSequence ()
+
+
     if not isPhyslite :
         # Include, and then set up the pileup analysis sequence:
         prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
 
-        from AsgAnalysisAlgorithms.PileupAnalysisSequence import \
-            makePileupAnalysisSequence
-        pileupSequence = makePileupAnalysisSequence(
-            dataType,
-            userPileupConfigs=prwfiles,
-            userLumicalcFiles=lumicalcfiles,
-        )
-        pileupSequence.configure( inputName = {}, outputName = {} )
-
-        # Add the pileup sequence to the job:
-        algSeq += pileupSequence
-
+        from AsgAnalysisAlgorithms.AsgAnalysisConfig import \
+            makePileupReweightingConfig
+        makePileupReweightingConfig (configSeq,
+                                     userPileupConfigs=prwfiles,
+                                     userLumicalcFiles=lumicalcfiles)
 
     vars += [ 'EventInfo.runNumber     -> runNumber',
               'EventInfo.eventNumber   -> eventNumber', ]
 
 
-    configSeq = ConfigSequence ()
-
-
     # Include, and then set up the electron analysis algorithm sequence:
     from EgammaAnalysisAlgorithms.ElectronAnalysisConfig import makeElectronCalibrationConfig, makeElectronWorkingPointConfig
 

PhysicsAnalysis/Algorithms/AsgAnalysisAlgorithms/python/AsgAnalysisConfig.py

@@ -4,6 +4,75 @@
 from AnalysisAlgorithmsConfig.ConfigBlock import ConfigBlock
 
 
+class PileupReweightingBlock (ConfigBlock):
+    """the ConfigBlock for pileup reweighting"""
+
+    def __init__ (self) :
+        super (PileupReweightingBlock, self).__init__ ()
+        self.campaign=None
+        self.files=None
+        self.useDefaultConfig=False
+        self.userLumicalcFiles=None
+        self.userPileupConfigs=None
+
+
+    def makeAlgs (self, config) :
+
+        from Campaigns.Utils import Campaign
+
+        try:
+            from AthenaCommon.Logging import logging
+        except ImportError:
+            import logging
+        log = logging.getLogger('makePileupAnalysisSequence')
+
+        # TODO: support per-campaign config
+
+        toolConfigFiles = []
+        toolLumicalcFiles = []
+        campaign = self.campaign
+        if self.files is not None and (campaign is None or campaign is Campaign.Unknown or self.userPileupConfigs is None):
+            if campaign is None or campaign is Campaign.Unknown:
+                from Campaigns.Utils import getMCCampaign
+                campaign = getMCCampaign(self.files)
+                if campaign:
+                    log.info(f'Autoconfiguring PRW with campaign: {campaign}')
+                else:
+                    log.info('Campaign could not be determined.')
+
+            if campaign:
+                if self.userPileupConfigs is None:
+                    from PileupReweighting.AutoconfigurePRW import getConfigurationFiles
+                    toolConfigFiles = getConfigurationFiles(campaign=campaign, files=self.files, useDefaultConfig=self.useDefaultConfig)
+                    log.info('Setting PRW configuration based on input files')
+
+                    if toolConfigFiles:
+                        log.info(f'Using PRW configuration: {", ".join(toolConfigFiles)}')
+                else:
+                    log.info('Using user provided PRW configuration')
+
+        if self.userPileupConfigs is not None:
+            toolConfigFiles = self.userPileupConfigs[:]
+
+        if self.userLumicalcFiles is not None:
+            log.info('Using user-provided lumicalc files')
+            toolLumicalcFiles = self.userLumicalcFiles[:]
+        else:
+            from PileupReweighting.AutoconfigurePRW import getLumicalcFiles
+            toolLumicalcFiles = getLumicalcFiles(campaign)
+
+        # Set up the only algorithm of the sequence:
+        alg = config.createAlgorithm( 'CP::PileupReweightingAlg', 'PileupReweightingAlg' )
+        config.addPrivateTool( 'pileupReweightingTool', 'CP::PileupReweightingTool' )
+        alg.pileupReweightingTool.ConfigFiles = toolConfigFiles
+        if not toolConfigFiles and dataType != "data":
+            log.info("No PRW config files provided. Disabling reweighting")
+            # Setting the weight decoration to the empty string disables the reweighting
+            alg.pileupWeightDecoration = ""
+        alg.pileupReweightingTool.LumiCalcFiles = toolLumicalcFiles
+
+
+
 class PtEtaSelectionBlock (ConfigBlock):
     """the ConfigBlock for a pt-eta selection"""
 
@@ -83,6 +152,23 @@ class OutputThinningBlock (ConfigBlock):
 
 
 
+def makePileupReweightingConfig( seq, campaign=None, files=None, useDefaultConfig=False, userLumicalcFiles=None, userPileupConfigs=None ):
+    """Create a PRW analysis config
+
+    Keyword arguments:
+    """
+    # TO DO: add explanation of the keyword arguments, left to experts
+
+    config = PileupReweightingBlock ()
+    config.campaign = campaign
+    config.files = files
+    config.useDefaultConfig = useDefaultConfig
+    config.userLumicalcFiles = userLumicalcFiles
+    config.userPileupConfigs = userPileupConfigs
+    seq.append (config)
+
+
+
 def makePtEtaSelectionConfig( seq, containerName,
                               *, postfix = '', minPt = None, maxEta = None,
                               selectionDecoration):