From f3fee7c75a8286d3ce680429b50cfc74ed4e9976 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 3 Mar 2022 09:34:56 -0600 Subject: [PATCH 01/41] One merged commit --- .../PatAlgos/python/slimming/enableDRN.py | 17 + .../slimming/patElectronDRNCorrector_cfi.py | 19 + .../slimming/patPhotonDRNCorrector_cfi.py | 19 + RecoEgamma/EgammaTools/BuildFile.xml | 1 + .../plugins/DRNCorrectionProducertT.cc | 450 ++++++++++++++++++ .../plugins/EGRegressionModifierDRN.cc | 246 ++++++++++ 6 files changed, 752 insertions(+) create mode 100644 PhysicsTools/PatAlgos/python/slimming/enableDRN.py create mode 100644 PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py create mode 100644 PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py create mode 100644 RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc create mode 100644 RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc diff --git a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py new file mode 100644 index 0000000000000..642e37262946b --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask + +def enableDRN(process): + process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") + process.DRNTask = cms.Task(process.patPhotonsDRN) + process.schedule.associate(process.DRNTask) + process.slimmedPhotons.modifierConfig.modifications.append( + cms.PSet( modifierName = cms.string("EGRegressionModifierDRN"), + patPhotons = cms.PSet( + source = cms.InputTag('selectedPatPhotons'), + correctionsSource = cms.InputTag('patPhotonsDRN') + ) + ) + ) + + return process diff --git a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py new file mode 100644 index 0000000000000..0a7e5ee2e4572 --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py @@ -0,0 +1,19 @@ +import FWCore.ParameterSet.Config as cms + +patElectronsDRN = cms.EDProducer("PatElectronDRNCorrectionProducer", + particleSource = cms.InputTag("selectedPatElectrons"), + rhoName = cms.InputTag("fixedGridRhoFastjetAll"), + reducedEcalRecHitsEB = cms.InputTag("reducedEcalRecHitsEB"), + reducedEcalRecHitsEE = cms.InputTag("reducedEcalRecHitsEE"), + reducedEcalRecHitsES = cms.InputTag("reducedEcalRecHitsES"), + + Client = cms.PSet( + mode = cms.string("Async"), + modelName = cms.string("electronObjectEnsemble"), + modelConfigPath = cms.FileInPath("RecoEgamma/EgammaElectronProducers/data/models/electronObjectEnsemble/config.pbtxt"), + allowedTries = cms.untracked.uint32(1), + timeout = cms.untracked.uint32(10), + useSharedMemory = cms.untracked.bool(False), + verbose = cms.untracked.bool(True) + ) +) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py new file mode 100644 index 0000000000000..8acf0b683b46c --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -0,0 +1,19 @@ +import FWCore.ParameterSet.Config as cms + +patPhotonsDRN = cms.EDProducer("PatPhotonDRNCorrectionProducer", + particleSource = cms.InputTag("selectedPatPhotons"), + rhoName = cms.InputTag("fixedGridRhoFastjetAll"), + reducedEcalRecHitsEB = cms.InputTag("reducedEcalRecHitsEB"), + reducedEcalRecHitsEE = cms.InputTag("reducedEcalRecHitsEE"), + reducedEcalRecHitsES = cms.InputTag("reducedEcalRecHitsES"), + + Client = cms.PSet( + mode = cms.string("Async"), + modelName = cms.string("photonObjectBothEnsemble"), + modelConfigPath = cms.FileInPath("RecoEgamma/EgammaPhotonProducers/data/models/photonObjectEnsemble/config.pbtxt"), + allowedTries = cms.untracked.uint32(1), + timeout = cms.untracked.uint32(10), + useSharedMemory = cms.untracked.bool(False), + verbose = cms.untracked.bool(True) + ) +) diff --git a/RecoEgamma/EgammaTools/BuildFile.xml b/RecoEgamma/EgammaTools/BuildFile.xml index 33d90ff89a012..8a5d985ab6994 100644 --- a/RecoEgamma/EgammaTools/BuildFile.xml +++ b/RecoEgamma/EgammaTools/BuildFile.xml @@ -17,6 +17,7 @@ + diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc new file mode 100644 index 0000000000000..b18a5249d972c --- /dev/null +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc @@ -0,0 +1,450 @@ +#include "HeterogeneousCore/SonicTriton/interface/TritonEDProducer.h" +#include "HeterogeneousCore/SonicTriton/interface/TritonData.h" + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "FWCore/Utilities/interface/Exception.h" + +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/EgammaCandidates/interface/Photon.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" +#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h" +#include "DataFormats/EgammaCandidates/interface/PhotonCore.h" +#include "DataFormats/Common/interface/ValueMap.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/EcalDetId/interface/EcalSubdetector.h" +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "DataFormats/EcalDetId/interface/EEDetId.h" +#include "DataFormats/EcalDetId/interface/ESDetId.h" +#include "DataFormats/EcalRecHit/interface/EcalRecHit.h" +#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h" +#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h" +#include "DataFormats/EgammaReco/interface/SuperCluster.h" + +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" +#include "Geometry/CaloGeometry/interface/TruncatedPyramid.h" +#include "Geometry/EcalAlgo/interface/EcalPreshowerGeometry.h" +#include "Geometry/CaloTopology/interface/EcalPreshowerTopology.h" +#include "Geometry/Records/interface/CaloGeometryRecord.h" +#include "Geometry/CaloTopology/interface/CaloTopology.h" + +#include "CondFormats/EcalObjects/interface/EcalPedestals.h" +#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h" + +#include "RecoEcal/EgammaCoreTools/interface/PositionCalc.h" + +#include +#include +#include +#include + +#include + +/* + * DRNCorrectionProducerT + * + * Producer template generate a ValueMap of corrected energies and resolutions + * ValueMap contains std::pair of corrected energy, resolution + * + * Author: Simon Rothman (MIT) + * Written 2022 + * + */ + +namespace { + float sigmoid(float x) { return 1.0f / (1.0f + exp(-x)); } + + float logcorrection(float x) { + static float ln2 = log(2); + return ln2 * 2 * (sigmoid(x) - 0.5); + } + + //correction factor is transformed by sigmoid and "logratioflip target" + float correction(float x) { return exp(-logcorrection(x)); } + + inline float rescale(float x, float min, float range){ + return (x-min)/range; + } + + //resolution is transformed by softplus function + float resolution(float x) { return log(1 + exp(x)); } + + const float RHO_MIN = 0.0f; + const float RHO_RANGE = 13.0f; + + const float HOE_MIN = 0.0f; + const float HOE_RANGE = 0.05f; + + const float XY_MIN = -150.0f; + const float XY_RANGE = 300.0f; + + const float Z_MIN = -330.0f; + const float Z_RANGE = 660.0f; + + const float NOISE_MIN = 0.9f; + const float NOISE_RANGE = 3.0f; + + const float ECAL_MIN = 0.0f; + const float ECAL_RANGE = 250.0f; + + const float ES_MIN = 0.0f; + const float ES_RANGE = 0.1f; + +} //anon namespace for private utility constants and functions + +template +class DRNCorrectionProducerT : public TritonEDProducer<> { +public: + explicit DRNCorrectionProducerT(const edm::ParameterSet& iConfig); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + void acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, Input& input) override; + void produce(edm::Event& iEvent, const edm::EventSetup& iSetup, Output const& iOutput) override; + +private: + const edm::InputTag particleSource_; + edm::EDGetTokenT> particleToken_; + edm::Handle> particles_; + + const edm::InputTag rhoName_; + edm::EDGetTokenT rhoToken_; + + edm::InputTag EBRecHitsName_, EERecHitsName_, ESRecHitsName_; + edm::EDGetTokenT EBRecHitsToken_, EERecHitsToken_, ESRecHitsToken_; + + size_t nPart_, nValidPart_; + + bool isEB(const T& part); + bool isEE(const T& part); + bool skip(const T& part); +}; + +template +DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) + : TritonEDProducer<>(iConfig, "DRNCorrectionProducerT"), + particleSource_{iConfig.getParameter("particleSource")}, + particleToken_(consumes(particleSource_)), + rhoName_{iConfig.getParameter("rhoName")}, + rhoToken_(consumes(rhoName_)), + EBRecHitsName_{iConfig.getParameter("reducedEcalRecHitsEB")}, + EERecHitsName_{iConfig.getParameter("reducedEcalRecHitsEE")}, + ESRecHitsName_{iConfig.getParameter("reducedEcalRecHitsES")}, + EBRecHitsToken_(consumes(EBRecHitsName_)), + EERecHitsToken_(consumes(EERecHitsName_)), + ESRecHitsToken_(consumes(ESRecHitsName_)) +{ + produces>>(); +} + +template +bool DRNCorrectionProducerT::isEB(const T& part){ + return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalBarrel; +} + +template +bool DRNCorrectionProducerT::isEE(const T& part){ + return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalEndcap; +} + +template +bool DRNCorrectionProducerT::skip(const T& part){ + /* + * Separated out from acquire() and produce() to ensure that skipping check is identical in both + * N.B. in MiniAOD there are sometimes particles with no RecHits + * We can not apply our regression to these, so we skip them + */ + return (!isEB(part) && !isEE(part)) || part.superCluster()->hitsAndFractions().empty(); +} + +template +void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, Input& iInput) { + /* + * Get products from event and event setup + */ + particles_ = iEvent.getHandle(particleToken_); + float rho = iEvent.get(rhoToken_); + edm::Handle EBRecHits = iEvent.getHandle(EBRecHitsToken_); + edm::Handle EERecHits = iEvent.getHandle(EERecHitsToken_); + edm::Handle ESRecHits = iEvent.getHandle(ESRecHitsToken_); + + edm::ESHandle ped; + edm::ESHandle pG; + + iSetup.get().get(ped); + iSetup.get().get(pG); + const CaloGeometry* geo = pG.product(); + const CaloSubdetectorGeometry* ecalEBGeom = + static_cast(geo->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); + const CaloSubdetectorGeometry* ecalEEGeom = + static_cast(geo->getSubdetectorGeometry(DetId::Ecal, EcalEndcap)); + const CaloSubdetectorGeometry* ecalESGeom = + static_cast(geo->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)); + + const EcalRecHitCollection* recHitsEB = EBRecHits.product(); + const EcalRecHitCollection* recHitsEE = EERecHits.product(); + const EcalRecHitCollection* recHitsES = ESRecHits.product(); + + nPart_ = particles_->size(); + + if (nPart_ == 0) { + client_->setBatchSize(0); + return; + } else { + client_->setBatchSize(1); + } + + /* + * Determine how many particles, how many RecHits there are in each subdetector + */ + unsigned nHitsECAL = 0, nHitsES = 0; + nValidPart_ = 0; + for (auto& part : *particles_) { + const reco::SuperClusterRef& sc = part.superCluster(); + + if(skip(part)) + continue; + + nHitsECAL += sc->hitsAndFractions().size(); + + for (auto iES = sc->preshowerClustersBegin(); iES != sc->preshowerClustersEnd(); ++iES) { + nHitsES += (*iES)->hitsAndFractions().size(); + } + + ++nValidPart_; + } + + /* + * Allocate DRN inputs ({SB} is one of ECAL, ES): + * x{SB}: (x, y, z, energy, [noise]) continuous-valued inputs per RecHit + * f{SB}: (flagVal) integer denoting RecHit flag values + * gainECAL: (gain) integer in (0, 1, 2) denoting gain value + * gx: (rho, H/E) additional high-level features. + * batch{SB}: graph models require explicitely passing the particle index for each vertex + */ + auto& inputxECAL = iInput.at("xECAL"); + inputxECAL.setShape(0, nHitsECAL); + auto dataxECAL = inputxECAL.allocate(); + auto& vdataxECAL = (*dataxECAL)[0]; + + auto& inputfECAL = iInput.at("fECAL"); + inputfECAL.setShape(0, nHitsECAL); + auto datafECAL = inputfECAL.allocate(); + auto& vdatafECAL = (*datafECAL)[0]; + + auto& inputGainECAL = iInput.at("gainECAL"); + inputGainECAL.setShape(0, nHitsECAL); + auto dataGainECAL = inputGainECAL.allocate(); + auto& vdataGainECAL = (*dataGainECAL)[0]; + + auto& inputGx = iInput.at("gx"); + inputGx.setShape(0, nValidPart_); + auto dataGx = inputGx.allocate(); + auto& vdataGx = (*dataGx)[0]; + + auto& inputBatchECAL = iInput.at("batchECAL"); + inputBatchECAL.setShape(0, nHitsECAL); + auto dataBatchECAL = inputBatchECAL.allocate(); + auto& vdataBatchECAL = (*dataBatchECAL)[0]; + + auto& inputxES = iInput.at("xES"); + inputxES.setShape(0, nHitsES); + auto dataxES = inputxES.allocate(); + auto& vdataxES = (*dataxES)[0]; + + auto& inputfES = iInput.at("fES"); + inputfES.setShape(0, nHitsES); + auto datafES = inputfES.allocate(); + auto& vdatafES = (*datafES)[0]; + + auto& inputBatchES = iInput.at("batchES"); + inputBatchES.setShape(0, nHitsES); + auto dataBatchES = inputBatchES.allocate(); + auto& vdataBatchES = (*dataBatchES)[0]; + + /* + * Fill input tensors by iterating over particles... + */ + int64_t partNum = 0; + std::shared_ptr geom; + for (auto& part : *particles_) { + const reco::SuperClusterRef& sc = part.superCluster(); + + if (skip(part)) + continue; + + std::vector> hitsAndFractions = sc->hitsAndFractions(); + EcalRecHitCollection::const_iterator hit; + + if (hitsAndFractions.empty()) //skip particles without RecHits + continue; + + //iterate over ECAL hits... + for (const auto& detitr : hitsAndFractions) { + DetId id = detitr.first.rawId(); + if (isEB(part)) { + geom = ecalEBGeom->getGeometry(id); + hit = recHitsEB->find(detitr.first); + } else { + geom = ecalEEGeom->getGeometry(id); + hit = recHitsEE->find(detitr.first); + } + + //fill xECAL + auto pos = geom->getPosition(); + vdataxECAL.push_back(rescale(pos.x(), XY_MIN, XY_RANGE)); + vdataxECAL.push_back(rescale(pos.y(), XY_MIN, XY_RANGE)); + vdataxECAL.push_back(rescale(pos.z(), Z_MIN, Z_RANGE)); + vdataxECAL.push_back(rescale(hit->energy() * detitr.second, ECAL_MIN, ECAL_RANGE)); + vdataxECAL.push_back(rescale(ped->find(detitr.first)->rms(1), NOISE_MIN, NOISE_RANGE)); + + //fill fECAL + int64_t flagVal = 0; + if (hit->checkFlag(EcalRecHit::kGood)) + flagVal += 1; + if (hit->checkFlag(EcalRecHit::kOutOfTime)) + flagVal += 2; + if (hit->checkFlag(EcalRecHit::kPoorCalib)) + flagVal += 4; + + vdatafECAL.push_back(flagVal); + + //fill gain + int64_t gainVal = 0; + if (hit->checkFlag(EcalRecHit::kHasSwitchToGain6)) + gainVal = 1; + else if (hit->checkFlag(EcalRecHit::kHasSwitchToGain1)) + gainVal = 0; + else + gainVal = 2; + + vdataGainECAL.push_back(gainVal); + + //fill batch number + vdataBatchECAL.push_back(partNum); + } //end iterate over ECAL hits + + //iterate over ES clusters... + for (auto iES = sc->preshowerClustersBegin(); iES != sc->preshowerClustersEnd(); ++iES) { + for (const auto& ESitr : (*iES)->hitsAndFractions()) { //iterate over ES hits + hit = recHitsES->find(ESitr.first); + geom = ecalESGeom->getGeometry(ESitr.first); + auto& pos = geom->getPosition(); + + //fill xES + vdataxES.push_back(rescale(pos.x(), XY_MIN, XY_RANGE)); + vdataxES.push_back(rescale(pos.y(), XY_MIN, XY_RANGE)); + vdataxES.push_back(rescale(pos.z(), Z_MIN, Z_RANGE)); + vdataxES.push_back(rescale(hit->energy(), ES_MIN, ES_RANGE)); + + //fill fES + int64_t flagVal = 0; + if (hit->checkFlag(EcalRecHit::kESGood)) + flagVal += 1; + + vdatafES.push_back(flagVal); + + //fill batchES + vdataBatchES.push_back(partNum); //ES hits only exist for EE particles + } //end iterate over ES hits + } //end iterate over ES clusters + + //fill gx + vdataGx.push_back(rescale(rho, RHO_MIN, RHO_RANGE)); + vdataGx.push_back(rescale(part.hadronicOverEm(), HOE_MIN, HOE_RANGE)); + + + //increment particle number + ++partNum; + } // end iterate over particles + + /* + * Convert input tensors to server data format + */ + inputxECAL.toServer(dataxECAL); + inputfECAL.toServer(datafECAL); + inputGainECAL.toServer(dataGainECAL); + inputBatchECAL.toServer(dataBatchECAL); + + inputGx.toServer(dataGx); + + inputxES.toServer(dataxES); + inputfES.toServer(datafES); + inputBatchES.toServer(dataBatchES); +} + +template +void DRNCorrectionProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup, Output const& iOutput) { + + particles_ = iEvent.getHandle(particleToken_); + + std::vector> corrections; + corrections.reserve(nPart_); + + //if there are no particles, the fromServer() call will fail + //but we can just put() an empty valueMap + if(nPart_){ + const auto& muOut = iOutput.at("mu").fromServer(); + const auto& sigmaOut = iOutput.at("sigma").fromServer(); + + unsigned i=0; + float mu, sigma, Epred, sigmaPred, rawE; + for (unsigned iPart = 0; iPart < nPart_; ++iPart) { + const auto& part = particles_->at(iPart); + if(!skip(part)) { + mu = correction(muOut[0][0 + 6 * i]); + sigma = resolution(sigmaOut[0][0 + 5 * i]); + ++i; + + rawE = particles_->at(iPart).superCluster()->rawEnergy(); + Epred = mu * rawE; + sigmaPred = sigma * rawE; + corrections.emplace_back(Epred, sigmaPred); + } else{ + corrections.emplace_back(-1.0f, -1.0f); + } + } + } + + //fill + auto out = std::make_unique>>(); + edm::ValueMap>::Filler filler(*out); + filler.insert(particles_, corrections.begin(), corrections.end()); + filler.fill(); + + iEvent.put(std::move(out)); +} + +template +void DRNCorrectionProducerT::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + TritonClient::fillPSetDescription(desc); + desc.add("particleSource"); + desc.add("rhoName"); + desc.add("reducedEcalRecHitsEB"); + desc.add("reducedEcalRecHitsEE"); + desc.add("reducedEcalRecHitsES"); + descriptions.addWithDefaultLabel(desc); +} + +using PatPhotonDRNCorrectionProducer = DRNCorrectionProducerT; +using GedPhotonDRNCorrectionProducer = DRNCorrectionProducerT; +using GsfElectronDRNCorrectionProducer = DRNCorrectionProducerT; +using PatElectronDRNCorrectionProducer = DRNCorrectionProducerT; + +//DEFINE_FWK_MODULE(DRNCorrectionProducerT); +DEFINE_FWK_MODULE(PatPhotonDRNCorrectionProducer); +DEFINE_FWK_MODULE(GedPhotonDRNCorrectionProducer); +DEFINE_FWK_MODULE(GsfElectronDRNCorrectionProducer); +DEFINE_FWK_MODULE(PatElectronDRNCorrectionProducer); diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc new file mode 100644 index 0000000000000..e1b731144b280 --- /dev/null +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -0,0 +1,246 @@ +#include "CommonTools/CandAlgos/interface/ModifyObjectValueBase.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/Utilities/interface/EDGetToken.h" + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/Common/interface/ValueMap.h" + +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" +#include "DataFormats/EgammaCandidates/interface/Photon.h" + +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "DataFormats/EcalDetId/interface/EEDetId.h" + +#include "RecoEgamma/EgammaTools/interface/EgammaRegressionContainer.h" +#include "RecoEgamma/EgammaTools/interface/EpCombinationTool.h" +#include "RecoEgamma/EgammaTools/interface/EcalClusterLocal.h" + +#include "Geometry/Records/interface/CaloGeometryRecord.h" +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" + +#include + +/* + * EGRegressionModifierDRN + * + * Object modifier to apply DRN regression. + * Designed to be a drop-in replacement for EGRegressionModifierVX + * + * Requires the appropriate DRNCorrectionProducerX(s) to also be in the path + * You can specify which of reco::GsfElectron, reco::Photon, pat::Electron, pat::Photon + * to apply corrections to in the config + * + */ + +class EGRegressionModifierDRN : public ModifyObjectValueBase { +public: + struct EleRegs { + EleRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc); + void setEventContent(const edm::EventSetup& iSetup); + EgammaRegressionContainer ecalOnlyMean; + EgammaRegressionContainer ecalOnlySigma; + EpCombinationTool epComb; + }; + + struct PhoRegs { + PhoRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc); + void setEventContent(const edm::EventSetup& iSetup); + EgammaRegressionContainer ecalOnlyMean; + EgammaRegressionContainer ecalOnlySigma; + }; + + EGRegressionModifierDRN(const edm::ParameterSet& conf, edm::ConsumesCollector& cc); + ~EGRegressionModifierDRN() override; + + void setEvent(const edm::Event&) final; + void setEventContent(const edm::EventSetup&) final; + + void modifyObject(reco::GsfElectron&) const final; + void modifyObject(reco::Photon&) const final; + + void modifyObject(pat::Electron&) const final; + void modifyObject(pat::Photon&) const final; + +private: + //edm::Event event_; + template + struct partVars { + edm::InputTag source; + edm::EDGetTokenT> token; + edm::View particles; + + edm::InputTag correctionsSource; + edm::EDGetTokenT>> correctionsToken; + edm::ValueMap> corrections; + + partVars(const edm::ParameterSet& config, edm::ConsumesCollector& cc){ + source = config.getParameter("source"); + token = cc.consumes(source); + + correctionsSource = config.getParameter("correctionsSource"); + correctionsToken = cc.consumes(correctionsSource); + } + + const std::pair getCorrection(T& part) const; + }; + + std::unique_ptr> patPhotons_; + std::unique_ptr> patElectrons_; + std::unique_ptr> gedPhotons_; + std::unique_ptr> gsfElectrons_; +}; + +EGRegressionModifierDRN::EGRegressionModifierDRN(const edm::ParameterSet& conf, edm::ConsumesCollector& cc) + : ModifyObjectValueBase(conf){ + + if (conf.exists("patPhotons")){ + patPhotons_ = std::make_unique>(conf.getParameterSet("patPhotons"), cc); + } + + if (conf.exists("gedPhotons")){ + gedPhotons_ = std::make_unique>(conf.getParameterSet("gedPhotons"), cc); + } + + if (conf.exists("patElectrons")){ + patElectrons_ = std::make_unique>(conf.getParameterSet("patElectrons"), cc); + } + + if (conf.exists("gsfElectrons")){ + gsfElectrons_ = std::make_unique>(conf.getParameterSet("gsfElectrons"), cc); + } +} + +EGRegressionModifierDRN::~EGRegressionModifierDRN() {} + +void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { + + if (patElectrons_){ + patElectrons_->particles = evt.get(patElectrons_->token); + patElectrons_->corrections = evt.get(patElectrons_->correctionsToken); + } + + if (patPhotons_){ + patPhotons_->particles = evt.get(patPhotons_->token); + patPhotons_->corrections = evt.get(patPhotons_->correctionsToken); + } + + if (gsfElectrons_){ + gsfElectrons_->particles = evt.get(gsfElectrons_->token); + gsfElectrons_->corrections = evt.get(gsfElectrons_->correctionsToken); + } + + if (gedPhotons_){ + gedPhotons_->particles = evt.get(gedPhotons_->token); + gedPhotons_->corrections = evt.get(gedPhotons_->correctionsToken); + } +} + +void EGRegressionModifierDRN::setEventContent(const edm::EventSetup& iSetup) {} + +void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { + if(!gsfElectrons_) + return; + + const std::pair& correction = gsfElectrons_->getCorrection(ele); + + if(correction.first <= 0) + return; + + ele.setCorrectedEcalEnergy(correction.first, true); + ele.setCorrectedEcalEnergyError(correction.second); + + throw cms::Exception("EGRegressionModifierDRN") + << "Electron energy corrections not fully implemented yet:" << std::endl + << "Still need E/p combination" << std::endl; + << "Do not enable DRN for electrons" << std::endl; + + const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination + const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); + ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); +} + +void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { + if(!patElectrons_) + return; + + const std::pair& correction = patElectrons_->getCorrection(ele); + + if(correction.first <= 0) + return; + + ele.setCorrectedEcalEnergy(correction.first, true); + ele.setCorrectedEcalEnergyError(correction.second); + + throw cms::Exception("EGRegressionModifierDRN") + << "Electron energy corrections not fully implemented yet:" << std::endl + << "Still need E/p combination" << std::endl; + << "Do not enable DRN for electrons" << std::endl; + + const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination + const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); + ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); +} + +void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { + if(!patPhotons_) + return; + const std::pair& correction = patPhotons_->getCorrection(pho); + + if(correction.first <= 0) + return; + + pho.setCorrectedEnergy(pat::Photon::P4type::regression2, correction.first, correction.second, true); +} + +void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { + if(!gedPhotons_) + return; + + const std::pair& correction = gedPhotons_->getCorrection(pho); + + if(correction.first <= 0) + return; + + pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); +}; + +template +const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) const{ + math::XYZTLorentzVectorD partP4 = part.p4(); + + bool matched = false; + unsigned i; + for (i = 0; i < particles.size(); ++i) { + const T& partIter = particles.at(i); + const auto& p4Iter = partIter.p4(); + if (p4Iter == partP4) { + matched = true; + break; + } + } + + if (!matched) { + throw cms::Exception("EGRegressionModifierDRN") + << "Matching failed in EGRegressionModifierDRN" << std::endl + << "This should not have been possible" << std::endl; + return std::pair(-1., -1.); + } + + edm::Ptr ptr = particles.ptrAt(i); + + std::pair correction = corrections[ptr]; + + return correction; +} + +DEFINE_EDM_PLUGIN(ModifyObjectValueFactory, EGRegressionModifierDRN, "EGRegressionModifierDRN"); From 32c5854653e23093d2795e8d01d9e687f45551fb Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 3 Mar 2022 11:05:28 -0600 Subject: [PATCH 02/41] Fix ES data getting to be compliant with newer CMSSW --- .../plugins/DRNCorrectionProducertT.cc | 19 ++++++++++--------- .../plugins/EGRegressionModifierDRN.cc | 4 ++-- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc index b18a5249d972c..3eb1383713615 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc @@ -124,6 +124,9 @@ class DRNCorrectionProducerT : public TritonEDProducer<> { edm::InputTag EBRecHitsName_, EERecHitsName_, ESRecHitsName_; edm::EDGetTokenT EBRecHitsToken_, EERecHitsToken_, ESRecHitsToken_; + edm::ESGetToken pedToken_; + edm::ESGetToken geomToken_; + size_t nPart_, nValidPart_; bool isEB(const T& part); @@ -132,8 +135,8 @@ class DRNCorrectionProducerT : public TritonEDProducer<> { }; template -DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) - : TritonEDProducer<>(iConfig, "DRNCorrectionProducerT"), +DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) : + TritonEDProducer<>(iConfig), particleSource_{iConfig.getParameter("particleSource")}, particleToken_(consumes(particleSource_)), rhoName_{iConfig.getParameter("rhoName")}, @@ -143,8 +146,9 @@ DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConf ESRecHitsName_{iConfig.getParameter("reducedEcalRecHitsES")}, EBRecHitsToken_(consumes(EBRecHitsName_)), EERecHitsToken_(consumes(EERecHitsName_)), - ESRecHitsToken_(consumes(ESRecHitsName_)) -{ + ESRecHitsToken_(consumes(ESRecHitsName_)), + pedToken_(esConsumes()), + geomToken_(esConsumes()){ produces>>(); } @@ -179,12 +183,9 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu edm::Handle EERecHits = iEvent.getHandle(EERecHitsToken_); edm::Handle ESRecHits = iEvent.getHandle(ESRecHitsToken_); - edm::ESHandle ped; - edm::ESHandle pG; + const auto& ped = &iSetup.getData(pedToken_); + const auto& geo = &iSetup.getData(geomToken_); - iSetup.get().get(ped); - iSetup.get().get(pG); - const CaloGeometry* geo = pG.product(); const CaloSubdetectorGeometry* ecalEBGeom = static_cast(geo->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); const CaloSubdetectorGeometry* ecalEEGeom = diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index e1b731144b280..2e29db5f7e28f 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -161,7 +161,7 @@ void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { throw cms::Exception("EGRegressionModifierDRN") << "Electron energy corrections not fully implemented yet:" << std::endl - << "Still need E/p combination" << std::endl; + << "Still need E/p combination" << std::endl << "Do not enable DRN for electrons" << std::endl; const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination @@ -183,7 +183,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { throw cms::Exception("EGRegressionModifierDRN") << "Electron energy corrections not fully implemented yet:" << std::endl - << "Still need E/p combination" << std::endl; + << "Still need E/p combination" << std::endl << "Do not enable DRN for electrons" << std::endl; const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination From 2da29a39b2e31a81fba9e009f288940e236c0583 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 3 Mar 2022 11:05:58 -0600 Subject: [PATCH 03/41] Added test --- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 269 ++++++++++++++++++++++ PhysicsTools/PatAlgos/test/runtests.sh | 1 + 2 files changed, 270 insertions(+) create mode 100644 PhysicsTools/PatAlgos/test/DRNtest_Hgg.py diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py new file mode 100644 index 0000000000000..1012a788e92c6 --- /dev/null +++ b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py @@ -0,0 +1,269 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: step2 -s PAT,VALIDATION:@miniAODValidation,DQM:@miniAODDQM --era Run2_2018 -n 100 --process PAT --conditions auto:phase1_2018_realistic --mc --scenario pp --eventcontent MINIAODSIM,DQM --datatier MINIAODSIM,DQMIO --procModifiers run2_miniAOD_UL_preSummer20 --no_exec --filein filelist:filelist --fileout file:step2.root +import FWCore.ParameterSet.Config as cms + +from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 +from Configuration.ProcessModifiers.run2_miniAOD_UL_preSummer20_cff import run2_miniAOD_UL_preSummer20 +from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton + +process = cms.Process('PAT',Run2_2018,run2_miniAOD_UL_preSummer20, enableSonicTriton) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('PhysicsTools.PatAlgos.slimming.metFilterPaths_cff') +process.load('Configuration.StandardSequences.PATMC_cff') +process.load('Configuration.StandardSequences.Validation_cff') +process.load('DQMServices.Core.DQMStoreNonLegacy_cff') +process.load('DQMOffline.Configuration.DQMOfflineMC_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(10000), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/0E6A5074-CE54-1C43-800F-6C4098689AD7.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/114188AD-C8BB-6842-B6B0-9B1042FD50AF.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/17BF73EE-8540-2E42-947E-9D5BEAE43845.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/1CE3CCAA-1669-064C-9E21-4158015D9352.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/2F141512-8811-2A4F-A0E5-BCCF42362BFF.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/392B7A19-1CF0-3141-B378-94D0A8D404E8.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/403F943F-062E-9441-82C5-E07CEC67A124.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/4CBBC908-50D3-804D-B126-C7AD19B1A3B1.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/57BB7A15-4B78-BA47-994F-B5901F0640F3.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/596B83A5-BDFE-0949-9F3C-2FA37812C8E2.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/7514C486-0907-124D-A993-A13A73662A9C.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/78863F64-B399-2F4B-A3EC-EE2E3E1E9D69.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/7C2D71F5-2304-B04A-920C-87102641EBB3.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/80C21552-D786-3844-BB43-4AD278276FAB.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/87242A4D-9A5A-3D45-A4DF-DF03CAC4F929.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/89695229-EDD9-4447-A607-5B2584310A28.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/8BAE8CEB-DF6B-4246-8F6D-ACB9417AD8B7.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/C72609A4-232D-F144-9B19-928EB086E69E.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/D13CFD8B-77DE-7344-8C13-E3D165877719.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/D521DEDC-8F7A-9D46-9B54-BBE8127C1F51.root', + '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/FE03E4BF-8C4D-A345-8077-2F246E02B3F1.root' + ), + secondaryFileNames = cms.untracked.vstring() +) + +process.options = cms.untracked.PSet( + FailPath = cms.untracked.vstring(), + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + SkipEvent = cms.untracked.vstring(), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), + dumpOptions = cms.untracked.bool(False), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + allowAnyLabel_=cms.required.untracked.uint32 + ), + numberOfConcurrentIOVs = cms.untracked.uint32(0) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + makeTriggerResults = cms.obsolete.untracked.bool, + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(1), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('step2 nevts:100'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(4), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('MINIAODSIM'), + filterName = cms.untracked.string('') + ), + dropMetaData = cms.untracked.string('ALL'), + eventAutoFlushCompressedSize = cms.untracked.int32(-900), + fastCloning = cms.untracked.bool(False), + fileName = cms.untracked.string('file:miniAOD_DRN_Hgg.root'), + outputCommands = process.MINIAODSIMEventContent.outputCommands, + overrideBranchesSplitLevel = cms.untracked.VPSet( + cms.untracked.PSet( + branch = cms.untracked.string('patPackedCandidates_packedPFCandidates__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoGenParticles_prunedGenParticles__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patTriggerObjectStandAlones_slimmedPatTrigger__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patPackedGenParticles_packedGenParticles__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patJets_slimmedJets__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVertices__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVerticesWithBS__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoCaloClusters_reducedEgamma_reducedESClusters_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('recoGenJets_slimmedGenJets__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('patJets_slimmedJetsPuppi__*'), + splitLevel = cms.untracked.int32(99) + ), + cms.untracked.PSet( + branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*'), + splitLevel = cms.untracked.int32(99) + ) + ), + overrideInputFileSplitLevels = cms.untracked.bool(True), + splitLevel = cms.untracked.int32(0) +) + +process.DQMoutput = cms.OutputModule("DQMRootOutputModule", + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('DQMIO'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('file:step2_inDQM.root'), + outputCommands = process.DQMEventContent.outputCommands, + splitLevel = cms.untracked.int32(0) +) + +# Additional output definition + + + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '') + +# Path and EndPath definitions +process.Flag_BadChargedCandidateFilter = cms.Path(process.BadChargedCandidateFilter) +process.Flag_BadChargedCandidateSummer16Filter = cms.Path(process.BadChargedCandidateSummer16Filter) +process.Flag_BadPFMuonDzFilter = cms.Path(process.BadPFMuonDzFilter) +process.Flag_BadPFMuonFilter = cms.Path(process.BadPFMuonFilter) +process.Flag_BadPFMuonSummer16Filter = cms.Path(process.BadPFMuonSummer16Filter) +process.Flag_CSCTightHalo2015Filter = cms.Path(process.CSCTightHalo2015Filter) +process.Flag_CSCTightHaloFilter = cms.Path(process.CSCTightHaloFilter) +process.Flag_CSCTightHaloTrkMuUnvetoFilter = cms.Path(process.CSCTightHaloTrkMuUnvetoFilter) +process.Flag_EcalDeadCellBoundaryEnergyFilter = cms.Path(process.EcalDeadCellBoundaryEnergyFilter) +process.Flag_EcalDeadCellTriggerPrimitiveFilter = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) +process.Flag_HBHENoiseFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseFilter) +process.Flag_HBHENoiseIsoFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseIsoFilter) +process.Flag_HcalStripHaloFilter = cms.Path(process.HcalStripHaloFilter) +process.Flag_METFilters = cms.Path(process.metFilters) +process.Flag_chargedHadronTrackResolutionFilter = cms.Path(process.chargedHadronTrackResolutionFilter) +process.Flag_ecalBadCalibFilter = cms.Path(process.ecalBadCalibFilter) +process.Flag_ecalLaserCorrFilter = cms.Path(process.ecalLaserCorrFilter) +process.Flag_eeBadScFilter = cms.Path(process.eeBadScFilter) +process.Flag_globalSuperTightHalo2016Filter = cms.Path(process.globalSuperTightHalo2016Filter) +process.Flag_globalTightHalo2016Filter = cms.Path(process.globalTightHalo2016Filter) +process.Flag_goodVertices = cms.Path(process.primaryVertexFilter) +process.Flag_hcalLaserEventFilter = cms.Path(process.hcalLaserEventFilter) +process.Flag_hfNoisyHitsFilter = cms.Path(process.hfNoisyHitsFilter) +process.Flag_muonBadTrackFilter = cms.Path(process.muonBadTrackFilter) +process.Flag_trackingFailureFilter = cms.Path(process.goodVertices+process.trackingFailureFilter) +process.Flag_trkPOGFilters = cms.Path(process.trkPOGFilters) +process.Flag_trkPOG_logErrorTooManyClusters = cms.Path(~process.logErrorTooManyClusters) +process.Flag_trkPOG_manystripclus53X = cms.Path(~process.manystripclus53X) +process.Flag_trkPOG_toomanystripclus53X = cms.Path(~process.toomanystripclus53X) +process.prevalidation_step = cms.Path(process.prevalidationMiniAOD) +process.validation_step = cms.EndPath(process.validationMiniAOD) +process.dqmoffline_step = cms.EndPath(process.DQMOfflineMiniAOD) +process.dqmofflineOnPAT_step = cms.EndPath(process.PostDQMOfflineMiniAOD) +process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) +process.DQMoutput_step = cms.EndPath(process.DQMoutput) + +# Schedule definition +process.schedule = cms.Schedule(process.Flag_HBHENoiseFilter,process.Flag_HBHENoiseIsoFilter,process.Flag_CSCTightHaloFilter,process.Flag_CSCTightHaloTrkMuUnvetoFilter,process.Flag_CSCTightHalo2015Filter,process.Flag_globalTightHalo2016Filter,process.Flag_globalSuperTightHalo2016Filter,process.Flag_HcalStripHaloFilter,process.Flag_hcalLaserEventFilter,process.Flag_EcalDeadCellTriggerPrimitiveFilter,process.Flag_EcalDeadCellBoundaryEnergyFilter,process.Flag_ecalBadCalibFilter,process.Flag_goodVertices,process.Flag_eeBadScFilter,process.Flag_ecalLaserCorrFilter,process.Flag_trkPOGFilters,process.Flag_chargedHadronTrackResolutionFilter,process.Flag_muonBadTrackFilter,process.Flag_BadChargedCandidateFilter,process.Flag_BadPFMuonFilter,process.Flag_BadPFMuonDzFilter,process.Flag_hfNoisyHitsFilter,process.Flag_BadChargedCandidateSummer16Filter,process.Flag_BadPFMuonSummer16Filter,process.Flag_trkPOG_manystripclus53X,process.Flag_trkPOG_toomanystripclus53X,process.Flag_trkPOG_logErrorTooManyClusters,process.Flag_METFilters,process.prevalidation_step,process.validation_step,process.dqmoffline_step,process.dqmofflineOnPAT_step,process.MINIAODSIMoutput_step,process.DQMoutput_step) +process.schedule.associate(process.patTask) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + + +# customisation of the process. + +# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools +process = miniAOD_customizeAllMC(process) + +from Validation.Performance.TimeMemoryInfo import customise as customise_profile + +process = customise_profile(process) + +from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN + +process = enableDRN(process) + +process.TritonService.verbose = cms.untracked.bool(True) +process.TritonService.fallback.verbose = cms.untracked.bool(True) + +keepMsgs = ['TritonClient', 'TritonService', 'DRNCorrectionProducerT', 'DRNCorrectionProducerT:TritonClient'] +for msg in keepMsgs: + setattr(process.MessageLogger.cerr, msg, + cms.untracked.PSet( + limit = cms.untracked.int32(100000000), + ) + ) + +# End of customisation functions + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton + +# End adding early deletion + diff --git a/PhysicsTools/PatAlgos/test/runtests.sh b/PhysicsTools/PatAlgos/test/runtests.sh index f523398861327..d9237478dfc81 100755 --- a/PhysicsTools/PatAlgos/test/runtests.sh +++ b/PhysicsTools/PatAlgos/test/runtests.sh @@ -54,3 +54,4 @@ cmsRun ${LOCAL_TEST_DIR}/patTuple_updateJets_fromMiniAOD_cfg.py || die 'Failure # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyPhotons_cfg.py || die 'Failure using patTuple_onlyPhotons_cfg.py' $? # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyTaus_cfg.py || die 'Failure using patTuple_onlyTaus_cfg.py' $? +cmsRun ${LOCAL_TEST_DIR}/DRNTest_cfg.py || die "Failure using DRNtest" $? From 616831b6dd1f569b8a877253e24dd71e696f5d32 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 3 Mar 2022 14:11:16 -0600 Subject: [PATCH 04/41] code-format and code-checks --- ...roducertT.cc => DRNCorrectionProducerT.cc} | 2 +- .../plugins/EGRegressionModifierDRN.cc | 91 +++++++++---------- 2 files changed, 45 insertions(+), 48 deletions(-) rename RecoEgamma/EgammaTools/plugins/{DRNCorrectionProducertT.cc => DRNCorrectionProducerT.cc} (99%) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc similarity index 99% rename from RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc rename to RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 3eb1383713615..33627ce8d48b3 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducertT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -357,7 +357,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu vdatafES.push_back(flagVal); //fill batchES - vdataBatchES.push_back(partNum); //ES hits only exist for EE particles + vdataBatchES.push_back(partNum); } //end iterate over ES hits } //end iterate over ES clusters diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index 2e29db5f7e28f..709ee89ad3de3 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -76,14 +76,14 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { template struct partVars { edm::InputTag source; - edm::EDGetTokenT> token; + edm::EDGetTokenT> token; edm::View particles; - + edm::InputTag correctionsSource; edm::EDGetTokenT>> correctionsToken; edm::ValueMap> corrections; - partVars(const edm::ParameterSet& config, edm::ConsumesCollector& cc){ + partVars(const edm::ParameterSet& config, edm::ConsumesCollector& cc) { source = config.getParameter("source"); token = cc.consumes(source); @@ -101,45 +101,43 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { }; EGRegressionModifierDRN::EGRegressionModifierDRN(const edm::ParameterSet& conf, edm::ConsumesCollector& cc) - : ModifyObjectValueBase(conf){ - - if (conf.exists("patPhotons")){ - patPhotons_ = std::make_unique>(conf.getParameterSet("patPhotons"), cc); - } + : ModifyObjectValueBase(conf) { + if (conf.exists("patPhotons")) { + patPhotons_ = std::make_unique>(conf.getParameterSet("patPhotons"), cc); + } - if (conf.exists("gedPhotons")){ - gedPhotons_ = std::make_unique>(conf.getParameterSet("gedPhotons"), cc); - } + if (conf.exists("gedPhotons")) { + gedPhotons_ = std::make_unique>(conf.getParameterSet("gedPhotons"), cc); + } - if (conf.exists("patElectrons")){ - patElectrons_ = std::make_unique>(conf.getParameterSet("patElectrons"), cc); - } + if (conf.exists("patElectrons")) { + patElectrons_ = std::make_unique>(conf.getParameterSet("patElectrons"), cc); + } - if (conf.exists("gsfElectrons")){ - gsfElectrons_ = std::make_unique>(conf.getParameterSet("gsfElectrons"), cc); - } + if (conf.exists("gsfElectrons")) { + gsfElectrons_ = std::make_unique>(conf.getParameterSet("gsfElectrons"), cc); + } } EGRegressionModifierDRN::~EGRegressionModifierDRN() {} void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { - - if (patElectrons_){ + if (patElectrons_) { patElectrons_->particles = evt.get(patElectrons_->token); patElectrons_->corrections = evt.get(patElectrons_->correctionsToken); } - if (patPhotons_){ + if (patPhotons_) { patPhotons_->particles = evt.get(patPhotons_->token); patPhotons_->corrections = evt.get(patPhotons_->correctionsToken); } - if (gsfElectrons_){ + if (gsfElectrons_) { gsfElectrons_->particles = evt.get(gsfElectrons_->token); gsfElectrons_->corrections = evt.get(gsfElectrons_->correctionsToken); } - if (gedPhotons_){ + if (gedPhotons_) { gedPhotons_->particles = evt.get(gedPhotons_->token); gedPhotons_->corrections = evt.get(gedPhotons_->correctionsToken); } @@ -148,75 +146,75 @@ void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { void EGRegressionModifierDRN::setEventContent(const edm::EventSetup& iSetup) {} void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { - if(!gsfElectrons_) + if (!gsfElectrons_) return; const std::pair& correction = gsfElectrons_->getCorrection(ele); - if(correction.first <= 0) + if (correction.first <= 0) return; ele.setCorrectedEcalEnergy(correction.first, true); ele.setCorrectedEcalEnergyError(correction.second); - throw cms::Exception("EGRegressionModifierDRN") - << "Electron energy corrections not fully implemented yet:" << std::endl - << "Still need E/p combination" << std::endl - << "Do not enable DRN for electrons" << std::endl; + throw cms::Exception("EGRegressionModifierDRN") + << "Electron energy corrections not fully implemented yet:" << std::endl + << "Still need E/p combination" << std::endl + << "Do not enable DRN for electrons" << std::endl; - const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination + const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); } void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { - if(!patElectrons_) + if (!patElectrons_) return; const std::pair& correction = patElectrons_->getCorrection(ele); - if(correction.first <= 0) + if (correction.first <= 0) return; ele.setCorrectedEcalEnergy(correction.first, true); ele.setCorrectedEcalEnergyError(correction.second); - throw cms::Exception("EGRegressionModifierDRN") - << "Electron energy corrections not fully implemented yet:" << std::endl - << "Still need E/p combination" << std::endl - << "Do not enable DRN for electrons" << std::endl; + throw cms::Exception("EGRegressionModifierDRN") + << "Electron energy corrections not fully implemented yet:" << std::endl + << "Still need E/p combination" << std::endl + << "Do not enable DRN for electrons" << std::endl; - const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination + const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); } void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { - if(!patPhotons_) + if (!patPhotons_) return; const std::pair& correction = patPhotons_->getCorrection(pho); - if(correction.first <= 0) - return; + if (correction.first <= 0) + return; pho.setCorrectedEnergy(pat::Photon::P4type::regression2, correction.first, correction.second, true); } void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { - if(!gedPhotons_) + if (!gedPhotons_) return; const std::pair& correction = gedPhotons_->getCorrection(pho); - if(correction.first <= 0) + if (correction.first <= 0) return; pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); }; template -const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) const{ - math::XYZTLorentzVectorD partP4 = part.p4(); +const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) const { + const math::XYZTLorentzVectorD& partP4 = part.p4(); bool matched = false; unsigned i; @@ -230,10 +228,9 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio } if (!matched) { - throw cms::Exception("EGRegressionModifierDRN") - << "Matching failed in EGRegressionModifierDRN" << std::endl - << "This should not have been possible" << std::endl; - return std::pair(-1., -1.); + throw cms::Exception("EGRegressionModifierDRN") << "Matching failed in EGRegressionModifierDRN" << std::endl + << "This should not have been possible" << std::endl; + return std::pair(-1., -1.); } edm::Ptr ptr = particles.ptrAt(i); From 3cdd06c1c56dc04cf6223af1adf2d8b4218b4b18 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 3 Mar 2022 14:21:52 -0600 Subject: [PATCH 05/41] Code-format (again??) --- .../plugins/DRNCorrectionProducerT.cc | 54 +++++++++---------- 1 file changed, 25 insertions(+), 29 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 33627ce8d48b3..72440f832caf0 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -73,9 +73,7 @@ namespace { //correction factor is transformed by sigmoid and "logratioflip target" float correction(float x) { return exp(-logcorrection(x)); } - inline float rescale(float x, float min, float range){ - return (x-min)/range; - } + inline float rescale(float x, float min, float range) { return (x - min) / range; } //resolution is transformed by softplus function float resolution(float x) { return log(1 + exp(x)); } @@ -91,7 +89,7 @@ namespace { const float Z_MIN = -330.0f; const float Z_RANGE = 660.0f; - + const float NOISE_MIN = 0.9f; const float NOISE_RANGE = 3.0f; @@ -101,7 +99,7 @@ namespace { const float ES_MIN = 0.0f; const float ES_RANGE = 0.1f; -} //anon namespace for private utility constants and functions +} // namespace template class DRNCorrectionProducerT : public TritonEDProducer<> { @@ -135,8 +133,8 @@ class DRNCorrectionProducerT : public TritonEDProducer<> { }; template -DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) : - TritonEDProducer<>(iConfig), +DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) + : TritonEDProducer<>(iConfig), particleSource_{iConfig.getParameter("particleSource")}, particleToken_(consumes(particleSource_)), rhoName_{iConfig.getParameter("rhoName")}, @@ -148,22 +146,22 @@ DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConf EERecHitsToken_(consumes(EERecHitsName_)), ESRecHitsToken_(consumes(ESRecHitsName_)), pedToken_(esConsumes()), - geomToken_(esConsumes()){ + geomToken_(esConsumes()) { produces>>(); } template -bool DRNCorrectionProducerT::isEB(const T& part){ - return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalBarrel; +bool DRNCorrectionProducerT::isEB(const T& part) { + return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalBarrel; } template -bool DRNCorrectionProducerT::isEE(const T& part){ - return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalEndcap; +bool DRNCorrectionProducerT::isEE(const T& part) { + return part.superCluster()->seed()->hitsAndFractions().at(0).first.subdetId() == EcalEndcap; } template -bool DRNCorrectionProducerT::skip(const T& part){ +bool DRNCorrectionProducerT::skip(const T& part) { /* * Separated out from acquire() and produce() to ensure that skipping check is identical in both * N.B. in MiniAOD there are sometimes particles with no RecHits @@ -214,13 +212,13 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu for (auto& part : *particles_) { const reco::SuperClusterRef& sc = part.superCluster(); - if(skip(part)) + if (skip(part)) continue; nHitsECAL += sc->hitsAndFractions().size(); for (auto iES = sc->preshowerClustersBegin(); iES != sc->preshowerClustersEnd(); ++iES) { - nHitsES += (*iES)->hitsAndFractions().size(); + nHitsES += (*iES)->hitsAndFractions().size(); } ++nValidPart_; @@ -288,7 +286,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu std::vector> hitsAndFractions = sc->hitsAndFractions(); EcalRecHitCollection::const_iterator hit; - if (hitsAndFractions.empty()) //skip particles without RecHits + if (hitsAndFractions.empty()) //skip particles without RecHits continue; //iterate over ECAL hits... @@ -307,8 +305,8 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu vdataxECAL.push_back(rescale(pos.x(), XY_MIN, XY_RANGE)); vdataxECAL.push_back(rescale(pos.y(), XY_MIN, XY_RANGE)); vdataxECAL.push_back(rescale(pos.z(), Z_MIN, Z_RANGE)); - vdataxECAL.push_back(rescale(hit->energy() * detitr.second, ECAL_MIN, ECAL_RANGE)); - vdataxECAL.push_back(rescale(ped->find(detitr.first)->rms(1), NOISE_MIN, NOISE_RANGE)); + vdataxECAL.push_back(rescale(hit->energy() * detitr.second, ECAL_MIN, ECAL_RANGE)); + vdataxECAL.push_back(rescale(ped->find(detitr.first)->rms(1), NOISE_MIN, NOISE_RANGE)); //fill fECAL int64_t flagVal = 0; @@ -357,18 +355,17 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu vdatafES.push_back(flagVal); //fill batchES - vdataBatchES.push_back(partNum); + vdataBatchES.push_back(partNum); } //end iterate over ES hits - } //end iterate over ES clusters + } //end iterate over ES clusters //fill gx vdataGx.push_back(rescale(rho, RHO_MIN, RHO_RANGE)); vdataGx.push_back(rescale(part.hadronicOverEm(), HOE_MIN, HOE_RANGE)); - //increment particle number ++partNum; - } // end iterate over particles + } // end iterate over particles /* * Convert input tensors to server data format @@ -387,7 +384,6 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu template void DRNCorrectionProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup, Output const& iOutput) { - particles_ = iEvent.getHandle(particleToken_); std::vector> corrections; @@ -395,24 +391,24 @@ void DRNCorrectionProducerT::produce(edm::Event& iEvent, const edm::EventSetu //if there are no particles, the fromServer() call will fail //but we can just put() an empty valueMap - if(nPart_){ + if (nPart_) { const auto& muOut = iOutput.at("mu").fromServer(); const auto& sigmaOut = iOutput.at("sigma").fromServer(); - unsigned i=0; + unsigned i = 0; float mu, sigma, Epred, sigmaPred, rawE; for (unsigned iPart = 0; iPart < nPart_; ++iPart) { const auto& part = particles_->at(iPart); - if(!skip(part)) { - mu = correction(muOut[0][0 + 6 * i]); - sigma = resolution(sigmaOut[0][0 + 5 * i]); + if (!skip(part)) { + mu = correction(muOut[0][0 + 6 * i]); + sigma = resolution(sigmaOut[0][0 + 5 * i]); ++i; rawE = particles_->at(iPart).superCluster()->rawEnergy(); Epred = mu * rawE; sigmaPred = sigma * rawE; corrections.emplace_back(Epred, sigmaPred); - } else{ + } else { corrections.emplace_back(-1.0f, -1.0f); } } From 0bf9e991fbb0d3dbe1c352e7c1342424fab5a5b4 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 07:59:39 -0600 Subject: [PATCH 06/41] Made test shorter --- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py index 1012a788e92c6..5727c61874ca4 100644 --- a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py +++ b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py @@ -27,7 +27,7 @@ process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.maxEvents = cms.untracked.PSet( - input = cms.untracked.int32(10000), + input = cms.untracked.int32(100), output = cms.optional.untracked.allowed(cms.int32,cms.PSet) ) From da3c714d7ca439d88bff104f352429783118e43e Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 08:27:47 -0600 Subject: [PATCH 07/41] Fixed model name --- .../PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index 8acf0b683b46c..44eb0666e3d47 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -9,7 +9,7 @@ Client = cms.PSet( mode = cms.string("Async"), - modelName = cms.string("photonObjectBothEnsemble"), + modelName = cms.string("photonObjectEnsemble"), modelConfigPath = cms.FileInPath("RecoEgamma/EgammaPhotonProducers/data/models/photonObjectEnsemble/config.pbtxt"), allowedTries = cms.untracked.uint32(1), timeout = cms.untracked.uint32(10), From 5af31a1c3bb0a4bd3aa76fba870737fd0dba9ac7 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 11:33:01 -0600 Subject: [PATCH 08/41] Not sure what's going on here tbh... --- .../ProcessModifiers/python/enableDRN_cff.py | 5 ++++- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 9 +++++---- 2 files changed, 9 insertions(+), 5 deletions(-) rename PhysicsTools/PatAlgos/python/slimming/enableDRN.py => Configuration/ProcessModifiers/python/enableDRN_cff.py (80%) diff --git a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py b/Configuration/ProcessModifiers/python/enableDRN_cff.py similarity index 80% rename from PhysicsTools/PatAlgos/python/slimming/enableDRN.py rename to Configuration/ProcessModifiers/python/enableDRN_cff.py index 642e37262946b..6156bf6639a94 100644 --- a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py +++ b/Configuration/ProcessModifiers/python/enableDRN_cff.py @@ -1,7 +1,7 @@ import FWCore.ParameterSet.Config as cms from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask -def enableDRN(process): +def _enableDRN(process): process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") process.DRNTask = cms.Task(process.patPhotonsDRN) process.schedule.associate(process.DRNTask) @@ -15,3 +15,6 @@ def enableDRN(process): ) return process + +from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 +enableDRN = cms.ProcessModifier(Run2_2018, _enableDRN) diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py index 5727c61874ca4..29f276b697470 100644 --- a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py +++ b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py @@ -5,11 +5,11 @@ # with command line options: step2 -s PAT,VALIDATION:@miniAODValidation,DQM:@miniAODDQM --era Run2_2018 -n 100 --process PAT --conditions auto:phase1_2018_realistic --mc --scenario pp --eventcontent MINIAODSIM,DQM --datatier MINIAODSIM,DQMIO --procModifiers run2_miniAOD_UL_preSummer20 --no_exec --filein filelist:filelist --fileout file:step2.root import FWCore.ParameterSet.Config as cms -from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 +from Configuration.Eras.Era_Run2_2018_DRN_cff import Run2_2018_DRN from Configuration.ProcessModifiers.run2_miniAOD_UL_preSummer20_cff import run2_miniAOD_UL_preSummer20 from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton -process = cms.Process('PAT',Run2_2018,run2_miniAOD_UL_preSummer20, enableSonicTriton) +process = cms.Process('PAT',Run2_2018_DRN,run2_miniAOD_UL_preSummer20, enableSonicTriton) # import of standard configurations process.load('Configuration.StandardSequences.Services_cff') @@ -25,6 +25,7 @@ process.load('DQMServices.Core.DQMStoreNonLegacy_cff') process.load('DQMOffline.Configuration.DQMOfflineMC_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Configuration.ProcessModifiers.enableDRN_cff') process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100), @@ -241,9 +242,9 @@ process = customise_profile(process) -from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN +#from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN -process = enableDRN(process) +#process = enableDRN(process) process.TritonService.verbose = cms.untracked.bool(True) process.TritonService.fallback.verbose = cms.untracked.bool(True) From fe1ee8ed268b6e7df0bbb6f46435e55627da7e97 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 11:40:20 -0600 Subject: [PATCH 09/41] Revert "Not sure what's going on here tbh..." This reverts commit 5af31a1c3bb0a4bd3aa76fba870737fd0dba9ac7. --- .../PatAlgos/python/slimming/enableDRN.py | 5 +---- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 9 ++++----- 2 files changed, 5 insertions(+), 9 deletions(-) rename Configuration/ProcessModifiers/python/enableDRN_cff.py => PhysicsTools/PatAlgos/python/slimming/enableDRN.py (80%) diff --git a/Configuration/ProcessModifiers/python/enableDRN_cff.py b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py similarity index 80% rename from Configuration/ProcessModifiers/python/enableDRN_cff.py rename to PhysicsTools/PatAlgos/python/slimming/enableDRN.py index 6156bf6639a94..642e37262946b 100644 --- a/Configuration/ProcessModifiers/python/enableDRN_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py @@ -1,7 +1,7 @@ import FWCore.ParameterSet.Config as cms from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask -def _enableDRN(process): +def enableDRN(process): process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") process.DRNTask = cms.Task(process.patPhotonsDRN) process.schedule.associate(process.DRNTask) @@ -15,6 +15,3 @@ def _enableDRN(process): ) return process - -from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 -enableDRN = cms.ProcessModifier(Run2_2018, _enableDRN) diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py index 29f276b697470..5727c61874ca4 100644 --- a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py +++ b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py @@ -5,11 +5,11 @@ # with command line options: step2 -s PAT,VALIDATION:@miniAODValidation,DQM:@miniAODDQM --era Run2_2018 -n 100 --process PAT --conditions auto:phase1_2018_realistic --mc --scenario pp --eventcontent MINIAODSIM,DQM --datatier MINIAODSIM,DQMIO --procModifiers run2_miniAOD_UL_preSummer20 --no_exec --filein filelist:filelist --fileout file:step2.root import FWCore.ParameterSet.Config as cms -from Configuration.Eras.Era_Run2_2018_DRN_cff import Run2_2018_DRN +from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 from Configuration.ProcessModifiers.run2_miniAOD_UL_preSummer20_cff import run2_miniAOD_UL_preSummer20 from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton -process = cms.Process('PAT',Run2_2018_DRN,run2_miniAOD_UL_preSummer20, enableSonicTriton) +process = cms.Process('PAT',Run2_2018,run2_miniAOD_UL_preSummer20, enableSonicTriton) # import of standard configurations process.load('Configuration.StandardSequences.Services_cff') @@ -25,7 +25,6 @@ process.load('DQMServices.Core.DQMStoreNonLegacy_cff') process.load('DQMOffline.Configuration.DQMOfflineMC_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') -process.load('Configuration.ProcessModifiers.enableDRN_cff') process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100), @@ -242,9 +241,9 @@ process = customise_profile(process) -#from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN +from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN -#process = enableDRN(process) +process = enableDRN(process) process.TritonService.verbose = cms.untracked.bool(True) process.TritonService.fallback.verbose = cms.untracked.bool(True) From c65a63df30e406e7388b75c6d21acfeaaf54128c Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 11:40:54 -0600 Subject: [PATCH 10/41] Rename customisation function appropriately --- PhysicsTools/PatAlgos/python/slimming/enableDRN.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py index 642e37262946b..171f95618a765 100644 --- a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py +++ b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py @@ -1,7 +1,7 @@ import FWCore.ParameterSet.Config as cms from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask -def enableDRN(process): +def customise(process): process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") process.DRNTask = cms.Task(process.patPhotonsDRN) process.schedule.associate(process.DRNTask) From e36b1164b7650b8c713efc914527741cbcd15606 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 12:19:05 -0600 Subject: [PATCH 11/41] Updated test config to call correct customisation function name --- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py index 5727c61874ca4..b430c9e6bb425 100644 --- a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py +++ b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py @@ -237,13 +237,9 @@ #call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools process = miniAOD_customizeAllMC(process) -from Validation.Performance.TimeMemoryInfo import customise as customise_profile +from PhysicsTools.PatAlgos.slimming.enableDRN import customise -process = customise_profile(process) - -from PhysicsTools.PatAlgos.slimming.enableDRN import enableDRN - -process = enableDRN(process) +process = customise(process) process.TritonService.verbose = cms.untracked.bool(True) process.TritonService.fallback.verbose = cms.untracked.bool(True) From 26dfae646d7b6cb9261299bb75a5deec22d04101 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 7 Mar 2022 19:07:36 -0600 Subject: [PATCH 12/41] Fixed customisation function to be compatible with cmsDriver --- PhysicsTools/PatAlgos/python/slimming/enableDRN.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py index 171f95618a765..cb2557174fddb 100644 --- a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py +++ b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py @@ -1,11 +1,11 @@ import FWCore.ParameterSet.Config as cms -from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask +from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications def customise(process): process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") process.DRNTask = cms.Task(process.patPhotonsDRN) process.schedule.associate(process.DRNTask) - process.slimmedPhotons.modifierConfig.modifications.append( + egamma_modifications.append( cms.PSet( modifierName = cms.string("EGRegressionModifierDRN"), patPhotons = cms.PSet( source = cms.InputTag('selectedPatPhotons'), From 30e291eb94b84223f2e81a4485b40fb160e01019 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 9 Mar 2022 15:17:52 -0600 Subject: [PATCH 13/41] Almost working..... --- Configuration/PyReleaseValidation/README.md | 1 + .../PyReleaseValidation/python/relval_2017.py | 3 ++ .../python/upgradeWorkflowComponents.py | 30 +++++++++++++++++++ 3 files changed, 34 insertions(+) diff --git a/Configuration/PyReleaseValidation/README.md b/Configuration/PyReleaseValidation/README.md index 2d597155457e6..f6b3aa1a361aa 100644 --- a/Configuration/PyReleaseValidation/README.md +++ b/Configuration/PyReleaseValidation/README.md @@ -53,6 +53,7 @@ The offsets currently in use are: * 0.17: Run-3 deep core seeding for JetCore iteration * 0.21: Production-like sequence * 0.24: 0 Tesla (Run-2, Run-3) +* 0.31: Photon energy corrections with DRN architecture * 0.61: `phase2_ecal_devel` era * 0.91: Track DNN modifier * 0.97: Premixing stage1 diff --git a/Configuration/PyReleaseValidation/python/relval_2017.py b/Configuration/PyReleaseValidation/python/relval_2017.py index 1686cbef71e4e..8ed28d70e8909 100644 --- a/Configuration/PyReleaseValidation/python/relval_2017.py +++ b/Configuration/PyReleaseValidation/python/relval_2017.py @@ -47,12 +47,14 @@ 10024.1,10024.2,10024.3,10024.4,10024.5, #10224.15, 10801.0,10802.0,10803.0,10804.0,10805.0,10806.0,10807.0,10808.0,10809.0,10859.0,10871.0, + 10804.31, 10842.0,10824.0,10825.0,10826.0,10823.0,11024.0,11025.0,11224.0, 10824.1,10824.5, 10824.6,11024.6,11224.6, 10824.8, #11024.15, 10842.501,10842.505, + 10824.31, 10824.501,10824.505, 10824.511, 10824.521, @@ -67,6 +69,7 @@ 11634.521, 11634.24,11834.24, 11834.13, + 11834.31, 11834.21, 11723.17, 12434.0,12634.0,12634.99, diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index f079efe18c78a..1305c1d77cb17 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -490,6 +490,36 @@ def condition(self, fragment, stepList, key, hasHarvest): '--procModifiers': 'mlpf' } +# photonDRN workflows +class UpgradeWorkflow_photonDRN(UpgradeWorkflow): + def setup_(self, step, stepName, stepDict, k, properties): + #print(step, stepName, k) + if 'Reco' in step: + stepDict[stepName][k] = merge([self.step3, stepDict[step][k]]) + #print("\t",stepDict[stepName][k]) + def condition(self, fragment, stepList, key, hasHarvest): + #return '2018' in key + return True + +upgradeWFs['photonDRN'] = UpgradeWorkflow_photonDRN( + steps = [ + 'Reco', + 'RecoNano', + ], + PU = [ + 'Reco', + 'RecoNano', + ], + suffix = '_photonDRN', + offset = 0.31, +) +upgradeWFs['photonDRN'].step3 = { + #'--datatier': 'GEN-SIM-RECO,RECOSIM,MINIAODSIM,NANOAODSIM,DQMIO', + #'--eventcontent': 'FEVTDEBUGHLT,RECOSIM,MINIAODSIM,NANOEDMAODSIM,DQM', + '--procModifiers': 'enableSonicTriton', + '--customise' : 'PhysicsTools/PatAlgos/slimming/enableDRN' +} + # Patatrack workflows: # - 2018 conditions, TTbar # - 2018 conditions, Z->mumu, From 82ced8d5953c0aab4b43255e9c6f2351a010c606 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 10 Mar 2022 12:06:14 -0600 Subject: [PATCH 14/41] Kevin found the problem :D --- Configuration/PyReleaseValidation/python/relval_2017.py | 5 ++--- .../python/upgradeWorkflowComponents.py | 9 +++------ 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_2017.py b/Configuration/PyReleaseValidation/python/relval_2017.py index 8ed28d70e8909..0a6d5192ad573 100644 --- a/Configuration/PyReleaseValidation/python/relval_2017.py +++ b/Configuration/PyReleaseValidation/python/relval_2017.py @@ -18,6 +18,7 @@ # (TTbar trackingOnly, trackingRun2, trackingOnlyRun2, trackingLowPU, pixelTrackingOnly) # (TTbar PU with JME NanoAOD, disable for now due to Run-3 Nano-Prompt preparation) # 2018 (ele guns 10, 35, 1000; pho guns 10, 35; mu guns 1, 10, 100, 1000, QCD 3TeV, QCD Flat) +# (pho guns 10, 35 with photonDRN enabled) # 2018 (ZMM, TTbar, ZEE, MinBias, TTbar PU, ZEE PU, TTbar design) # (TTbar trackingOnly, pixelTrackingOnly) # (HE collapse: TTbar, TTbar PU, TTbar design) @@ -47,14 +48,13 @@ 10024.1,10024.2,10024.3,10024.4,10024.5, #10224.15, 10801.0,10802.0,10803.0,10804.0,10805.0,10806.0,10807.0,10808.0,10809.0,10859.0,10871.0, - 10804.31, + 10804.31, 10805.31, 10842.0,10824.0,10825.0,10826.0,10823.0,11024.0,11025.0,11224.0, 10824.1,10824.5, 10824.6,11024.6,11224.6, 10824.8, #11024.15, 10842.501,10842.505, - 10824.31, 10824.501,10824.505, 10824.511, 10824.521, @@ -69,7 +69,6 @@ 11634.521, 11634.24,11834.24, 11834.13, - 11834.31, 11834.21, 11723.17, 12434.0,12634.0,12634.99, diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 1305c1d77cb17..d3abfd6cd1010 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -493,29 +493,26 @@ def condition(self, fragment, stepList, key, hasHarvest): # photonDRN workflows class UpgradeWorkflow_photonDRN(UpgradeWorkflow): def setup_(self, step, stepName, stepDict, k, properties): - #print(step, stepName, k) if 'Reco' in step: stepDict[stepName][k] = merge([self.step3, stepDict[step][k]]) - #print("\t",stepDict[stepName][k]) def condition(self, fragment, stepList, key, hasHarvest): - #return '2018' in key - return True + return '2018' in key and "SingleGamma" in fragment upgradeWFs['photonDRN'] = UpgradeWorkflow_photonDRN( steps = [ 'Reco', 'RecoNano', + 'RecoFakeHLT' ], PU = [ 'Reco', 'RecoNano', + 'RecoFakeHLT' ], suffix = '_photonDRN', offset = 0.31, ) upgradeWFs['photonDRN'].step3 = { - #'--datatier': 'GEN-SIM-RECO,RECOSIM,MINIAODSIM,NANOAODSIM,DQMIO', - #'--eventcontent': 'FEVTDEBUGHLT,RECOSIM,MINIAODSIM,NANOEDMAODSIM,DQM', '--procModifiers': 'enableSonicTriton', '--customise' : 'PhysicsTools/PatAlgos/slimming/enableDRN' } From 2f80e2ffe7c5e8a63d4c3da78f909dce7d23a769 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Fri, 11 Mar 2022 10:08:10 -0600 Subject: [PATCH 15/41] Removed test --- PhysicsTools/PatAlgos/test/DRNtest_Hgg.py | 265 ---------------------- PhysicsTools/PatAlgos/test/runtests.sh | 2 - 2 files changed, 267 deletions(-) delete mode 100644 PhysicsTools/PatAlgos/test/DRNtest_Hgg.py diff --git a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py b/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py deleted file mode 100644 index b430c9e6bb425..0000000000000 --- a/PhysicsTools/PatAlgos/test/DRNtest_Hgg.py +++ /dev/null @@ -1,265 +0,0 @@ -# Auto generated configuration file -# using: -# Revision: 1.19 -# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v -# with command line options: step2 -s PAT,VALIDATION:@miniAODValidation,DQM:@miniAODDQM --era Run2_2018 -n 100 --process PAT --conditions auto:phase1_2018_realistic --mc --scenario pp --eventcontent MINIAODSIM,DQM --datatier MINIAODSIM,DQMIO --procModifiers run2_miniAOD_UL_preSummer20 --no_exec --filein filelist:filelist --fileout file:step2.root -import FWCore.ParameterSet.Config as cms - -from Configuration.Eras.Era_Run2_2018_cff import Run2_2018 -from Configuration.ProcessModifiers.run2_miniAOD_UL_preSummer20_cff import run2_miniAOD_UL_preSummer20 -from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton - -process = cms.Process('PAT',Run2_2018,run2_miniAOD_UL_preSummer20, enableSonicTriton) - -# import of standard configurations -process.load('Configuration.StandardSequences.Services_cff') -process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') -process.load('FWCore.MessageService.MessageLogger_cfi') -process.load('Configuration.EventContent.EventContent_cff') -process.load('SimGeneral.MixingModule.mixNoPU_cfi') -process.load('Configuration.StandardSequences.GeometryRecoDB_cff') -process.load('Configuration.StandardSequences.MagneticField_cff') -process.load('PhysicsTools.PatAlgos.slimming.metFilterPaths_cff') -process.load('Configuration.StandardSequences.PATMC_cff') -process.load('Configuration.StandardSequences.Validation_cff') -process.load('DQMServices.Core.DQMStoreNonLegacy_cff') -process.load('DQMOffline.Configuration.DQMOfflineMC_cff') -process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') - -process.maxEvents = cms.untracked.PSet( - input = cms.untracked.int32(100), - output = cms.optional.untracked.allowed(cms.int32,cms.PSet) -) - -# Input source -process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring( - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/0E6A5074-CE54-1C43-800F-6C4098689AD7.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/114188AD-C8BB-6842-B6B0-9B1042FD50AF.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/17BF73EE-8540-2E42-947E-9D5BEAE43845.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/1CE3CCAA-1669-064C-9E21-4158015D9352.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/2F141512-8811-2A4F-A0E5-BCCF42362BFF.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/392B7A19-1CF0-3141-B378-94D0A8D404E8.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/403F943F-062E-9441-82C5-E07CEC67A124.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/4CBBC908-50D3-804D-B126-C7AD19B1A3B1.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/57BB7A15-4B78-BA47-994F-B5901F0640F3.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/596B83A5-BDFE-0949-9F3C-2FA37812C8E2.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/7514C486-0907-124D-A993-A13A73662A9C.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/78863F64-B399-2F4B-A3EC-EE2E3E1E9D69.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/7C2D71F5-2304-B04A-920C-87102641EBB3.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/80C21552-D786-3844-BB43-4AD278276FAB.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/87242A4D-9A5A-3D45-A4DF-DF03CAC4F929.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/89695229-EDD9-4447-A607-5B2584310A28.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/8BAE8CEB-DF6B-4246-8F6D-ACB9417AD8B7.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/C72609A4-232D-F144-9B19-928EB086E69E.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/D13CFD8B-77DE-7344-8C13-E3D165877719.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/D521DEDC-8F7A-9D46-9B54-BBE8127C1F51.root', - '/store/mc/RunIISummer20UL18RECO/GluGluHToGG_M100_TuneCP5_13TeV-amcatnloFXFX-pythia8/AODSIM/106X_upgrade2018_realistic_v11_L1v1-v1/2540000/FE03E4BF-8C4D-A345-8077-2F246E02B3F1.root' - ), - secondaryFileNames = cms.untracked.vstring() -) - -process.options = cms.untracked.PSet( - FailPath = cms.untracked.vstring(), - IgnoreCompletely = cms.untracked.vstring(), - Rethrow = cms.untracked.vstring(), - SkipEvent = cms.untracked.vstring(), - allowUnscheduled = cms.obsolete.untracked.bool, - canDeleteEarly = cms.untracked.vstring(), - deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), - dumpOptions = cms.untracked.bool(False), - emptyRunLumiMode = cms.obsolete.untracked.string, - eventSetup = cms.untracked.PSet( - forceNumberOfConcurrentIOVs = cms.untracked.PSet( - allowAnyLabel_=cms.required.untracked.uint32 - ), - numberOfConcurrentIOVs = cms.untracked.uint32(0) - ), - fileMode = cms.untracked.string('FULLMERGE'), - forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), - makeTriggerResults = cms.obsolete.untracked.bool, - numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), - numberOfConcurrentRuns = cms.untracked.uint32(1), - numberOfStreams = cms.untracked.uint32(0), - numberOfThreads = cms.untracked.uint32(1), - printDependencies = cms.untracked.bool(False), - sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, - throwIfIllegalParameter = cms.untracked.bool(True), - wantSummary = cms.untracked.bool(False) -) - -# Production Info -process.configurationMetadata = cms.untracked.PSet( - annotation = cms.untracked.string('step2 nevts:100'), - name = cms.untracked.string('Applications'), - version = cms.untracked.string('$Revision: 1.19 $') -) - -# Output definition - -process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", - compressionAlgorithm = cms.untracked.string('LZMA'), - compressionLevel = cms.untracked.int32(4), - dataset = cms.untracked.PSet( - dataTier = cms.untracked.string('MINIAODSIM'), - filterName = cms.untracked.string('') - ), - dropMetaData = cms.untracked.string('ALL'), - eventAutoFlushCompressedSize = cms.untracked.int32(-900), - fastCloning = cms.untracked.bool(False), - fileName = cms.untracked.string('file:miniAOD_DRN_Hgg.root'), - outputCommands = process.MINIAODSIMEventContent.outputCommands, - overrideBranchesSplitLevel = cms.untracked.VPSet( - cms.untracked.PSet( - branch = cms.untracked.string('patPackedCandidates_packedPFCandidates__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoGenParticles_prunedGenParticles__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patTriggerObjectStandAlones_slimmedPatTrigger__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patPackedGenParticles_packedGenParticles__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patJets_slimmedJets__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVertices__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoVertexs_offlineSlimmedPrimaryVerticesWithBS__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoCaloClusters_reducedEgamma_reducedESClusters_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEBRecHits_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedEERecHits_*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('recoGenJets_slimmedGenJets__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('patJets_slimmedJetsPuppi__*'), - splitLevel = cms.untracked.int32(99) - ), - cms.untracked.PSet( - branch = cms.untracked.string('EcalRecHitsSorted_reducedEgamma_reducedESRecHits_*'), - splitLevel = cms.untracked.int32(99) - ) - ), - overrideInputFileSplitLevels = cms.untracked.bool(True), - splitLevel = cms.untracked.int32(0) -) - -process.DQMoutput = cms.OutputModule("DQMRootOutputModule", - dataset = cms.untracked.PSet( - dataTier = cms.untracked.string('DQMIO'), - filterName = cms.untracked.string('') - ), - fileName = cms.untracked.string('file:step2_inDQM.root'), - outputCommands = process.DQMEventContent.outputCommands, - splitLevel = cms.untracked.int32(0) -) - -# Additional output definition - - - -# Other statements -from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '') - -# Path and EndPath definitions -process.Flag_BadChargedCandidateFilter = cms.Path(process.BadChargedCandidateFilter) -process.Flag_BadChargedCandidateSummer16Filter = cms.Path(process.BadChargedCandidateSummer16Filter) -process.Flag_BadPFMuonDzFilter = cms.Path(process.BadPFMuonDzFilter) -process.Flag_BadPFMuonFilter = cms.Path(process.BadPFMuonFilter) -process.Flag_BadPFMuonSummer16Filter = cms.Path(process.BadPFMuonSummer16Filter) -process.Flag_CSCTightHalo2015Filter = cms.Path(process.CSCTightHalo2015Filter) -process.Flag_CSCTightHaloFilter = cms.Path(process.CSCTightHaloFilter) -process.Flag_CSCTightHaloTrkMuUnvetoFilter = cms.Path(process.CSCTightHaloTrkMuUnvetoFilter) -process.Flag_EcalDeadCellBoundaryEnergyFilter = cms.Path(process.EcalDeadCellBoundaryEnergyFilter) -process.Flag_EcalDeadCellTriggerPrimitiveFilter = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) -process.Flag_HBHENoiseFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseFilter) -process.Flag_HBHENoiseIsoFilter = cms.Path(process.HBHENoiseFilterResultProducer+process.HBHENoiseIsoFilter) -process.Flag_HcalStripHaloFilter = cms.Path(process.HcalStripHaloFilter) -process.Flag_METFilters = cms.Path(process.metFilters) -process.Flag_chargedHadronTrackResolutionFilter = cms.Path(process.chargedHadronTrackResolutionFilter) -process.Flag_ecalBadCalibFilter = cms.Path(process.ecalBadCalibFilter) -process.Flag_ecalLaserCorrFilter = cms.Path(process.ecalLaserCorrFilter) -process.Flag_eeBadScFilter = cms.Path(process.eeBadScFilter) -process.Flag_globalSuperTightHalo2016Filter = cms.Path(process.globalSuperTightHalo2016Filter) -process.Flag_globalTightHalo2016Filter = cms.Path(process.globalTightHalo2016Filter) -process.Flag_goodVertices = cms.Path(process.primaryVertexFilter) -process.Flag_hcalLaserEventFilter = cms.Path(process.hcalLaserEventFilter) -process.Flag_hfNoisyHitsFilter = cms.Path(process.hfNoisyHitsFilter) -process.Flag_muonBadTrackFilter = cms.Path(process.muonBadTrackFilter) -process.Flag_trackingFailureFilter = cms.Path(process.goodVertices+process.trackingFailureFilter) -process.Flag_trkPOGFilters = cms.Path(process.trkPOGFilters) -process.Flag_trkPOG_logErrorTooManyClusters = cms.Path(~process.logErrorTooManyClusters) -process.Flag_trkPOG_manystripclus53X = cms.Path(~process.manystripclus53X) -process.Flag_trkPOG_toomanystripclus53X = cms.Path(~process.toomanystripclus53X) -process.prevalidation_step = cms.Path(process.prevalidationMiniAOD) -process.validation_step = cms.EndPath(process.validationMiniAOD) -process.dqmoffline_step = cms.EndPath(process.DQMOfflineMiniAOD) -process.dqmofflineOnPAT_step = cms.EndPath(process.PostDQMOfflineMiniAOD) -process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) -process.DQMoutput_step = cms.EndPath(process.DQMoutput) - -# Schedule definition -process.schedule = cms.Schedule(process.Flag_HBHENoiseFilter,process.Flag_HBHENoiseIsoFilter,process.Flag_CSCTightHaloFilter,process.Flag_CSCTightHaloTrkMuUnvetoFilter,process.Flag_CSCTightHalo2015Filter,process.Flag_globalTightHalo2016Filter,process.Flag_globalSuperTightHalo2016Filter,process.Flag_HcalStripHaloFilter,process.Flag_hcalLaserEventFilter,process.Flag_EcalDeadCellTriggerPrimitiveFilter,process.Flag_EcalDeadCellBoundaryEnergyFilter,process.Flag_ecalBadCalibFilter,process.Flag_goodVertices,process.Flag_eeBadScFilter,process.Flag_ecalLaserCorrFilter,process.Flag_trkPOGFilters,process.Flag_chargedHadronTrackResolutionFilter,process.Flag_muonBadTrackFilter,process.Flag_BadChargedCandidateFilter,process.Flag_BadPFMuonFilter,process.Flag_BadPFMuonDzFilter,process.Flag_hfNoisyHitsFilter,process.Flag_BadChargedCandidateSummer16Filter,process.Flag_BadPFMuonSummer16Filter,process.Flag_trkPOG_manystripclus53X,process.Flag_trkPOG_toomanystripclus53X,process.Flag_trkPOG_logErrorTooManyClusters,process.Flag_METFilters,process.prevalidation_step,process.validation_step,process.dqmoffline_step,process.dqmofflineOnPAT_step,process.MINIAODSIMoutput_step,process.DQMoutput_step) -process.schedule.associate(process.patTask) -from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask -associatePatAlgosToolsTask(process) - - -# customisation of the process. - -# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools -from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC - -#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools -process = miniAOD_customizeAllMC(process) - -from PhysicsTools.PatAlgos.slimming.enableDRN import customise - -process = customise(process) - -process.TritonService.verbose = cms.untracked.bool(True) -process.TritonService.fallback.verbose = cms.untracked.bool(True) - -keepMsgs = ['TritonClient', 'TritonService', 'DRNCorrectionProducerT', 'DRNCorrectionProducerT:TritonClient'] -for msg in keepMsgs: - setattr(process.MessageLogger.cerr, msg, - cms.untracked.PSet( - limit = cms.untracked.int32(100000000), - ) - ) - -# End of customisation functions - -# Customisation from command line - -# Add early deletion of temporary data products to reduce peak memory need -from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete -process = customiseEarlyDelete(process) -from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton - -# End adding early deletion - diff --git a/PhysicsTools/PatAlgos/test/runtests.sh b/PhysicsTools/PatAlgos/test/runtests.sh index d9237478dfc81..a627636c7dc70 100755 --- a/PhysicsTools/PatAlgos/test/runtests.sh +++ b/PhysicsTools/PatAlgos/test/runtests.sh @@ -53,5 +53,3 @@ cmsRun ${LOCAL_TEST_DIR}/patTuple_updateJets_fromMiniAOD_cfg.py || die 'Failure # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyMuons_cfg.py || die 'Failure using patTuple_onlyMuons_cfg.py' $? # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyPhotons_cfg.py || die 'Failure using patTuple_onlyPhotons_cfg.py' $? # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyTaus_cfg.py || die 'Failure using patTuple_onlyTaus_cfg.py' $? - -cmsRun ${LOCAL_TEST_DIR}/DRNTest_cfg.py || die "Failure using DRNtest" $? From d357aa70d4f5234bfe8b687394f30b746a7cf9f3 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:21:01 -0500 Subject: [PATCH 16/41] UserFloat functionality --- .../plugins/EGRegressionModifierDRN.cc | 87 ++++++++++--------- 1 file changed, 44 insertions(+), 43 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index 709ee89ad3de3..6abecfba95eef 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -44,21 +44,6 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { public: - struct EleRegs { - EleRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc); - void setEventContent(const edm::EventSetup& iSetup); - EgammaRegressionContainer ecalOnlyMean; - EgammaRegressionContainer ecalOnlySigma; - EpCombinationTool epComb; - }; - - struct PhoRegs { - PhoRegs(const edm::ParameterSet& iConfig, edm::ConsumesCollector& cc); - void setEventContent(const edm::EventSetup& iSetup); - EgammaRegressionContainer ecalOnlyMean; - EgammaRegressionContainer ecalOnlySigma; - }; - EGRegressionModifierDRN(const edm::ParameterSet& conf, edm::ConsumesCollector& cc); ~EGRegressionModifierDRN() override; @@ -83,15 +68,31 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { edm::EDGetTokenT>> correctionsToken; edm::ValueMap> corrections; + bool userFloat; + std::string energyFloat, resFloat; + partVars(const edm::ParameterSet& config, edm::ConsumesCollector& cc) { source = config.getParameter("source"); token = cc.consumes(source); correctionsSource = config.getParameter("correctionsSource"); correctionsToken = cc.consumes(correctionsSource); + + if(config.exists("energyFloat")){ + userFloat=true; + energyFloat = config.getParameter("energyFloat"); + resFloat = config.getParameter("resFloat"); + } else{ + userFloat=false; + } } const std::pair getCorrection(T& part) const; + + const bool doUserFloat(T& part, std::pair& correction) const{ + part.addUserFloat(energyFloat, correction.first); + part.addUserFloat(resFloat, correction.second); + } }; std::unique_ptr> patPhotons_; @@ -151,20 +152,17 @@ void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { const std::pair& correction = gsfElectrons_->getCorrection(ele); - if (correction.first <= 0) - return; - - ele.setCorrectedEcalEnergy(correction.first, true); - ele.setCorrectedEcalEnergyError(correction.second); + if (gsfElectrons_.userFloat){ + gsfElectrons_.doUserFloat(ele, correction); + } else if (correction.first > 0 && correction.second > 0) { + ele.setCorrectedEcalEnergy(correction.first, true); + ele.setCorrectedEcalEnergyError(correction.second); + } throw cms::Exception("EGRegressionModifierDRN") << "Electron energy corrections not fully implemented yet:" << std::endl << "Still need E/p combination" << std::endl << "Do not enable DRN for electrons" << std::endl; - - const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination - const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); - ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); } void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { @@ -173,31 +171,31 @@ void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { const std::pair& correction = patElectrons_->getCorrection(ele); - if (correction.first <= 0) - return; - - ele.setCorrectedEcalEnergy(correction.first, true); - ele.setCorrectedEcalEnergyError(correction.second); + if(patElectrons_.userFloat){ + patElectrons_.doUserFloat(ele, correction); + } else if (correction.first > 0 && correction.second > 0) { + ele.setCorrectedEcalEnergy(correction.first, true); + ele.setCorrectedEcalEnergyError(correction.second); + } throw cms::Exception("EGRegressionModifierDRN") << "Electron energy corrections not fully implemented yet:" << std::endl << "Still need E/p combination" << std::endl << "Do not enable DRN for electrons" << std::endl; - - const std::pair trackerCombo(1.0, 1.0); //TODO: compute E/p combination - const math::XYZTLorentzVector newP4 = ele.p4() * trackerCombo.first / ele.p4().t(); - ele.correctMomentum(newP4, ele.trackMomentumError(), trackerCombo.second); } void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { if (!patPhotons_) return; - const std::pair& correction = patPhotons_->getCorrection(pho); - if (correction.first <= 0) - return; + const std::pair& correction = patPhotons_->getCorrection(pho); - pho.setCorrectedEnergy(pat::Photon::P4type::regression2, correction.first, correction.second, true); + if(patPhotons_.userFloat){ + patPhotons_.doUserFloat(pho, correction); + } else if (correction.first > 0 && correction.second > 0) { + pho.setCorrectedEnergy(pat::Photon::P4type::regression2, + correction.first, correction.second, true); + } } void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { @@ -206,10 +204,12 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { const std::pair& correction = gedPhotons_->getCorrection(pho); - if (correction.first <= 0) - return; - - pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); + if(patPhotons_.userFloat){ + patPhotons_.doUserFloat(pho, correction); + } else if (correction.first > 0 && correction.second > 0) { + pho.setCorrectedEnergy(reco::Photon::P4type::regression2, + correction.first, correction.second, true); + } }; template @@ -228,8 +228,9 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio } if (!matched) { - throw cms::Exception("EGRegressionModifierDRN") << "Matching failed in EGRegressionModifierDRN" << std::endl - << "This should not have been possible" << std::endl; + throw cms::Exception("EGRegressionModifierDRN") + << "Matching failed in EGRegressionModifierDRN" << std::endl + << "This should not have been possible" << std::endl; return std::pair(-1., -1.); } From 9556a83fb32abe62e64a51d96ed670811d4043f7 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:33:41 -0500 Subject: [PATCH 17/41] Fixed fatal typos --- .../EgammaTools/plugins/EGRegressionModifierDRN.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index 6abecfba95eef..ff48f0be3f3cc 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -89,7 +89,7 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { const std::pair getCorrection(T& part) const; - const bool doUserFloat(T& part, std::pair& correction) const{ + const void doUserFloat(T& part, std::pair& correction) const{ part.addUserFloat(energyFloat, correction.first); part.addUserFloat(resFloat, correction.second); } @@ -152,7 +152,7 @@ void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { const std::pair& correction = gsfElectrons_->getCorrection(ele); - if (gsfElectrons_.userFloat){ + if (gsfElectrons_->userFloat){ gsfElectrons_.doUserFloat(ele, correction); } else if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); @@ -171,7 +171,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { const std::pair& correction = patElectrons_->getCorrection(ele); - if(patElectrons_.userFloat){ + if(patElectrons_->userFloat){ patElectrons_.doUserFloat(ele, correction); } else if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); @@ -190,7 +190,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { const std::pair& correction = patPhotons_->getCorrection(pho); - if(patPhotons_.userFloat){ + if(patPhotons_->userFloat){ patPhotons_.doUserFloat(pho, correction); } else if (correction.first > 0 && correction.second > 0) { pho.setCorrectedEnergy(pat::Photon::P4type::regression2, @@ -204,7 +204,7 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { const std::pair& correction = gedPhotons_->getCorrection(pho); - if(patPhotons_.userFloat){ + if(patPhotons_->userFloat){ patPhotons_.doUserFloat(pho, correction); } else if (correction.first > 0 && correction.second > 0) { pho.setCorrectedEnergy(reco::Photon::P4type::regression2, From 2637202f0f29759b2d77084d439ad4bcfb807609 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:37:52 -0500 Subject: [PATCH 18/41] No reason to touch runtests.sh --- .../PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py | 1 - .../PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py | 1 - PhysicsTools/PatAlgos/test/runtests.sh | 1 + 3 files changed, 1 insertion(+), 2 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py index 0a7e5ee2e4572..8f434ca4272c2 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py @@ -14,6 +14,5 @@ allowedTries = cms.untracked.uint32(1), timeout = cms.untracked.uint32(10), useSharedMemory = cms.untracked.bool(False), - verbose = cms.untracked.bool(True) ) ) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index 44eb0666e3d47..2e1642a1c97f4 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -14,6 +14,5 @@ allowedTries = cms.untracked.uint32(1), timeout = cms.untracked.uint32(10), useSharedMemory = cms.untracked.bool(False), - verbose = cms.untracked.bool(True) ) ) diff --git a/PhysicsTools/PatAlgos/test/runtests.sh b/PhysicsTools/PatAlgos/test/runtests.sh index a627636c7dc70..f523398861327 100755 --- a/PhysicsTools/PatAlgos/test/runtests.sh +++ b/PhysicsTools/PatAlgos/test/runtests.sh @@ -53,3 +53,4 @@ cmsRun ${LOCAL_TEST_DIR}/patTuple_updateJets_fromMiniAOD_cfg.py || die 'Failure # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyMuons_cfg.py || die 'Failure using patTuple_onlyMuons_cfg.py' $? # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyPhotons_cfg.py || die 'Failure using patTuple_onlyPhotons_cfg.py' $? # cmsRun ${LOCAL_TEST_DIR}/patTuple_onlyTaus_cfg.py || die 'Failure using patTuple_onlyTaus_cfg.py' $? + From 1a5de2f9cac094f7da530d497b0dcc88cda9ac0c Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:41:01 -0500 Subject: [PATCH 19/41] Pointers.. --- RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index ff48f0be3f3cc..63b0c1b350d7d 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -153,7 +153,7 @@ void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { const std::pair& correction = gsfElectrons_->getCorrection(ele); if (gsfElectrons_->userFloat){ - gsfElectrons_.doUserFloat(ele, correction); + gsfElectrons_->doUserFloat(ele, correction); } else if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); ele.setCorrectedEcalEnergyError(correction.second); @@ -172,7 +172,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { const std::pair& correction = patElectrons_->getCorrection(ele); if(patElectrons_->userFloat){ - patElectrons_.doUserFloat(ele, correction); + patElectrons_->doUserFloat(ele, correction); } else if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); ele.setCorrectedEcalEnergyError(correction.second); @@ -191,7 +191,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { const std::pair& correction = patPhotons_->getCorrection(pho); if(patPhotons_->userFloat){ - patPhotons_.doUserFloat(pho, correction); + patPhotons_->doUserFloat(pho, correction); } else if (correction.first > 0 && correction.second > 0) { pho.setCorrectedEnergy(pat::Photon::P4type::regression2, correction.first, correction.second, true); @@ -205,7 +205,7 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { const std::pair& correction = gedPhotons_->getCorrection(pho); if(patPhotons_->userFloat){ - patPhotons_.doUserFloat(pho, correction); + patPhotons_->doUserFloat(pho, correction); } else if (correction.first > 0 && correction.second > 0) { pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); From f994140284748782131a57c378190c4fdb6fc2d8 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:49:07 -0500 Subject: [PATCH 20/41] Clean up DRNCorrectionProducerT --- .../plugins/DRNCorrectionProducerT.cc | 48 +++++++------------ .../plugins/EGRegressionModifierDRN.cc | 2 - 2 files changed, 16 insertions(+), 34 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 72440f832caf0..a2e10fcd86076 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -7,12 +7,8 @@ #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" - #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/Exception.h" - #include "DataFormats/PatCandidates/interface/Photon.h" #include "DataFormats/PatCandidates/interface/Electron.h" #include "DataFormats/EgammaCandidates/interface/Photon.h" @@ -44,12 +40,7 @@ #include "RecoEcal/EgammaCoreTools/interface/PositionCalc.h" -#include -#include -#include -#include - -#include +#include /* * DRNCorrectionProducerT @@ -63,20 +54,20 @@ */ namespace { - float sigmoid(float x) { return 1.0f / (1.0f + exp(-x)); } + float sigmoid(float x) { return 1.0f / (1.0f + std::expf(-x)); } float logcorrection(float x) { - static float ln2 = log(2); + static float ln2 = std::logf(2); return ln2 * 2 * (sigmoid(x) - 0.5); } //correction factor is transformed by sigmoid and "logratioflip target" - float correction(float x) { return exp(-logcorrection(x)); } + float correction(float x) { return std::expf(-logcorrection(x)); } inline float rescale(float x, float min, float range) { return (x - min) / range; } //resolution is transformed by softplus function - float resolution(float x) { return log(1 + exp(x)); } + float resolution(float x) { return log(1 + std::expf(x)); } const float RHO_MIN = 0.0f; const float RHO_RANGE = 13.0f; @@ -112,14 +103,10 @@ class DRNCorrectionProducerT : public TritonEDProducer<> { void produce(edm::Event& iEvent, const edm::EventSetup& iSetup, Output const& iOutput) override; private: - const edm::InputTag particleSource_; edm::EDGetTokenT> particleToken_; - edm::Handle> particles_; - const edm::InputTag rhoName_; edm::EDGetTokenT rhoToken_; - edm::InputTag EBRecHitsName_, EERecHitsName_, ESRecHitsName_; edm::EDGetTokenT EBRecHitsToken_, EERecHitsToken_, ESRecHitsToken_; edm::ESGetToken pedToken_; @@ -135,16 +122,14 @@ class DRNCorrectionProducerT : public TritonEDProducer<> { template DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConfig) : TritonEDProducer<>(iConfig), - particleSource_{iConfig.getParameter("particleSource")}, - particleToken_(consumes(particleSource_)), - rhoName_{iConfig.getParameter("rhoName")}, - rhoToken_(consumes(rhoName_)), - EBRecHitsName_{iConfig.getParameter("reducedEcalRecHitsEB")}, - EERecHitsName_{iConfig.getParameter("reducedEcalRecHitsEE")}, - ESRecHitsName_{iConfig.getParameter("reducedEcalRecHitsES")}, - EBRecHitsToken_(consumes(EBRecHitsName_)), - EERecHitsToken_(consumes(EERecHitsName_)), - ESRecHitsToken_(consumes(ESRecHitsName_)), + particleToken_(consumes(iConfig.getParameter("particleSource"))), + rhoToken_(consumes(iConfig.getParameter("rhoName"))), + EBRecHitsToken_(consumes( + iConfig.getParameter("reducedEcalRecHitsEB"))), + EERecHitsToken_(consumes( + iConfig.getParameter("reducedEcalRecHitsEE"))), + ESRecHitsToken_(consumes( + iConfig.getParameter("reducedEcalRecHitsES"))), pedToken_(esConsumes()), geomToken_(esConsumes()) { produces>>(); @@ -175,7 +160,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu /* * Get products from event and event setup */ - particles_ = iEvent.getHandle(particleToken_); + const auto& particles_ = iEvent.getHandle(particleToken_); float rho = iEvent.get(rhoToken_); edm::Handle EBRecHits = iEvent.getHandle(EBRecHitsToken_); edm::Handle EERecHits = iEvent.getHandle(EERecHitsToken_); @@ -384,7 +369,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu template void DRNCorrectionProducerT::produce(edm::Event& iEvent, const edm::EventSetup& iSetup, Output const& iOutput) { - particles_ = iEvent.getHandle(particleToken_); + const auto& particles_ = iEvent.getHandle(particleToken_); std::vector> corrections; corrections.reserve(nPart_); @@ -404,7 +389,7 @@ void DRNCorrectionProducerT::produce(edm::Event& iEvent, const edm::EventSetu sigma = resolution(sigmaOut[0][0 + 5 * i]); ++i; - rawE = particles_->at(iPart).superCluster()->rawEnergy(); + rawE = part.superCluster()->rawEnergy(); Epred = mu * rawE; sigmaPred = sigma * rawE; corrections.emplace_back(Epred, sigmaPred); @@ -440,7 +425,6 @@ using GedPhotonDRNCorrectionProducer = DRNCorrectionProducerT; using GsfElectronDRNCorrectionProducer = DRNCorrectionProducerT; using PatElectronDRNCorrectionProducer = DRNCorrectionProducerT; -//DEFINE_FWK_MODULE(DRNCorrectionProducerT); DEFINE_FWK_MODULE(PatPhotonDRNCorrectionProducer); DEFINE_FWK_MODULE(GedPhotonDRNCorrectionProducer); DEFINE_FWK_MODULE(GsfElectronDRNCorrectionProducer); diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index 63b0c1b350d7d..f1261c52723ab 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -28,8 +28,6 @@ #include "Geometry/Records/interface/CaloGeometryRecord.h" #include "Geometry/CaloGeometry/interface/CaloGeometry.h" -#include - /* * EGRegressionModifierDRN * From e5db2aca2105beaf9e0cc0653bbc06854c232810 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 09:57:31 -0500 Subject: [PATCH 21/41] Error fixing... --- .../plugins/DRNCorrectionProducerT.cc | 10 +++++----- .../plugins/EGRegressionModifierDRN.cc | 18 ++++++------------ 2 files changed, 11 insertions(+), 17 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index a2e10fcd86076..14750cdb7a8c4 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -40,7 +40,7 @@ #include "RecoEcal/EgammaCoreTools/interface/PositionCalc.h" -#include +#include /* * DRNCorrectionProducerT @@ -54,20 +54,20 @@ */ namespace { - float sigmoid(float x) { return 1.0f / (1.0f + std::expf(-x)); } + float sigmoid(float x) { return 1.0f / (1.0f + std::exp(-x)); } float logcorrection(float x) { - static float ln2 = std::logf(2); + static float ln2 = std::log(2); return ln2 * 2 * (sigmoid(x) - 0.5); } //correction factor is transformed by sigmoid and "logratioflip target" - float correction(float x) { return std::expf(-logcorrection(x)); } + float correction(float x) { return std::exp(-logcorrection(x)); } inline float rescale(float x, float min, float range) { return (x - min) / range; } //resolution is transformed by softplus function - float resolution(float x) { return log(1 + std::expf(x)); } + float resolution(float x) { return std::log(1 + std::exp(x)); } const float RHO_MIN = 0.0f; const float RHO_RANGE = 13.0f; diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index f1261c52723ab..a993a886457be 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -9,8 +9,6 @@ #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" - #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "DataFormats/Common/interface/ValueMap.h" @@ -43,7 +41,6 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { public: EGRegressionModifierDRN(const edm::ParameterSet& conf, edm::ConsumesCollector& cc); - ~EGRegressionModifierDRN() override; void setEvent(const edm::Event&) final; void setEventContent(const edm::EventSetup&) final; @@ -55,16 +52,15 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { void modifyObject(pat::Photon&) const final; private: - //edm::Event event_; template struct partVars { edm::InputTag source; edm::EDGetTokenT> token; - edm::View particles; + const edm::View* particles; edm::InputTag correctionsSource; edm::EDGetTokenT>> correctionsToken; - edm::ValueMap> corrections; + const edm::ValueMap>* corrections; bool userFloat; std::string energyFloat, resFloat; @@ -87,7 +83,7 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { const std::pair getCorrection(T& part) const; - const void doUserFloat(T& part, std::pair& correction) const{ + const void doUserFloat(T& part, const std::pair& correction) const{ part.addUserFloat(energyFloat, correction.first); part.addUserFloat(resFloat, correction.second); } @@ -118,8 +114,6 @@ EGRegressionModifierDRN::EGRegressionModifierDRN(const edm::ParameterSet& conf, } } -EGRegressionModifierDRN::~EGRegressionModifierDRN() {} - void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { if (patElectrons_) { patElectrons_->particles = evt.get(patElectrons_->token); @@ -216,8 +210,8 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio bool matched = false; unsigned i; - for (i = 0; i < particles.size(); ++i) { - const T& partIter = particles.at(i); + for (i = 0; i < particles->size(); ++i) { + const T& partIter = particles->at(i); const auto& p4Iter = partIter.p4(); if (p4Iter == partP4) { matched = true; @@ -234,7 +228,7 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio edm::Ptr ptr = particles.ptrAt(i); - std::pair correction = corrections[ptr]; + std::pair correction = (*corrections)[ptr]; return correction; } From ec15ac71286ad6fb22facd8f8b8fbbad9a22005b Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 10:11:28 -0500 Subject: [PATCH 22/41] Should compile now --- .../plugins/DRNCorrectionProducerT.cc | 2 +- .../plugins/EGRegressionModifierDRN.cc | 26 ++++++++----------- 2 files changed, 12 insertions(+), 16 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 14750cdb7a8c4..d32c0332594c9 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -40,7 +40,7 @@ #include "RecoEcal/EgammaCoreTools/interface/PositionCalc.h" -#include +#include /* * DRNCorrectionProducerT diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index a993a886457be..d84fb9afe12d3 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -116,23 +116,23 @@ EGRegressionModifierDRN::EGRegressionModifierDRN(const edm::ParameterSet& conf, void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { if (patElectrons_) { - patElectrons_->particles = evt.get(patElectrons_->token); - patElectrons_->corrections = evt.get(patElectrons_->correctionsToken); + patElectrons_->particles = &evt.get(patElectrons_->token); + patElectrons_->corrections = &evt.get(patElectrons_->correctionsToken); } if (patPhotons_) { - patPhotons_->particles = evt.get(patPhotons_->token); - patPhotons_->corrections = evt.get(patPhotons_->correctionsToken); + patPhotons_->particles = &evt.get(patPhotons_->token); + patPhotons_->corrections = &evt.get(patPhotons_->correctionsToken); } if (gsfElectrons_) { - gsfElectrons_->particles = evt.get(gsfElectrons_->token); - gsfElectrons_->corrections = evt.get(gsfElectrons_->correctionsToken); + gsfElectrons_->particles = &evt.get(gsfElectrons_->token); + gsfElectrons_->corrections = &evt.get(gsfElectrons_->correctionsToken); } if (gedPhotons_) { - gedPhotons_->particles = evt.get(gedPhotons_->token); - gedPhotons_->corrections = evt.get(gedPhotons_->correctionsToken); + gedPhotons_->particles = &evt.get(gedPhotons_->token); + gedPhotons_->corrections = &evt.get(gedPhotons_->correctionsToken); } } @@ -144,9 +144,7 @@ void EGRegressionModifierDRN::modifyObject(reco::GsfElectron& ele) const { const std::pair& correction = gsfElectrons_->getCorrection(ele); - if (gsfElectrons_->userFloat){ - gsfElectrons_->doUserFloat(ele, correction); - } else if (correction.first > 0 && correction.second > 0) { + if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); ele.setCorrectedEcalEnergyError(correction.second); } @@ -196,9 +194,7 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { const std::pair& correction = gedPhotons_->getCorrection(pho); - if(patPhotons_->userFloat){ - patPhotons_->doUserFloat(pho, correction); - } else if (correction.first > 0 && correction.second > 0) { + if (correction.first > 0 && correction.second > 0) { pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); } @@ -226,7 +222,7 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio return std::pair(-1., -1.); } - edm::Ptr ptr = particles.ptrAt(i); + edm::Ptr ptr = particles->ptrAt(i); std::pair correction = (*corrections)[ptr]; From cc93d6596d8cc4d4a8545e410c708ce3248e98fb Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 10:53:14 -0500 Subject: [PATCH 23/41] empty commit to get cms bot to rerun code checks --- RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index d84fb9afe12d3..dfa10d8aeb486 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -230,3 +230,4 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio } DEFINE_EDM_PLUGIN(ModifyObjectValueFactory, EGRegressionModifierDRN, "EGRegressionModifierDRN"); + From c3927d08786e3b6d21c55daaff6c4091994c9ff6 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 16 Mar 2022 11:14:52 -0500 Subject: [PATCH 24/41] Code-format --- .../plugins/DRNCorrectionProducerT.cc | 9 +++---- .../plugins/EGRegressionModifierDRN.cc | 26 ++++++++----------- 2 files changed, 14 insertions(+), 21 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index d32c0332594c9..42913850d1197 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -124,12 +124,9 @@ DRNCorrectionProducerT::DRNCorrectionProducerT(const edm::ParameterSet& iConf : TritonEDProducer<>(iConfig), particleToken_(consumes(iConfig.getParameter("particleSource"))), rhoToken_(consumes(iConfig.getParameter("rhoName"))), - EBRecHitsToken_(consumes( - iConfig.getParameter("reducedEcalRecHitsEB"))), - EERecHitsToken_(consumes( - iConfig.getParameter("reducedEcalRecHitsEE"))), - ESRecHitsToken_(consumes( - iConfig.getParameter("reducedEcalRecHitsES"))), + EBRecHitsToken_(consumes(iConfig.getParameter("reducedEcalRecHitsEB"))), + EERecHitsToken_(consumes(iConfig.getParameter("reducedEcalRecHitsEE"))), + ESRecHitsToken_(consumes(iConfig.getParameter("reducedEcalRecHitsES"))), pedToken_(esConsumes()), geomToken_(esConsumes()) { produces>>(); diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index dfa10d8aeb486..fa7c0f490dc30 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -72,18 +72,18 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { correctionsSource = config.getParameter("correctionsSource"); correctionsToken = cc.consumes(correctionsSource); - if(config.exists("energyFloat")){ - userFloat=true; + if (config.exists("energyFloat")) { + userFloat = true; energyFloat = config.getParameter("energyFloat"); resFloat = config.getParameter("resFloat"); - } else{ - userFloat=false; + } else { + userFloat = false; } } const std::pair getCorrection(T& part) const; - const void doUserFloat(T& part, const std::pair& correction) const{ + const void doUserFloat(T& part, const std::pair& correction) const { part.addUserFloat(energyFloat, correction.first); part.addUserFloat(resFloat, correction.second); } @@ -161,7 +161,7 @@ void EGRegressionModifierDRN::modifyObject(pat::Electron& ele) const { const std::pair& correction = patElectrons_->getCorrection(ele); - if(patElectrons_->userFloat){ + if (patElectrons_->userFloat) { patElectrons_->doUserFloat(ele, correction); } else if (correction.first > 0 && correction.second > 0) { ele.setCorrectedEcalEnergy(correction.first, true); @@ -180,11 +180,10 @@ void EGRegressionModifierDRN::modifyObject(pat::Photon& pho) const { const std::pair& correction = patPhotons_->getCorrection(pho); - if(patPhotons_->userFloat){ + if (patPhotons_->userFloat) { patPhotons_->doUserFloat(pho, correction); } else if (correction.first > 0 && correction.second > 0) { - pho.setCorrectedEnergy(pat::Photon::P4type::regression2, - correction.first, correction.second, true); + pho.setCorrectedEnergy(pat::Photon::P4type::regression2, correction.first, correction.second, true); } } @@ -195,8 +194,7 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { const std::pair& correction = gedPhotons_->getCorrection(pho); if (correction.first > 0 && correction.second > 0) { - pho.setCorrectedEnergy(reco::Photon::P4type::regression2, - correction.first, correction.second, true); + pho.setCorrectedEnergy(reco::Photon::P4type::regression2, correction.first, correction.second, true); } }; @@ -216,9 +214,8 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio } if (!matched) { - throw cms::Exception("EGRegressionModifierDRN") - << "Matching failed in EGRegressionModifierDRN" << std::endl - << "This should not have been possible" << std::endl; + throw cms::Exception("EGRegressionModifierDRN") << "Matching failed in EGRegressionModifierDRN" << std::endl + << "This should not have been possible" << std::endl; return std::pair(-1., -1.); } @@ -230,4 +227,3 @@ const std::pair EGRegressionModifierDRN::partVars::getCorrectio } DEFINE_EDM_PLUGIN(ModifyObjectValueFactory, EGRegressionModifierDRN, "EGRegressionModifierDRN"); - From 722602b5288c00803119dc127741441936e1a4e4 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 08:34:52 -0500 Subject: [PATCH 25/41] Don't need ES Handles --- RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 42913850d1197..9711bd587717a 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -173,9 +173,9 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu const CaloSubdetectorGeometry* ecalESGeom = static_cast(geo->getSubdetectorGeometry(DetId::Ecal, EcalPreshower)); - const EcalRecHitCollection* recHitsEB = EBRecHits.product(); - const EcalRecHitCollection* recHitsEE = EERecHits.product(); - const EcalRecHitCollection* recHitsES = ESRecHits.product(); + const auto& recHitsEB = iEvent.get(EBRecHitsToken_); + const auto& recHitsEE = iEvent.get(EERecHitsToken_); + const auto& recHitsES = iEvent.get(ESRecHitsToken_); nPart_ = particles_->size(); From c658fab99193e71c04791bbbe66202fff8145147 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 08:40:59 -0500 Subject: [PATCH 26/41] No longer pointers --- .../EgammaTools/plugins/DRNCorrectionProducerT.cc | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 9711bd587717a..6cf5888a09072 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -159,9 +159,6 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu */ const auto& particles_ = iEvent.getHandle(particleToken_); float rho = iEvent.get(rhoToken_); - edm::Handle EBRecHits = iEvent.getHandle(EBRecHitsToken_); - edm::Handle EERecHits = iEvent.getHandle(EERecHitsToken_); - edm::Handle ESRecHits = iEvent.getHandle(ESRecHitsToken_); const auto& ped = &iSetup.getData(pedToken_); const auto& geo = &iSetup.getData(geomToken_); @@ -268,18 +265,15 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu std::vector> hitsAndFractions = sc->hitsAndFractions(); EcalRecHitCollection::const_iterator hit; - if (hitsAndFractions.empty()) //skip particles without RecHits - continue; - //iterate over ECAL hits... for (const auto& detitr : hitsAndFractions) { DetId id = detitr.first.rawId(); if (isEB(part)) { geom = ecalEBGeom->getGeometry(id); - hit = recHitsEB->find(detitr.first); + hit = recHitsEB.find(detitr.first); } else { geom = ecalEEGeom->getGeometry(id); - hit = recHitsEE->find(detitr.first); + hit = recHitsEE.ind(detitr.first); } //fill xECAL @@ -319,7 +313,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu //iterate over ES clusters... for (auto iES = sc->preshowerClustersBegin(); iES != sc->preshowerClustersEnd(); ++iES) { for (const auto& ESitr : (*iES)->hitsAndFractions()) { //iterate over ES hits - hit = recHitsES->find(ESitr.first); + hit = recHitsES.find(ESitr.first); geom = ecalESGeom->getGeometry(ESitr.first); auto& pos = geom->getPosition(); From 509d4a1dea7579643d9a0de02af11bd25f2393f8 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 08:43:36 -0500 Subject: [PATCH 27/41] Typo fix --- RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 6cf5888a09072..6499b8a352459 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -273,7 +273,7 @@ void DRNCorrectionProducerT::acquire(edm::Event const& iEvent, edm::EventSetu hit = recHitsEB.find(detitr.first); } else { geom = ecalEEGeom->getGeometry(id); - hit = recHitsEE.ind(detitr.first); + hit = recHitsEE.find(detitr.first); } //fill xECAL From 84c52f22ea7065270735218b3f081d9af33fe987 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 08:55:35 -0500 Subject: [PATCH 28/41] Adding process modifier --- .../ProcessModifiers/python/photonDRN_cff.py | 5 +++++ .../PatAlgos/python/slimming/slimming_cff.py | 4 ++++ .../egammaObjectModificationsInMiniAOD_cff.py | 14 ++++++++++++++ 3 files changed, 23 insertions(+) create mode 100644 Configuration/ProcessModifiers/python/photonDRN_cff.py diff --git a/Configuration/ProcessModifiers/python/photonDRN_cff.py b/Configuration/ProcessModifiers/python/photonDRN_cff.py new file mode 100644 index 0000000000000..8cfc55a112a1f --- /dev/null +++ b/Configuration/ProcessModifiers/python/photonDRN_cff.py @@ -0,0 +1,5 @@ +import FWCore.ParameterSet.Config as cms + +#modifier to enable DRN energy regression for photons + +photonDRN = cms.Modifier() diff --git a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py index 306efa71e690e..e822de16cde05 100644 --- a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py @@ -102,3 +102,7 @@ _phase2_timing_slimmingTask = cms.Task(slimmingTask.copy(), offlineSlimmedPrimaryVertices4D) phase2_timing.toReplaceWith(slimmingTask,_phase2_timing_slimmingTask) + +from PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi import patPhotonsDRN +from Configuration.ProcessModifiers.photonDRN_cff import photonDRN +photonDRN.toReplaceWith(slimmingTask, cms.Task(slimmingTask.copy(), patPhotonsDRN)) diff --git a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py index 351cb21abf91c..c1d4d6ca96e66 100644 --- a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py +++ b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py @@ -145,6 +145,14 @@ def setup_mva(val_pset,cat_pset,prod_name,mva_name): ) ) +photonDRNModifier = cms.PSet( + modifierName = cms.strong("EGRegressionModifierDRN"), + patPhotons = cms.PSet( + source = cms.InputTag("selectedPatPhotons"), + correctionsSource = cms.InputTag('patPhotonsDRN') + ) + ) + def appendReducedEgammaEnergyScaleAndSmearingModifier(modifiers): modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier) @@ -158,6 +166,9 @@ def appendEgamma8XLegacyAppendableModifiers (modifiers): def appendEgammaHIPhotonIsolationModifier(modifiers): modifiers.append(egammaHIPhotonIsolationModifier) +def appendPhotonDRNModifier(modifiers): + modifiers.append(photonDRNModifier) + from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17 from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL (run2_miniAOD_94XFall17 | run2_miniAOD_UL).toModify(egamma_modifications,appendReducedEgammaEnergyScaleAndSmearingModifier) @@ -170,3 +181,6 @@ def appendEgammaHIPhotonIsolationModifier(modifiers): from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(egamma_modifications, appendEgammaHIPhotonIsolationModifier) + +from Configuration.ProcessModifiers.photonDRN_cff import photonDRN +photonDRN.toMOdify(egamma_modifications, appendPhotonDRNModifier) From 0e55eb0690788c9b84ee70fdb7128d363f608b30 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 09:18:07 -0500 Subject: [PATCH 29/41] Typo fix --- .../python/egammaObjectModificationsInMiniAOD_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py index c1d4d6ca96e66..a3119a674696f 100644 --- a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py +++ b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py @@ -146,7 +146,7 @@ def setup_mva(val_pset,cat_pset,prod_name,mva_name): ) photonDRNModifier = cms.PSet( - modifierName = cms.strong("EGRegressionModifierDRN"), + modifierName = cms.string("EGRegressionModifierDRN"), patPhotons = cms.PSet( source = cms.InputTag("selectedPatPhotons"), correctionsSource = cms.InputTag('patPhotonsDRN') @@ -183,4 +183,4 @@ def appendPhotonDRNModifier(modifiers): pp_on_AA.toModify(egamma_modifications, appendEgammaHIPhotonIsolationModifier) from Configuration.ProcessModifiers.photonDRN_cff import photonDRN -photonDRN.toMOdify(egamma_modifications, appendPhotonDRNModifier) +photonDRN.toModify(egamma_modifications, appendPhotonDRNModifier) From c99da3ce2519385641e2f669e5ff50e0392cbb7a Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 09:20:49 -0500 Subject: [PATCH 30/41] userFloats by default --- .../python/egammaObjectModificationsInMiniAOD_cff.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py index a3119a674696f..9c5630ead8109 100644 --- a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py +++ b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py @@ -149,7 +149,9 @@ def setup_mva(val_pset,cat_pset,prod_name,mva_name): modifierName = cms.string("EGRegressionModifierDRN"), patPhotons = cms.PSet( source = cms.InputTag("selectedPatPhotons"), - correctionsSource = cms.InputTag('patPhotonsDRN') + correctionsSource = cms.InputTag('patPhotonsDRN'), + energyFloat = cms.string("energyDRN"), + resFloat = cms.string("resolutionDRN") ) ) From 8a6939358e05401176188ddf53a8887ffb223196 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 13:19:51 -0500 Subject: [PATCH 31/41] RelVal use modifier --- .../python/upgradeWorkflowComponents.py | 3 +-- .../PatAlgos/python/slimming/enableDRN.py | 17 ----------------- 2 files changed, 1 insertion(+), 19 deletions(-) delete mode 100644 PhysicsTools/PatAlgos/python/slimming/enableDRN.py diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index d3abfd6cd1010..37567986655d5 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -513,8 +513,7 @@ def condition(self, fragment, stepList, key, hasHarvest): offset = 0.31, ) upgradeWFs['photonDRN'].step3 = { - '--procModifiers': 'enableSonicTriton', - '--customise' : 'PhysicsTools/PatAlgos/slimming/enableDRN' + '--procModifiers': 'enableSonicTriton,photonDRN' } # Patatrack workflows: diff --git a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py b/PhysicsTools/PatAlgos/python/slimming/enableDRN.py deleted file mode 100644 index cb2557174fddb..0000000000000 --- a/PhysicsTools/PatAlgos/python/slimming/enableDRN.py +++ /dev/null @@ -1,17 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications - -def customise(process): - process.load("PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi") - process.DRNTask = cms.Task(process.patPhotonsDRN) - process.schedule.associate(process.DRNTask) - egamma_modifications.append( - cms.PSet( modifierName = cms.string("EGRegressionModifierDRN"), - patPhotons = cms.PSet( - source = cms.InputTag('selectedPatPhotons'), - correctionsSource = cms.InputTag('patPhotonsDRN') - ) - ) - ) - - return process From fa89ab103a6ea9383ce44f0fbc32e908337676b8 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 13:26:31 -0500 Subject: [PATCH 32/41] Replace p4 matching --- .../plugins/EGRegressionModifierDRN.cc | 27 +++++++------------ 1 file changed, 9 insertions(+), 18 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index fa7c0f490dc30..cc572bde43c1b 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -65,6 +65,8 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { bool userFloat; std::string energyFloat, resFloat; + unsigned i; + partVars(const edm::ParameterSet& config, edm::ConsumesCollector& cc) { source = config.getParameter("source"); token = cc.consumes(source); @@ -79,6 +81,8 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { } else { userFloat = false; } + + i=0; } const std::pair getCorrection(T& part) const; @@ -118,21 +122,25 @@ void EGRegressionModifierDRN::setEvent(const edm::Event& evt) { if (patElectrons_) { patElectrons_->particles = &evt.get(patElectrons_->token); patElectrons_->corrections = &evt.get(patElectrons_->correctionsToken); + patElectrons_->i = 0; } if (patPhotons_) { patPhotons_->particles = &evt.get(patPhotons_->token); patPhotons_->corrections = &evt.get(patPhotons_->correctionsToken); + patPhotons_->i = 0; } if (gsfElectrons_) { gsfElectrons_->particles = &evt.get(gsfElectrons_->token); gsfElectrons_->corrections = &evt.get(gsfElectrons_->correctionsToken); + gsfElectrons_->i = 0; } if (gedPhotons_) { gedPhotons_->particles = &evt.get(gedPhotons_->token); gedPhotons_->corrections = &evt.get(gedPhotons_->correctionsToken); + gedPhotons_->i = 0; } } @@ -202,24 +210,7 @@ template const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) const { const math::XYZTLorentzVectorD& partP4 = part.p4(); - bool matched = false; - unsigned i; - for (i = 0; i < particles->size(); ++i) { - const T& partIter = particles->at(i); - const auto& p4Iter = partIter.p4(); - if (p4Iter == partP4) { - matched = true; - break; - } - } - - if (!matched) { - throw cms::Exception("EGRegressionModifierDRN") << "Matching failed in EGRegressionModifierDRN" << std::endl - << "This should not have been possible" << std::endl; - return std::pair(-1., -1.); - } - - edm::Ptr ptr = particles->ptrAt(i); + edm::Ptr ptr = particles->ptrAt(i++); std::pair correction = (*corrections)[ptr]; From bb7c7278d3b8f3b65f0fbaf910f8121c7dfe7181 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 13:53:02 -0500 Subject: [PATCH 33/41] Clean up after removing p4 comparison --- RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index cc572bde43c1b..0ce79de5b446f 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -85,7 +85,7 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { i=0; } - const std::pair getCorrection(T& part) const; + const std::pair getCorrection(T& part); const void doUserFloat(T& part, const std::pair& correction) const { part.addUserFloat(energyFloat, correction.first); @@ -207,9 +207,7 @@ void EGRegressionModifierDRN::modifyObject(reco::Photon& pho) const { }; template -const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) const { - const math::XYZTLorentzVectorD& partP4 = part.p4(); - +const std::pair EGRegressionModifierDRN::partVars::getCorrection(T& part) { edm::Ptr ptr = particles->ptrAt(i++); std::pair correction = (*corrections)[ptr]; From 8c0bd7c518787b1611136c91bedd0852ee737f1e Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 17 Mar 2022 14:05:50 -0500 Subject: [PATCH 34/41] Code-format --- RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc index 0ce79de5b446f..a6f54a847e7b2 100644 --- a/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc +++ b/RecoEgamma/EgammaTools/plugins/EGRegressionModifierDRN.cc @@ -82,7 +82,7 @@ class EGRegressionModifierDRN : public ModifyObjectValueBase { userFloat = false; } - i=0; + i = 0; } const std::pair getCorrection(T& part); From 1ab9afd8c837ec23b7a4ddc8cfaf8928388c7bd2 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 4 Apr 2022 09:33:19 -0500 Subject: [PATCH 35/41] photonDRN modifier now includes enableSonicTriton --- Configuration/ProcessModifiers/python/photonDRN_cff.py | 8 ++++++-- PhysicsTools/PatAlgos/python/slimming/slimming_cff.py | 4 ++-- RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc | 6 ++++-- .../python/egammaObjectModificationsInMiniAOD_cff.py | 4 ++-- 4 files changed, 14 insertions(+), 8 deletions(-) diff --git a/Configuration/ProcessModifiers/python/photonDRN_cff.py b/Configuration/ProcessModifiers/python/photonDRN_cff.py index 8cfc55a112a1f..438677ec800c3 100644 --- a/Configuration/ProcessModifiers/python/photonDRN_cff.py +++ b/Configuration/ProcessModifiers/python/photonDRN_cff.py @@ -1,5 +1,9 @@ import FWCore.ParameterSet.Config as cms +from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton -#modifier to enable DRN energy regression for photons +#behind-the-scenes modifier that only turns on the DRN photon regression +_photonDRN = cms.Modifier() -photonDRN = cms.Modifier() +#modifier to enable DRN energy regression for photons +#requires also having enableSonicTriton +photonDRN = cms.ModifierChain(_photonDRN, enableSonicTriton) diff --git a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py index e822de16cde05..91edf0e01dc43 100644 --- a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py @@ -104,5 +104,5 @@ phase2_timing.toReplaceWith(slimmingTask,_phase2_timing_slimmingTask) from PhysicsTools.PatAlgos.slimming.patPhotonDRNCorrector_cfi import patPhotonsDRN -from Configuration.ProcessModifiers.photonDRN_cff import photonDRN -photonDRN.toReplaceWith(slimmingTask, cms.Task(slimmingTask.copy(), patPhotonsDRN)) +from Configuration.ProcessModifiers.photonDRN_cff import _photonDRN +_photonDRN.toReplaceWith(slimmingTask, cms.Task(slimmingTask.copy(), patPhotonsDRN)) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 6499b8a352459..7a7e929de5de2 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -411,8 +411,10 @@ void DRNCorrectionProducerT::fillDescriptions(edm::ConfigurationDescriptions& descriptions.addWithDefaultLabel(desc); } -using PatPhotonDRNCorrectionProducer = DRNCorrectionProducerT; -using GedPhotonDRNCorrectionProducer = DRNCorrectionProducerT; +//reco:: template instances are supported +//uncomment the lines below to enable them +//using PatPhotonDRNCorrectionProducer = DRNCorrectionProducerT; +//using GedPhotonDRNCorrectionProducer = DRNCorrectionProducerT; using GsfElectronDRNCorrectionProducer = DRNCorrectionProducerT; using PatElectronDRNCorrectionProducer = DRNCorrectionProducerT; diff --git a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py index 9c5630ead8109..848b9a16c182b 100644 --- a/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py +++ b/RecoEgamma/EgammaTools/python/egammaObjectModificationsInMiniAOD_cff.py @@ -184,5 +184,5 @@ def appendPhotonDRNModifier(modifiers): from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(egamma_modifications, appendEgammaHIPhotonIsolationModifier) -from Configuration.ProcessModifiers.photonDRN_cff import photonDRN -photonDRN.toModify(egamma_modifications, appendPhotonDRNModifier) +from Configuration.ProcessModifiers.photonDRN_cff import _photonDRN +_photonDRN.toModify(egamma_modifications, appendPhotonDRNModifier) From fc9c472fe8b70f782e481d19ea848f5ccb12d71a Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 4 Apr 2022 09:56:56 -0500 Subject: [PATCH 36/41] use fillDescriptions defaults for recHits --- .../slimming/patElectronDRNCorrector_cfi.py | 3 --- .../python/slimming/patPhotonDRNCorrector_cfi.py | 5 +---- .../plugins/DRNCorrectionProducerT.cc | 16 +++++++++------- 3 files changed, 10 insertions(+), 14 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py index 8f434ca4272c2..fcfc5a122052e 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py @@ -3,9 +3,6 @@ patElectronsDRN = cms.EDProducer("PatElectronDRNCorrectionProducer", particleSource = cms.InputTag("selectedPatElectrons"), rhoName = cms.InputTag("fixedGridRhoFastjetAll"), - reducedEcalRecHitsEB = cms.InputTag("reducedEcalRecHitsEB"), - reducedEcalRecHitsEE = cms.InputTag("reducedEcalRecHitsEE"), - reducedEcalRecHitsES = cms.InputTag("reducedEcalRecHitsES"), Client = cms.PSet( mode = cms.string("Async"), diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index 2e1642a1c97f4..14824aacca3b6 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -3,9 +3,6 @@ patPhotonsDRN = cms.EDProducer("PatPhotonDRNCorrectionProducer", particleSource = cms.InputTag("selectedPatPhotons"), rhoName = cms.InputTag("fixedGridRhoFastjetAll"), - reducedEcalRecHitsEB = cms.InputTag("reducedEcalRecHitsEB"), - reducedEcalRecHitsEE = cms.InputTag("reducedEcalRecHitsEE"), - reducedEcalRecHitsES = cms.InputTag("reducedEcalRecHitsES"), Client = cms.PSet( mode = cms.string("Async"), @@ -13,6 +10,6 @@ modelConfigPath = cms.FileInPath("RecoEgamma/EgammaPhotonProducers/data/models/photonObjectEnsemble/config.pbtxt"), allowedTries = cms.untracked.uint32(1), timeout = cms.untracked.uint32(10), - useSharedMemory = cms.untracked.bool(False), + useSharedMemory = cms.untracked.bool(True), ) ) diff --git a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc index 7a7e929de5de2..9efcb4bb5e7c7 100644 --- a/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc +++ b/RecoEgamma/EgammaTools/plugins/DRNCorrectionProducerT.cc @@ -405,20 +405,22 @@ void DRNCorrectionProducerT::fillDescriptions(edm::ConfigurationDescriptions& TritonClient::fillPSetDescription(desc); desc.add("particleSource"); desc.add("rhoName"); - desc.add("reducedEcalRecHitsEB"); - desc.add("reducedEcalRecHitsEE"); - desc.add("reducedEcalRecHitsES"); + desc.add("reducedEcalRecHitsEB", edm::InputTag("reducedEcalRecHitsEB")); + desc.add("reducedEcalRecHitsEE", edm::InputTag("reducedEcalRecHitsEE")); + desc.add("reducedEcalRecHitsES", edm::InputTag("reducedEcalRecHitsES")); descriptions.addWithDefaultLabel(desc); } //reco:: template instances are supported //uncomment the lines below to enable them -//using PatPhotonDRNCorrectionProducer = DRNCorrectionProducerT; + +//using GsfElectronDRNCorrectionProducer = DRNCorrectionProducerT; //using GedPhotonDRNCorrectionProducer = DRNCorrectionProducerT; -using GsfElectronDRNCorrectionProducer = DRNCorrectionProducerT; +//DEFINE_FWK_MODULE(GedPhotonDRNCorrectionProducer); +//DEFINE_FWK_MODULE(GsfElectronDRNCorrectionProducer); + using PatElectronDRNCorrectionProducer = DRNCorrectionProducerT; +using PatPhotonDRNCorrectionProducer = DRNCorrectionProducerT; DEFINE_FWK_MODULE(PatPhotonDRNCorrectionProducer); -DEFINE_FWK_MODULE(GedPhotonDRNCorrectionProducer); -DEFINE_FWK_MODULE(GsfElectronDRNCorrectionProducer); DEFINE_FWK_MODULE(PatElectronDRNCorrectionProducer); From 78558dc873f3dba5a8ce149413cffcb676375727 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Mon, 4 Apr 2022 09:57:45 -0500 Subject: [PATCH 37/41] shared memory on --- .../PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py index fcfc5a122052e..88e17f5fb860d 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py @@ -10,6 +10,6 @@ modelConfigPath = cms.FileInPath("RecoEgamma/EgammaElectronProducers/data/models/electronObjectEnsemble/config.pbtxt"), allowedTries = cms.untracked.uint32(1), timeout = cms.untracked.uint32(10), - useSharedMemory = cms.untracked.bool(False), + useSharedMemory = cms.untracked.bool(True), ) ) From 7ecb877ffd29f4f172484a722287387bd10cee54 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Wed, 13 Apr 2022 09:38:31 -0500 Subject: [PATCH 38/41] test clone... --- .../PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index 14824aacca3b6..d496be4020316 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -1,5 +1,7 @@ import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.PatPhotonDRNCorrectionProducer_cfi import PatPhotonDRNCorrectionProducer + patPhotonsDRN = cms.EDProducer("PatPhotonDRNCorrectionProducer", particleSource = cms.InputTag("selectedPatPhotons"), rhoName = cms.InputTag("fixedGridRhoFastjetAll"), From a8702fa63c079d5458d3960c14fa3f1a91f9bc7f Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 14 Apr 2022 09:01:17 -0500 Subject: [PATCH 39/41] Revert "test clone..." This reverts commit 7ecb877ffd29f4f172484a722287387bd10cee54. --- .../PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index d496be4020316..14824aacca3b6 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -1,7 +1,5 @@ import FWCore.ParameterSet.Config as cms -from PhysicsTools.PatAlgos.PatPhotonDRNCorrectionProducer_cfi import PatPhotonDRNCorrectionProducer - patPhotonsDRN = cms.EDProducer("PatPhotonDRNCorrectionProducer", particleSource = cms.InputTag("selectedPatPhotons"), rhoName = cms.InputTag("fixedGridRhoFastjetAll"), From 5977c4b3d7009dab49fed9d45e13bc4d5c6f537e Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 14 Apr 2022 08:58:06 -0500 Subject: [PATCH 40/41] Cloning fillDescriptions config --- .../slimming/patPhotonDRNCorrector_cfi.py | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py index 14824aacca3b6..68ee77d41f1e1 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patPhotonDRNCorrector_cfi.py @@ -1,15 +1,14 @@ -import FWCore.ParameterSet.Config as cms +import FWCore.ParameterSet.Config as cms +from RecoEgamma.EgammaTools.patPhotonDRNCorrectionProducer_cfi import patPhotonDRNCorrectionProducer -patPhotonsDRN = cms.EDProducer("PatPhotonDRNCorrectionProducer", - particleSource = cms.InputTag("selectedPatPhotons"), - rhoName = cms.InputTag("fixedGridRhoFastjetAll"), - - Client = cms.PSet( - mode = cms.string("Async"), - modelName = cms.string("photonObjectEnsemble"), - modelConfigPath = cms.FileInPath("RecoEgamma/EgammaPhotonProducers/data/models/photonObjectEnsemble/config.pbtxt"), - allowedTries = cms.untracked.uint32(1), - timeout = cms.untracked.uint32(10), - useSharedMemory = cms.untracked.bool(True), +patPhotonsDRN = patPhotonDRNCorrectionProducer.clone( + particleSource = 'selectedPatPhotons', + rhoName = 'fixedGridRhoFastjetAll', + Client = patPhotonDRNCorrectionProducer.Client.clone( + mode = 'Async', + allowedTries = 1, + modelName = 'photonObjectEnsemble', + modelConfigPath = 'RecoEgamma/EgammaPhotonProducers/data/models/photonObjectEnsemble/config.pbtxt', + timeout = 10 + ) ) -) From c8484f967bc79ed897a0e046832513f74eb14da5 Mon Sep 17 00:00:00 2001 From: Simon Rothman Date: Thu, 14 Apr 2022 09:04:25 -0500 Subject: [PATCH 41/41] Same for electrons --- .../slimming/patElectronDRNCorrector_cfi.py | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py index 88e17f5fb860d..94fe00cb1b93a 100644 --- a/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/patElectronDRNCorrector_cfi.py @@ -1,15 +1,15 @@ import FWCore.ParameterSet.Config as cms -patElectronsDRN = cms.EDProducer("PatElectronDRNCorrectionProducer", - particleSource = cms.InputTag("selectedPatElectrons"), - rhoName = cms.InputTag("fixedGridRhoFastjetAll"), +from RecoEgamma.EgammaTools.patElectronDRNCorrectionProducer_cfi import patElectronDRNCorrectionProducer - Client = cms.PSet( - mode = cms.string("Async"), - modelName = cms.string("electronObjectEnsemble"), - modelConfigPath = cms.FileInPath("RecoEgamma/EgammaElectronProducers/data/models/electronObjectEnsemble/config.pbtxt"), - allowedTries = cms.untracked.uint32(1), - timeout = cms.untracked.uint32(10), - useSharedMemory = cms.untracked.bool(True), +patElectronsDRN = patElectronDRNCorrectionProducer.clone( + particleSource = 'selectedPatElectrons', + rhoName = 'fixedGridRhoFastjetAll', + Client = patElectronDRNCorrectionProducer.Client.clone( + mode = 'Async', + allowedTries = 1, + modelName = 'electronObjectEnsemble', + modelConfigPath = 'RecoEgamma/EgammaElectronProducers/data/models/electronObjectEnsemble/config.pbtxt', + timeout = 10 + ) ) -)