diff --git a/RecoParticleFlow/Configuration/plugins/HepMCCopy.cc b/RecoParticleFlow/Configuration/plugins/HepMCCopy.cc index 64f4ad679dea6..091b7f5cddff1 100644 --- a/RecoParticleFlow/Configuration/plugins/HepMCCopy.cc +++ b/RecoParticleFlow/Configuration/plugins/HepMCCopy.cc @@ -1,4 +1,6 @@ #include "FWCore/Framework/interface/one/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/ServiceRegistry/interface/Service.h" #include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h" @@ -10,19 +12,27 @@ class HepMCCopy : public edm::one::EDProducer<> { explicit HepMCCopy(edm::ParameterSet const& p); ~HepMCCopy() override = default; void produce(edm::Event& e, const edm::EventSetup& c) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: + const edm::EDGetTokenT hepMCToken_; }; -HepMCCopy::HepMCCopy(edm::ParameterSet const& p) { +void HepMCCopy::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", {"generatorSmeared"}); + descriptions.addWithDefaultLabel(desc); +} + +HepMCCopy::HepMCCopy(edm::ParameterSet const& p) + : hepMCToken_(consumes(p.getParameter("src"))) { // This producer produces a HepMCProduct, a copy of the original one produces(); } void HepMCCopy::produce(edm::Event& iEvent, const edm::EventSetup& es) { - edm::Handle theHepMCProduct; - bool source = iEvent.getByLabel("generatorSmeared", theHepMCProduct); - if (!source) { + const auto& theHepMCProduct = iEvent.getHandle(hepMCToken_); + if (theHepMCProduct.isValid()) { auto pu_product = std::make_unique(); iEvent.put(std::move(pu_product)); } else { diff --git a/RecoParticleFlow/Configuration/python/HepMCCopy_cfi.py b/RecoParticleFlow/Configuration/python/HepMCCopy_cfi.py index 9e9e20b195d18..8fecb461b2a5e 100644 --- a/RecoParticleFlow/Configuration/python/HepMCCopy_cfi.py +++ b/RecoParticleFlow/Configuration/python/HepMCCopy_cfi.py @@ -1,3 +1,4 @@ import FWCore.ParameterSet.Config as cms -generator = cms.EDProducer("HepMCCopy") +from RecoParticleFlow.Configuration.HepMCCopy import HepMCCopy +generator = HepMCCopy() diff --git a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterCollectionMerger.cc b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterCollectionMerger.cc index 367e18d6358f7..a524a41d66c8d 100644 --- a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterCollectionMerger.cc +++ b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterCollectionMerger.cc @@ -16,13 +16,19 @@ class PFClusterCollectionMerger : public edm::global::EDProducer<> { public: PFClusterCollectionMerger(const edm::ParameterSet& conf) { - const std::vector& inputs = conf.getParameter >("inputs"); + const std::vector& inputs = conf.getParameter>("inputs"); for (const auto& input : inputs) { _inputs.push_back(consumes(input)); } produces(); } + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add>("inputs", {}); + descriptions.addWithDefaultLabel(desc); + } + void produce(edm::StreamID, edm::Event& e, const edm::EventSetup& es) const override { auto output = std::make_unique(); for (const auto& input : _inputs) { @@ -34,7 +40,7 @@ class PFClusterCollectionMerger : public edm::global::EDProducer<> { } private: - std::vector > _inputs; + std::vector> _inputs; }; DEFINE_FWK_MODULE(PFClusterCollectionMerger); diff --git a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterProducer.cc b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterProducer.cc index fffd17515e2e9..c4e367c57d2e5 100644 --- a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterProducer.cc +++ b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterProducer.cc @@ -22,6 +22,7 @@ class PFClusterProducer : public edm::stream::EDProducer<> { void beginRun(const edm::Run&, const edm::EventSetup&) override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: // inputs @@ -33,8 +34,8 @@ class PFClusterProducer : public edm::stream::EDProducer<> { // options const bool _prodInitClusters; // the actual algorithm - std::vector > _cleaners; - std::vector > _seedcleaners; + std::vector> _cleaners; + std::vector> _seedcleaners; std::unique_ptr _seedFinder; std::unique_ptr _initialClustering; std::unique_ptr _pfClusterBuilder; @@ -45,6 +46,33 @@ class PFClusterProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFClusterProducer); +void PFClusterProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("recHitsSource", {}); + desc.add("usePFThresholdsFromDB", false); + edm::ParameterSetDescription psd; + psd.setUnknown(); + desc.addVPSet("recHitCleaners", psd, {}); + { + edm::ParameterSetDescription psd1; + psd1.add>("RecHitFlagsToBeExcluded", {}); + psd1.add("algoName"); + desc.addVPSet("seedCleaners", psd1, {}); + } + { + edm::ParameterSetDescription pset; + pset.add("algoName"); + pset.add("nNeighbours", 0); + pset.addVPSet("thresholdsByDetector", psd, {}); + desc.add("seedFinder", pset); + } + desc.add("initialClusteringStep", psd); + desc.add("pfClusterBuilder", psd); + desc.add("positionReCalc", psd); + desc.add("energyCorrector", psd); + descriptions.addWithDefaultLabel(desc); +} + #ifdef PFLOW_DEBUG #define LOGVERB(x) edm::LogVerbatim(x) #define LOGWARN(x) edm::LogWarning(x) diff --git a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterTimeSelector.cc b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterTimeSelector.cc index ea39264862700..5161db390c874 100644 --- a/RecoParticleFlow/PFClusterProducer/plugins/PFClusterTimeSelector.cc +++ b/RecoParticleFlow/PFClusterProducer/plugins/PFClusterTimeSelector.cc @@ -20,6 +20,7 @@ class PFClusterTimeSelector : public edm::stream::EDProducer<> { void beginRun(const edm::Run& run, const edm::EventSetup& es) override; void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); protected: struct CutInfo { @@ -39,6 +40,124 @@ class PFClusterTimeSelector : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFClusterTimeSelector); +void PFClusterTimeSelector::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", {"particleFlowClusterECALWithTimeUncorrected"}); + { + std::vector vpset; + vpset.reserve(10); + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 0.0); + pset.addParameter("maxEnergy", 1.0); + pset.addParameter("endcap", false); + pset.addParameter("minTime", -12.); + pset.addParameter("maxTime", 12.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 0.0); + pset.addParameter("maxEnergy", 1.0); + pset.addParameter("endcap", true); + pset.addParameter("minTime", -31.5); + pset.addParameter("maxTime", 31.5); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 1.0); + pset.addParameter("maxEnergy", 2.0); + pset.addParameter("endcap", false); + pset.addParameter("minTime", -6.); + pset.addParameter("maxTime", 6.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 1.0); + pset.addParameter("maxEnergy", 2.0); + pset.addParameter("endcap", true); + pset.addParameter("minTime", -20.5); + pset.addParameter("maxTime", 20.5); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 2.0); + pset.addParameter("maxEnergy", 5.0); + pset.addParameter("endcap", false); + pset.addParameter("minTime", -4.); + pset.addParameter("maxTime", 4.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 2.0); + pset.addParameter("maxEnergy", 5.0); + pset.addParameter("endcap", true); + pset.addParameter("minTime", -12.); + pset.addParameter("maxTime", 12.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 5.0); + pset.addParameter("maxEnergy", 20.0); + pset.addParameter("endcap", false); + pset.addParameter("minTime", -4.); + pset.addParameter("maxTime", 4.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 5.0); + pset.addParameter("maxEnergy", 20.0); + pset.addParameter("endcap", true); + pset.addParameter("minTime", -5.); + pset.addParameter("maxTime", 5.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 20.0); + pset.addParameter("maxEnergy", 1e24); + pset.addParameter("endcap", false); + pset.addParameter("minTime", -4.); + pset.addParameter("maxTime", 4.); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("depth", 1.0); + pset.addParameter("minEnergy", 20.0); + pset.addParameter("maxEnergy", 1e24); + pset.addParameter("endcap", true); + pset.addParameter("minTime", -5.); + pset.addParameter("maxTime", 5.); + vpset.emplace_back(pset); + } + edm::ParameterSetDescription psd; + psd.add("depth", 1.0); + psd.add("minEnergy", 0.0); + psd.add("maxEnergy", 1e24); + psd.add("endcap", false); + psd.add("minTime", -50.); + psd.add("maxTime", 50.); + desc.addVPSet("cuts", psd, vpset); + } + descriptions.add("particleFlowClusterECALTimeSelected", desc); +} + using namespace std; using namespace edm; diff --git a/RecoParticleFlow/PFClusterProducer/plugins/PFMultiDepthClusterProducer.cc b/RecoParticleFlow/PFClusterProducer/plugins/PFMultiDepthClusterProducer.cc index 0a8ee49166a5d..f0421f24eba5a 100644 --- a/RecoParticleFlow/PFClusterProducer/plugins/PFMultiDepthClusterProducer.cc +++ b/RecoParticleFlow/PFClusterProducer/plugins/PFMultiDepthClusterProducer.cc @@ -25,6 +25,7 @@ class PFMultiDepthClusterProducer : public edm::stream::EDProducer<> { void beginRun(const edm::Run&, const edm::EventSetup&) override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: // inputs @@ -40,6 +41,38 @@ class PFMultiDepthClusterProducer : public edm::stream::EDProducer<> { DEFINE_FWK_MODULE(PFMultiDepthClusterProducer); +void PFMultiDepthClusterProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("clustersSource", {}); + desc.add("energyCorrector", {}); + { + edm::ParameterSetDescription pset0; + pset0.add("algoName", "PFMultiDepthClusterizer"); + { + edm::ParameterSetDescription pset1; + pset1.add("algoName", "Basic2DGenericPFlowPositionCalc"); + { + edm::ParameterSetDescription psd; + psd.add>("depths", {}); + psd.add("detector"); + psd.add>("logWeightDenominator", {}); + pset1.addVPSet("logWeightDenominatorByDetector", psd, {}); + } + pset1.add("minAllowedNormalization", 1e-09); + pset1.add("minFractionInCalc", 1e-09); + pset1.add("posCalcNCrystals", -1); + pset0.add("allCellsPositionCalc", pset1); + } + pset0.add("minFractionToKeep", 1e-07); + pset0.add("nSigmaEta", 2.0); + pset0.add("nSigmaPhi", 2.0); + desc.add("pfClusterBuilder", pset0); + } + desc.add("positionReCalc", {}); + desc.add("usePFThresholdsFromDB", false); + descriptions.addWithDefaultLabel(desc); +} + #ifdef PFLOW_DEBUG #define LOGVERB(x) edm::LogVerbatim(x) #define LOGWARN(x) edm::LogWarning(x) diff --git a/RecoParticleFlow/PFClusterProducer/plugins/PFRecHitProducer.cc b/RecoParticleFlow/PFClusterProducer/plugins/PFRecHitProducer.cc index 0fa102bd5c5e0..5f8079449c560 100644 --- a/RecoParticleFlow/PFClusterProducer/plugins/PFRecHitProducer.cc +++ b/RecoParticleFlow/PFClusterProducer/plugins/PFRecHitProducer.cc @@ -100,9 +100,10 @@ void PFRecHitProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup } void PFRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters edm::ParameterSetDescription desc; - desc.setUnknown(); - descriptions.addDefault(desc); + edm::ParameterSetDescription psd; + psd.setUnknown(); + desc.add("navigator", psd); + desc.addVPSet("producers", psd, {}); + descriptions.addWithDefaultLabel(desc); } diff --git a/RecoParticleFlow/PFClusterProducer/python/particleFlowClusterECALTimeSelected_cfi.py b/RecoParticleFlow/PFClusterProducer/python/particleFlowClusterECALTimeSelected_cfi.py deleted file mode 100644 index 4969c8a94134c..0000000000000 --- a/RecoParticleFlow/PFClusterProducer/python/particleFlowClusterECALTimeSelected_cfi.py +++ /dev/null @@ -1,90 +0,0 @@ -import FWCore.ParameterSet.Config as cms -particleFlowClusterECALTimeSelected = cms.EDProducer( - "PFClusterTimeSelector", - src = cms.InputTag('particleFlowClusterECALWithTimeUncorrected'), - - cuts = cms.VPSet( - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(0.0), - maxEnergy = cms.double(1.0), - endcap = cms.bool(False), - minTime = cms.double(-12.), - maxTime = cms.double(12.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(0.0), - maxEnergy = cms.double(1.0), - endcap = cms.bool(True), - minTime = cms.double(-31.5), - maxTime = cms.double(31.5) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(1.0), - maxEnergy = cms.double(2.0), - endcap = cms.bool(False), - minTime = cms.double(-6.), - maxTime = cms.double(6.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(1.0), - maxEnergy = cms.double(2.0), - endcap = cms.bool(True), - minTime = cms.double(-20.5), - maxTime = cms.double(20.5) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(2.0), - maxEnergy = cms.double(5.0), - endcap = cms.bool(False), - minTime = cms.double(-4.), - maxTime = cms.double(4.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(2.0), - maxEnergy = cms.double(5.0), - endcap = cms.bool(True), - minTime = cms.double(-12.), - maxTime = cms.double(12.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(5.0), - maxEnergy = cms.double(20.0), - endcap = cms.bool(False), - minTime = cms.double(-4.), - maxTime = cms.double(4.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(5.0), - maxEnergy = cms.double(20.0), - endcap = cms.bool(True), - minTime = cms.double(-5.), - maxTime = cms.double(5.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(20.0), - maxEnergy = cms.double(1e24), - endcap = cms.bool(False), - minTime = cms.double(-4.), - maxTime = cms.double(4.) - ), - cms.PSet( - depth=cms.double(1.0), - minEnergy = cms.double(20.0), - maxEnergy = cms.double(1e24), - endcap = cms.bool(True), - minTime = cms.double(-5.), - maxTime = cms.double(5.) - ) - ) -) - - diff --git a/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.cc b/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.cc index da488d22bc26a..3fb0deff21666 100644 --- a/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.cc +++ b/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.cc @@ -12,10 +12,10 @@ using namespace edm; using namespace reco; PFClusterAnalyzer::PFClusterAnalyzer(const edm::ParameterSet& iConfig) - : inputTagPFClusters_(iConfig.getParameter("PFClusters")), + : inputTokenPFClusters_(consumes(iConfig.getParameter("PFClusters"))), verbose_(iConfig.getUntrackedParameter("verbose", false)), printBlocks_(iConfig.getUntrackedParameter("printBlocks", false)) { - LogDebug("PFClusterAnalyzer") << " input collection : " << inputTagPFClusters_; + LogDebug("PFClusterAnalyzer") << " input collection : " << iConfig.getParameter("PFClusters"); } void PFClusterAnalyzer::beginRun(const edm::Run& run, const edm::EventSetup& es) {} @@ -26,7 +26,7 @@ void PFClusterAnalyzer::analyze(const Event& iEvent, const EventSetup& iSetup) { // get PFClusters Handle pfClusters; - fetchCandidateCollection(pfClusters, inputTagPFClusters_, iEvent); + fetchCandidateCollection(pfClusters, inputTokenPFClusters_, iEvent); // get PFClusters for isolation @@ -49,13 +49,13 @@ void PFClusterAnalyzer::analyze(const Event& iEvent, const EventSetup& iSetup) { } void PFClusterAnalyzer::fetchCandidateCollection(Handle& c, - const InputTag& tag, + const edm::EDGetTokenT& token, const Event& iEvent) const { - bool found = iEvent.getByLabel(tag, c); + c = iEvent.getHandle(token); - if (!found) { + if (!c.isValid()) { ostringstream err; - err << " cannot get PFClusters: " << tag << endl; + err << " cannot get PFClusters " << endl; LogError("PFClusters") << err.str(); throw cms::Exception("MissingProduct", err.str()); } diff --git a/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.h b/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.h index 06415e0268e7c..524a368ff8d7e 100644 --- a/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.h +++ b/RecoParticleFlow/PFClusterProducer/test/PFClusterAnalyzer.h @@ -33,14 +33,14 @@ class PFClusterAnalyzer : public edm::one::EDAnalyzer { private: void fetchCandidateCollection(edm::Handle& c, - const edm::InputTag& tag, + const edm::EDGetTokenT& token, const edm::Event& iSetup) const; /* void printElementsInBlocks(const reco::PFCluster& cluster, */ /* std::ostream& out=std::cout) const; */ /// PFClusters in which we'll look for pile up particles - const edm::InputTag inputTagPFClusters_; + const edm::EDGetTokenT inputTokenPFClusters_; /// verbose ? const bool verbose_; diff --git a/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.cc b/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.cc index 2a063a1ef463b..52ce4c26bc3b5 100644 --- a/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.cc +++ b/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.cc @@ -14,8 +14,9 @@ using namespace edm; using namespace reco; PFClusterComparator::PFClusterComparator(const edm::ParameterSet& iConfig) - : inputTagPFClusters_(iConfig.getParameter("PFClusters")), - inputTagPFClustersCompare_(iConfig.getParameter("PFClustersCompare")), + : inputTokenPFClusters_(consumes(iConfig.getParameter("PFClusters"))), + inputTokenPFClustersCompare_( + consumes(iConfig.getParameter("PFClustersCompare"))), verbose_(iConfig.getUntrackedParameter("verbose", false)), printBlocks_(iConfig.getUntrackedParameter("printBlocks", false)) { usesResource("TFileService"); @@ -37,7 +38,7 @@ PFClusterComparator::PFClusterComparator(const edm::ParameterSet& iConfig) posZ_new = fs->make("posZ_new", "log10(E cluster)", 50000, 0, 500); deltaZ = fs->make("delta_Z", "Z_{old} - Z_{new}", 5000, -5, 5); - LogDebug("PFClusterComparator") << " input collection : " << inputTagPFClusters_; + LogDebug("PFClusterComparator") << " input collection : " << iConfig.getParameter("PFClusters"); } void PFClusterComparator::analyze(const Event& iEvent, const EventSetup& iSetup) { @@ -46,10 +47,10 @@ void PFClusterComparator::analyze(const Event& iEvent, const EventSetup& iSetup) // get PFClusters Handle pfClusters; - fetchCandidateCollection(pfClusters, inputTagPFClusters_, iEvent); + fetchCandidateCollection(pfClusters, inputTokenPFClusters_, iEvent); Handle pfClustersCompare; - fetchCandidateCollection(pfClustersCompare, inputTagPFClustersCompare_, iEvent); + fetchCandidateCollection(pfClustersCompare, inputTokenPFClustersCompare_, iEvent); // get PFClusters for isolation @@ -145,13 +146,13 @@ void PFClusterComparator::analyze(const Event& iEvent, const EventSetup& iSetup) } void PFClusterComparator::fetchCandidateCollection(Handle& c, - const InputTag& tag, + const edm::EDGetTokenT& token, const Event& iEvent) const { - bool found = iEvent.getByLabel(tag, c); + c = iEvent.getHandle(token); - if (!found) { + if (!c.isValid()) { ostringstream err; - err << " cannot get PFClusters: " << tag << endl; + err << " cannot get PFClusters " << endl; LogError("PFClusters") << err.str(); throw cms::Exception("MissingProduct", err.str()); } diff --git a/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.h b/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.h index 584d2f535b5b0..2c4c95e3fcf6f 100644 --- a/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.h +++ b/RecoParticleFlow/PFClusterProducer/test/PFClusterComparator.h @@ -36,15 +36,15 @@ class PFClusterComparator : public edm::one::EDAnalyzer &c, - const edm::InputTag &tag, + const edm::EDGetTokenT &token, const edm::Event &iSetup) const; /* void printElementsInBlocks(const reco::PFCluster& cluster, */ /* std::ostream& out=std::cout) const; */ /// PFClusters in which we'll look for pile up particles - const edm::InputTag inputTagPFClusters_; - const edm::InputTag inputTagPFClustersCompare_; + const edm::EDGetTokenT inputTokenPFClusters_; + const edm::EDGetTokenT inputTokenPFClustersCompare_; /// verbose ? const bool verbose_; diff --git a/RecoParticleFlow/PFProducer/plugins/PFBlockProducer.cc b/RecoParticleFlow/PFProducer/plugins/PFBlockProducer.cc index e684868a6b366..f5c8fae8c0413 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFBlockProducer.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFBlockProducer.cc @@ -25,6 +25,7 @@ class PFBlockProducer : public edm::stream::EDProducer<> { void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: /// verbose ? @@ -37,6 +38,318 @@ class PFBlockProducer : public edm::stream::EDProducer<> { DEFINE_FWK_MODULE(PFBlockProducer); +void PFBlockProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + // verbosity + desc.addUntracked("verbose", false); + // Debug flag + desc.addUntracked("debug", false); + //define what we are importing into particle flow + //from the various subdetectors + // importers are executed in the order they are defined here!!! + //order matters for some modules (it is pointed out where this is important) + // you can find a list of all available importers in: + // plugins/importers + { + std::vector vpset; + vpset.reserve(12); + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GSFTrackImporter"); + pset.addParameter("source", {"pfTrackElec"}); + pset.addParameter("gsfsAreSecondary", false); + pset.addParameter("superClustersArePF", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "ConvBremTrackImporter"); + pset.addParameter("source", {"pfTrackElec"}); + pset.addParameter("vetoEndcap", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "SuperClusterImporter"); + pset.addParameter("source_eb", + {"particleFlowSuperClusterECAL:particleFlowSuperClusterECALBarrel"}); + pset.addParameter( + "source_ee", {"particleFlowSuperClusterECAL:particleFlowSuperClusterECALEndcapWithPreshower"}); + pset.addParameter("maximumHoverE", 0.5); + pset.addParameter("minSuperClusterPt", 10.0); + pset.addParameter("minPTforBypass", 100.0); + pset.addParameter("hbheRecHitsTag", {"hbhereco"}); + pset.addParameter("maxSeverityHB", 9); + pset.addParameter("maxSeverityHE", 9); + pset.addParameter("usePFThresholdsFromDB", false); + pset.addParameter("superClustersArePF", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "ConversionTrackImporter"); + pset.addParameter("source", {"pfConversions"}); + pset.addParameter("vetoEndcap", false); + vpset.emplace_back(pset); + } + // V0's not actually used in particle flow block building so far + //NuclearInteraction's also come in Loose and VeryLoose varieties + { + edm::ParameterSet pset; + pset.addParameter("importerName", "NuclearInteractionTrackImporter"); + pset.addParameter("source", {"pfDisplacedTrackerVertex"}); + pset.addParameter("vetoEndcap", false); + vpset.emplace_back(pset); + } + //for best timing GeneralTracksImporter should come after + // all secondary track importers + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GeneralTracksImporter"); + pset.addParameter("source", {"pfTrack"}); + pset.addParameter("vetoEndcap", false); + pset.addParameter("muonSrc", {"muons1stStep"}); + pset.addParameter("trackQuality", "highPurity"); + pset.addParameter("cleanBadConvertedBrems", true); + pset.addParameter("useIterativeTracking", true); + pset.addParameter>("DPtOverPtCuts_byTrackAlgo", {10.0, 10.0, 10.0, 10.0, 10.0, 5.0}); + pset.addParameter>("NHitCuts_byTrackAlgo", {3, 3, 3, 3, 3, 3}); + pset.addParameter("muonMaxDPtOPt", 1); + vpset.emplace_back(pset); + } + // secondary GSF tracks are also turned off + // to properly set SC based links you need to run ECAL importer + // after you've imported all SCs to the block + { + edm::ParameterSet pset; + pset.addParameter("importerName", "ECALClusterImporter"); + pset.addParameter("source", {"particleFlowClusterECAL"}); + pset.addParameter("BCtoPFCMap", {"particleFlowSuperClusterECAL:PFClusterAssociationEBEE"}); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GenericClusterImporter"); + pset.addParameter("source", {"particleFlowClusterHCAL"}); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GenericClusterImporter"); + pset.addParameter("source", {"particleFlowBadHcalPseudoCluster"}); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GenericClusterImporter"); + pset.addParameter("source", {"particleFlowClusterHO"}); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GenericClusterImporter"); + pset.addParameter("source", {"particleFlowClusterHF"}); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("importerName", "GenericClusterImporter"); + pset.addParameter("source", {"particleFlowClusterPS"}); + vpset.emplace_back(pset); + } + edm::ParameterSetDescription psd; + psd.add("importerName"); + psd.add("source", {}); + psd.addOptional("gsfsAreSecondary", false); + psd.addOptional("superClustersArePF", false); + psd.addOptional("source_eb", {}); + psd.addOptional("source_ee", {}); + psd.addOptional("maximumHoverE", 1E9); + psd.addOptional("minSuperClusterPt", -1); + psd.addOptional("minPTforBypass", -1); + psd.addOptional("hbheRecHitsTag", {}); + psd.addOptional("maxSeverityHB", 1E9); + psd.addOptional("maxSeverityHE", 1E9); + psd.addOptional("usePFThresholdsFromDB", false); + psd.addOptional("vetoEndcap", false); + psd.addOptional("muonSrc", {}); + psd.addOptional("trackQuality"); + psd.addOptional("cleanBadConvertedBrems", false); + psd.addOptional("useIterativeTracking", false); + psd.addOptional>("DPtOverPtCuts_byTrackAlgo", {}); + psd.addOptional>("NHitCuts_byTrackAlgo", {}); + psd.addOptional("muonMaxDPtOPt", 1E9); + psd.addOptional("BCtoPFCMap", {}); + psd.addOptional("maxDPtOPt", 1E9); + psd.addOptional("vetoMode", 0); + psd.addOptional("vetoSrc", {}); + psd.addOptional("timeValueMap", {}); + psd.addOptional("timeErrorMap", {}); + psd.addOptional("timeQualityMap", {}); + psd.addOptional("timeQualityThreshold", 0); + psd.addOptional("timeValueMapGsf", {}); + psd.addOptional("timeErrorMapGsf", {}); + psd.addOptional("timeQualityMapGsf", {}); + desc.addVPSet("elementImporters", psd, vpset); + } + //linking definitions + // you can find a list of all available linkers in: + // plugins/linkers + // see : plugins/kdtrees for available KDTree Types + // to enable a KDTree for a linking pair, write a KDTree linker + // and set useKDTree = True in the linker PSet + //order does not matter here since we are defining a lookup table + { + std::vector vpset; + vpset.reserve(18); + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "PreshowerAndECALLinker"); + pset.addParameter("linkType", "PS1:ECAL"); + pset.addParameter("useKDTree ", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "PreshowerAndECALLinker"); + pset.addParameter("linkType", "PS2:ECAL"); + pset.addParameter("useKDTree ", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "TrackAndECALLinker"); + pset.addParameter("linkType", "TRACK:ECAL"); + pset.addParameter("useKDTree ", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "TrackAndHCALLinker"); + pset.addParameter("linkType", "TRACK:HCAL"); + pset.addParameter("useKDTree", true); + pset.addParameter("trajectoryLayerEntrance", "HCALEntrance"); + pset.addParameter("trajectoryLayerExit", "HCALExit"); + pset.addParameter("nMaxHcalLinksPerTrack", + 1); // the max hcal links per track (negative values: no restriction) + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "TrackAndHOLinker"); + pset.addParameter("linkType", "TRACK:HO"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "ECALAndHCALLinker"); + pset.addParameter("linkType", "ECAL:HCAL"); + pset.addParameter("minAbsEtaEcal", 2.5); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "HCALAndHOLinker"); + pset.addParameter("linkType", "HCAL:HO"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "HFEMAndHFHADLinker"); + pset.addParameter("linkType", "HFEM:HFHAD"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "TrackAndTrackLinker"); + pset.addParameter("linkType", "TRACK:TRACK"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "ECALAndECALLinker"); + pset.addParameter("linkType", "ECAL:ECAL"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "GSFAndECALLinker"); + pset.addParameter("linkType", "GSF:ECAL"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "TrackAndGSFLinker"); + pset.addParameter("linkType", "TRACK:GSF"); + pset.addParameter("useKDTree", false); + pset.addParameter("useConvertedBrems", true); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "GSFAndBREMLinker"); + pset.addParameter("linkType", "GSF:BREM"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "GSFAndGSFLinker"); + pset.addParameter("linkType", "GSF:GSF"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "ECALAndBREMLinker"); + pset.addParameter("linkType", "ECAL:BREM"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "GSFAndHCALLinker"); + pset.addParameter("linkType", "GSF:HCAL"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "HCALAndBREMLinker"); + pset.addParameter("linkType", "HCAL:BREM"); + pset.addParameter("useKDTree", false); + vpset.emplace_back(pset); + } + { + edm::ParameterSet pset; + pset.addParameter("linkerName", "SCAndECALLinker"); + pset.addParameter("linkType", "SC:ECAL"); + pset.addParameter("useKDTree", false); + pset.addParameter("SuperClusterMatchByRef", true); + vpset.emplace_back(pset); + } + edm::ParameterSetDescription psd; + psd.add("linkerName"); + psd.add("linkType"); + psd.add("useKDTree", false); + psd.addOptional("trajectoryLayerEntrance"); + psd.addOptional("trajectoryLayerExit"); + psd.addOptional("nMaxHcalLinksPerTrack", 0); + psd.addOptional("minAbsEtaEcal", -1); + psd.addOptional("useConvertedBrems", false); + psd.addOptional("SuperClusterMatchByRef", false); + desc.addVPSet("linkDefinitions", psd, vpset); + } + descriptions.addWithDefaultLabel(desc); +} + using namespace std; using namespace edm; diff --git a/RecoParticleFlow/PFProducer/plugins/PFCandidateChecker.cc b/RecoParticleFlow/PFProducer/plugins/PFCandidateChecker.cc index 6fe62d2352a1b..10fdfbab6e5eb 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFCandidateChecker.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFCandidateChecker.cc @@ -34,10 +34,10 @@ class PFCandidateChecker : public edm::stream::EDAnalyzer<> { void printElementsInBlocks(const reco::PFCandidate& cand, std::ostream& out = std::cout) const; /// PFCandidates in which we'll look for pile up particles - edm::InputTag inputTagPFCandidatesReco_; - edm::InputTag inputTagPFCandidatesReReco_; - edm::InputTag inputTagPFJetsReco_; - edm::InputTag inputTagPFJetsReReco_; + edm::EDGetTokenT inputTokenPFCandidatesReco_; + edm::EDGetTokenT inputTokenPFCandidatesReReco_; + edm::EDGetTokenT inputTokenPFJetsReco_; + edm::EDGetTokenT inputTokenPFJetsReReco_; /// Cuts for comparison double deltaEMax_; @@ -66,13 +66,15 @@ using namespace edm; using namespace reco; PFCandidateChecker::PFCandidateChecker(const edm::ParameterSet& iConfig) { - inputTagPFCandidatesReco_ = iConfig.getParameter("pfCandidatesReco"); + inputTokenPFCandidatesReco_ = + consumes(iConfig.getParameter("pfCandidatesReco")); - inputTagPFCandidatesReReco_ = iConfig.getParameter("pfCandidatesReReco"); + inputTokenPFCandidatesReReco_ = + consumes(iConfig.getParameter("pfCandidatesReReco")); - inputTagPFJetsReco_ = iConfig.getParameter("pfJetsReco"); + inputTokenPFJetsReco_ = consumes(iConfig.getParameter("pfJetsReco")); - inputTagPFJetsReReco_ = iConfig.getParameter("pfJetsReReco"); + inputTokenPFJetsReReco_ = consumes(iConfig.getParameter("pfJetsReReco")); deltaEMax_ = iConfig.getParameter("deltaEMax"); @@ -88,8 +90,8 @@ PFCandidateChecker::PFCandidateChecker(const edm::ParameterSet& iConfig) { entry_ = 0; - LogDebug("PFCandidateChecker") << " input collections : " << inputTagPFCandidatesReco_ << " " - << inputTagPFCandidatesReReco_; + LogDebug("PFCandidateChecker") << " input collections : " << iConfig.getParameter("pfCandidatesReco") << " " + << iConfig.getParameter("pfCandidatesReReco"); } void PFCandidateChecker::analyze(const Event& iEvent, const EventSetup& iSetup) { @@ -97,17 +99,10 @@ void PFCandidateChecker::analyze(const Event& iEvent, const EventSetup& iSetup) // get PFCandidates - Handle pfCandidatesReco; - iEvent.getByLabel(inputTagPFCandidatesReco_, pfCandidatesReco); - - Handle pfCandidatesReReco; - iEvent.getByLabel(inputTagPFCandidatesReReco_, pfCandidatesReReco); - - Handle pfJetsReco; - iEvent.getByLabel(inputTagPFJetsReco_, pfJetsReco); - - Handle pfJetsReReco; - iEvent.getByLabel(inputTagPFJetsReReco_, pfJetsReReco); + const auto& pfCandidatesReco = iEvent.getHandle(inputTokenPFCandidatesReco_); + const auto& pfCandidatesReReco = iEvent.getHandle(inputTokenPFCandidatesReReco_); + const auto& pfJetsReco = iEvent.getHandle(inputTokenPFJetsReco_); + const auto& pfJetsReReco = iEvent.getHandle(inputTokenPFJetsReReco_); reco::PFCandidateCollection pfReco, pfReReco; diff --git a/RecoParticleFlow/PFProducer/plugins/PFConcretePFCandidateProducer.cc b/RecoParticleFlow/PFProducer/plugins/PFConcretePFCandidateProducer.cc index bebb6bf04f7d2..652ebaa96a908 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFConcretePFCandidateProducer.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFConcretePFCandidateProducer.cc @@ -14,15 +14,22 @@ class PFConcretePFCandidateProducer : public edm::stream::EDProducer<> { ~PFConcretePFCandidateProducer() override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: - edm::InputTag inputColl_; + const edm::EDGetTokenT inputColl_; }; DEFINE_FWK_MODULE(PFConcretePFCandidateProducer); -PFConcretePFCandidateProducer::PFConcretePFCandidateProducer(const edm::ParameterSet& iConfig) { - inputColl_ = iConfig.getParameter("src"); +void PFConcretePFCandidateProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", {"particleFlow"}); + descriptions.add("pfConcretePFCandidateProducer", desc); +} + +PFConcretePFCandidateProducer::PFConcretePFCandidateProducer(const edm::ParameterSet& iConfig) + : inputColl_(consumes(iConfig.getParameter("src"))) { // register products produces(); } @@ -30,10 +37,9 @@ PFConcretePFCandidateProducer::PFConcretePFCandidateProducer(const edm::Paramete PFConcretePFCandidateProducer::~PFConcretePFCandidateProducer() {} void PFConcretePFCandidateProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { - edm::Handle inputColl; - bool inputOk = iEvent.getByLabel(inputColl_, inputColl); + const auto& inputColl = iEvent.getHandle(inputColl_); - if (!inputOk) { + if (!inputColl.isValid()) { // nothing ... I guess we prefer to send an exception in the next lines } diff --git a/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc b/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc index c0fc66e281e46..ef3e8573b00af 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc @@ -31,17 +31,18 @@ class PFElectronTranslator : public edm::stream::EDProducer<> { ~PFElectronTranslator() override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); typedef std::vector>> IsolationValueMaps; private: // to retrieve the collection from the event bool fetchCandidateCollection(edm::Handle& c, - const edm::InputTag& tag, + const edm::EDGetTokenT& token, const edm::Event& iEvent) const; // to retrieve the collection from the event void fetchGsfCollection(edm::Handle& c, - const edm::InputTag& tag, + const edm::EDGetTokenT& token, const edm::Event& iEvent) const; // makes a basic cluster from PFBlockElement and add it to the collection ; the corrected energy is taken @@ -88,10 +89,10 @@ class PFElectronTranslator : public edm::stream::EDProducer<> { const reco::PFBlockElement& pfbe) const; private: - edm::InputTag inputTagPFCandidates_; - edm::InputTag inputTagPFCandidateElectrons_; - edm::InputTag inputTagGSFTracks_; - std::vector inputTagIsoVals_; + edm::EDGetTokenT inputTokenPFCandidates_; + edm::EDGetTokenT inputTokenPFCandidateElectrons_; + edm::EDGetTokenT inputTokenGSFTracks_; + std::vector>> inputTokenIsoVals_; std::string PFBasicClusterCollection_; std::string PFPreshowerClusterCollection_; std::string PFSuperClusterCollection_; @@ -140,10 +141,37 @@ class PFElectronTranslator : public edm::stream::EDProducer<> { DEFINE_FWK_MODULE(PFElectronTranslator); +void PFElectronTranslator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("PFCandidate", {"pfSelectedElectrons"}); + desc.add("PFCandidateElectron", {"particleFlowTmp:electrons"}); + desc.add("GSFTracks", {"electronGsfTracks"}); + desc.add("PFBasicClusters", "pf"); + desc.add("PFPreshowerClusters", "pf"); + desc.add("PFSuperClusters", "pf"); + desc.add("ElectronMVA", "pf"); + desc.add("ElectronSC", "pf"); + desc.add("PFGsfElectron", "pf"); + desc.add("PFGsfElectronCore", "pf"); + desc.add("MVACutBlock", {}); + desc.add("CheckStatusFlag", true); + desc.add("useIsolationValues", false); + { + edm::ParameterSetDescription pset; + pset.add("pfSumChargedHadronPt", {"elPFIsoValueCharged04PFId"}); + pset.add("pfSumPhotonEt", {"elPFIsoValueGamma04PFId"}); + pset.add("pfSumNeutralHadronEt", {"elPFIsoValueNeutral04PFId"}); + pset.add("pfSumPUPt", {"elPFIsoValuePU04PFId"}); + desc.add("isolationValues", pset); + } + descriptions.addWithDefaultLabel(desc); +} + PFElectronTranslator::PFElectronTranslator(const edm::ParameterSet& iConfig) { - inputTagPFCandidates_ = iConfig.getParameter("PFCandidate"); - inputTagPFCandidateElectrons_ = iConfig.getParameter("PFCandidateElectron"); - inputTagGSFTracks_ = iConfig.getParameter("GSFTracks"); + inputTokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidate")); + inputTokenPFCandidateElectrons_ = + consumes(iConfig.getParameter("PFCandidateElectron")); + inputTokenGSFTracks_ = consumes(iConfig.getParameter("GSFTracks")); bool useIsolationValues = iConfig.getParameter("useIsolationValues"); if (useIsolationValues) { @@ -151,10 +179,13 @@ PFElectronTranslator::PFElectronTranslator(const edm::ParameterSet& iConfig) { throw cms::Exception("PFElectronTranslator|InternalError") << "Missing ParameterSet isolationValues"; else { edm::ParameterSet isoVals = iConfig.getParameter("isolationValues"); - inputTagIsoVals_.push_back(isoVals.getParameter("pfSumChargedHadronPt")); - inputTagIsoVals_.push_back(isoVals.getParameter("pfSumPhotonEt")); - inputTagIsoVals_.push_back(isoVals.getParameter("pfSumNeutralHadronEt")); - inputTagIsoVals_.push_back(isoVals.getParameter("pfSumPUPt")); + inputTokenIsoVals_.push_back( + consumes>(isoVals.getParameter("pfSumChargedHadronPt"))); + inputTokenIsoVals_.push_back( + consumes>(isoVals.getParameter("pfSumPhotonEt"))); + inputTokenIsoVals_.push_back( + consumes>(isoVals.getParameter("pfSumNeutralHadronEt"))); + inputTokenIsoVals_.push_back(consumes>(isoVals.getParameter("pfSumPUPt"))); } } @@ -207,11 +238,11 @@ void PFElectronTranslator::produce(edm::Event& iEvent, const edm::EventSetup& iS edm::ValueMap::Filler scRefFiller(*scMap_p); edm::Handle pfCandidates; - bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidates_, iEvent); + bool status = fetchCandidateCollection(pfCandidates, inputTokenPFCandidates_, iEvent); - IsolationValueMaps isolationValues(inputTagIsoVals_.size()); - for (size_t j = 0; j < inputTagIsoVals_.size(); ++j) { - iEvent.getByLabel(inputTagIsoVals_[j], isolationValues[j]); + IsolationValueMaps isolationValues(inputTokenIsoVals_.size()); + for (size_t j = 0; j < inputTokenIsoVals_.size(); ++j) { + isolationValues[j] = iEvent.getHandle(inputTokenIsoVals_[j]); } // clear the vectors @@ -356,26 +387,26 @@ void PFElectronTranslator::produce(edm::Event& iEvent, const edm::EventSetup& iS } bool PFElectronTranslator::fetchCandidateCollection(edm::Handle& c, - const edm::InputTag& tag, + const edm::EDGetTokenT& token, const edm::Event& iEvent) const { - bool found = iEvent.getByLabel(tag, c); + c = iEvent.getHandle(token); - if (!found && !emptyIsOk_) { + if (!c.isValid() && !emptyIsOk_) { std::ostringstream err; - err << " cannot get PFCandidates: " << tag << std::endl; + err << " cannot get PFCandidates " << std::endl; edm::LogError("PFElectronTranslator") << err.str(); } - return found; + return c.isValid(); } void PFElectronTranslator::fetchGsfCollection(edm::Handle& c, - const edm::InputTag& tag, + const edm::EDGetTokenT& token, const edm::Event& iEvent) const { - bool found = iEvent.getByLabel(tag, c); + c = iEvent.getHandle(token); - if (!found) { + if (!c.isValid()) { std::ostringstream err; - err << " cannot get GSFTracks: " << tag << std::endl; + err << " cannot get GSFTracks " << std::endl; edm::LogError("PFElectronTranslator") << err.str(); throw cms::Exception("MissingProduct", err.str()); } @@ -468,7 +499,7 @@ void PFElectronTranslator::createSuperClusterGsfMapRefs( void PFElectronTranslator::fillMVAValueMap(edm::Event& iEvent, edm::ValueMap::Filler& filler) { gsfMvaMap_.clear(); edm::Handle pfCandidates; - bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidateElectrons_, iEvent); + bool status = fetchCandidateCollection(pfCandidates, inputTokenPFCandidateElectrons_, iEvent); unsigned ncand = (status) ? pfCandidates->size() : 0; for (unsigned i = 0; i < ncand; ++i) { @@ -482,7 +513,7 @@ void PFElectronTranslator::fillMVAValueMap(edm::Event& iEvent, edm::ValueMap gsfTracks; - fetchGsfCollection(gsfTracks, inputTagGSFTracks_, iEvent); + fetchGsfCollection(gsfTracks, inputTokenGSFTracks_, iEvent); unsigned ngsf = gsfTracks->size(); std::vector values; for (unsigned igsf = 0; igsf < ngsf; ++igsf) { @@ -503,7 +534,7 @@ void PFElectronTranslator::fillMVAValueMap(edm::Event& iEvent, edm::ValueMap::Filler& filler) const { edm::Handle gsfTracks; - fetchGsfCollection(gsfTracks, inputTagGSFTracks_, iEvent); + fetchGsfCollection(gsfTracks, inputTokenGSFTracks_, iEvent); unsigned ngsf = gsfTracks->size(); std::vector values; for (unsigned igsf = 0; igsf < ngsf; ++igsf) { diff --git a/RecoParticleFlow/PFProducer/plugins/PFLinker.cc b/RecoParticleFlow/PFProducer/plugins/PFLinker.cc index fa8689e81a88c..2e8b5fd964bdc 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFLinker.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFLinker.cc @@ -29,6 +29,7 @@ class PFLinker : public edm::stream::EDProducer<> { ~PFLinker() override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: template @@ -77,6 +78,22 @@ class PFLinker : public edm::stream::EDProducer<> { DEFINE_FWK_MODULE(PFLinker); +void PFLinker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add>("PFCandidate", {edm::InputTag("particleFlow")}); + desc.add("GsfElectrons", {"gedGsfElectrons"}); + desc.add("Photons", {"gedPhotons"}); + desc.add("Muons", {"muons", "muons1stStep2muonsMap"}); + desc.add("ProducePFCandidates", true); + desc.add("FillMuonRefs", true); + desc.add("OutputPF", ""); + desc.add("ValueMapElectrons", "electrons"); + desc.add("ValueMapPhotons", "photons"); + desc.add("ValueMapMerged", "all"); + desc.add("forceElectronsInHGCAL", false); + descriptions.add("pfLinker", desc); +} + PFLinker::PFLinker(const edm::ParameterSet& iConfig) { // vector of InputTag; more than 1 is not for RECO, it is for analysis diff --git a/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py b/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py index 82eca42e7f077..cba8b0c709209 100644 --- a/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py +++ b/RecoParticleFlow/PFProducer/python/particleFlowBlock_cfi.py @@ -1,155 +1,7 @@ import FWCore.ParameterSet.Config as cms -particleFlowBlock = cms.EDProducer( - "PFBlockProducer", - # verbosity - verbose = cms.untracked.bool(False), - # Debug flag - debug = cms.untracked.bool(False), - - #define what we are importing into particle flow - #from the various subdetectors - # importers are executed in the order they are defined here!!! - #order matters for some modules (it is pointed out where this is important) - # you can find a list of all available importers in: - # plugins/importers - elementImporters = cms.VPSet( - cms.PSet( importerName = cms.string("GSFTrackImporter"), - source = cms.InputTag("pfTrackElec"), - gsfsAreSecondary = cms.bool(False), - superClustersArePF = cms.bool(True) ), - cms.PSet( importerName = cms.string("ConvBremTrackImporter"), - source = cms.InputTag("pfTrackElec"), - vetoEndcap = cms.bool(False)), - cms.PSet( importerName = cms.string("SuperClusterImporter"), - source_eb = cms.InputTag("particleFlowSuperClusterECAL:particleFlowSuperClusterECALBarrel"), - source_ee = cms.InputTag("particleFlowSuperClusterECAL:particleFlowSuperClusterECALEndcapWithPreshower"), - maximumHoverE = cms.double(0.5), - minSuperClusterPt = cms.double(10.0), - minPTforBypass = cms.double(100.0), - hbheRecHitsTag = cms.InputTag('hbhereco'), - maxSeverityHB = cms.int32(9), - maxSeverityHE = cms.int32(9), - usePFThresholdsFromDB = cms.bool(False), - superClustersArePF = cms.bool(True) ), - cms.PSet( importerName = cms.string("ConversionTrackImporter"), - source = cms.InputTag("pfConversions"), - vetoEndcap = cms.bool(False)), - # V0's not actually used in particle flow block building so far - #cms.PSet( importerName = cms.string("V0TrackImporter"), - # source = cms.InputTag("pfV0"), - # vetoEndcap = cms.bool(False)), - #NuclearInteraction's also come in Loose and VeryLoose varieties - cms.PSet( importerName = cms.string("NuclearInteractionTrackImporter"), - source = cms.InputTag("pfDisplacedTrackerVertex"), - vetoEndcap = cms.bool(False)), - #for best timing GeneralTracksImporter should come after - # all secondary track importers - cms.PSet( importerName = cms.string("GeneralTracksImporter"), - source = cms.InputTag("pfTrack"), - vetoEndcap = cms.bool(False), - muonSrc = cms.InputTag("muons1stStep"), - trackQuality = cms.string("highPurity"), - cleanBadConvertedBrems = cms.bool(True), - useIterativeTracking = cms.bool(True), - DPtOverPtCuts_byTrackAlgo = cms.vdouble(10.0,10.0,10.0, - 10.0,10.0,5.0), - NHitCuts_byTrackAlgo = cms.vuint32(3,3,3,3,3,3), - muonMaxDPtOPt = cms.double(1) - ), - # secondary GSF tracks are also turned off - #cms.PSet( importerName = cms.string("GSFTrackImporter"), - # source = cms.InputTag("pfTrackElec:Secondary"), - # gsfsAreSecondary = cms.bool(True), - # superClustersArePF = cms.bool(True) ), - # to properly set SC based links you need to run ECAL importer - # after you've imported all SCs to the block - cms.PSet( importerName = cms.string("ECALClusterImporter"), - source = cms.InputTag("particleFlowClusterECAL"), - BCtoPFCMap = cms.InputTag('particleFlowSuperClusterECAL:PFClusterAssociationEBEE') ), - cms.PSet( importerName = cms.string("GenericClusterImporter"), - source = cms.InputTag("particleFlowClusterHCAL") ), - cms.PSet( importerName = cms.string("GenericClusterImporter"), - source = cms.InputTag("particleFlowBadHcalPseudoCluster") ), - cms.PSet( importerName = cms.string("GenericClusterImporter"), - source = cms.InputTag("particleFlowClusterHO") ), - cms.PSet( importerName = cms.string("GenericClusterImporter"), - source = cms.InputTag("particleFlowClusterHF") ), - cms.PSet( importerName = cms.string("GenericClusterImporter"), - source = cms.InputTag("particleFlowClusterPS") ), - ), - - #linking definitions - # you can find a list of all available linkers in: - # plugins/linkers - # see : plugins/kdtrees for available KDTree Types - # to enable a KDTree for a linking pair, write a KDTree linker - # and set useKDTree = True in the linker PSet - #order does not matter here since we are defining a lookup table - linkDefinitions = cms.VPSet( - cms.PSet( linkerName = cms.string("PreshowerAndECALLinker"), - linkType = cms.string("PS1:ECAL"), - useKDTree = cms.bool(True) ), - cms.PSet( linkerName = cms.string("PreshowerAndECALLinker"), - linkType = cms.string("PS2:ECAL"), - useKDTree = cms.bool(True) ), - cms.PSet( linkerName = cms.string("TrackAndECALLinker"), - linkType = cms.string("TRACK:ECAL"), - useKDTree = cms.bool(True) ), - cms.PSet( linkerName = cms.string("TrackAndHCALLinker"), - linkType = cms.string("TRACK:HCAL"), - useKDTree = cms.bool(True), - trajectoryLayerEntrance = cms.string("HCALEntrance"), - trajectoryLayerExit = cms.string("HCALExit"), - nMaxHcalLinksPerTrack = cms.int32(1) # the max hcal links per track (negative values: no restriction) - ), - cms.PSet( linkerName = cms.string("TrackAndHOLinker"), - linkType = cms.string("TRACK:HO"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("ECALAndHCALLinker"), - linkType = cms.string("ECAL:HCAL"), - minAbsEtaEcal = cms.double(2.5), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("HCALAndHOLinker"), - linkType = cms.string("HCAL:HO"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("HFEMAndHFHADLinker"), - linkType = cms.string("HFEM:HFHAD"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("TrackAndTrackLinker"), - linkType = cms.string("TRACK:TRACK"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("ECALAndECALLinker"), - linkType = cms.string("ECAL:ECAL"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("GSFAndECALLinker"), - linkType = cms.string("GSF:ECAL"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("TrackAndGSFLinker"), - linkType = cms.string("TRACK:GSF"), - useKDTree = cms.bool(False), - useConvertedBrems = cms.bool(True) ), - cms.PSet( linkerName = cms.string("GSFAndBREMLinker"), - linkType = cms.string("GSF:BREM"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("GSFAndGSFLinker"), - linkType = cms.string("GSF:GSF"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("ECALAndBREMLinker"), - linkType = cms.string("ECAL:BREM"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("GSFAndHCALLinker"), - linkType = cms.string("GSF:HCAL"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("HCALAndBREMLinker"), - linkType = cms.string("HCAL:BREM"), - useKDTree = cms.bool(False) ), - cms.PSet( linkerName = cms.string("SCAndECALLinker"), - linkType = cms.string("SC:ECAL"), - useKDTree = cms.bool(False), - SuperClusterMatchByRef = cms.bool(True) ) - ) -) +from RecoParticleFlow.PFProducer.PFBlockProducer import PFBlockProducer +particleFlowBlock = PFBlockProducer() for imp in particleFlowBlock.elementImporters: if imp.importerName.value() == "SuperClusterImporter": diff --git a/RecoParticleFlow/PFProducer/python/pfConcretePFCandidateProducer_cfi.py b/RecoParticleFlow/PFProducer/python/pfConcretePFCandidateProducer_cfi.py deleted file mode 100644 index c013558b582d0..0000000000000 --- a/RecoParticleFlow/PFProducer/python/pfConcretePFCandidateProducer_cfi.py +++ /dev/null @@ -1,5 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfConcretePFCandidateProducer = cms.EDProducer("PFConcretePFCandidateProducer", - src = cms.InputTag('particleFlow') - ) diff --git a/RecoParticleFlow/PFProducer/python/pfElectronTranslator_cfi.py b/RecoParticleFlow/PFProducer/python/pfElectronTranslator_cfi.py index 679ddf57fc58a..5ce30e7a85e43 100644 --- a/RecoParticleFlow/PFProducer/python/pfElectronTranslator_cfi.py +++ b/RecoParticleFlow/PFProducer/python/pfElectronTranslator_cfi.py @@ -1,26 +1,6 @@ import FWCore.ParameterSet.Config as cms from RecoParticleFlow.PFProducer.pfElectronTranslatorMVACut_cfi import * +from RecoParticleFlow.PFProducer.PFElectronTranslator import PFElectronTranslator -pfElectronTranslator = cms.EDProducer("PFElectronTranslator", - PFCandidate = cms.InputTag("pfSelectedElectrons"), - PFCandidateElectron = cms.InputTag("particleFlowTmp:electrons"), - GSFTracks = cms.InputTag("electronGsfTracks"), - PFBasicClusters = cms.string("pf"), - PFPreshowerClusters = cms.string("pf"), - PFSuperClusters = cms.string("pf"), - ElectronMVA = cms.string("pf"), - ElectronSC = cms.string("pf"), - PFGsfElectron = cms.string("pf"), - PFGsfElectronCore = cms.string("pf"), - MVACutBlock = cms.PSet(pfElecMva), - CheckStatusFlag = cms.bool(True), - - useIsolationValues = cms.bool(False), - isolationValues = cms.PSet( - pfSumChargedHadronPt = cms.InputTag('elPFIsoValueCharged04PFId'), - pfSumPhotonEt = cms.InputTag('elPFIsoValueGamma04PFId'), - pfSumNeutralHadronEt= cms.InputTag('elPFIsoValueNeutral04PFId'), - pfSumPUPt= cms.InputTag('elPFIsoValuePU04PFId'), - ) - ) +pfElectronTranslator = PFElectronTranslator().clone(MVACutBlock = cms.PSet(pfElecMva)) diff --git a/RecoParticleFlow/PFProducer/python/pfLinker_cfi.py b/RecoParticleFlow/PFProducer/python/pfLinker_cfi.py deleted file mode 100644 index 8b25503a78456..0000000000000 --- a/RecoParticleFlow/PFProducer/python/pfLinker_cfi.py +++ /dev/null @@ -1,15 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfLinker = cms.EDProducer("PFLinker", - PFCandidate = cms.VInputTag(cms.InputTag("particleFlow")), - GsfElectrons = cms.InputTag("gedGsfElectrons"), - Photons = cms.InputTag("gedPhotons"), - Muons = cms.InputTag("muons","muons1stStep2muonsMap"), - ProducePFCandidates = cms.bool(True), - FillMuonRefs = cms.bool(True), - OutputPF = cms.string(""), - ValueMapElectrons = cms.string("electrons"), - ValueMapPhotons = cms.string("photons"), - ValueMapMerged = cms.string("all"), - forceElectronsInHGCAL = cms.bool(False) - ) diff --git a/RecoParticleFlow/PFProducer/test/EgGEDPhotonAnalyzer.cc b/RecoParticleFlow/PFProducer/test/EgGEDPhotonAnalyzer.cc index 38a2fe74c6764..6f7b14bb914a7 100644 --- a/RecoParticleFlow/PFProducer/test/EgGEDPhotonAnalyzer.cc +++ b/RecoParticleFlow/PFProducer/test/EgGEDPhotonAnalyzer.cc @@ -56,8 +56,6 @@ class EgGEDPhotonAnalyzer : public edm::one::EDAnalyzer pfToken_; + const edm::EDGetTokenT phoToken_; + const edm::EDGetTokenT mcToken_; + const edm::EDGetTokenT gedPhoToken_; }; // @@ -91,9 +94,10 @@ class EgGEDPhotonAnalyzer : public edm::one::EDAnalyzer(edm::InputTag("particleFlow"))), + phoToken_(consumes(edm::InputTag("photons"))), + mcToken_(consumes(edm::InputTag("VtxSmeared"))), + gedPhoToken_(consumes(edm::InputTag("gedPhotons"))) { usesResource(TFileService::kSharedResource); edm::Service fs; @@ -166,25 +170,10 @@ EgGEDPhotonAnalyzer::~EgGEDPhotonAnalyzer() { // ------------ method called to for each event ------------ void EgGEDPhotonAnalyzer::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) { // Candidate info - Handle collection; - InputTag label("particleFlow"); // <- Special electron coll. - iEvent.getByLabel(label, collection); - std::vector candidates = (*collection.product()); - - InputTag recoPhotonLabel(string("photons")); - Handle theRecoPhotonCollection; - iEvent.getByLabel(recoPhotonLabel, theRecoPhotonCollection); - const PhotonCollection theRecoPh = *(theRecoPhotonCollection.product()); - - InputTag MCTruthCollection(string("VtxSmeared")); - edm::Handle pMCTruth; - iEvent.getByLabel(MCTruthCollection, pMCTruth); - const HepMC::GenEvent *genEvent = pMCTruth->GetEvent(); - - InputTag gedPhotonLabel(string("gedPhotons")); - Handle theGedPhotonCollection; - iEvent.getByLabel(gedPhotonLabel, theGedPhotonCollection); - const PhotonCollection theGedPh = *(theGedPhotonCollection.product()); + const auto &candidates = iEvent.get(pfToken_); + const auto &theRecoPh = iEvent.get(phoToken_); + const auto &genEvent = iEvent.get(mcToken_).GetEvent(); + const auto &theGedPh = iEvent.get(gedPhoToken_); bool debug = true; @@ -212,14 +201,13 @@ void EgGEDPhotonAnalyzer::analyze(const edm::Event &iEvent, const edm::EventSetu if (debug) cout << " MC particle: pt " << ptmc << " eta,phi " << etamc << ", " << phimc << endl; - std::vector::iterator it; - for (it = candidates.begin(); it != candidates.end(); ++it) { - reco::PFCandidate::ParticleType type = (*it).particleId(); + for (const auto &cand : candidates) { + reco::PFCandidate::ParticleType type = cand.particleId(); if (type == reco::PFCandidate::gamma) { - reco::PhotonRef phref = (*it).photonRef(); - float eta = (*it).eta(); - float phi = (*it).phi(); + reco::PhotonRef phref = cand.photonRef(); + float eta = cand.eta(); + float phi = cand.phi(); float deta = etamc - eta; float dphi = normalizedPhi(phimc - phi); @@ -258,7 +246,7 @@ void EgGEDPhotonAnalyzer::analyze(const edm::Event &iEvent, const edm::EventSetu } if (debug) - cout << " PF photon matched: pt " << (*it).pt() << " eta,phi " << eta << ", " << phi << endl; + cout << " PF photon matched: pt " << cand.pt() << " eta,phi " << eta << ", " << phi << endl; // all for the moment } } // End PFCandidates Electron Selection diff --git a/RecoParticleFlow/PFProducer/test/GsfGEDElectronAnalyzer.cc b/RecoParticleFlow/PFProducer/test/GsfGEDElectronAnalyzer.cc index 8a973d19904d5..bef74e7b29f6c 100644 --- a/RecoParticleFlow/PFProducer/test/GsfGEDElectronAnalyzer.cc +++ b/RecoParticleFlow/PFProducer/test/GsfGEDElectronAnalyzer.cc @@ -91,6 +91,13 @@ class GsfGEDElectronAnalyzer : public edm::one::EDAnalyzer pfToken_; + const edm::EDGetTokenT gsfEleToken_; + const edm::EDGetTokenT mcToken_; + const edm::EDGetTokenT gedEleToken_; + const edm::EDGetTokenT> metToken_; + const edm::EDGetTokenT> reMetToken_; }; // @@ -105,9 +112,12 @@ class GsfGEDElectronAnalyzer : public edm::one::EDAnalyzer(edm::InputTag("particleFlow::reRECO"))), + gsfEleToken_(consumes(edm::InputTag("gsfElectrons"))), + mcToken_(consumes(edm::InputTag("genParticles"))), + gedEleToken_(consumes(edm::InputTag("gedGsfElectrons::reRECO"))), + metToken_(consumes>(edm::InputTag("pfMet::RECO"))), + reMetToken_(consumes>(edm::InputTag("pfMet::reRECO"))) { usesResource(TFileService::kSharedResource); edm::Service fs; @@ -238,36 +248,15 @@ GsfGEDElectronAnalyzer::~GsfGEDElectronAnalyzer() { // ------------ method called to for each event ------------ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) { // Candidate info - Handle collection; - InputTag label("particleFlow::reRECO"); // <- Special electron coll. - iEvent.getByLabel(label, collection); - std::vector candidates = (*collection.product()); - - InputTag egammaLabel(string("gsfElectrons")); - Handle theGsfEleCollection; - iEvent.getByLabel(egammaLabel, theGsfEleCollection); - const GsfElectronCollection theGsfEle = *(theGsfEleCollection.product()); - - InputTag MCTruthCollection(string("genParticles")); - edm::Handle > pMCTruth; - iEvent.getByLabel(MCTruthCollection, pMCTruth); - - InputTag gedEleLabel(string("gedGsfElectrons::reRECO")); - Handle theGedEleCollection; - iEvent.getByLabel(gedEleLabel, theGedEleCollection); - const GsfElectronCollection theGedEle = *(theGedEleCollection.product()); - - //get and plot the reco met - InputTag pfMETRecoLabel("pfMet::RECO"); - Handle > recoMet; - iEvent.getByLabel(pfMETRecoLabel, recoMet); - pf_MET_reco->Fill(recoMet->at(0).et()); - - //get and plot the rereco met - InputTag pfMETReRecoLabel("pfMet::reRECO"); - Handle > rerecoMet; - iEvent.getByLabel(pfMETReRecoLabel, rerecoMet); - pf_MET_rereco->Fill(rerecoMet->at(0).et()); + const auto &candidates = iEvent.get(pfToken_); + const auto &theGsfEle = iEvent.get(gsfEleToken_); + const auto &pMCTruth = iEvent.get(mcToken_); + const auto &theGedEle = iEvent.get(gedEleToken_); + const auto &recoMet = iEvent.get(metToken_); + const auto &rerecoMet = iEvent.get(reMetToken_); + + pf_MET_reco->Fill(recoMet[0].et()); + pf_MET_rereco->Fill(rerecoMet[0].et()); bool debug = true; @@ -278,13 +267,13 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS // Validation from generator events - for (std::vector::const_iterator cP = pMCTruth->begin(); cP != pMCTruth->end(); cP++) { - float etamc = cP->eta(); - float phimc = cP->phi(); - float ptmc = cP->pt(); - float Emc = cP->energy(); + for (const auto &cP : pMCTruth) { + float etamc = cP.eta(); + float phimc = cP.phi(); + float ptmc = cP.pt(); + float Emc = cP.energy(); - if (abs(cP->pdgId()) == 11 && cP->status() == 1 && cP->pt() > 2. && fabs(cP->eta()) < 2.5) { + if (abs(cP.pdgId()) == 11 && cP.status() == 1 && cP.pt() > 2. && fabs(cP.eta()) < 2.5) { h_etamc_ele->Fill(etamc); h_ptmc_ele->Fill(ptmc); @@ -296,16 +285,15 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS if (debug) cout << " MC particle: pt " << ptmc << " eta,phi " << etamc << ", " << phimc << endl; - std::vector::iterator it; - for (it = candidates.begin(); it != candidates.end(); ++it) { - reco::PFCandidate::ParticleType type = (*it).particleId(); + for (const auto &cand : candidates) { + reco::PFCandidate::ParticleType type = cand.particleId(); if (type == reco::PFCandidate::e) { - float eta = (*it).eta(); - float phi = (*it).phi(); - float pfmva = (*it).mva_e_pi(); + float eta = cand.eta(); + float phi = cand.phi(); + float pfmva = cand.mva_e_pi(); - reco::GsfTrackRef refGsf = (*it).gsfTrackRef(); + reco::GsfTrackRef refGsf = cand.gsfTrackRef(); //ElectronSeedRef seedRef= refGsf->extra()->seedRef().castTo(); float deta = etamc - eta; @@ -314,7 +302,7 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS if (dR < 0.05) { MindR = dR; - mvaCutEle = (*it).mva_e_pi(); + mvaCutEle = cand.mva_e_pi(); /* if(seedRef->isEcalDriven()) isPfEcDr = true; @@ -323,7 +311,7 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS */ if (debug) - cout << " PF ele matched: pt " << (*it).pt() << " (" << (*it).ecalEnergy() / std::cosh(eta) << ") " + cout << " PF ele matched: pt " << cand.pt() << " (" << cand.ecalEnergy() / std::cosh(eta) << ") " << " eta,phi " << eta << ", " << phi << " pfmva " << pfmva << endl; // all for the moment } @@ -351,26 +339,26 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS bool isEgTrDr = false; bool isEgEcDr = false; - for (uint j = 0; j < theGsfEle.size(); j++) { - reco::GsfTrackRef egGsfTrackRef = (theGsfEle[j]).gsfTrack(); - float etareco = theGsfEle[j].eta(); - float phireco = theGsfEle[j].phi(); + for (const auto &gsfEle : theGsfEle) { + reco::GsfTrackRef egGsfTrackRef = gsfEle.gsfTrack(); + float etareco = gsfEle.eta(); + float phireco = gsfEle.phi(); - float pfmva = theGsfEle[j].mva_e_pi(); + float pfmva = gsfEle.mva_e_pi(); - reco::GsfTrackRef refGsf = theGsfEle[j].gsfTrack(); + reco::GsfTrackRef refGsf = gsfEle.gsfTrack(); //ElectronSeedRef seedRef= refGsf->extra()->seedRef().castTo(); float deta = etamc - etareco; float dphi = normalizedPhi(phimc - phireco); float dR = sqrt(deta * deta + dphi * dphi); - float SCEnergy = (theGsfEle[j]).superCluster()->energy(); + float SCEnergy = gsfEle.superCluster()->energy(); float ErecoEtrue = SCEnergy / Emc; if (dR < 0.05) { if (debug) - cout << " EG ele matched: pt " << theGsfEle[j].pt() << " (" << SCEnergy / std::cosh(etareco) << ") " + cout << " EG ele matched: pt " << gsfEle.pt() << " (" << SCEnergy / std::cosh(etareco) << ") " << " eta,phi " << etareco << ", " << phireco << " pfmva " << pfmva << endl; if (fabs(etamc) < 0.5) { @@ -389,8 +377,8 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS eg_EEcalEtrue_5->Fill(ErecoEtrue); } - if ((theGsfEle[j].parentSuperCluster()).isNonnull()) { - float SCPF = (theGsfEle[j]).parentSuperCluster()->rawEnergy(); + if ((gsfEle.parentSuperCluster()).isNonnull()) { + float SCPF = gsfEle.parentSuperCluster()->rawEnergy(); float EpfEtrue = SCPF / Emc; if (fabs(etamc) < 0.5) { pf_EEcalEtrue_1->Fill(EpfEtrue); @@ -407,47 +395,47 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS if (fabs(etamc) >= 2.0 && fabs(etamc) < 2.5) { pf_EEcalEtrue_5->Fill(EpfEtrue); } - const reco::GsfElectron::ShowerShape &pfshapes = theGsfEle[j].showerShape(); + const reco::GsfElectron::ShowerShape &pfshapes = gsfEle.showerShape(); pf_e1x5_all->Fill(pfshapes.e1x5); pf_sihih_all->Fill(pfshapes.sigmaIetaIeta); pf_r9_all->Fill(pfshapes.r9); - pf_scshh_all->Fill((theGsfEle[j]).parentSuperCluster()->etaWidth()); - pf_scsff_all->Fill((theGsfEle[j]).parentSuperCluster()->phiWidth()); + pf_scshh_all->Fill(gsfEle.parentSuperCluster()->etaWidth()); + pf_scsff_all->Fill(gsfEle.parentSuperCluster()->phiWidth()); if (std::abs(etareco) < 1.479) { pf_e1x5_eb->Fill(pfshapes.e1x5); pf_sihih_eb->Fill(pfshapes.sigmaIetaIeta); pf_r9_eb->Fill(pfshapes.r9); - pf_scshh_eb->Fill((theGsfEle[j]).parentSuperCluster()->etaWidth()); - pf_scsff_eb->Fill((theGsfEle[j]).parentSuperCluster()->phiWidth()); + pf_scshh_eb->Fill(gsfEle.parentSuperCluster()->etaWidth()); + pf_scsff_eb->Fill(gsfEle.parentSuperCluster()->phiWidth()); } if (std::abs(etareco) >= 1.479) { pf_e1x5_ee->Fill(pfshapes.e1x5); pf_sihih_ee->Fill(pfshapes.sigmaIetaIeta); pf_r9_ee->Fill(pfshapes.r9); - pf_scshh_ee->Fill((theGsfEle[j]).parentSuperCluster()->etaWidth()); - pf_scsff_ee->Fill((theGsfEle[j]).parentSuperCluster()->phiWidth()); + pf_scshh_ee->Fill(gsfEle.parentSuperCluster()->etaWidth()); + pf_scsff_ee->Fill(gsfEle.parentSuperCluster()->phiWidth()); } } - eg_e1x5_all->Fill(theGsfEle[j].e1x5()); - eg_sihih_all->Fill(theGsfEle[j].sigmaIetaIeta()); - eg_r9_all->Fill(theGsfEle[j].r9()); - eg_scshh_all->Fill((theGsfEle[j]).superCluster()->etaWidth()); - eg_scsff_all->Fill((theGsfEle[j]).superCluster()->phiWidth()); + eg_e1x5_all->Fill(gsfEle.e1x5()); + eg_sihih_all->Fill(gsfEle.sigmaIetaIeta()); + eg_r9_all->Fill(gsfEle.r9()); + eg_scshh_all->Fill(gsfEle.superCluster()->etaWidth()); + eg_scsff_all->Fill(gsfEle.superCluster()->phiWidth()); if (std::abs(etareco) < 1.479) { - eg_e1x5_eb->Fill(theGsfEle[j].e1x5()); - eg_sihih_eb->Fill(theGsfEle[j].sigmaIetaIeta()); - eg_r9_eb->Fill(theGsfEle[j].r9()); - eg_scshh_eb->Fill((theGsfEle[j]).superCluster()->etaWidth()); - eg_scsff_eb->Fill((theGsfEle[j]).superCluster()->phiWidth()); + eg_e1x5_eb->Fill(gsfEle.e1x5()); + eg_sihih_eb->Fill(gsfEle.sigmaIetaIeta()); + eg_r9_eb->Fill(gsfEle.r9()); + eg_scshh_eb->Fill(gsfEle.superCluster()->etaWidth()); + eg_scsff_eb->Fill(gsfEle.superCluster()->phiWidth()); } if (std::abs(etareco) >= 1.479) { - eg_e1x5_ee->Fill(theGsfEle[j].e1x5()); - eg_sihih_ee->Fill(theGsfEle[j].sigmaIetaIeta()); - eg_r9_ee->Fill(theGsfEle[j].r9()); - eg_scshh_ee->Fill((theGsfEle[j]).superCluster()->etaWidth()); - eg_scsff_ee->Fill((theGsfEle[j]).superCluster()->phiWidth()); + eg_e1x5_ee->Fill(gsfEle.e1x5()); + eg_sihih_ee->Fill(gsfEle.sigmaIetaIeta()); + eg_r9_ee->Fill(gsfEle.r9()); + eg_scshh_ee->Fill(gsfEle.superCluster()->etaWidth()); + eg_scsff_ee->Fill(gsfEle.superCluster()->phiWidth()); } MindREG = dR; @@ -480,26 +468,26 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS bool isGedEgTrDr = false; bool isGedEgEcDr = false; - for (uint j = 0; j < theGedEle.size(); j++) { - reco::GsfTrackRef egGsfTrackRef = (theGedEle[j]).gsfTrack(); - float etareco = theGedEle[j].eta(); - float phireco = theGedEle[j].phi(); - float pfmva = theGedEle[j].mva_e_pi(); + for (const auto &gedEle : theGedEle) { + reco::GsfTrackRef egGsfTrackRef = gedEle.gsfTrack(); + float etareco = gedEle.eta(); + float phireco = gedEle.phi(); + float pfmva = gedEle.mva_e_pi(); - reco::GsfTrackRef refGsf = theGedEle[j].gsfTrack(); + reco::GsfTrackRef refGsf = gedEle.gsfTrack(); //ElectronSeedRef seedRef= refGsf->extra()->seedRef().castTo(); float deta = etamc - etareco; float dphi = normalizedPhi(phimc - phireco); float dR = sqrt(deta * deta + dphi * dphi); - float SCEnergy = (theGedEle[j]).superCluster()->energy(); + float SCEnergy = gedEle.superCluster()->energy(); float ErecoEtrue = SCEnergy / Emc; if (dR < 0.05) { const reco::PFCandidate *matchPF = NULL; if (debug) - cout << " GED ele matched: pt " << theGedEle[j].pt() << " (" << SCEnergy / std::cosh(etareco) << ") " + cout << " GED ele matched: pt " << gedEle.pt() << " (" << SCEnergy / std::cosh(etareco) << ") " << " eta,phi " << etareco << ", " << phireco << " pfmva " << pfmva << endl; for (unsigned k = 0; k < candidates.size(); ++k) { @@ -539,7 +527,7 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS << ", " << matchPF->phi() << " pfmva " << matchPF->mva_e_pi() << endl; std::cout << "GED Clusters: " << std::endl; - for( const auto& c : theGedEle[j].superCluster()->clusters() ) { + for( const auto& c : gedEle.superCluster()->clusters() ) { std::cout << " E/eta/phi : " << c->energy() << '/' << c->eta() << '/' << c->phi() << std::endl; @@ -555,24 +543,24 @@ void GsfGEDElectronAnalyzer::analyze(const edm::Event &iEvent, const edm::EventS */ } - ged_e1x5_all->Fill(theGedEle[j].e1x5()); - ged_sihih_all->Fill(theGedEle[j].sigmaIetaIeta()); - ged_r9_all->Fill(theGedEle[j].r9()); - ged_scshh_all->Fill((theGedEle[j]).superCluster()->etaWidth()); - ged_scsff_all->Fill((theGedEle[j]).superCluster()->phiWidth()); + ged_e1x5_all->Fill(gedEle.e1x5()); + ged_sihih_all->Fill(gedEle.sigmaIetaIeta()); + ged_r9_all->Fill(gedEle.r9()); + ged_scshh_all->Fill(gedEle.superCluster()->etaWidth()); + ged_scsff_all->Fill(gedEle.superCluster()->phiWidth()); if (std::abs(etareco) < 1.479) { - ged_e1x5_eb->Fill(theGedEle[j].e1x5()); - ged_sihih_eb->Fill(theGedEle[j].sigmaIetaIeta()); - ged_r9_eb->Fill(theGedEle[j].r9()); - ged_scshh_eb->Fill((theGedEle[j]).superCluster()->etaWidth()); - ged_scsff_eb->Fill((theGedEle[j]).superCluster()->phiWidth()); + ged_e1x5_eb->Fill(gedEle.e1x5()); + ged_sihih_eb->Fill(gedEle.sigmaIetaIeta()); + ged_r9_eb->Fill(gedEle.r9()); + ged_scshh_eb->Fill(gedEle.superCluster()->etaWidth()); + ged_scsff_eb->Fill(gedEle.superCluster()->phiWidth()); } if (std::abs(etareco) >= 1.479) { - ged_e1x5_ee->Fill(theGedEle[j].e1x5()); - ged_sihih_ee->Fill(theGedEle[j].sigmaIetaIeta()); - ged_r9_ee->Fill(theGedEle[j].r9()); - ged_scshh_ee->Fill((theGedEle[j]).superCluster()->etaWidth()); - ged_scsff_eb->Fill((theGedEle[j]).superCluster()->phiWidth()); + ged_e1x5_ee->Fill(gedEle.e1x5()); + ged_sihih_ee->Fill(gedEle.sigmaIetaIeta()); + ged_r9_ee->Fill(gedEle.r9()); + ged_scshh_ee->Fill(gedEle.superCluster()->etaWidth()); + ged_scsff_eb->Fill(gedEle.superCluster()->phiWidth()); } MindRGedEg = dR; diff --git a/RecoParticleFlow/PFSimProducer/plugins/ConvBremSeedProducer.cc b/RecoParticleFlow/PFSimProducer/plugins/ConvBremSeedProducer.cc index 3877f7e621c46..3f811274f9ec5 100644 --- a/RecoParticleFlow/PFSimProducer/plugins/ConvBremSeedProducer.cc +++ b/RecoParticleFlow/PFSimProducer/plugins/ConvBremSeedProducer.cc @@ -77,7 +77,12 @@ class ConvBremSeedProducer : public edm::stream::EDProducer<> { std::vector sharedHits(const std::vector > >&); - edm::ParameterSet conf_; + const edm::EDGetTokenT pfToken_; + const edm::EDGetTokenT pixelHitsToken_; + const edm::EDGetTokenT rphirecHitsToken_; + const edm::EDGetTokenT matchedrecHitsToken_; + const edm::EDGetTokenT thePfRecTrackToken_; + const GeometricSearchTracker* geomSearchTracker_; const TrackerInteractionGeometry* geometry_; const TrackerGeometry* tracker_; @@ -120,7 +125,12 @@ using namespace std; using namespace reco; ConvBremSeedProducer::ConvBremSeedProducer(const ParameterSet& iConfig) - : conf_(iConfig), + : pfToken_(consumes(iConfig.getParameter("PFClusters"))), + pixelHitsToken_(consumes(iConfig.getParameter("pixelRecHits"))), + rphirecHitsToken_(consumes(iConfig.getParameter("rphirecHits"))), + matchedrecHitsToken_( + consumes(iConfig.getParameter("matchedrecHits"))), + thePfRecTrackToken_(consumes(iConfig.getParameter("PFRecTrackLabel"))), fieldMap_(nullptr), layerMap_(56, static_cast(nullptr)), negLayerOffset_(27), @@ -131,7 +141,7 @@ ConvBremSeedProducer::ConvBremSeedProducer(const ParameterSet& iConfig) magFieldToken_beginRun_(esConsumes()), magFieldMapToken_(esConsumes()), hitBuilderToken_( - esConsumes(edm::ESInputTag("", conf_.getParameter("TTRHBuilder")))) { + esConsumes(edm::ESInputTag("", iConfig.getParameter("TTRHBuilder")))) { produces(); } @@ -143,24 +153,18 @@ void ConvBremSeedProducer::produce(Event& iEvent, const EventSetup& iSetup) { ///INPUT COLLECTIONS ///PF CLUSTERS - Handle PfC; - iEvent.getByLabel(conf_.getParameter("PFClusters"), PfC); - const PFClusterCollection& PPP = *(PfC.product()); + const auto& PPP = iEvent.get(pfToken_); ///PIXEL - Handle pixelHits; - iEvent.getByLabel(conf_.getParameter("pixelRecHits"), pixelHits); + const auto& pixelHits = iEvent.getHandle(pixelHitsToken_); ///STRIP - Handle rphirecHits; - iEvent.getByLabel(conf_.getParameter("rphirecHits"), rphirecHits); - Handle matchedrecHits; - iEvent.getByLabel(conf_.getParameter("matchedrecHits"), matchedrecHits); + const auto& rphirecHits = iEvent.getHandle(rphirecHitsToken_); + const auto& matchedrecHits = iEvent.getHandle(matchedrecHitsToken_); //GSFPFRECTRACKS - Handle thePfRecTrackCollection; - iEvent.getByLabel(conf_.getParameter("PFRecTrackLabel"), thePfRecTrackCollection); - const GsfPFRecTrackCollection PfRTkColl = *(thePfRecTrackCollection.product()); + const auto& thePfRecTrackCollection = iEvent.getHandle(thePfRecTrackToken_); + const auto& PfRTkColl = *thePfRecTrackCollection; ///OUTPUT COLLECTION auto output = std::make_unique(); diff --git a/RecoParticleFlow/PFTracking/plugins/ElectronSeedMerger.cc b/RecoParticleFlow/PFTracking/plugins/ElectronSeedMerger.cc index b1ec3132365ce..980e4f80ad318 100644 --- a/RecoParticleFlow/PFTracking/plugins/ElectronSeedMerger.cc +++ b/RecoParticleFlow/PFTracking/plugins/ElectronSeedMerger.cc @@ -18,6 +18,7 @@ class ElectronSeedMerger : public edm::global::EDProducer<> { public: explicit ElectronSeedMerger(const edm::ParameterSet&); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override; @@ -30,6 +31,13 @@ using namespace edm; using namespace std; using namespace reco; +void ElectronSeedMerger::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("EcalBasedSeeds", edm::InputTag("ecalDrivenElectronSeeds")); + desc.add("TkBasedSeeds", edm::InputTag("trackerDrivenElectronSeeds:SeedsForGsf")); + descriptions.addWithDefaultLabel(desc); +} + ElectronSeedMerger::ElectronSeedMerger(const ParameterSet& iConfig) : ecalSeedToken_{consumes(iConfig.getParameter("EcalBasedSeeds"))} { edm::InputTag tkSeedLabel_ = iConfig.getParameter("TkBasedSeeds"); diff --git a/RecoParticleFlow/PFTracking/plugins/GoodSeedProducer.cc b/RecoParticleFlow/PFTracking/plugins/GoodSeedProducer.cc index 95f2ab480f955..03e90bd96d08d 100644 --- a/RecoParticleFlow/PFTracking/plugins/GoodSeedProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/GoodSeedProducer.cc @@ -76,6 +76,7 @@ class GoodSeedProducer final : public edm::stream::EDProducer("MaxEOverP", 3.0); + desc.add("Smoother", "GsfTrajectorySmoother_forPreId"); + desc.add("UseQuality", true); + desc.add("PFPSClusterLabel", {"particleFlowClusterPS"}); + desc.add("ThresholdFile", "RecoParticleFlow/PFTracking/data/Threshold.dat"); + desc.add("TMVAMethod", "BDT"); + desc.add("MaxEta", 2.4); + desc.add("EtaMap", "RecoParticleFlow/PFBlockProducer/data/resmap_ECAL_eta.dat"); + desc.add("PhiMap", "RecoParticleFlow/PFBlockProducer/data/resmap_ECAL_phi.dat"); + desc.add("PreCkfLabel", "SeedsForCkf"); + desc.add("NHitsInSeed", 3); + desc.add("Fitter", "GsfTrajectoryFitter_forPreId"); + desc.add("TTRHBuilder", "WithAngleAndTemplate"); + desc.add("PreGsfLabel", "SeedsForGsf"); + desc.add("MinEOverP", 0.3); + desc.add("Weights1", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat1.xml"); + desc.add("Weights2", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat2.xml"); + desc.add("Weights3", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat3.xml"); + desc.add("Weights4", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat4.xml"); + desc.add("Weights5", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat5.xml"); + desc.add("Weights6", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat6.xml"); + desc.add("Weights7", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat7.xml"); + desc.add("Weights8", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat8.xml"); + desc.add("Weights9", "RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat9.xml"); + desc.add("PFEcalClusterLabel", {"particleFlowClusterECAL"}); + desc.add("PFHcalClusterLabel", {"particleFlowClusterHCAL"}), + desc.add("PSThresholdFile", "RecoParticleFlow/PFTracking/data/PSThreshold.dat"); + desc.add("MinPt", 2.0); + desc.add>("TkColList", {edm::InputTag("generalTracks")}); + desc.addUntracked("UseTMVA", true); + desc.add("TrackQuality", "highPurity"); + desc.add("MaxPt", 50.0); + desc.add("ApplyIsolation", false); + desc.add("EcalStripSumE_deltaPhiOverQ_minValue", -0.1); + desc.add("EcalStripSumE_minClusEnergy", 0.1); + desc.add("EcalStripSumE_deltaEta", 0.03); + desc.add("EcalStripSumE_deltaPhiOverQ_maxValue", 0.5); + desc.add("EOverPLead_minValue", 0.95); + desc.add("HOverPLead_maxValue", 0.05); + desc.add("HcalWindow", 0.184); + desc.add("ClusterThreshold", 0.5); + desc.add("UsePreShower", false); + desc.add("PreIdLabel", "preid"); + desc.addUntracked("ProducePreId", true); + desc.addUntracked("PtThresholdSavePreId", 1.0); + desc.add("Min_dr", 0.2); + descriptions.addWithDefaultLabel(desc); +} + GoodSeedProducer::GoodSeedProducer(const ParameterSet& iConfig, const goodseedhelpers::HeavyObjectCache*) : pfTransformer_(nullptr), conf_(iConfig), diff --git a/RecoParticleFlow/PFTracking/plugins/HGCalTrackCollectionProducer.cc b/RecoParticleFlow/PFTracking/plugins/HGCalTrackCollectionProducer.cc index 99a80659987a3..f81ebcad6985d 100644 --- a/RecoParticleFlow/PFTracking/plugins/HGCalTrackCollectionProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/HGCalTrackCollectionProducer.cc @@ -39,12 +39,13 @@ class HGCalTrackCollectionProducer : public edm::stream::EDProducer<> { public: HGCalTrackCollectionProducer(const edm::ParameterSet&); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: void produce(edm::Event&, const edm::EventSetup&) override; void beginLuminosityBlock(const edm::LuminosityBlock&, const edm::EventSetup&) override; - edm::EDGetTokenT > src_; + edm::EDGetTokenT> src_; // variables needed for copied goodPtResolution function // need to go back and figure out sensible values @@ -64,7 +65,7 @@ class HGCalTrackCollectionProducer : public edm::stream::EDProducer<> { std::array, 1> hgcGeometryTokens_; // 3 --> 1; extrapolate to hgcee only std::array hgcGeometries_; // 3 --> 1; extrapolate to hgcee only - std::array >, 1> plusSurface_, + std::array>, 1> plusSurface_, minusSurface_; // 3 --> 1; extrapolate to hgcee only std::unique_ptr mat_prop_; @@ -72,13 +73,26 @@ class HGCalTrackCollectionProducer : public edm::stream::EDProducer<> { float diskInnerRadius_; }; +void HGCalTrackCollectionProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", {"pfTrack"}); + desc.add("trackQuality", "highPurity"); + desc.add("useIterativeTracking", true); + desc.add>("DPtOverPtCuts_byTrackAlgo", {10.0, 10.0, 10.0, 10.0, 10.0, 5.0}); + desc.add>("NHitCuts_byTrackAlgo", {3, 3, 3, 3, 3, 3}); + edm::ParameterSetDescription pset; + pset.add("HGC_ECAL", "HGCalEESensitive"); + desc.add("hgcalGeometryNames", pset); + descriptions.add("hgcalTrackCollection", desc); +} + HGCalTrackCollectionProducer::HGCalTrackCollectionProducer(const edm::ParameterSet& iConfig) - : src_(consumes >(iConfig.getParameter("src"))), + : src_(consumes>(iConfig.getParameter("src"))), trackQuality_((iConfig.existsAs("trackQuality")) ? reco::TrackBase::qualityByName(iConfig.getParameter("trackQuality")) : reco::TrackBase::highPurity), - DPtovPtCut_(iConfig.getParameter >("DPtOverPtCuts_byTrackAlgo")), - NHitCut_(iConfig.getParameter >("NHitCuts_byTrackAlgo")), + DPtovPtCut_(iConfig.getParameter>("DPtOverPtCuts_byTrackAlgo")), + NHitCut_(iConfig.getParameter>("NHitCuts_byTrackAlgo")), useIterTracking_(iConfig.getParameter("useIterativeTracking")), magneticFieldToken_(esConsumes()), tkerGeomToken_(esConsumes()) { @@ -133,7 +147,7 @@ void HGCalTrackCollectionProducer::beginLuminosityBlock(const edm::LuminosityBlo } void HGCalTrackCollectionProducer::produce(edm::Event& evt, const edm::EventSetup& iSetup) { - edm::Handle > trackHandle; + edm::Handle> trackHandle; evt.getByToken(src_, trackHandle); const auto& tracks = *trackHandle; diff --git a/RecoParticleFlow/PFTracking/plugins/LightPFTrackProducer.cc b/RecoParticleFlow/PFTracking/plugins/LightPFTrackProducer.cc index 9608a14c76d2f..a3f7c905184c5 100644 --- a/RecoParticleFlow/PFTracking/plugins/LightPFTrackProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/LightPFTrackProducer.cc @@ -17,6 +17,8 @@ class LightPFTrackProducer : public edm::stream::EDProducer<> { ///Destructor ~LightPFTrackProducer() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -26,7 +28,7 @@ class LightPFTrackProducer : public edm::stream::EDProducer<> { ///PFTrackTransformer PFTrackTransformer* pfTransformer_; - std::vector > tracksContainers_; + std::vector> tracksContainers_; const edm::ESGetToken magneticFieldToken_; ///TRACK QUALITY @@ -37,13 +39,22 @@ class LightPFTrackProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(LightPFTrackProducer); +void LightPFTrackProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("TrackQuality", "highPurity"); + desc.add("UseQuality", true); + desc.add>( + "TkColList", {edm::InputTag("generalTracks"), edm::InputTag("secStep"), edm::InputTag("thStep")}); + descriptions.add("lightpftrack", desc); +} + using namespace std; using namespace edm; LightPFTrackProducer::LightPFTrackProducer(const ParameterSet& iConfig) : pfTransformer_(nullptr), magneticFieldToken_(esConsumes()) { produces(); - std::vector tags = iConfig.getParameter >("TkColList"); + std::vector tags = iConfig.getParameter>("TkColList"); for (unsigned int i = 0; i < tags.size(); ++i) tracksContainers_.push_back(consumes(tags[i])); diff --git a/RecoParticleFlow/PFTracking/plugins/PFConversionProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFConversionProducer.cc index f0a3ad6e14cd7..14b05ccffd339 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFConversionProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFConversionProducer.cc @@ -22,6 +22,8 @@ class PFConversionProducer : public edm::stream::EDProducer<> { ///Destructor ~PFConversionProducer() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -41,6 +43,13 @@ class PFConversionProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFConversionProducer); +void PFConversionProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("conversionCollection", {"allConversions", ""}); + desc.add("PrimaryVertexLabel", {"offlinePrimaryVertices"}); + descriptions.add("pfConversions", desc); +} + typedef std::multimap > BlockMap; using namespace std; using namespace edm; diff --git a/RecoParticleFlow/PFTracking/plugins/PFDisplacedTrackerVertexProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFDisplacedTrackerVertexProducer.cc index ee7e1794acdc8..02b49be0a9520 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFDisplacedTrackerVertexProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFDisplacedTrackerVertexProducer.cc @@ -16,6 +16,8 @@ class PFDisplacedTrackerVertexProducer : public edm::stream::EDProducer<> { ///Destructor ~PFDisplacedTrackerVertexProducer() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -34,6 +36,13 @@ class PFDisplacedTrackerVertexProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFDisplacedTrackerVertexProducer); +void PFDisplacedTrackerVertexProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("displacedTrackerVertexColl", {"particleFlowDisplacedVertex"}); + desc.add("trackColl", {"generalTracks"}); + descriptions.add("pfDisplacedTrackerVertex", desc); +} + using namespace std; using namespace edm; PFDisplacedTrackerVertexProducer::PFDisplacedTrackerVertexProducer(const ParameterSet& iConfig) diff --git a/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexCandidateProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexCandidateProducer.cc index feb4d96a263ac..a2cfd529d0a7b 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexCandidateProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexCandidateProducer.cc @@ -28,6 +28,7 @@ class PFDisplacedVertexCandidateProducer : public edm::stream::EDProducer<> { ~PFDisplacedVertexCandidateProducer() override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: /// Reco Tracks used to spot the nuclear interactions @@ -49,6 +50,43 @@ class PFDisplacedVertexCandidateProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFDisplacedVertexCandidateProducer); +void PFDisplacedVertexCandidateProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + // The track collection use for the fitting. May be any collection. + // The only condition is that it shall contain the hit pattern information + desc.add("trackCollection", {"generalTracks"}); + // verbosity + desc.addUntracked("verbose", false); + // Debug flag + desc.addUntracked("debug", false); + // maximum dca distance for two tracks to be linked + desc.add("dcaCut", 0.5); + // minimum distance of secondary vertex with respect to the primary + desc.add("primaryVertexCut", 1.8); + // maximum distance between the DCA Point and the inner hit of the track + // not used for the moment + desc.add("dcaPInnerHitCut", 1000.0); + // Primary vertex information used for dxy calculation + desc.add("mainVertexLabel", {"offlinePrimaryVertices", ""}); + desc.add("offlineBeamSpotLabel", {"offlineBeamSpot", ""}); + // Tracks preselection to reduce the combinatorics in PFDisplacedVertexCandidates + // this cuts are repeated then in a smarter way in the PFDisplacedVertexFinder + // be sure you are consistent between them. + { + edm::ParameterSetDescription pset; + // selection parameters for secondary tracks + pset.add("nChi2_max", 5.); + pset.add("pt_min", 0.2); + // if the tracks is not a good candidate to be a secondary (dxy cut) restrict in minimal pt + // this cut reduce drastically the combinatorics. It is very useful to reduce the + // PFDisplacedVertex timing + pset.add("pt_min_prim", 0.8); + pset.add("dxy", 0.2); + desc.add("tracksSelectorParameters", pset); + } + descriptions.add("particleFlowDisplacedVertexCandidate", desc); +} + using namespace std; using namespace edm; diff --git a/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexProducer.cc index 9359db8cf9150..a81d564fee85e 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFDisplacedVertexProducer.cc @@ -32,6 +32,7 @@ class PFDisplacedVertexProducer : public edm::stream::EDProducer<> { ~PFDisplacedVertexProducer() override; void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: /// Collection of DisplacedVertex Candidates used as input for @@ -58,6 +59,92 @@ class PFDisplacedVertexProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFDisplacedVertexProducer); +void PFDisplacedVertexProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("vertexCandidatesLabel", {"particleFlowDisplacedVertexCandidate"}); + // verbosity + desc.addUntracked("verbose", false); + // Debug flag + desc.addUntracked("debug", false); + // maximum transverse distance between two points to be used in Seed + desc.add("transvSize", 1.0); + // maximum longitudinal distance between two points to be used in Seed + desc.add("longSize", 5); + // minimal radius below which we do not reconstruct interactions + // typically the position of the first Pixel layer or beam pipe + desc.add("primaryVertexCut", 1.8); + // radius below which we don't wamt to reconstruct displaced + // vertices + desc.add("tobCut", 100); + // z below which we don't want to reconstruct displaced + // vertices + desc.add("tecCut", 220); + // the minimal accepted weight for the tracks calculated in the + // adaptive vertex fitter to be associated to the displaced vertex + // this correspond to the sigmacut of 6 + desc.add("minAdaptWeight", 0.5); + // this flag is designed to reduce the timing of the algorithm in the high pile-up conditions. 2 tracks + // vertices are the most sensitives to the pile-ups. + desc.addUntracked("switchOff2TrackVertex", true); + // ------------ Paramemeters for the track selection ------------ + // Primary vertex information used for dxy calculation + desc.add("mainVertexLabel", {"offlinePrimaryVertices", ""}); + desc.add("offlineBeamSpotLabel", {"offlineBeamSpot", ""}); + // Parameters used to apply cuts + { + edm::ParameterSetDescription pset; + pset.add("bSelectTracks", true); + // If a track is high purity it is always kept + pset.add("quality", "HighPurity"); + // Following cuts are applyed to non high purity tracks + // nChi2_max and pt_min cuts are applyed to the primary and secondary tracks + pset.add("nChi2_max", 5.); + pset.add("pt_min", 0.2); + // nChi2_min applyed only to primary tracks which may be short + // remove fake pixel triplets + pset.add("nChi2_min", 0.5); + // Cuts applyed to the secondary tracks long and displaced + pset.add("dxy_min", 0.2); + pset.add("nHits_min", 6); + pset.add("nOuterHits_max", 9); + desc.add("tracksSelectorParameters", pset); + } + // ------------ Paramemeters for the vertex identification ------------ + { + edm::ParameterSetDescription pset; + pset.add("bIdentifyVertices", true); + // Minimal sum pt of secondary tracks for displaced vertices. + // Below this value we find either loopers splitted in two parts eiter + // fake vertices in forward direction + pset.add("pt_min", 0.5); + // Minimal pT and log10(P_primary/P_secondary) for primary track in kinks (Primary+Secondary) + // which are not identifier as K-+ decays + pset.add("pt_kink_min", 3.0); + pset.add("logPrimSec_min", 0.0); + // maximum absoluta value of eta for loopers + pset.add("looper_eta_max", 0.1); + // Masses cuts for selections + // CVmin K0min K0max K-min K-max Ldmin Ldmax Nuclmin_ee + pset.add>("masses", {0.050, 0.485, 0.515, 0.480, 0.520, 1.107, 1.125, 0.200}); + // Angle between the primaryVertex-secondaryVertex direction and secondary tracks direction + // this angle means that the final system shall propagate in the same direction than initial system + // all_max, CV and V0 max + pset.add>("angles", {15, 15}); + desc.add("vertexIdentifierParameters", pset); + } + // Adaptive Vertex Fitter parameters identical to the default ones except sigmacut. + // The default value is sigmacut = 3 too tight for displaced vertices + // see CMS NOTE-2008/033 for more details + { + edm::ParameterSetDescription pset; + pset.add("sigmacut", 6.); + pset.add("Tini", 256.); + pset.add("ratio", 0.25); + desc.add("avfParameters", pset); + } + descriptions.add("particleFlowDisplacedVertex", desc); +} + using namespace std; using namespace edm; diff --git a/RecoParticleFlow/PFTracking/plugins/PFElecTkProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFElecTkProducer.cc index d066241913ed5..e72433298ee8d 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFElecTkProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFElecTkProducer.cc @@ -69,6 +69,7 @@ class PFElecTkProducer final : public edm::stream::EDProducer gsfInnerMomentumCache_; }; +void PFElecTkProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("TrajInEvents", false); + desc.add("Fitter", "GsfElectronFittingSmoother"); + desc.add("ModeMomentum", true); + desc.add("applyEGSelection", false); + desc.add("applyGsfTrackCleaning", true); + desc.add("applyAlsoGsfAngularCleaning", true); + desc.add("maxDEtaGsfAngularCleaning", 0.05); + desc.add("maxDPhiBremTangGsfAngularCleaning", 0.05); + desc.add("useFifthStepForTrackerDrivenGsf", false); + desc.add("useFifthStepForEcalDrivenGsf", false); + desc.add("MaxConvBremRecoPT", 49.0); + desc.add("MinDEtaGsfSC", 0.06); + desc.add("MinDPhiGsfSC", 0.15); + desc.add("MinSCEnergy", 4.0); + desc.add("TTRHBuilder", "WithTrackAngle"); + desc.add("GsfTrackModuleLabel", {"electronGsfTracks"}); + desc.add("Propagator", "fwdElectronPropagator"); + desc.add("PFRecTrackLabel", {"pfTrack"}); + desc.add("PFEcalClusters", {"particleFlowClusterECAL"}); + desc.add("PrimaryVertexLabel", {"offlinePrimaryVertices"}); + desc.add("useConvBremFinder", true); + desc.add("PFNuclear", {"pfDisplacedTrackerVertex"}); + desc.add("PFConversions", {"pfConversions"}); + desc.add("PFV0", {"pfV0"}); + desc.add("useNuclear", false); + desc.add("useV0", false); + desc.add("useConversions", false); + desc.add("debugGsfCleaning", false); + desc.add("AbsEtaBarrelEndcapsSeparation", 1.479); + desc.add("PtLowHighSeparation", 20); + desc.add("pf_convBremFinderID_mvaCutBarrelLowPt", 0.6); + desc.add("pf_convBremFinderID_mvaCutBarrelHighPt", 0.97); + desc.add("pf_convBremFinderID_mvaCutEndcapsLowPt", 0.9); + desc.add("pf_convBremFinderID_mvaCutEndcapsHighPt", 0.995); + desc.add( + "pf_convBremFinderID_mvaWeightFileBarrelLowPt", + edm::FileInPath("RecoParticleFlow/PFTracking/data/" + "TMVAClassification_ConvBremFinder_Testetlt20absetalt1_479_BDT.weights.xml")); + desc.add( + "pf_convBremFinderID_mvaWeightFileBarrelHighPt", + edm::FileInPath("RecoParticleFlow/PFTracking/data/" + "TMVAClassification_ConvBremFinder_Testetgt20absetalt1_479_BDT.weights.xml")); + desc.add( + "pf_convBremFinderID_mvaWeightFileEndcapsLowPt", + edm::FileInPath("RecoParticleFlow/PFTracking/data/" + "TMVAClassification_ConvBremFinder_Testetlt20absetagt1_479_BDT.weights.xml")); + desc.add( + "pf_convBremFinderID_mvaWeightFileEndcapsHighPt", + edm::FileInPath("RecoParticleFlow/PFTracking/data/" + "TMVAClassification_ConvBremFinder_Testetgt20absetagt1_479_BDT.weights.xml")); + descriptions.addWithDefaultLabel(desc); +} + using namespace std; using namespace edm; using namespace reco; diff --git a/RecoParticleFlow/PFTracking/plugins/PFNuclearProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFNuclearProducer.cc index 2f7221efbfd36..3206f772e713f 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFNuclearProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFNuclearProducer.cc @@ -16,6 +16,8 @@ class PFNuclearProducer : public edm::stream::EDProducer<> { ///Destructor ~PFNuclearProducer() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -26,7 +28,7 @@ class PFNuclearProducer : public edm::stream::EDProducer<> { ///PFTrackTransformer PFTrackTransformer* pfTransformer_; double likelihoodCut_; - std::vector > nuclearContainers_; + std::vector> nuclearContainers_; const edm::ESGetToken magneticFieldToken_; }; @@ -34,6 +36,14 @@ class PFNuclearProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFNuclearProducer); +void PFNuclearProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + // cut on the likelihood of the nuclear interaction + desc.add("likelihoodCut", 0.1); + desc.add>("nuclearColList", {edm::InputTag("firstnuclearInteractionMaker")}); + descriptions.add("pfNuclear", desc); +} + using namespace std; using namespace edm; PFNuclearProducer::PFNuclearProducer(const ParameterSet& iConfig) @@ -41,7 +51,7 @@ PFNuclearProducer::PFNuclearProducer(const ParameterSet& iConfig) produces(); produces(); - std::vector tags = iConfig.getParameter >("nuclearColList"); + std::vector tags = iConfig.getParameter>("nuclearColList"); for (unsigned int i = 0; i < tags.size(); ++i) nuclearContainers_.push_back(consumes(tags[i])); diff --git a/RecoParticleFlow/PFTracking/plugins/PFTrackProducer.cc b/RecoParticleFlow/PFTracking/plugins/PFTrackProducer.cc index 096dc3b29bd0e..ea616e7dc993e 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFTrackProducer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFTrackProducer.cc @@ -30,6 +30,8 @@ class PFTrackProducer : public edm::stream::EDProducer<> { ///Constructor explicit PFTrackProducer(const edm::ParameterSet&); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -57,6 +59,19 @@ class PFTrackProducer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFTrackProducer); +void PFTrackProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("TrackQuality", "highPurity"); + desc.add("UseQuality", true); + desc.add("GsfTrackModuleLabel", {"electronGsfTracks"}); + desc.add>("TkColList", {edm::InputTag("generalTracks")}); + desc.add("PrimaryVertexLabel", {"offlinePrimaryVertices"}); + desc.add("MuColl", {"muons1stStep"}); + desc.add("TrajInEvents", false); + desc.add("GsfTracksInEvents", true); + descriptions.add("pfTrack", desc); +} + using namespace std; using namespace edm; using namespace reco; diff --git a/RecoParticleFlow/PFTracking/plugins/PFV0Producer.cc b/RecoParticleFlow/PFTracking/plugins/PFV0Producer.cc index 3489c4d8e1043..24cfe708ed31f 100644 --- a/RecoParticleFlow/PFTracking/plugins/PFV0Producer.cc +++ b/RecoParticleFlow/PFTracking/plugins/PFV0Producer.cc @@ -18,6 +18,8 @@ class PFV0Producer : public edm::stream::EDProducer<> { ///Destructor ~PFV0Producer() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void beginRun(const edm::Run&, const edm::EventSetup&) override; void endRun(const edm::Run&, const edm::EventSetup&) override; @@ -27,7 +29,7 @@ class PFV0Producer : public edm::stream::EDProducer<> { ///PFTrackTransformer PFTrackTransformer* pfTransformer_; - std::vector > V0list_; + std::vector> V0list_; const edm::ESGetToken magneticFieldToken_; }; @@ -35,6 +37,13 @@ class PFV0Producer : public edm::stream::EDProducer<> { #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PFV0Producer); +void PFV0Producer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add>( + "V0List", {edm::InputTag("generalV0Candidates", "Kshort"), edm::InputTag("generalV0Candidates", "Lambda")}); + descriptions.add("pfV0", desc); +} + using namespace std; using namespace edm; using namespace reco; @@ -43,7 +52,7 @@ PFV0Producer::PFV0Producer(const ParameterSet& iConfig) produces(); produces(); - std::vector tags = iConfig.getParameter >("V0List"); + std::vector tags = iConfig.getParameter>("V0List"); for (unsigned int i = 0; i < tags.size(); ++i) V0list_.push_back(consumes(tags[i])); diff --git a/RecoParticleFlow/PFTracking/python/hgcalTrackCollection_cfi.py b/RecoParticleFlow/PFTracking/python/hgcalTrackCollection_cfi.py deleted file mode 100644 index 576ea498e3f12..0000000000000 --- a/RecoParticleFlow/PFTracking/python/hgcalTrackCollection_cfi.py +++ /dev/null @@ -1,16 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -hgcalTrackCollection = cms.EDProducer( - "HGCalTrackCollectionProducer", - src = cms.InputTag("pfTrack"), - trackQuality = cms.string("highPurity"), - # From GeneralTracksImporter - useIterativeTracking = cms.bool(True), - DPtOverPtCuts_byTrackAlgo = cms.vdouble(10.0,10.0,10.0,10.0,10.0,5.0), - NHitCuts_byTrackAlgo = cms.vuint32(3,3,3,3,3,3), - - # From HGCClusterizer - hgcalGeometryNames = cms.PSet( HGC_ECAL = cms.string('HGCalEESensitive'), - ), - -) diff --git a/RecoParticleFlow/PFTracking/python/lightpftrack_cfi.py b/RecoParticleFlow/PFTracking/python/lightpftrack_cfi.py deleted file mode 100644 index 5088c9dfba08e..0000000000000 --- a/RecoParticleFlow/PFTracking/python/lightpftrack_cfi.py +++ /dev/null @@ -1,9 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -lightpftrackprod = cms.EDProducer("LightPFTrackProducer", - TrackQuality = cms.string('highPurity'), - UseQuality = cms.bool(True), - TkColList = cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("secStep"), cms.InputTag("thStep")) -) - - diff --git a/RecoParticleFlow/PFTracking/python/mergedElectronSeeds_cfi.py b/RecoParticleFlow/PFTracking/python/mergedElectronSeeds_cfi.py index e5dc112043e21..21ed35c4e02ba 100644 --- a/RecoParticleFlow/PFTracking/python/mergedElectronSeeds_cfi.py +++ b/RecoParticleFlow/PFTracking/python/mergedElectronSeeds_cfi.py @@ -1,10 +1,7 @@ import FWCore.ParameterSet.Config as cms - -electronMergedSeeds =cms.EDProducer("ElectronSeedMerger", - EcalBasedSeeds = cms.InputTag("ecalDrivenElectronSeeds"), - TkBasedSeeds = cms.InputTag("trackerDrivenElectronSeeds:SeedsForGsf") - ) +from RecoParticleFlow.PFTracking.ElectronSeedMerger import ElectronSeedMerger +electronMergedSeeds = ElectronSeedMerger() from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(electronMergedSeeds, TkBasedSeeds = '') diff --git a/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertexCandidate_cfi.py b/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertexCandidate_cfi.py deleted file mode 100644 index 149d89dd16510..0000000000000 --- a/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertexCandidate_cfi.py +++ /dev/null @@ -1,47 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -particleFlowDisplacedVertexCandidate = cms.EDProducer("PFDisplacedVertexCandidateProducer", - - - # The track collection use for the fitting. May be any collection. - # The only condition is that it shall contain the hit pattern information - trackCollection = cms.InputTag("generalTracks"), - - # verbosity - verbose = cms.untracked.bool(False), - - # Debug flag - debug = cms.untracked.bool(False), - - # maximum dca distance for two tracks to be linked - dcaCut = cms.double(0.5), - - # minimum distance of secondary vertex with respect to the primary - primaryVertexCut = cms.double(1.8), - - # maximum distance between the DCA Point and the inner hit of the track - # not used for the moment - dcaPInnerHitCut = cms.double(1000.0), - - # Primary vertex information used for dxy calculation - mainVertexLabel = cms.InputTag("offlinePrimaryVertices", ""), - offlineBeamSpotLabel = cms.InputTag("offlineBeamSpot", ""), - - # Tracks preselection to reduce the combinatorics in PFDisplacedVertexCandidates - # this cuts are repeated then in a smarter way in the PFDisplacedVertexFinder - # be sure you are consistent between them. - tracksSelectorParameters = cms.PSet( - # selection parameters for secondary tracks - nChi2_max = cms.double(5.), - pt_min = cms.double(.2), - # if the tracks is not a good candidate to be a secondary (dxy cut) restrict in minimal pt - # this cut reduce drastically the combinatorics. It is very useful to reduce the - # PFDisplacedVertex timing - pt_min_prim = cms.double(.8), - dxy = cms.double(.2), - - ) - -) - - diff --git a/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertex_cfi.py b/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertex_cfi.py deleted file mode 100644 index 15b8e0d9d0991..0000000000000 --- a/RecoParticleFlow/PFTracking/python/particleFlowDisplacedVertex_cfi.py +++ /dev/null @@ -1,99 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -particleFlowDisplacedVertex = cms.EDProducer("PFDisplacedVertexProducer", - - vertexCandidatesLabel = cms.InputTag("particleFlowDisplacedVertexCandidate"), - - # verbosity - verbose = cms.untracked.bool(False), - - # Debug flag - debug = cms.untracked.bool(False), - - # maximum transverse distance between two points to be used in Seed - transvSize = cms.double(1.0), - - # maximum longitudinal distance between two points to be used in Seed - longSize = cms.double(5), - - # minimal radius below which we do not reconstruct interactions - # typically the position of the first Pixel layer or beam pipe - primaryVertexCut = cms.double(1.8), - - # radius below which we don't wamt to reconstruct displaced - # vertices - tobCut = cms.double(100), - - # z below which we don't want to reconstruct displaced - # vertices - tecCut = cms.double(220), - - # the minimal accepted weight for the tracks calculated in the - # adaptive vertex fitter to be associated to the displaced vertex - # this correspond to the sigmacut of 6 - minAdaptWeight = cms.double(0.5), - - # this flag is designed to reduce the timing of the algorithm in the high pile-up conditions. 2 tracks - # vertices are the most sensitives to the pile-ups. - switchOff2TrackVertex = cms.untracked.bool(True), - - # ------------ Paramemeters for the track selection ------------ - - # Primary vertex information used for dxy calculation - mainVertexLabel = cms.InputTag("offlinePrimaryVertices", ""), - offlineBeamSpotLabel = cms.InputTag("offlineBeamSpot", ""), - - # Parameters used to apply cuts - tracksSelectorParameters = cms.PSet( - bSelectTracks = cms.bool(True), - # If a track is high purity it is always kept - quality = cms.string("HighPurity"), - # Following cuts are applyed to non high purity tracks - # nChi2_max and pt_min cuts are applyed to the primary and secondary tracks - nChi2_max = cms.double(5.), - pt_min = cms.double(.2), - # nChi2_min applyed only to primary tracks which may be short - # remove fake pixel triplets - nChi2_min = cms.double(.5), - # Cuts applyed to the secondary tracks long and displaced - dxy_min = cms.double(.2), - nHits_min = cms.int32(6), - nOuterHits_max = cms.int32(9) - ), - - # ------------ Paramemeters for the vertex identification ------------ - - vertexIdentifierParameters = cms.PSet( - bIdentifyVertices = cms.bool(True), - # Minimal sum pt of secondary tracks for displaced vertices. - # Below this value we find either loopers splitted in two parts eiter - # fake vertices in forward direction - pt_min = cms.double(0.5), - # Minimal pT and log10(P_primary/P_secondary) for primary track in kinks (Primary+Secondary) - # which are not identifier as K-+ decays - pt_kink_min = cms.double(3.0), - logPrimSec_min = cms.double(0.0), - # maximum absoluta value of eta for loopers - looper_eta_max = cms.double(0.1), - # Masses cuts for selections - # CVmin K0min K0max K-min K-max Ldmin Ldmax Nuclmin_ee - masses = cms.vdouble(0.050, 0.485, 0.515, 0.480, 0.520, 1.107, 1.125, 0.200), - # Angle between the primaryVertex-secondaryVertex direction and secondary tracks direction - # this angle means that the final system shall propagate in the same direction than initial system - # all_max, CV and V0 max - angles = cms.vdouble(15, 15) - ), - - # Adaptive Vertex Fitter parameters identical to the default ones except sigmacut. - # The default value is sigmacut = 3 too tight for displaced vertices - # see CMS NOTE-2008/033 for more details - avfParameters = cms.PSet( - sigmacut = cms.double(6.), - Tini = cms.double(256.), - ratio = cms.double(0.25) - ) - - -) - - diff --git a/RecoParticleFlow/PFTracking/python/pfConversions_cfi.py b/RecoParticleFlow/PFTracking/python/pfConversions_cfi.py deleted file mode 100644 index 22026802a57aa..0000000000000 --- a/RecoParticleFlow/PFTracking/python/pfConversions_cfi.py +++ /dev/null @@ -1,11 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -# -# Author: M. Gouzevitch base on N. Marinelli work -# -pfConversions = cms.EDProducer("PFConversionProducer", - conversionCollection = cms.InputTag("allConversions", ""), - PrimaryVertexLabel = cms.InputTag("offlinePrimaryVertices") -) - - diff --git a/RecoParticleFlow/PFTracking/python/pfDisplacedTrackerVertex_cfi.py b/RecoParticleFlow/PFTracking/python/pfDisplacedTrackerVertex_cfi.py deleted file mode 100644 index c586624503dec..0000000000000 --- a/RecoParticleFlow/PFTracking/python/pfDisplacedTrackerVertex_cfi.py +++ /dev/null @@ -1,10 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfDisplacedTrackerVertex = cms.EDProducer("PFDisplacedTrackerVertexProducer", - # cut on the likelihood of the nuclear interaction - displacedTrackerVertexColl = cms.InputTag("particleFlowDisplacedVertex"), - trackColl = cms.InputTag("generalTracks") - - ) - - diff --git a/RecoParticleFlow/PFTracking/python/pfNuclear_cfi.py b/RecoParticleFlow/PFTracking/python/pfNuclear_cfi.py deleted file mode 100644 index 3f878b0d7ecd1..0000000000000 --- a/RecoParticleFlow/PFTracking/python/pfNuclear_cfi.py +++ /dev/null @@ -1,9 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfNuclear = cms.EDProducer("PFNuclearProducer", - # cut on the likelihood of the nuclear interaction - likelihoodCut = cms.double(0.1), - nuclearColList = cms.VInputTag(cms.InputTag("firstnuclearInteractionMaker")) - ) - - diff --git a/RecoParticleFlow/PFTracking/python/pfTrackElec_cfi.py b/RecoParticleFlow/PFTracking/python/pfTrackElec_cfi.py index 0758a3b3949eb..243e2f0132b0b 100644 --- a/RecoParticleFlow/PFTracking/python/pfTrackElec_cfi.py +++ b/RecoParticleFlow/PFTracking/python/pfTrackElec_cfi.py @@ -1,45 +1,7 @@ import FWCore.ParameterSet.Config as cms -pfTrackElec = cms.EDProducer("PFElecTkProducer", - TrajInEvents = cms.bool(False), - Fitter = cms.string('GsfElectronFittingSmoother'), - ModeMomentum = cms.bool(True), - applyEGSelection = cms.bool(False), - applyGsfTrackCleaning = cms.bool(True), - applyAlsoGsfAngularCleaning = cms.bool(True), - maxDEtaGsfAngularCleaning = cms.double(0.05), - maxDPhiBremTangGsfAngularCleaning = cms.double(0.05), - useFifthStepForTrackerDrivenGsf = cms.bool(False), - useFifthStepForEcalDrivenGsf = cms.bool(False), - MaxConvBremRecoPT = cms.double(49.0), - MinDEtaGsfSC = cms.double(0.06), - MinDPhiGsfSC = cms.double(0.15), - MinSCEnergy = cms.double(4.0), - TTRHBuilder = cms.string('WithTrackAngle'), - GsfTrackModuleLabel = cms.InputTag("electronGsfTracks"), - Propagator = cms.string('fwdElectronPropagator'), - PFRecTrackLabel = cms.InputTag("pfTrack"), - PFEcalClusters = cms.InputTag("particleFlowClusterECAL"), - PrimaryVertexLabel = cms.InputTag("offlinePrimaryVertices"), - useConvBremFinder = cms.bool(True), - PFNuclear = cms.InputTag("pfDisplacedTrackerVertex"), - PFConversions = cms.InputTag("pfConversions"), - PFV0 = cms.InputTag("pfV0"), - useNuclear = cms.bool(False), - useV0 = cms.bool(False), - useConversions = cms.bool(False), - debugGsfCleaning = cms.bool(False), - AbsEtaBarrelEndcapsSeparation = cms.double(1.479), - PtLowHighSeparation = cms.double(20), - pf_convBremFinderID_mvaCutBarrelLowPt = cms.double(0.6), - pf_convBremFinderID_mvaCutBarrelHighPt = cms.double(0.97), - pf_convBremFinderID_mvaCutEndcapsLowPt = cms.double(0.9), - pf_convBremFinderID_mvaCutEndcapsHighPt = cms.double(0.995), - pf_convBremFinderID_mvaWeightFileBarrelLowPt = cms.FileInPath('RecoParticleFlow/PFTracking/data/TMVAClassification_ConvBremFinder_Testetlt20absetalt1_479_BDT.weights.xml'), - pf_convBremFinderID_mvaWeightFileBarrelHighPt = cms.FileInPath('RecoParticleFlow/PFTracking/data/TMVAClassification_ConvBremFinder_Testetgt20absetalt1_479_BDT.weights.xml'), - pf_convBremFinderID_mvaWeightFileEndcapsLowPt = cms.FileInPath('RecoParticleFlow/PFTracking/data/TMVAClassification_ConvBremFinder_Testetlt20absetagt1_479_BDT.weights.xml'), - pf_convBremFinderID_mvaWeightFileEndcapsHighPt = cms.FileInPath('RecoParticleFlow/PFTracking/data/TMVAClassification_ConvBremFinder_Testetgt20absetagt1_479_BDT.weights.xml') -) +from RecoParticleFlow.PFTracking.PFElecTkProducer import PFElecTkProducer +pfTrackElec = PFElecTkProducer() from Configuration.ProcessModifiers.egamma_lowPt_exclusive_cff import egamma_lowPt_exclusive egamma_lowPt_exclusive.toModify(pfTrackElec,MinSCEnergy = 1.0) diff --git a/RecoParticleFlow/PFTracking/python/pfTrack_cfi.py b/RecoParticleFlow/PFTracking/python/pfTrack_cfi.py deleted file mode 100644 index 34b5e7cace701..0000000000000 --- a/RecoParticleFlow/PFTracking/python/pfTrack_cfi.py +++ /dev/null @@ -1,14 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfTrack = cms.EDProducer("PFTrackProducer", - TrackQuality = cms.string('highPurity'), - UseQuality = cms.bool(True), - GsfTrackModuleLabel = cms.InputTag("electronGsfTracks"), - TkColList = cms.VInputTag(cms.InputTag("generalTracks")), - PrimaryVertexLabel = cms.InputTag("offlinePrimaryVertices"), - MuColl = cms.InputTag("muons1stStep"), - TrajInEvents = cms.bool(False), - GsfTracksInEvents = cms.bool(True), -) - - diff --git a/RecoParticleFlow/PFTracking/python/pfV0_cfi.py b/RecoParticleFlow/PFTracking/python/pfV0_cfi.py deleted file mode 100644 index cae86a853d672..0000000000000 --- a/RecoParticleFlow/PFTracking/python/pfV0_cfi.py +++ /dev/null @@ -1,11 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -pfV0 = cms.EDProducer( - "PFV0Producer", - V0List = cms.VInputTag(cms.InputTag("generalV0Candidates","Kshort"), - cms.InputTag("generalV0Candidates","Lambda") - ) - -) - - diff --git a/RecoParticleFlow/PFTracking/python/trackerDrivenElectronSeeds_cfi.py b/RecoParticleFlow/PFTracking/python/trackerDrivenElectronSeeds_cfi.py index cdb6bdbf4357a..2049d8b9eee1c 100644 --- a/RecoParticleFlow/PFTracking/python/trackerDrivenElectronSeeds_cfi.py +++ b/RecoParticleFlow/PFTracking/python/trackerDrivenElectronSeeds_cfi.py @@ -1,53 +1,7 @@ import FWCore.ParameterSet.Config as cms -trackerDrivenElectronSeeds = cms.EDProducer("GoodSeedProducer", - MaxEOverP = cms.double(3.0), - Smoother = cms.string('GsfTrajectorySmoother_forPreId'), - UseQuality = cms.bool(True), - PFPSClusterLabel = cms.InputTag("particleFlowClusterPS"), - ThresholdFile = cms.string('RecoParticleFlow/PFTracking/data/Threshold.dat'), - TMVAMethod = cms.string('BDT'), - MaxEta = cms.double(2.4), - EtaMap = cms.string('RecoParticleFlow/PFBlockProducer/data/resmap_ECAL_eta.dat'), - PhiMap = cms.string('RecoParticleFlow/PFBlockProducer/data/resmap_ECAL_phi.dat'), - PreCkfLabel = cms.string('SeedsForCkf'), - NHitsInSeed = cms.int32(3), - Fitter = cms.string('GsfTrajectoryFitter_forPreId'), - TTRHBuilder = cms.string('WithAngleAndTemplate'), - PreGsfLabel = cms.string('SeedsForGsf'), - MinEOverP = cms.double(0.3), - Weights1 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat1.xml'), - Weights2 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat2.xml'), - Weights3 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat3.xml'), - Weights4 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat4.xml'), - Weights5 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat5.xml'), - Weights6 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat6.xml'), - Weights7 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat7.xml'), - Weights8 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat8.xml'), - Weights9 = cms.string('RecoParticleFlow/PFTracking/data/MVA_BDTTrackDrivenSeed_cat9.xml'), - PFEcalClusterLabel = cms.InputTag("particleFlowClusterECAL"), - PFHcalClusterLabel = cms.InputTag("particleFlowClusterHCAL"), - PSThresholdFile = cms.string('RecoParticleFlow/PFTracking/data/PSThreshold.dat'), - MinPt = cms.double(2.0), - TkColList = cms.VInputTag(cms.InputTag("generalTracks")), - UseTMVA = cms.untracked.bool(True), - TrackQuality = cms.string('highPurity'), - MaxPt = cms.double(50.0), - ApplyIsolation = cms.bool(False), - EcalStripSumE_deltaPhiOverQ_minValue = cms.double(-0.1), - EcalStripSumE_minClusEnergy = cms.double(0.1), - EcalStripSumE_deltaEta = cms.double(0.03), - EcalStripSumE_deltaPhiOverQ_maxValue = cms.double(0.5), - EOverPLead_minValue = cms.double(0.95), - HOverPLead_maxValue = cms.double(0.05), - HcalWindow=cms.double(0.184), - ClusterThreshold = cms.double(0.5), - UsePreShower =cms.bool(False), - PreIdLabel = cms.string('preid'), - ProducePreId = cms.untracked.bool(True), - PtThresholdSavePreId = cms.untracked.double(1.0), - Min_dr = cms.double(0.2) -) +from RecoParticleFlow.PFTracking.GoodSeedProducer import GoodSeedProducer +trackerDrivenElectronSeeds = GoodSeedProducer() from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017 from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA