#include <ProdTutorial/L1ECALPrefiringWeightProducer/plugins/L1ECALPrefiringWeightProducer.cc>

Inheritance diagram for L1PrefiringWeightProducer:

Public Member Functions
	L1PrefiringWeightProducer (const edm::ParameterSet &)

	~L1PrefiringWeightProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
double	getPrefiringRateEcal (double eta, double pt, TH2F *h_prefmap, fluctuations fluctuation) const

double	getPrefiringRateMuon (double eta, double phi, double pt, fluctuations fluctuation) const

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const std::string	dataeraEcal_

const std::string	dataeraMuon_

std::unique_ptr< TFile >	file_prefiringmaps_

std::unique_ptr< TFile >	file_prefiringparams_

TH2F *	h_prefmap_jet_

TH2F *	h_prefmap_photon_

const double	jetMaxMuonFraction_

const edm::EDGetTokenT< std::vector< pat::Jet > >	jets_token_

bool	missingInputEcal_

bool	missingInputMuon_

const edm::EDGetTokenT< std::vector< pat::Muon > >	muon_token_

const edm::EDPutTokenT< float >	nonPrefiringProbDownToken_

const edm::EDPutTokenT< float >	nonPrefiringProbECALDownToken_

const edm::EDPutTokenT< float >	nonPrefiringProbECALToken_

const edm::EDPutTokenT< float >	nonPrefiringProbECALUpToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonDownStatToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonDownSystToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonDownToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonUpStatToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonUpSystToken_

const edm::EDPutTokenT< float >	nonPrefiringProbMuonUpToken_

const edm::EDPutTokenT< float >	nonPrefiringProbToken_

const edm::EDPutTokenT< float >	nonPrefiringProbUpToken_

TF1 *	parametrization0p0To0p2_

TF1 *	parametrization0p2To0p3_

TF1 *	parametrization0p3To0p55_

TF1 *	parametrization0p55To0p83_

TF1 *	parametrization0p83To1p24_

TF1 *	parametrization1p24To1p4_

TF1 *	parametrization1p4To1p6_

TF1 *	parametrization1p6To1p8_

TF1 *	parametrization1p8To2p1_

TF1 *	parametrization2p1To2p25_

TF1 *	parametrization2p25To2p4_

TF1 *	parametrizationHotSpot_

const edm::EDGetTokenT< std::vector< pat::Photon > >	photons_token_

const double	prefiringRateSystUncEcal_

const double	prefiringRateSystUncMuon_

const bool	useEMpt_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 42 of file L1PrefiringWeightProducer.cc.

Constructor & Destructor Documentation

◆ L1PrefiringWeightProducer()

L1PrefiringWeightProducer::L1PrefiringWeightProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 103 of file L1PrefiringWeightProducer.cc.

References dataeraEcal_, dataeraMuon_, file_prefiringmaps_, file_prefiringparams_, alignmentValidation::fname, edm::ParameterSet::getParameter(), h_prefmap_jet_, h_prefmap_photon_, missingInputEcal_, missingInputMuon_, parametrization0p0To0p2_, parametrization0p2To0p3_, parametrization0p3To0p55_, parametrization0p55To0p83_, parametrization0p83To1p24_, parametrization1p24To1p4_, parametrization1p4To1p6_, parametrization1p6To1p8_, parametrization1p8To2p1_, parametrization2p1To2p25_, parametrization2p25To2p4_, parametrizationHotSpot_, AlCaHLTBitMon_QueryRunRegistry::string, and useEMpt_.

     : photons_token_(consumes<std::vector<pat::Photon> >(iConfig.getParameter<edm::InputTag>("ThePhotons"))),
       jets_token_(consumes<std::vector<pat::Jet> >(iConfig.getParameter<edm::InputTag>("TheJets"))),
       muon_token_(consumes<std::vector<pat::Muon> >(iConfig.getParameter<edm::InputTag>("TheMuons"))),
       nonPrefiringProbToken_(produces<float>("nonPrefiringProb")),
       nonPrefiringProbUpToken_(produces<float>("nonPrefiringProbUp")),
       nonPrefiringProbDownToken_(produces<float>("nonPrefiringProbDown")),
       nonPrefiringProbECALToken_(produces<float>("nonPrefiringProbECAL")),
       nonPrefiringProbECALUpToken_(produces<float>("nonPrefiringProbECALUp")),
       nonPrefiringProbECALDownToken_(produces<float>("nonPrefiringProbECALDown")),
       nonPrefiringProbMuonToken_(produces<float>("nonPrefiringProbMuon")),
       nonPrefiringProbMuonUpToken_(produces<float>("nonPrefiringProbMuonUp")),
       nonPrefiringProbMuonDownToken_(produces<float>("nonPrefiringProbMuonDown")),
       nonPrefiringProbMuonUpSystToken_(produces<float>("nonPrefiringProbMuonSystUp")),
       nonPrefiringProbMuonDownSystToken_(produces<float>("nonPrefiringProbMuonSystDown")),
       nonPrefiringProbMuonUpStatToken_(produces<float>("nonPrefiringProbMuonStatUp")),
       nonPrefiringProbMuonDownStatToken_(produces<float>("nonPrefiringProbMuonStatDown")),
       dataeraEcal_(iConfig.getParameter<std::string>("DataEraECAL")),
       dataeraMuon_(iConfig.getParameter<std::string>("DataEraMuon")),
       useEMpt_(iConfig.getParameter<bool>("UseJetEMPt")),
       prefiringRateSystUncEcal_(iConfig.getParameter<double>("PrefiringRateSystematicUnctyECAL")),
       prefiringRateSystUncMuon_(iConfig.getParameter<double>("PrefiringRateSystematicUnctyMuon")),
       jetMaxMuonFraction_(iConfig.getParameter<double>("JetMaxMuonFraction")) {
   missingInputEcal_ = false;
   missingInputMuon_ = false;
 
   std::string fname = iConfig.getParameter<std::string>("L1Maps");
   edm::FileInPath mapsfilepath("PhysicsTools/PatUtils/data/" + fname);
   file_prefiringmaps_ = std::make_unique<TFile>(mapsfilepath.fullPath().c_str(), "read");
   if (file_prefiringmaps_ == nullptr) {
     missingInputEcal_ = true;
     edm::LogError("L1PrefireWeightProducer")
         << "File with maps not found. All prefiring weights set to 0. " << std::endl;
   }
   TString mapphotonfullname = "L1prefiring_photonptvseta_" + dataeraEcal_;
   if (!file_prefiringmaps_->Get(mapphotonfullname)) {
     missingInputEcal_ = true;
     edm::LogError("L1PrefireWeightProducer")
         << "Photon map not found. All photons prefiring weights set to 0. " << std::endl;
   }
   h_prefmap_photon_ = file_prefiringmaps_->Get<TH2F>(mapphotonfullname);
   TString mapjetfullname =
       (useEMpt_) ? "L1prefiring_jetemptvseta_" + dataeraEcal_ : "L1prefiring_jetptvseta_" + dataeraEcal_;
   if (!file_prefiringmaps_->Get(mapjetfullname)) {
     missingInputEcal_ = true;
     edm::LogError("L1PrefireWeightProducer") << "Jet map not found. All jets prefiring weights set to 0. " << std::endl;
   }
   h_prefmap_jet_ = file_prefiringmaps_->Get<TH2F>(mapjetfullname);
   file_prefiringmaps_->Close();
 
   std::string fnameMuon = iConfig.getParameter<std::string>("L1MuonParametrizations");
   edm::FileInPath paramsfilepath("PhysicsTools/PatUtils/data/" + fnameMuon);
   file_prefiringparams_ = std::make_unique<TFile>(paramsfilepath.fullPath().c_str(), "read");
   if (file_prefiringparams_ == nullptr) {
     missingInputMuon_ = true;
     edm::LogError("L1PrefireWeightProducer")
         << "File with muon parametrizations not found. All prefiring weights set to 0." << std::endl;
   }
   TString paramName = "L1prefiring_muonparam_0.0To0.2_" + dataeraMuon_;
   parametrization0p0To0p2_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_0.2To0.3_" + dataeraMuon_;
   parametrization0p2To0p3_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_0.3To0.55_" + dataeraMuon_;
   parametrization0p3To0p55_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_0.55To0.83_" + dataeraMuon_;
   parametrization0p55To0p83_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_0.83To1.24_" + dataeraMuon_;
   parametrization0p83To1p24_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_1.24To1.4_" + dataeraMuon_;
   parametrization1p24To1p4_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_1.4To1.6_" + dataeraMuon_;
   parametrization1p4To1p6_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_1.6To1.8_" + dataeraMuon_;
   parametrization1p6To1p8_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_1.8To2.1_" + dataeraMuon_;
   parametrization1p8To2p1_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_2.1To2.25_" + dataeraMuon_;
   parametrization2p1To2p25_ = file_prefiringparams_->Get<TF1>(paramName);
   paramName = "L1prefiring_muonparam_2.25To2.4_" + dataeraMuon_;
   parametrization2p25To2p4_ = file_prefiringparams_->Get<TF1>(paramName);
 
   if (parametrization0p0To0p2_ == nullptr || parametrization0p2To0p3_ == nullptr ||
       parametrization0p3To0p55_ == nullptr || parametrization0p55To0p83_ == nullptr ||
       parametrization0p83To1p24_ == nullptr || parametrization1p24To1p4_ == nullptr ||
       parametrization1p4To1p6_ == nullptr || parametrization1p6To1p8_ == nullptr ||
       parametrization1p8To2p1_ == nullptr || parametrization2p1To2p25_ == nullptr ||
       parametrization2p25To2p4_ == nullptr) {
     missingInputMuon_ = true;
     edm::LogError("L1PrefireWeightProducer")
         << "Muon parametrization not found for at least one bin. All prefiring weights set to 0." << std::endl;
   }
 
   paramName = "L1prefiring_muonparam_HotSpot_" + dataeraMuon_;
   parametrizationHotSpot_ = file_prefiringparams_->Get<TF1>(paramName);
   file_prefiringparams_->Close();
   if ((dataeraMuon_.find("2016") != std::string::npos) && parametrizationHotSpot_ == nullptr) {
     missingInputMuon_ = true;
     edm::LogError("L1PrefireWeightProducer")
         << "Year is 2016 and no Muon parametrization is found for hot spot. All prefiring weights set to 0."
         << std::endl;
   }
 }

◆ ~L1PrefiringWeightProducer()

L1PrefiringWeightProducer::~L1PrefiringWeightProducer ( )

override

Definition at line 206 of file L1PrefiringWeightProducer.cc.

206 {}

Member Function Documentation

◆ fillDescriptions()

void L1PrefiringWeightProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 443 of file L1PrefiringWeightProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                            {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("TheMuons", edm::InputTag("slimmedMuons"));
   desc.add<edm::InputTag>("ThePhotons", edm::InputTag("slimmedPhotons"));
   desc.add<edm::InputTag>("TheJets", edm::InputTag("slimmedJets"));
   desc.add<std::string>("L1Maps", "L1PrefiringMaps.root");
   desc.add<std::string>("L1MuonParametrizations", "L1MuonPrefiringParametriations.root");
   desc.add<std::string>("DataEraECAL", "2017BtoF");
   desc.add<std::string>("DataEraMuon", "2016");
   desc.add<bool>("UseJetEMPt", false);
   desc.add<double>("PrefiringRateSystematicUnctyECAL", 0.2);
   desc.add<double>("PrefiringRateSystematicUnctyMuon", 0.2);
   desc.add<double>("JetMaxMuonFraction", 0.5);
   descriptions.add("l1PrefiringWeightProducer", desc);
 }

◆ getPrefiringRateEcal()

double L1PrefiringWeightProducer::getPrefiringRateEcal	(	double	eta,
		double	pt,
		TH2F *	h_prefmap,
		fluctuations	fluctuation
	)		const

private

Definition at line 346 of file L1PrefiringWeightProducer.cc.

References down, PVValHelper::eta, SiStripPI::max, SiStripPI::min, totemT2DQMSource_cfi::nbinsy, funct::pow(), prefiringRateSystUncEcal_, DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), and up.

Referenced by produce().

                                                                                        {
   //Check pt is not above map overflow
   int nbinsy = h_prefmap->GetNbinsY();
   double maxy = h_prefmap->GetYaxis()->GetBinLowEdge(nbinsy + 1);
   if (pt >= maxy)
     pt = maxy - 0.01;
   int thebin = h_prefmap->FindBin(eta, pt);
 
   double prefrate = h_prefmap->GetBinContent(thebin);
 
   double statuncty = h_prefmap->GetBinError(thebin);
   double systuncty = prefiringRateSystUncEcal_ * prefrate;
 
   if (fluctuation == up)
     prefrate = std::min(1., prefrate + sqrt(pow(statuncty, 2) + pow(systuncty, 2)));
   else if (fluctuation == down)
     prefrate = std::max(0., prefrate - sqrt(pow(statuncty, 2) + pow(systuncty, 2)));
   if (prefrate > 1.) {
     edm::LogWarning("L1PrefireWeightProducer") << "Found a prefiring probability > 1. Setting to 1." << std::endl;
     return 1.;
   }
   return prefrate;
 }

◆ getPrefiringRateMuon()

double L1PrefiringWeightProducer::getPrefiringRateMuon	(	double	eta,
		double	phi,
		double	pt,
		fluctuations	fluctuation
	)		const

private

Definition at line 373 of file L1PrefiringWeightProducer.cc.

References funct::abs(), dataeraMuon_, down, downStat, downSyst, PVValHelper::eta, LogDebug, SiStripPI::max, SiStripPI::min, parametrization0p0To0p2_, parametrization0p2To0p3_, parametrization0p3To0p55_, parametrization0p55To0p83_, parametrization0p83To1p24_, parametrization1p24To1p4_, parametrization1p4To1p6_, parametrization1p6To1p8_, parametrization1p8To2p1_, parametrization2p1To2p25_, parametrization2p25To2p4_, parametrizationHotSpot_, phi, funct::pow(), prefiringRateSystUncMuon_, DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), up, upStat, and upSyst.

Referenced by produce().

                                                                                        {
   double prefrate;
   double statuncty;
   if ((dataeraMuon_.find("2016") != std::string::npos) && (eta > 1.24 && eta < 1.6) &&
       (phi > 2.44346 && phi < 2.79253)) {
     prefrate = parametrizationHotSpot_->Eval(pt);
     statuncty = parametrizationHotSpot_->GetParError(2);
   } else if (std::abs(eta) < 0.2) {
     prefrate = parametrization0p0To0p2_->Eval(pt);
     statuncty = parametrization0p0To0p2_->GetParError(2);
   } else if (std::abs(eta) < 0.3) {
     prefrate = parametrization0p2To0p3_->Eval(pt);
     statuncty = parametrization0p2To0p3_->GetParError(2);
   } else if (std::abs(eta) < 0.55) {
     prefrate = parametrization0p3To0p55_->Eval(pt);
     statuncty = parametrization0p3To0p55_->GetParError(2);
   } else if (std::abs(eta) < 0.83) {
     prefrate = parametrization0p55To0p83_->Eval(pt);
     statuncty = parametrization0p55To0p83_->GetParError(2);
   } else if (std::abs(eta) < 1.24) {
     prefrate = parametrization0p83To1p24_->Eval(pt);
     statuncty = parametrization0p83To1p24_->GetParError(2);
   } else if (std::abs(eta) < 1.4) {
     prefrate = parametrization1p24To1p4_->Eval(pt);
     statuncty = parametrization1p24To1p4_->GetParError(2);
   } else if (std::abs(eta) < 1.6) {
     prefrate = parametrization1p4To1p6_->Eval(pt);
     statuncty = parametrization1p4To1p6_->GetParError(2);
   } else if (std::abs(eta) < 1.8) {
     prefrate = parametrization1p6To1p8_->Eval(pt);
     statuncty = parametrization1p6To1p8_->GetParError(2);
   } else if (std::abs(eta) < 2.1) {
     prefrate = parametrization1p8To2p1_->Eval(pt);
     statuncty = parametrization1p8To2p1_->GetParError(2);
   } else if (std::abs(eta) < 2.25) {
     prefrate = parametrization2p1To2p25_->Eval(pt);
     statuncty = parametrization2p1To2p25_->GetParError(2);
   } else if (std::abs(eta) < 2.4) {
     prefrate = parametrization2p25To2p4_->Eval(pt);
     statuncty = parametrization2p25To2p4_->GetParError(2);
   } else {
     LogDebug("L1PrefireWeightProducer") << "Muon outside of |eta| <= 2.4. Prefiring weight set to 0." << std::endl;
     return 0.;
   }
   double systuncty = prefiringRateSystUncMuon_ * prefrate;
 
   if (fluctuation == up)
     prefrate = std::min(1., prefrate + sqrt(pow(statuncty, 2) + pow(systuncty, 2)));
   else if (fluctuation == down)
     prefrate = std::max(0., prefrate - sqrt(pow(statuncty, 2) + pow(systuncty, 2)));
   else if (fluctuation == upSyst)
     prefrate = std::min(1., prefrate + systuncty);
   else if (fluctuation == downSyst)
     prefrate = std::max(0., prefrate - systuncty);
   else if (fluctuation == upStat)
     prefrate = std::min(1., prefrate + statuncty);
   else if (fluctuation == downStat)
     prefrate = std::max(0., prefrate - statuncty);
 
   if (prefrate > 1.) {
     edm::LogWarning("L1PrefireWeightProducer") << "Found a prefiring probability > 1. Setting to 1." << std::endl;
     return 1.;
   }
   return prefrate;
 }

◆ produce()

void L1PrefiringWeightProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 208 of file L1PrefiringWeightProducer.cc.

                                                                                      {
   using namespace edm;
 
   //Photons
   const std::vector<pat::Photon>& thePhotons = iEvent.get(photons_token_);
 
   //Jets
   const std::vector<pat::Jet>& theJets = iEvent.get(jets_token_);
 
   //Muons
   const std::vector<pat::Muon>& theMuons = iEvent.get(muon_token_);
 
   //Probability for the event NOT to prefire, computed with the prefiring maps per object.
   //Up and down values correspond to the resulting value when shifting up/down all prefiring rates in prefiring maps.
   double nonPrefiringProba[3] = {1., 1., 1.};      //0: central, 1: up, 2: down
   double nonPrefiringProbaECAL[3] = {1., 1., 1.};  //0: central, 1: up, 2: down
   double nonPrefiringProbaMuon[7] = {
       1., 1., 1., 1., 1., 1., 1.};  //0: central, 1: up, 2: down, 3: up stat, 4: down stat, 5: up syst, 6: down syst
 
   for (const auto fluct : {fluctuations::central, fluctuations::up, fluctuations::down}) {
     if (!missingInputEcal_) {
       for (const auto& photon : thePhotons) {
         double pt_gam = photon.pt();
         double eta_gam = photon.eta();
         if (pt_gam < 20.)
           continue;
         if (fabs(eta_gam) < 2.)
           continue;
         if (fabs(eta_gam) > 3.)
           continue;
         double prefiringprob_gam = getPrefiringRateEcal(eta_gam, pt_gam, h_prefmap_photon_, fluct);
         nonPrefiringProbaECAL[fluct] *= (1. - prefiringprob_gam);
       }
 
       //Now applying the prefiring maps to jets in the affected regions.
       for (const auto& jet : theJets) {
         double pt_jet = jet.pt();
         double eta_jet = jet.eta();
         double phi_jet = jet.phi();
         if (pt_jet < 20.)
           continue;
         if (fabs(eta_jet) < 2.)
           continue;
         if (fabs(eta_jet) > 3.)
           continue;
         if (jetMaxMuonFraction_ > 0 && jet.muonEnergyFraction() > jetMaxMuonFraction_)
           continue;
         //Loop over photons to remove overlap
         double nonprefiringprobfromoverlappingphotons = 1.;
         bool foundOverlappingPhotons = false;
         for (const auto& photon : thePhotons) {
           double pt_gam = photon.pt();
           double eta_gam = photon.eta();
           double phi_gam = photon.phi();
           if (pt_gam < 20.)
             continue;
           if (fabs(eta_gam) < 2.)
             continue;
           if (fabs(eta_gam) > 3.)
             continue;
           double dR2 = reco::deltaR2(eta_jet, phi_jet, eta_gam, phi_gam);
           if (dR2 > 0.16)
             continue;
           double prefiringprob_gam = getPrefiringRateEcal(eta_gam, pt_gam, h_prefmap_photon_, fluct);
           nonprefiringprobfromoverlappingphotons *= (1. - prefiringprob_gam);
           foundOverlappingPhotons = true;
         }
         //useEMpt =true if one wants to use maps parametrized vs Jet EM pt instead of pt.
         if (useEMpt_)
           pt_jet *= (jet.neutralEmEnergyFraction() + jet.chargedEmEnergyFraction());
         double nonprefiringprobfromoverlappingjet = 1. - getPrefiringRateEcal(eta_jet, pt_jet, h_prefmap_jet_, fluct);
 
         if (!foundOverlappingPhotons) {
           nonPrefiringProbaECAL[fluct] *= nonprefiringprobfromoverlappingjet;
         }
         //If overlapping photons have a non prefiring rate larger than the jet, then replace these weights by the jet one
         else if (nonprefiringprobfromoverlappingphotons > nonprefiringprobfromoverlappingjet) {
           if (nonprefiringprobfromoverlappingphotons > 0.) {
             nonPrefiringProbaECAL[fluct] *= nonprefiringprobfromoverlappingjet / nonprefiringprobfromoverlappingphotons;
           } else {
             nonPrefiringProbaECAL[fluct] = 0.;
           }
         }
         //Last case: if overlapping photons have a non prefiring rate smaller than the jet, don't consider the jet in the event weight, and do nothing.
       }
     }
     //Now calculate prefiring weights for muons
     if (!missingInputMuon_) {
       for (const auto& muon : theMuons) {
         double pt = muon.pt();
         double phi = muon.phi();
         double eta = muon.eta();
         // Remove crappy tracker muons which would not have prefired the L1 trigger
         if (pt < 5 || !muon.isLooseMuon())
           continue;
         double prefiringprob_mu = getPrefiringRateMuon(eta, phi, pt, fluct);
         nonPrefiringProbaMuon[fluct] *= (1. - prefiringprob_mu);
       }
     }
   }
   // Calculate combined weight as product of the weight for individual objects
   for (const auto fluct : {fluctuations::central, fluctuations::up, fluctuations::down}) {
     nonPrefiringProba[fluct] = nonPrefiringProbaECAL[fluct] * nonPrefiringProbaMuon[fluct];
   }
   // Calculate statistical and systematic uncertainty separately in the muon case
   for (const auto fluct :
        {fluctuations::upSyst, fluctuations::downSyst, fluctuations::upStat, fluctuations::downStat}) {
     if (!missingInputMuon_) {
       for (const auto& muon : theMuons) {
         double pt = muon.pt();
         double phi = muon.phi();
         double eta = muon.eta();
         // Remove crappy tracker muons which would not have prefired the L1 trigger
         if (pt < 5 || !muon.isLooseMuon())
           continue;
         double prefiringprob_mu = getPrefiringRateMuon(eta, phi, pt, fluct);
         nonPrefiringProbaMuon[fluct] *= (1. - prefiringprob_mu);
       }
     }
   }
   //Move global prefire weights, as well as those for muons, photons, and jets, to the event
   iEvent.emplace(nonPrefiringProbToken_, nonPrefiringProba[0]);
   iEvent.emplace(nonPrefiringProbUpToken_, nonPrefiringProba[1]);
   iEvent.emplace(nonPrefiringProbDownToken_, nonPrefiringProba[2]);
 
   iEvent.emplace(nonPrefiringProbECALToken_, nonPrefiringProbaECAL[0]);
   iEvent.emplace(nonPrefiringProbECALUpToken_, nonPrefiringProbaECAL[1]);
   iEvent.emplace(nonPrefiringProbECALDownToken_, nonPrefiringProbaECAL[2]);
 
   iEvent.emplace(nonPrefiringProbMuonToken_, nonPrefiringProbaMuon[0]);
   iEvent.emplace(nonPrefiringProbMuonUpToken_, nonPrefiringProbaMuon[1]);
   iEvent.emplace(nonPrefiringProbMuonDownToken_, nonPrefiringProbaMuon[2]);
   iEvent.emplace(nonPrefiringProbMuonUpStatToken_, nonPrefiringProbaMuon[3]);
   iEvent.emplace(nonPrefiringProbMuonDownStatToken_, nonPrefiringProbaMuon[4]);
   iEvent.emplace(nonPrefiringProbMuonUpSystToken_, nonPrefiringProbaMuon[5]);
   iEvent.emplace(nonPrefiringProbMuonDownSystToken_, nonPrefiringProbaMuon[6]);
 }