L1PrefiringWeightProducer Class Reference

#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.

    : 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;
  }
}

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_.

~L1PrefiringWeightProducer()

L1PrefiringWeightProducer::~L1PrefiringWeightProducer ( )

override

Definition at line 206 of file L1PrefiringWeightProducer.cc.

{}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 443 of file L1PrefiringWeightProducer.cc.

                                                                                           {
  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);
}

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

getPrefiringRateEcal()

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

private

Definition at line 346 of file L1PrefiringWeightProducer.cc.

                                                                                       {
  //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;
}

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

Referenced by produce().

getPrefiringRateMuon()

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

private

Definition at line 373 of file L1PrefiringWeightProducer.cc.

                                                                                       {
  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;
}

References funct::abs(), dataeraMuon_, down, downStat, downSyst, PVValHelper::eta, LogDebug, SiStripPI::max, 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().

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]);
}

References central, reco::deltaR2(), down, downStat, downSyst, PVValHelper::eta, getPrefiringRateEcal(), getPrefiringRateMuon(), h_prefmap_jet_, h_prefmap_photon_, iEvent, metsig::jet, jetMaxMuonFraction_, jets_token_, missingInputEcal_, missingInputMuon_, muon_token_, nonPrefiringProbDownToken_, nonPrefiringProbECALDownToken_, nonPrefiringProbECALToken_, nonPrefiringProbECALUpToken_, nonPrefiringProbMuonDownStatToken_, nonPrefiringProbMuonDownSystToken_, nonPrefiringProbMuonDownToken_, nonPrefiringProbMuonToken_, nonPrefiringProbMuonUpStatToken_, nonPrefiringProbMuonUpSystToken_, nonPrefiringProbMuonUpToken_, nonPrefiringProbToken_, nonPrefiringProbUpToken_, phi, muons2muons_cfi::photon, photons_token_, DiDispStaMuonMonitor_cfi::pt, up, upStat, upSyst, and useEMpt_.

Member Data Documentation

dataeraEcal_

const std::string L1PrefiringWeightProducer::dataeraEcal_

private

Definition at line 93 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer().

dataeraMuon_

const std::string L1PrefiringWeightProducer::dataeraMuon_

private

Definition at line 94 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

file_prefiringmaps_

std::unique_ptr<TFile> L1PrefiringWeightProducer::file_prefiringmaps_

private

Definition at line 75 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer().

file_prefiringparams_

std::unique_ptr<TFile> L1PrefiringWeightProducer::file_prefiringparams_

private

Definition at line 76 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer().

h_prefmap_jet_

TH2F* L1PrefiringWeightProducer::h_prefmap_jet_

private

Definition at line 92 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer(), and produce().

h_prefmap_photon_

TH2F* L1PrefiringWeightProducer::h_prefmap_photon_

private

Definition at line 91 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer(), and produce().

jetMaxMuonFraction_

const double L1PrefiringWeightProducer::jetMaxMuonFraction_

private

Definition at line 98 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

jets_token_

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

private

Definition at line 56 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

missingInputEcal_

bool L1PrefiringWeightProducer::missingInputEcal_

private

Definition at line 99 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer(), and produce().

missingInputMuon_

bool L1PrefiringWeightProducer::missingInputMuon_

private

Definition at line 100 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer(), and produce().

muon_token_

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

private

Definition at line 57 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbDownToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbDownToken_

private

Definition at line 61 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbECALDownToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbECALDownToken_

private

Definition at line 65 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbECALToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbECALToken_

private

Definition at line 63 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbECALUpToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbECALUpToken_

private

Definition at line 64 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonDownStatToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonDownStatToken_

private

Definition at line 73 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonDownSystToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonDownSystToken_

private

Definition at line 71 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonDownToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonDownToken_

private

Definition at line 69 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonToken_

private

Definition at line 67 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonUpStatToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonUpStatToken_

private

Definition at line 72 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonUpSystToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonUpSystToken_

private

Definition at line 70 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbMuonUpToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbMuonUpToken_

private

Definition at line 68 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbToken_

private

Definition at line 59 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

nonPrefiringProbUpToken_

const edm::EDPutTokenT<float> L1PrefiringWeightProducer::nonPrefiringProbUpToken_

private

Definition at line 60 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

parametrization0p0To0p2_

TF1* L1PrefiringWeightProducer::parametrization0p0To0p2_

private

Definition at line 78 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization0p2To0p3_

TF1* L1PrefiringWeightProducer::parametrization0p2To0p3_

private

Definition at line 79 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization0p3To0p55_

TF1* L1PrefiringWeightProducer::parametrization0p3To0p55_

private

Definition at line 80 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization0p55To0p83_

TF1* L1PrefiringWeightProducer::parametrization0p55To0p83_

private

Definition at line 81 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization0p83To1p24_

TF1* L1PrefiringWeightProducer::parametrization0p83To1p24_

private

Definition at line 82 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization1p24To1p4_

TF1* L1PrefiringWeightProducer::parametrization1p24To1p4_

private

Definition at line 83 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization1p4To1p6_

TF1* L1PrefiringWeightProducer::parametrization1p4To1p6_

private

Definition at line 84 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization1p6To1p8_

TF1* L1PrefiringWeightProducer::parametrization1p6To1p8_

private

Definition at line 85 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization1p8To2p1_

TF1* L1PrefiringWeightProducer::parametrization1p8To2p1_

private

Definition at line 86 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization2p1To2p25_

TF1* L1PrefiringWeightProducer::parametrization2p1To2p25_

private

Definition at line 87 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrization2p25To2p4_

TF1* L1PrefiringWeightProducer::parametrization2p25To2p4_

private

Definition at line 88 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

parametrizationHotSpot_

TF1* L1PrefiringWeightProducer::parametrizationHotSpot_

private

Definition at line 89 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon(), and L1PrefiringWeightProducer().

photons_token_

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

private

Definition at line 55 of file L1PrefiringWeightProducer.cc.

Referenced by produce().

prefiringRateSystUncEcal_

const double L1PrefiringWeightProducer::prefiringRateSystUncEcal_

private

Definition at line 96 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateEcal().

prefiringRateSystUncMuon_

const double L1PrefiringWeightProducer::prefiringRateSystUncMuon_

private

Definition at line 97 of file L1PrefiringWeightProducer.cc.

Referenced by getPrefiringRateMuon().

useEMpt_

const bool L1PrefiringWeightProducer::useEMpt_

private

Definition at line 95 of file L1PrefiringWeightProducer.cc.

Referenced by L1PrefiringWeightProducer(), and produce().