python.AsgAnalysisConfig.PileupReweightingBlock Class Reference

Inheritance diagram for python.AsgAnalysisConfig.PileupReweightingBlock:

Collaboration diagram for python.AsgAnalysisConfig.PileupReweightingBlock:

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

Public Attributes
	writeColumnarToolVariables
	alternativeConfig
	writeDetailedPileupValues
	files = config.flags.Input.Files
	useDefaultConfig

Detailed Description

the ConfigBlock for pileup reweighting

Definition at line 213 of file AsgAnalysisConfig.py.

Constructor & Destructor Documentation

__init__()

python.AsgAnalysisConfig.PileupReweightingBlock.__init__

(

self

)

Definition at line 216 of file AsgAnalysisConfig.py.

    def __init__ (self) :
        super().__init__ ()
        self.addOption ('campaign', None, type=None,
            info="the MC campaign for the PRW auto-configuration.")
        self.addOption ('files', None, type=list,
            info="the input files being processed (list of strings). "
            "Alternative to auto-configuration.")
        self.addOption ('useDefaultConfig', True, type=bool,
            info="whether to use the central PRW files.")
        self.addOption ('GRLSuffixDict', {}, type=dict,
            info="a year-suffix dictionary to help with autoconfiguration of "
            "GRL-specific PRW configuration, e.g. selecting 'BjetHLT'.")
        self.addOption ('userLumicalcFiles', None, type=list,
            info="user-provided lumicalc files (list of strings). Alternative "
            "to auto-configuration.")
        self.addOption ('userLumicalcFilesPerCampaign', None, type=dict,
            info="user-provided lumicalc files (dictionary of list of strings, "
            "with MC campaigns as the keys). Alternative to auto-configuration.")
        self.addOption ('userPileupConfigs', None, type=list,
            info="user-provided PRW files (list of strings). Alternative to "
            "auto-configuration.")
        self.addOption ('userPileupConfigsPerCampaign', None, type=dict,
            info="user-provided PRW files (dictionary of list of strings, with "
            "MC campaigns as the keys).")
        self.addOption ('postfix', '', type=str,
            info="a postfix to apply to decorations and algorithm names. "
            "Typically not needed unless several instances of `PileupReweighting` are scheduled.")
        self.addOption ('alternativeConfig', False, type=bool,
            info="whether this is used as an additional alternative config for `PileupReweighting`. "
            "Will only store the alternative pileup weight in that case.")
        self.addOption ('unrepresentedDataWarningThreshold', 1e-4, type=float,
            info="suppress the unrepresented-data WARNING when the unrepresented "
            "fraction is below this value (default 0.01%). Set to 0 to always "
            "warn.")
        self.addOption ('writeColumnarToolVariables', False, type=bool,
            info="whether to add `EventInfo` variables needed for running the columnar tool(s) on the output n-tuple. (EXPERIMENTAL).",
            expertMode=True)
        self.addOption ('writeDetailedPileupValues', False, type=bool,
            info="whether to write the average and actual pileup values with and without data scale factor.")
 

Member Function Documentation

instanceName()

python.AsgAnalysisConfig.PileupReweightingBlock.instanceName

(

self

)

Return the instance name for this block

Definition at line 256 of file AsgAnalysisConfig.py.

    def instanceName (self) :
        """Return the instance name for this block"""
        return self.postfix
 

makeAlgs()

python.AsgAnalysisConfig.PileupReweightingBlock.makeAlgs	(		self,
			config )

Definition at line 260 of file AsgAnalysisConfig.py.

    def makeAlgs (self, config) :
 
        from Campaigns.Utils import Campaign
 
        log = logging.getLogger("makePileupAnalysisSequence")
 
        eventInfoVar = [
            ("runNumber", "unsigned"),
            ("eventNumber", "unsigned_long"),
        ]
        if config.dataType() is not DataType.Data:
            eventInfoVar.extend([
                ("mcChannelNumber", "unsigned"),
            ])
        # for now still write the average and actual pileup values until the new p-tag is available
        eventInfoVar.extend([
            ("averageInteractionsPerCrossing", "float"),
            ("actualInteractionsPerCrossing", "float"),
        ])
        if self.writeColumnarToolVariables:
            # This is not strictly necessary, as the columnar users
            # could recreate this, but it is also a single constant int,
            # that should compress exceedingly well.
            eventInfoVar.extend([
                ("eventTypeBitmask", "int"),
            ])
 
        if config.isPhyslite() and not self.alternativeConfig:
            # PHYSLITE already has these variables defined, just need to copy them to the output
            log.info("Physlite does not need pileup reweighting. Variables will be copied from input instead.")
            if self.writeDetailedPileupValues:
                log.warning("writeDetailedPileupValues is set to True, but Physlite does not have these variables. They will not be written to the output.")
 
            eventInfoVar.extend([
                ("correctedScaledInteractionsPerCrossing", "float"),
            ])
            for var_name, var_type in eventInfoVar:
                config.addOutputVar("EventInfo", var_name, var_name, noSys=True, auxType=var_type)
 
            if config.dataType() is not DataType.Data:
                config.addOutputVar("EventInfo", "PileupWeight_%SYS%", "weight_pileup", auxType="float")
                if config.geometry() is LHCPeriod.Run2:
                    config.addOutputVar("EventInfo", "beamSpotWeight", "weight_beamspot", noSys=True, auxType="float")
            return
 
        # check files from flags
        if self.files is None and config.flags is not None:
            self.files = config.flags.Input.Files
 
        campaign = self.campaign
        # if user didn't explicitly configure campaign, let's try setting it from metadata
        if self.campaign is None:
            # if we used flags, campaign is auto-determined
            if config.campaign() is not None and config.campaign() is not Campaign.Unknown:
                campaign = config.campaign()
                log.info("Auto-configuring campaign for PRW from flags: %s", campaign.value)
            elif config.dataType() is DataType.Data:
                log.info("Inferring campaign from data year: %d", config.dataYear())
                campaign = {
                    2015: Campaign.MC20a,
                    2016: Campaign.MC20a,
                    2017: Campaign.MC20d,
                    2018: Campaign.MC20e,
                    2022: Campaign.MC23a,
                    2023: Campaign.MC23d,
                    2024: Campaign.MC23e,
                    2025: Campaign.MC23g,
                    2026: Campaign.MC23g,
                }.get(config.dataYear(), Campaign.Unknown)
            else:
                # we try to determine campaign from files if above failed
                if self.files is not None:
                    from Campaigns.Utils import getMCCampaign
                    campaign = getMCCampaign(self.files)
                    if campaign and campaign is not Campaign.Unknown:
                        log.info("Auto-configuring campaign for PRW from files: %s", campaign.value)
                    else:
                        log.info("Campaign could not be determined.")
 
 
        toolConfigFiles = []
        toolLumicalcFiles = []
 
        # PRW config files should only be configured if we run on MC
        # Run 4 not supported yet
        if (config.dataType() is not DataType.Data and
            config.geometry() is not LHCPeriod.Run4):
            # check if user provides per-campaign pileup config list
            if self.userPileupConfigs is not None and self.userPileupConfigsPerCampaign is not None:
                raise ValueError("Both userPileupConfigs and userPileupConfigsPerCampaign specified,"
                                 " use only one of the options!")
            if self.userPileupConfigsPerCampaign is not None:
                if not campaign:
                    raise Exception("userPileupConfigsPerCampaign requires campaign to be configured!")
                if campaign is Campaign.Unknown:
                    raise Exception("userPileupConfigsPerCampaign used, but campaign = Unknown!")
                try:
                    toolConfigFiles = self.userPileupConfigsPerCampaign[campaign.value][:]
                    log.info("Using user provided per-campaign PRW configuration")
                except KeyError as e:
                    raise KeyError(f"Unconfigured campaign {e} for userPileupConfigsPerCampaign!")
 
            elif self.userPileupConfigs is not None:
                toolConfigFiles = self.userPileupConfigs[:]
                log.info("Using user provided PRW configuration")
 
            else:
                if self.useDefaultConfig and self.files is None:
                    raise ValueError("useDefaultConfig requires files to be configured!"
                                     " Either pass them as an option or use flags.")
 
                from PileupReweighting.AutoconfigurePRW import getConfigurationFiles
                if campaign and campaign is not Campaign.Unknown:
                    toolConfigFiles = getConfigurationFiles(campaign=campaign,
                                                            files=self.files,
                                                            useDefaultConfig=self.useDefaultConfig,
                                                            data_type=config.dataType(),
                                                            GRLSuffixDict=self.GRLSuffixDict)
                    if self.useDefaultConfig:
                        log.info("Auto-configuring universal/default PRW config")
                    else:
                        log.info("Auto-configuring per-sample PRW config files based on input files")
                else:
                    log.info("No campaign specified, no PRW config files configured")
 
 
        # check if user provides per-campaign lumical config list
        if self.userLumicalcFilesPerCampaign is not None and self.userLumicalcFiles is not None:
            raise ValueError("Both userLumicalcFiles and userLumicalcFilesPerCampaign specified,"
                             " use only one of the options!")
        if self.userLumicalcFilesPerCampaign is not None:
            if not campaign:
                raise Exception('userLumicalcFilesPerCampaign requires campaign to be configured!')
            if campaign is Campaign.Unknown:
                raise Exception('userLumicalcFilesPerCampaign used, but campaign = Unknown!')
            try:
                toolLumicalcFiles = self.userLumicalcFilesPerCampaign[campaign.value][:]
                log.info("Using user-provided per-campaign lumicalc files")
            except KeyError as e:
                raise KeyError(f"Unconfigured campaign {e} for userLumicalcFilesPerCampaign!")
        elif self.userLumicalcFiles is not None:
            toolLumicalcFiles = self.userLumicalcFiles[:]
            log.info("Using user-provided lumicalc files")
        else:
            if campaign and campaign not in {Campaign.Unknown, Campaign.PhaseII}:
                from PileupReweighting.AutoconfigurePRW import getLumicalcFiles
                toolLumicalcFiles = getLumicalcFiles(campaign, self.GRLSuffixDict)
                log.info("Using auto-configured lumicalc files")
            else:
                log.info("No campaign specified, no lumicalc files configured for PRW")
 
        # Set up the only algorithm of the sequence:
        if config.geometry() is LHCPeriod.Run4:
            warnings.warn_explicit(
                "Pileup reweighting is not yet supported for Run 4 geometry",
                Run4FallbackWarning, filename="", lineno=0)
            alg = config.createAlgorithm("CP::EventDecoratorAlg", "EventDecoratorAlg")
            alg.uint32Decorations = {
                "RandomRunNumber": config.flags.Input.RunNumbers[0]
            }
 
        else:
            alg = config.createAlgorithm("CP::PileupReweightingAlg", "PileupReweightingAlg")
            config.addPrivateTool("pileupReweightingTool", "CP::PileupReweightingTool")
            alg.pileupReweightingTool.ConfigFiles = toolConfigFiles
            if not toolConfigFiles and config.dataType() is not DataType.Data:
                log.info("No PRW config files provided. Disabling reweighting")
                # Setting the weight decoration to the empty string disables the reweighting
                alg.pileupWeightDecoration = ""
            else:
                alg.pileupWeightDecoration = f"PileupWeight{self.postfix}_%SYS%"
            alg.pileupReweightingTool.LumiCalcFiles = toolLumicalcFiles
            alg.pileupReweightingTool.UnrepresentedDataWarningThreshold = (
                self.unrepresentedDataWarningThreshold)
 
            # pile-up values
            if not self.alternativeConfig:
                if self.writeDetailedPileupValues:
                    alg.correctedScaledAverageMuDecoration = "correctedScaledAverageInteractionsPerCrossing"
                    alg.correctedScaledActualMuDecoration = "correctedScaledActualInteractionsPerCrossing"
                    alg.correctedAverageMuDecoration = "correctedUnscaledAverageInteractionsPerCrossing"
                    alg.correctedActualMuDecoration = "correctedUnscaledActualInteractionsPerCrossing"
 
                    eventInfoVar.extend([
                        ("correctedScaledAverageInteractionsPerCrossing", "float"),
                        ("correctedScaledActualInteractionsPerCrossing", "float"),
                        ("correctedUnscaledAverageInteractionsPerCrossing", "float"),
                        ("correctedUnscaledActualInteractionsPerCrossing", "float"),
                    ])
 
                    if campaign is Campaign.MC20a:
                        config.addOutputVar("EventInfo", "correctedScaledAverageInteractionsPerCrossing", "correctedScaledInteractionsPerCrossing", noSys=True, auxType="float")
                    elif campaign >= Campaign.MC20d and config.geometry() is not LHCPeriod.Run4:
                        config.addOutputVar("EventInfo", "correctedScaledActualInteractionsPerCrossing", "correctedScaledInteractionsPerCrossing", noSys=True, auxType="float")
                else:
                    if campaign is Campaign.MC20a:
                        alg.correctedScaledAverageMuDecoration = "correctedScaledInteractionsPerCrossing"
                    elif campaign >= Campaign.MC20d:
                        alg.correctedScaledActualMuDecoration = "correctedScaledInteractionsPerCrossing"
                    eventInfoVar.extend([
                        ("correctedScaledInteractionsPerCrossing", "float"),
                    ])
 
        if not self.alternativeConfig:
            for var_name, var_type in eventInfoVar:
                config.addOutputVar("EventInfo", var_name, var_name, noSys=True, auxType=var_type)
 
            if config.dataType() is not DataType.Data and config.geometry() is LHCPeriod.Run2:
                config.addOutputVar("EventInfo", "beamSpotWeight", "weight_beamspot", noSys=True, auxType="float")
 
        if config.dataType() is not DataType.Data and toolConfigFiles:
            config.addOutputVar("EventInfo", f"PileupWeight{self.postfix}_%SYS%",
                                f"weight_pileup{self.postfix}", auxType="float")
 
 

Member Data Documentation

alternativeConfig

python.AsgAnalysisConfig.PileupReweightingBlock.alternativeConfig

Definition at line 287 of file AsgAnalysisConfig.py.

files

python.AsgAnalysisConfig.PileupReweightingBlock.files = config.flags.Input.Files

Definition at line 307 of file AsgAnalysisConfig.py.

useDefaultConfig

python.AsgAnalysisConfig.PileupReweightingBlock.useDefaultConfig

Definition at line 378 of file AsgAnalysisConfig.py.

writeColumnarToolVariables

python.AsgAnalysisConfig.PileupReweightingBlock.writeColumnarToolVariables

Definition at line 279 of file AsgAnalysisConfig.py.

writeDetailedPileupValues

python.AsgAnalysisConfig.PileupReweightingBlock.writeDetailedPileupValues

Definition at line 290 of file AsgAnalysisConfig.py.

---

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

• AsgAnalysisConfig.py