From e10f0bf39dc5f91381095a896922cd258718fd0f Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 19 May 2021 15:50:58 +0200 Subject: [PATCH 01/19] merge conflict with master --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 32 ++++- CommonTools/ParticleFlow/plugins/PFPileUp.h | 9 +- .../ParticleFlow/plugins/PFnoPileUp.cc | 45 +++++++ CommonTools/ParticleFlow/plugins/PFnoPileUp.h | 48 ++++++++ CommonTools/ParticleFlow/python/pfCHS_cff.py | 16 +++ .../ParticleFlow/python/pfNoPileUpJME_cff.py | 28 ++++- .../ParticleFlow/python/pfPileUp_cfi.py | 5 +- .../PileupAlgos/plugins/PuppiProducer.cc | 43 ++++++- .../PileupAlgos/plugins/PuppiProducer.h | 5 + CommonTools/PileupAlgos/python/Puppi_cff.py | 3 + .../test/recomputePuppiOnMiniAOD.py | 115 ++++++++++++++++++ .../interface/PrimaryVertexAssignment.h | 45 ++++++- .../RecoAlgos/plugins/PrimaryVertexSorter.cc | 2 + .../RecoAlgos/plugins/PrimaryVertexSorter.h | 20 +++ .../python}/primaryVertexAssociation_cfi.py | 0 .../python/sortedPFPrimaryVertices_cfi.py | 10 +- .../python/sortedPackedPrimaryVertices_cfi.py | 15 +++ .../python/sortedPrimaryVertices_cfi.py | 7 ++ .../RecoAlgos/src/PrimaryVertexAssignment.cc | 33 ++++- .../PatAlgos/python/slimming/miniAOD_tools.py | 10 +- .../python/slimming/puppiForMET_cff.py | 6 +- .../PatAlgos/python/slimming/slimming_cff.py | 2 +- .../python/tools/jetCollectionTools.py | 8 +- .../PatAlgos/test/miniAOD/example_addJet.py | 4 +- .../PatAlgos/test/miniAOD/example_ei.py | 2 +- .../test/miniAOD/example_jet_and_met.py | 6 +- .../runMETCorrectionsAndUncertainties.py | 33 ++--- .../python/pfDeepBoostedJet_cff.py | 2 +- .../ONNXRuntime/python/pfDeepFlavour_cff.py | 2 +- .../JetProducers/python/hepTopTaggerV2_cff.py | 3 +- 30 files changed, 501 insertions(+), 58 deletions(-) create mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUp.cc create mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUp.h create mode 100644 CommonTools/ParticleFlow/python/pfCHS_cff.py create mode 100644 CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py rename {PhysicsTools/PatAlgos/python/slimming => CommonTools/RecoAlgos/python}/primaryVertexAssociation_cfi.py (100%) create mode 100644 CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index e3681db53e9c4..b8b599fbbd9f1 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -20,6 +20,14 @@ PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { tokenVertices_ = consumes(iConfig.getParameter("Vertices")); + fUseVertexAssociation = iConfig.getParameter("useVertexAssociation"); + vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); + if (fUseVertexAssociation) { + tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); + tokenVertexAssociationQuality_ = + consumes>(iConfig.getParameter("vertexAssociation")); + } + enable_ = iConfig.getParameter("Enable"); verbose_ = iConfig.getUntrackedParameter("verbose", false); @@ -93,10 +101,26 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { "error."); } - pileUpAlgo_.process(*pfCandidatesRef, *vertices); - pOutput->insert( - pOutput->end(), pileUpAlgo_.getPFCandidatesFromPU().begin(), pileUpAlgo_.getPFCandidatesFromPU().end()); - + if (fUseVertexAssociation) { + edm::Handle> assoHandle; + iEvent.getByToken(tokenVertexAssociation_, assoHandle); + const edm::Association* associatedPV = assoHandle.product(); + edm::Handle> assoQualityHandle; + iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); + const edm::ValueMap* associationQuality = assoQualityHandle.product(); + PFCollection pfCandidatesFromPU; + for (unsigned i = 0; i < (*pfCandidatesRef).size(); i++) { + const reco::VertexRef& PVOrig = (*associatedPV)[(*pfCandidatesRef)[i]]; + int quality = (*associationQuality)[(*pfCandidatesRef)[i]]; + if (PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_)) + pfCandidatesFromPU.push_back((*pfCandidatesRef)[i]); + } + pOutput->insert(pOutput->end(), pfCandidatesFromPU.begin(), pfCandidatesFromPU.end()); + } else { + pileUpAlgo_.process(*pfCandidatesRef, *vertices); + pOutput->insert( + pOutput->end(), pileUpAlgo_.getPFCandidatesFromPU().begin(), pileUpAlgo_.getPFCandidatesFromPU().end()); + } // for ( PFCollection::const_iterator byValueBegin = pileUpAlgo_.getPFCandidatesFromPU().begin(), // byValueEnd = pileUpAlgo_.getPFCandidatesFromPU().end(), ibyValue = byValueBegin; // ibyValue != byValueEnd; ++ibyValue ) { diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.h b/CommonTools/ParticleFlow/plugins/PFPileUp.h index 6016386986150..07e114c1d8f9e 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.h +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.h @@ -15,6 +15,7 @@ #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/Association.h" #include "CommonTools/ParticleFlow/interface/PFPileUpAlgo.h" @@ -30,9 +31,10 @@ produces the corresponding collection of PileUpCandidates. class PFPileUp : public edm::stream::EDProducer<> { public: - typedef std::vector > PFCollection; + typedef std::vector> PFCollection; typedef edm::View PFView; typedef std::vector PFCollectionByValue; + typedef edm::Association CandToVertex; explicit PFPileUp(const edm::ParameterSet&); @@ -59,6 +61,11 @@ class PFPileUp : public edm::stream::EDProducer<> { /// use the closest z vertex if a track is not in a vertex bool checkClosestZVertex_; + + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; + bool fUseVertexAssociation; + int vertexAssociationQuality_; }; #endif diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc new file mode 100644 index 0000000000000..0bd240110be12 --- /dev/null +++ b/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc @@ -0,0 +1,45 @@ +#include "CommonTools/ParticleFlow/plugins/PFnoPileUp.h" + +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "FWCore/Framework/interface/ESHandle.h" + +// #include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Framework/interface/EventSetup.h" + +using namespace std; +using namespace edm; +using namespace reco; + +PFnoPileUp::PFnoPileUp(const edm::ParameterSet& iConfig) { + tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); + vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); + tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); + tokenVertexAssociationQuality_ = + consumes>(iConfig.getParameter("vertexAssociation")); + produces>(); +} + +PFnoPileUp::~PFnoPileUp() {} + +void PFnoPileUp::produce(Event& iEvent, const EventSetup& iSetup) { + unique_ptr> pOutput(new edm::PtrVector); + Handle candidateView; + iEvent.getByToken(tokenCandidatesView_, candidateView); + edm::Handle> assoHandle; + iEvent.getByToken(tokenVertexAssociation_, assoHandle); + const edm::Association* associatedPV = assoHandle.product(); + edm::Handle> assoQualityHandle; + iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); + const edm::ValueMap* associationQuality = assoQualityHandle.product(); + for (unsigned i = 0; i < candidateView->size(); i++) { + const reco::VertexRef& PVOrig = (*associatedPV)[candidateView->ptrAt(i)]; + int quality = (*associationQuality)[candidateView->ptrAt(i)]; + if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) + pOutput->push_back(candidateView->ptrAt(i)); + } + iEvent.put(std::move(pOutput)); +} + +DEFINE_FWK_MODULE(PFnoPileUp); \ No newline at end of file diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUp.h b/CommonTools/ParticleFlow/plugins/PFnoPileUp.h new file mode 100644 index 0000000000000..412dd326252c7 --- /dev/null +++ b/CommonTools/ParticleFlow/plugins/PFnoPileUp.h @@ -0,0 +1,48 @@ +#ifndef CommonTools_ParticleFlow_PFnoPileUp_ +#define CommonTools_ParticleFlow_PFnoPileUp_ + +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/Association.h" + +/**\class PFnoPileUp +\brief Identifies pile-up candidates from a collection of Candidates, and +produces the corresponding collection of NoPileUpCandidates. + +\author Andreas Hinzmann +\date May 2021 + +*/ + +class PFnoPileUp : public edm::stream::EDProducer<> { +public: + typedef edm::View CandidateView; + typedef edm::Association CandToVertex; + + explicit PFnoPileUp(const edm::ParameterSet&); + + ~PFnoPileUp() override; + + void produce(edm::Event&, const edm::EventSetup&) override; + +private: + edm::EDGetTokenT tokenCandidatesView_; + edm::EDGetTokenT tokenVertices_; + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; + int vertexAssociationQuality_; +}; + +#endif diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py new file mode 100644 index 0000000000000..c1912df9720de --- /dev/null +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms +from CommonTools.ParticleFlow.pfNoPileUpJME_cff import adapt, pfPileUpJME +from PhysicsTools.PatAlgos.sortedPackedPrimaryVertices_cfi import sortedPackedPrimaryVertices + +packedPrimaryVertexAssociationJME = sortedPackedPrimaryVertices.clone( + produceSortedVertices = False, + producePileUpCollection = False, + produceNoPileUpCollection = False +) +adapt(packedPrimaryVertexAssociationJME) + +pfCHS = cms.EDProducer("PFnoPileUp", + candidates = cms.InputTag("packedPFCandidates"), + vertexAssociationQuality = pfPileUpJME.vertexAssociationQuality, + vertexAssociation = cms.InputTag("packedPrimaryVertexAssociationJME","original") + ) diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index 0907848fe1db6..445e08283b952 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -2,16 +2,38 @@ from CommonTools.ParticleFlow.pfPileUp_cfi import pfPileUp as _pfPileUp from CommonTools.ParticleFlow.TopProjectors.pfNoPileUp_cfi import pfNoPileUp as _pfNoPileUp -from CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi import * +from CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi import goodOfflinePrimaryVertices +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation + +def adapt(primaryVertexAssociationJME): + # options for quality PrimaryDz = 6 (used in PUPPI) + primaryVertexAssociationJME.assignment.maxDzSigForPrimaryAssignment = 1e10 + primaryVertexAssociationJME.assignment.maxDzForPrimaryAssignment = 0.3 + primaryVertexAssociationJME.assignment.maxDzErrorForPrimaryAssignment = 1e10 + primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged = 2 + primaryVertexAssociationJME.assignment.PtMaxCharged = 20. + primaryVertexAssociationJME.assignment.EtaMinUseDz = 2.4 + primaryVertexAssociationJME.assignment.OnlyUseFirstDz = True + from Configuration.Eras.Modifier_phase2_common_cff import phase2_common + phase2_common.toModify( + primaryVertexAssociationJME.assignment, + maxDzForPrimaryAssignment=0.1, + EtaMinUseDz = 4.0 + ) +primaryVertexAssociationJME = primaryVertexAssociation.clone(vertices = 'goodOfflinePrimaryVertices') +adapt(primaryVertexAssociationJME) pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', - Vertices = 'goodOfflinePrimaryVertices', - checkClosestZVertex = False ) + useVertexAssociation = True, + vertexAssociationQuality = 7, + vertexAssociation = cms.InputTag('primaryVertexAssociationJME','original'), + ) pfNoPileUpJME = _pfNoPileUp.clone(topCollection = 'pfPileUpJME', bottomCollection = 'particleFlowPtrs' ) pfNoPileUpJMETask = cms.Task( goodOfflinePrimaryVertices, + primaryVertexAssociationJME, pfPileUpJME, pfNoPileUpJME ) diff --git a/CommonTools/ParticleFlow/python/pfPileUp_cfi.py b/CommonTools/ParticleFlow/python/pfPileUp_cfi.py index 4696123d18f91..025d6479ad2eb 100644 --- a/CommonTools/ParticleFlow/python/pfPileUp_cfi.py +++ b/CommonTools/ParticleFlow/python/pfPileUp_cfi.py @@ -8,5 +8,8 @@ # pile-up identification now enabled by default. To be studied for jets Enable = cms.bool(True), verbose = cms.untracked.bool(False), - checkClosestZVertex = cms.bool(True) + checkClosestZVertex = cms.bool(True), + useVertexAssociation = cms.bool(False), + vertexAssociationQuality = cms.int32(0), + vertexAssociation = cms.InputTag(''), ) diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc index cfbeb0cc02ff9..4543064dbb12a 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc @@ -41,6 +41,13 @@ PuppiProducer::PuppiProducer(const edm::ParameterSet& iConfig) { tokenPFCandidates_ = consumes(iConfig.getParameter("candName")); tokenVertices_ = consumes(iConfig.getParameter("vertexName")); + fUseVertexAssociation = iConfig.getParameter("useVertexAssociation"); + vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); + if (fUseVertexAssociation) { + tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); + tokenVertexAssociationQuality_ = + consumes>(iConfig.getParameter("vertexAssociation")); + } fUsePUProxyValue = iConfig.getParameter("usePUProxyValue"); @@ -80,6 +87,17 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { iEvent.getByToken(tokenVertices_, hVertexProduct); const reco::VertexCollection* pvCol = hVertexProduct.product(); + edm::Handle> assoHandle; + const edm::Association* associatedPV = nullptr; + edm::Handle> assoQualityHandle; + const edm::ValueMap* associationQuality = nullptr; + if ((fUseVertexAssociation) && (!fUseExistingWeights)) { + iEvent.getByToken(tokenVertexAssociation_, assoHandle); + associatedPV = assoHandle.product(); + iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); + associationQuality = assoQualityHandle.product(); + } + double puProxyValue = 0.; if (fUsePUProxyValue) { puProxyValue = iEvent.get(puProxyValueToken_); @@ -95,6 +113,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { //Fill the reco objects fRecoObjCollection.clear(); fRecoObjCollection.reserve(pfCol->size()); + size_t ic = 0; for (auto const& aPF : *pfCol) { RecoObj pReco; pReco.pt = aPF.pt(); @@ -110,7 +129,25 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { uint pVtxId = 0; bool isLepton = ((std::abs(pReco.pdgId) == 11) || (std::abs(pReco.pdgId) == 13)); const pat::PackedCandidate* lPack = dynamic_cast(&aPF); - if (lPack == nullptr) { + + if (fUseVertexAssociation) { + const reco::VertexRef& PVOrig = (*associatedPV)[reco::CandidatePtr(hPFProduct, ic)]; + int quality = (*associationQuality)[reco::CandidatePtr(hPFProduct, ic)]; + if (PVOrig.isNonnull() && (quality >= vertexAssociationQuality_)) { + closestVtx = PVOrig.get(); + pVtxId = PVOrig.key(); + } + if (std::abs(pReco.charge) == 0) + pReco.id = 0; + else if (fPuppiNoLep && isLepton) + pReco.id = 3; + else if (closestVtx != nullptr && pVtxId == 0) + pReco.id = 1; // Associated to main vertex + else if (closestVtx != nullptr && pVtxId > 0) + pReco.id = 2; // Associated to PU + else + pReco.id = 0; // Unassociated + } else if (lPack == nullptr) { const reco::PFCandidate* pPF = dynamic_cast(&aPF); double curdz = 9999; int closestVtxForUnassociateds = -9999; @@ -230,6 +267,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { } fRecoObjCollection.push_back(pReco); + ic++; } fPuppiContainer->initialize(fRecoObjCollection); @@ -401,6 +439,9 @@ void PuppiProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("vtxZCut", 24); desc.add("candName", edm::InputTag("particleFlow")); desc.add("vertexName", edm::InputTag("offlinePrimaryVertices")); + desc.add("useVertexAssociation", false); + desc.add("vertexAssociationQuality", 0); + desc.add("vertexAssociation", edm::InputTag("")); desc.add("applyCHS", true); desc.add("invertPuppi", false); desc.add("useExp", false); diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.h b/CommonTools/PileupAlgos/plugins/PuppiProducer.h index befcf4c6a7f0a..bef5c7d797646 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.h +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.h @@ -34,6 +34,7 @@ class PuppiProducer : public edm::stream::EDProducer<> { typedef std::vector PFOutputCollection; typedef std::vector PackedOutputCollection; typedef edm::View PFView; + typedef edm::Association CandToVertex; private: virtual void beginJob(); @@ -42,6 +43,8 @@ class PuppiProducer : public edm::stream::EDProducer<> { edm::EDGetTokenT tokenPFCandidates_; edm::EDGetTokenT tokenVertices_; + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; edm::EDGetTokenT tokenPuppiContainer_; edm::EDGetTokenT tokenPuppiCandidates_; edm::EDGetTokenT tokenPackedPuppiCandidates_; @@ -59,6 +62,8 @@ class PuppiProducer : public edm::stream::EDProducer<> { std::string fPuppiName; std::string fPFName; std::string fPVName; + bool fUseVertexAssociation; + int vertexAssociationQuality_; bool fPuppiDiagnostics; bool fPuppiNoLep; bool fUseFromPVLooseTight; diff --git a/CommonTools/PileupAlgos/python/Puppi_cff.py b/CommonTools/PileupAlgos/python/Puppi_cff.py index 107aea9a49cab..b3dfc16923d9c 100644 --- a/CommonTools/PileupAlgos/python/Puppi_cff.py +++ b/CommonTools/PileupAlgos/python/Puppi_cff.py @@ -31,6 +31,9 @@ NumOfPUVtxsForCharged = 2, PtMaxCharged = 20., PtMaxNeutralsStartSlope = 20., + useVertexAssociation = True, + vertexAssociationQuality = cms.int32(6), + vertexAssociation = cms.InputTag('primaryVertexAssociationJME','original'), #candName = cms.string('packedPFCandidates'), #vertexName = cms.string('offlineSlimmedPrimaryVertices'), clonePackedCands = False, # should only be set to True for MiniAOD diff --git a/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py new file mode 100644 index 0000000000000..5a799908344e1 --- /dev/null +++ b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py @@ -0,0 +1,115 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: step5 --conditions auto:run2_mc --nThreads 2 -n 10 --era Run2_2016 --eventcontent MINIAODSIM --filein file:step3_inMINIAODSIM.root -s NANO --datatier NANOAODSIM --mc --fileout file:step5.root +import FWCore.ParameterSet.Config as cms + +from Configuration.Eras.Era_Run2_2016_cff import Run2_2016 + +process = cms.Process('NANO',Run2_2016) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('PhysicsTools.NanoAOD.nano_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(10), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/h/hinzmann/stable_13TeV/jetmet/mtd/CMSSW_11_1_8/src/25202.0_TTbar_13+TTbar_13+DIGIUP15_PU25+RECOUP15_PU25+HARVESTUP15_PU25+NANOUP15_PU25/step3_inMINIAODSIM.root'), + secondaryFileNames = cms.untracked.vstring() +) + +process.options = cms.untracked.PSet( + FailPath = cms.untracked.vstring(), + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + SkipEvent = cms.untracked.vstring(), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + + ), + numberOfConcurrentIOVs = cms.untracked.uint32(1) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + makeTriggerResults = cms.obsolete.untracked.bool, + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(1), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(1), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('step5 nevts:10'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", + compressionAlgorithm = cms.untracked.string('LZMA'), + compressionLevel = cms.untracked.int32(9), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('MINIAODSIM'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('file:updatedMINIAODSIM.root'), + outputCommands = process.MINIAODSIMEventContent.outputCommands +) + +# Additional output definition + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc', '') + +from CommonTools.PileupAlgos.customizePuppiTune_cff import UpdatePuppiTune_MC +UpdatePuppiTune_MC(process) + +# Path and EndPath definitions +process.puppi_step = cms.Path(process.puppiSequence) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) + +# Schedule definition +process.schedule = cms.Schedule(process.puppi_step,process.endjob_step,process.MINIAODSIMoutput_step) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) + +#Setup FWK for multithreaded +process.options.numberOfThreads=cms.untracked.uint32(2) +process.options.numberOfStreams=cms.untracked.uint32(0) +process.options.numberOfConcurrentLuminosityBlocks=cms.untracked.uint32(1) + +# customisation of the process. + +# End of customisation functions + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion diff --git a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h index da7626850313e..ac62013cc66c0 100644 --- a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h +++ b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h @@ -12,6 +12,7 @@ #include "DataFormats/Candidate/interface/Candidate.h" #include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" #include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" @@ -41,7 +42,12 @@ class PrimaryVertexAssignment { maxDxySigForNotReconstructedPrimary_(iConfig.getParameter("maxDxySigForNotReconstructedPrimary")), maxDxyForNotReconstructedPrimary_(iConfig.getParameter("maxDxyForNotReconstructedPrimary")), useTiming_(iConfig.getParameter("useTiming")), - preferHighRanked_(iConfig.getParameter("preferHighRanked")) {} + preferHighRanked_(iConfig.getParameter("preferHighRanked")), + fNumOfPUVtxsForCharged_(iConfig.getParameter("NumOfPUVtxsForCharged")), + fDzCutForChargedFromPUVtxs_(iConfig.getParameter("DzCutForChargedFromPUVtxs")), + fPtMaxCharged_(iConfig.getParameter("PtMaxCharged")), + fEtaMinUseDz_(iConfig.getParameter("EtaMinUseDz")), + fOnlyUseFirstDz_(iConfig.getParameter("OnlyUseFirstDz")) {} ~PrimaryVertexAssignment() {} @@ -54,6 +60,15 @@ class PrimaryVertexAssignment { const edm::View& jets, const TransientTrackBuilder& builder) const; + std::pair chargedHadronVertex( + const reco::VertexCollection& vertices, + int iVertex, + const reco::Track* track, + float trackTime, + float trackTimeResolution, // <0 if timing not available for this object + const edm::View& jets, + const TransientTrackBuilder& builder) const; + std::pair chargedHadronVertex( const reco::VertexCollection& vertices, const reco::TrackRef& trackRef, @@ -82,6 +97,29 @@ class PrimaryVertexAssignment { return chargedHadronVertex( vertices, reco::TrackRef(), &(*pfcand.gsfTrackRef()), time, timeResolution, jets, builder); } + + std::pair chargedHadronVertex(const reco::VertexCollection& vertices, + const pat::PackedCandidate& pfcand, + const edm::View& jets, + const TransientTrackBuilder& builder) const { + float time = 0, timeResolution = -1; + if (useTiming_ && pfcand.timeError() > 0) { + time = pfcand.time(); + timeResolution = pfcand.timeError(); + } + if (!pfcand.hasTrackDetails()) + return std::pair(-1, PrimaryVertexAssignment::Unassigned); + else + return chargedHadronVertex( + vertices, + (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose) ? pfcand.vertexRef().key() : -1, + &pfcand.pseudoTrack(), + time, + timeResolution, + jets, + builder); + } + std::pair chargedHadronVertex(const reco::VertexCollection& vertices, const reco::RecoChargedRefCandidate& chcand, const edm::ValueMap* trackTimeTag, @@ -112,6 +150,11 @@ class PrimaryVertexAssignment { double maxDxyForNotReconstructedPrimary_; bool useTiming_; bool preferHighRanked_; + int fNumOfPUVtxsForCharged_; + double fDzCutForChargedFromPUVtxs_; + double fPtMaxCharged_; + double fEtaMinUseDz_; + bool fOnlyUseFirstDz_; }; #endif diff --git a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.cc b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.cc index c9dad79418207..b019100fa3e3b 100644 --- a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.cc +++ b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.cc @@ -6,3 +6,5 @@ typedef PrimaryVertexSorter > RecoCha DEFINE_FWK_MODULE(RecoChargedRefCandidatePrimaryVertexSorter); typedef PrimaryVertexSorter > PFCandidatePrimaryVertexSorter; DEFINE_FWK_MODULE(PFCandidatePrimaryVertexSorter); +typedef PrimaryVertexSorter > PackedCandidatePrimaryVertexSorter; +DEFINE_FWK_MODULE(PackedCandidatePrimaryVertexSorter); diff --git a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h index 300ce6cb2c14b..fa78ebf5de8d6 100644 --- a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h +++ b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h @@ -20,6 +20,7 @@ #include "CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h" #include "CommonTools/RecoAlgos/interface/PrimaryVertexSorting.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" /**\class PrimaryVertexSorter * \author Andrea Rizzi @@ -311,6 +312,9 @@ template <> inline void PrimaryVertexSorter>::doConsumesForTiming(const edm::ParameterSet& iConfig) { } +template <> +inline void PrimaryVertexSorter>::doConsumesForTiming(const edm::ParameterSet& iConfig) {} + template <> inline bool PrimaryVertexSorter>::needsProductsForTiming() { return true; @@ -321,6 +325,11 @@ inline bool PrimaryVertexSorter>::needsProductsFo return false; } +template <> +inline bool PrimaryVertexSorter>::needsProductsForTiming() { + return false; +} + template <> inline std::pair PrimaryVertexSorter>::runAlgo(const reco::VertexCollection& vertices, @@ -343,4 +352,15 @@ inline std::pair PrimaryVertexSorter +std::pair PrimaryVertexSorter>::runAlgo( + const reco::VertexCollection& vertices, + const pat::PackedCandidate& pf, + const edm::ValueMap* trackTimeTag, + const edm::ValueMap* trackTimeResoTag, + const edm::View& jets, + const TransientTrackBuilder& builder) { + return assignmentAlgo_.chargedHadronVertex(vertices, pf, jets, builder); +} + #endif diff --git a/PhysicsTools/PatAlgos/python/slimming/primaryVertexAssociation_cfi.py b/CommonTools/RecoAlgos/python/primaryVertexAssociation_cfi.py similarity index 100% rename from PhysicsTools/PatAlgos/python/slimming/primaryVertexAssociation_cfi.py rename to CommonTools/RecoAlgos/python/primaryVertexAssociation_cfi.py diff --git a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py index ef8876b177ebf..2b67ed5dc0ae6 100644 --- a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py @@ -18,7 +18,14 @@ maxDxySigForNotReconstructedPrimary = cms.double(2), #in AND with next maxDxyForNotReconstructedPrimary = cms.double(0.01), #in AND with prev useTiming = cms.bool(False), - preferHighRanked = cms.bool(False) + preferHighRanked = cms.bool(False), + + #options used in PUPPI + NumOfPUVtxsForCharged = cms.int32(-1), + DzCutForChargedFromPUVtxs = cms.double(0.2), + PtMaxCharged = cms.double(-1), + EtaMinUseDz = cms.double(-1), + OnlyUseFirstDz = cms.bool(False), ), particles = cms.InputTag("particleFlow"), vertices= cms.InputTag("offlinePrimaryVertices"), @@ -31,4 +38,3 @@ produceNoPileUpCollection = cms.bool(True), ) - diff --git a/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py new file mode 100644 index 0000000000000..7b4bf97166295 --- /dev/null +++ b/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py @@ -0,0 +1,15 @@ +import FWCore.ParameterSet.Config as cms +from CommonTools.RecoAlgos.sortedPFPrimaryVertices_cfi import sortedPFPrimaryVertices +sortedPackedPrimaryVertices = cms.EDProducer("PackedCandidatePrimaryVertexSorter", + sorting = cms.PSet(), + assignment = sortedPFPrimaryVertices.assignment, + particles = cms.InputTag("packedPFCandidates"), + vertices= cms.InputTag("offlineSlimmedPrimaryVertices"), + jets= cms.InputTag("slimmedJets"), + qualityForPrimary = cms.int32(3), + usePVMET = cms.bool(True), + produceAssociationToOriginalVertices = cms.bool(True), + produceSortedVertices = cms.bool(True), + producePileUpCollection = cms.bool(True), + produceNoPileUpCollection = cms.bool(True), +) diff --git a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py index e2d877bf93292..901c85e9d1760 100644 --- a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py @@ -19,6 +19,13 @@ maxDxyForNotReconstructedPrimary = cms.double(0.01), #in AND with prev useTiming = cms.bool(False), preferHighRanked = cms.bool(False), + + #options used in PUPPI + NumOfPUVtxsForCharged = cms.int32(-1), + DzCutForChargedFromPUVtxs = cms.double(0.2), + PtMaxCharged = cms.double(-1), + EtaMinUseDz = cms.double(-1), + OnlyUseFirstDz = cms.bool(False), ), particles = cms.InputTag("trackRefsForJets"), trackTimeTag = cms.InputTag(""), diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 83ca81b2679fe..6ef1d658a8973 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -28,6 +28,19 @@ std::pair PrimaryVertexAssignment::charge } index++; } + return chargedHadronVertex(vertices, iVertex, track, time, timeReso, jets, builder); +} + +std::pair PrimaryVertexAssignment::chargedHadronVertex( + const reco::VertexCollection& vertices, + int iVertex, + const reco::Track* track, + float time, + float timeReso, // <0 if timing not available for this object + const edm::View& jets, + const TransientTrackBuilder& builder) const { + typedef reco::VertexCollection::const_iterator IV; + typedef reco::Vertex::trackRef_iterator IT; bool useTime = useTiming_; if (edm::isNotFinite(time) || timeReso < 1e-6) { @@ -54,6 +67,11 @@ std::pair PrimaryVertexAssignment::charge } } + // recover cases where the primary vertex is split + if ((iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && + (std::abs(track->dz(vertices.at(0).position())) < fDzCutForChargedFromPUVtxs_)) + return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); + if (iVertex >= 0) return std::pair(iVertex, PrimaryVertexAssignment::UsedInFit); @@ -89,13 +107,26 @@ std::pair PrimaryVertexAssignment::charge // first use "closest in Z" with tight cuts (targetting primary particles) const float add_cov = vtxIdMinSignif >= 0 ? vertices[vtxIdMinSignif].covariance(2, 2) : 0.f; const float dzE = sqrt(track->dzError() * track->dzError() + add_cov); - if (vtxIdMinSignif >= 0 and + if (!fOnlyUseFirstDz_ and vtxIdMinSignif >= 0 and (dzmin < maxDzForPrimaryAssignment_ and dzmin / dzE < maxDzSigForPrimaryAssignment_ and track->dzError() < maxDzErrorForPrimaryAssignment_) and (!useTime or dtmin / timeReso < maxDtSigForPrimaryAssignment_)) { iVertex = vtxIdMinSignif; } + // consider only distances to first vertex for association of pileup vertices (originally used in PUPPI) + if ((fOnlyUseFirstDz_) && (vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_)) + iVertex = ((std::abs(track->dz(vertices.at(0).position())) < maxDzForPrimaryAssignment_ and + std::abs(track->dz(vertices.at(0).position())) / dzE < maxDzSigForPrimaryAssignment_ and + track->dzError() < maxDzErrorForPrimaryAssignment_) and + (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) + ? 0 + : vtxIdMinSignif; + + // protect high pT particles from association to pileup vertices and assign them to the first vertex + if ((fPtMaxCharged_ > 0) && (vtxIdMinSignif >= 0) && (track->pt() > fPtMaxCharged_)) + iVertex = 0; + if (iVertex >= 0) return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index 7130afe2c1ad6..f4ee51a85d229 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -198,14 +198,12 @@ def _add_slimmedMETsNoHF(process): # ================== NoHF pfMET # ================== CHSMET - process.CHSCands = cms.EDFilter("CandPtrSelector", - src=cms.InputTag("packedPFCandidates"), - cut=cms.string("fromPV(0) > 0") - ) - task.add(process.CHSCands) + process.load("CommonTools.ParticleFlow.pfCHS_cff") + task.add(process.packedPrimaryVertexAssociationJME) + task.add(process.pfCHS) from RecoMET.METProducers.pfMet_cfi import pfMet - process.pfMetCHS = pfMet.clone(src = 'CHSCands') + process.pfMetCHS = pfMet.clone(src = 'pfCHS') task.add(process.pfMetCHS) addMETCollection(process, diff --git a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py index 3d45ca91911fa..27a1bea045697 100644 --- a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py @@ -12,19 +12,23 @@ def makePuppies( process ): def makePuppiesFromMiniAOD( process, createScheduledSequence=False ): task = getPatAlgosToolsTask(process) + process.load('CommonTools.ParticleFlow.pfCHS_cff') + task.add(process.packedPrimaryVertexAssociationJME) process.load('CommonTools.PileupAlgos.Puppi_cff') task.add(process.puppi) process.puppi.candName = 'packedPFCandidates' process.puppi.clonePackedCands = True process.puppi.vertexName = 'offlineSlimmedPrimaryVertices' process.puppi.useExistingWeights = True + process.puppi.vertexAssociation = 'packedPrimaryVertexAssociationJME:original' task.add(process.puppiNoLep) process.puppiNoLep.candName = 'packedPFCandidates' process.puppiNoLep.clonePackedCands = True process.puppiNoLep.vertexName = 'offlineSlimmedPrimaryVertices' process.puppiNoLep.useExistingWeights = True + process.puppiNoLep.vertexAssociation = 'packedPrimaryVertexAssociationJME:original' #making a sequence for people running the MET tool in scheduled mode if createScheduledSequence: - puppiMETSequence = cms.Sequence(process.puppi*process.puppiNoLep) + puppiMETSequence = cms.Sequence(process.packedPrimaryVertexAssociationJME*process.puppi*process.puppiNoLep) setattr(process, "puppiMETSequence", puppiMETSequence) diff --git a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py index b8963bd0e0f96..306efa71e690e 100644 --- a/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/slimming_cff.py @@ -6,7 +6,7 @@ from PhysicsTools.PatAlgos.slimming.offlineSlimmedPrimaryVertices_cfi import * from PhysicsTools.PatAlgos.slimming.offlineSlimmedPrimaryVertices4D_cfi import * from PhysicsTools.PatAlgos.slimming.offlineSlimmedPrimaryVerticesWithBS_cfi import * -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import * +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import * from PhysicsTools.PatAlgos.slimming.genParticles_cff import * from PhysicsTools.PatAlgos.slimming.genParticleAssociation_cff import * from PhysicsTools.PatAlgos.slimming.selectedPatTrigger_cfi import * diff --git a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py index e327f3d46fb0d..f39e4b0a90c16 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py @@ -282,11 +282,9 @@ def addRecoJetCollection(self, # CHS # elif recoJetInfo.jetPUMethod == "chs": - self.addProcessAndTask(proc, pfCand, cms.EDFilter("CandPtrSelector", - src = cms.InputTag(self.pfLabel), - cut = cms.string("fromPV"), - ) - ) + from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME + self.addProcessAndTask(proc, pfCand, pfCHS.clone()) + self.prerequisites.append(process.packedPrimaryVertexAssociationJME) self.prerequisites.append(pfCand) # # PUPPI diff --git a/PhysicsTools/PatAlgos/test/miniAOD/example_addJet.py b/PhysicsTools/PatAlgos/test/miniAOD/example_addJet.py index df1a5b96f7877..8e574b1ea1391 100644 --- a/PhysicsTools/PatAlgos/test/miniAOD/example_addJet.py +++ b/PhysicsTools/PatAlgos/test/miniAOD/example_addJet.py @@ -20,10 +20,10 @@ from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets -process.chs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) +process.load("CommonTools.ParticleFlow.pfCHS_cff") process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it -process.ak4PFJetsCHS = ak4PFJets.clone(src = 'chs', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it +process.ak4PFJetsCHS = ak4PFJets.clone(src = 'pfCHS', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles') process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") diff --git a/PhysicsTools/PatAlgos/test/miniAOD/example_ei.py b/PhysicsTools/PatAlgos/test/miniAOD/example_ei.py index 6ca1deea96755..57b0f2d420e98 100644 --- a/PhysicsTools/PatAlgos/test/miniAOD/example_ei.py +++ b/PhysicsTools/PatAlgos/test/miniAOD/example_ei.py @@ -36,7 +36,7 @@ 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')) #do projections -process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) +process.load("CommonTools.ParticleFlow.pfCHS_cff") process.pfNoMuonCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHS"), veto = cms.InputTag("selectedMuons")) process.pfNoElectronsCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHS"), veto = cms.InputTag("selectedElectrons")) diff --git a/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py b/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py index a91458a60a1fb..7aa247e8cf60b 100644 --- a/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py +++ b/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py @@ -19,10 +19,12 @@ from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets from RecoMET.METProducers.pfMet_cfi import pfMet -process.chs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) +process.load("CommonTools.ParticleFlow.pfCHS_cff") +task.add(process.packedPrimaryVertexAssociationJME) +task.add(process.pfCHS) process.ak5PFJets = ak5PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it -process.ak5PFJetsCHS = ak5PFJets.clone(src = 'chs', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it +process.ak5PFJetsCHS = ak5PFJets.clone(src = 'pfCHS', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak5GenJets = ak5GenJets.clone(src = 'packedGenParticles') process.pfMet = pfMet.clone(src = "packedPFCandidates") process.pfMet.calculateSignificance = False # this can't be easily implemented on packed PF candidates at the moment diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index 804dbff34d274..a0505f5ad0886 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -914,20 +914,8 @@ def getMETUncertainties(self, process, metType, metModName, electronCollection, #--------------------------------------------------------------------- # PFPhotons : #------------ - if self._parameters["Puppi"].value or not self._parameters["onMiniAOD"].value: - cutforpfNoPileUp = cms.string("") - else: - cutforpfNoPileUp = cms.string("fromPV > 1") - - pfNoPileUp = cms.EDFilter("CandPtrSelector", - src = pfCandCollection, - cut = cutforpfNoPileUp - ) - addToProcessAndTask("pfNoPileUp"+postfix, pfNoPileUp, process, task) - metUncSequence += getattr(process, "pfNoPileUp"+postfix) - pfPhotons = cms.EDFilter("CandPtrSelector", - src = cms.InputTag("pfNoPileUp"+postfix), + src = pfCandCollection, cut = cms.string("abs(pdgId) = 22") ) addToProcessAndTask("pfPhotons"+postfix, pfPhotons, process, task) @@ -1605,13 +1593,8 @@ def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, pos if chs: CHSname="chs" jetColName="ak4PFJetsCHS" - - pfCHS=None - if self._parameters["onMiniAOD"].value: - pfCHS = cms.EDFilter("CandPtrSelector", src = pfCandCollection, cut = cms.string("fromPV")) - pfCandColl = cms.InputTag("pfNoPileUpJME"+postfix) - addToProcessAndTask("pfNoPileUpJME"+postfix, pfCHS, process, task) - patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix) + if self._parameters["onMiniAOD"].value: + pfCandColl = cms.InputTag("pfCHS") else: addToProcessAndTask("tmpPFCandCollPtr"+postfix, cms.EDProducer("PFCandidateFwdPtrProducer", @@ -1620,8 +1603,10 @@ def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, pos process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff") task.add(process.pfNoPileUpJMETask) configtools.cloneProcessingSnippet(process, getattr(process,"pfNoPileUpJMESequence"), postfix, addToTask = True ) + getattr(process, "primaryVertexAssociationJME"+postfix).particles = pfCandCollection getattr(process, "pfPileUpJME"+postfix).PFCandidates = "tmpPFCandCollPtr"+postfix getattr(process, "pfNoPileUpJME"+postfix).bottomCollection = "tmpPFCandCollPtr"+postfix + getattr(process, "pfNoPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociationJME'+postfix+':original' pfCandColl = "pfNoPileUpJME"+postfix patMetModuleSequence += getattr(process, "tmpPFCandCollPtr"+postfix) patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix) @@ -1711,10 +1696,12 @@ def miniAODConfigurationPre(self, process, patMetModuleSequence, pfCandCollectio ##adding the necessary chs and track met configuration task = getPatAlgosToolsTask(process) - pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV(0)>0")) - addToProcessAndTask("pfCHS", pfCHS, process, task) + from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME + addToProcessAndTask("packedPrimaryVertexAssociationJME",packedPrimaryVertexAssociationJME.clone(), process, task) + patMetModuleSequence += getattr(process, "packedPrimaryVertexAssociationJME") + addToProcessAndTask("pfCHS", pfCHS.clone(), process, task) from RecoMET.METProducers.pfMet_cfi import pfMet - pfMetCHS = pfMet.clone(src = 'pfCHS') + pfMetCHS = pfMet.clone(src = "pfCHS") addToProcessAndTask("pfMetCHS", pfMetCHS, process, task) addMETCollection(process, diff --git a/RecoBTag/ONNXRuntime/python/pfDeepBoostedJet_cff.py b/RecoBTag/ONNXRuntime/python/pfDeepBoostedJet_cff.py index 8233fbd8c9288..cd07ad7088339 100644 --- a/RecoBTag/ONNXRuntime/python/pfDeepBoostedJet_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfDeepBoostedJet_cff.py @@ -20,7 +20,7 @@ ) from CommonTools.PileupAlgos.Puppi_cff import puppi -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation # This task is not used, useful only if we run DeepFlavour from RECO # jets (RECO/AOD) diff --git a/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py b/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py index e4c446a178028..6786543ecfa9c 100644 --- a/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfDeepFlavour_cff.py @@ -9,7 +9,7 @@ from RecoBTag.ONNXRuntime.pfDeepCombinedJetTags_cfi import pfDeepCombinedJetTags from RecoBTag.ONNXRuntime.pfNegativeDeepFlavourJetTags_cfi import pfNegativeDeepFlavourJetTags from CommonTools.PileupAlgos.Puppi_cff import puppi -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation # This task is not used, useful only if we run DeepFlavour from RECO # jets (RECO/AOD) diff --git a/RecoJets/JetProducers/python/hepTopTaggerV2_cff.py b/RecoJets/JetProducers/python/hepTopTaggerV2_cff.py index cbdaeec689b27..7f62bf9ddc676 100644 --- a/RecoJets/JetProducers/python/hepTopTaggerV2_cff.py +++ b/RecoJets/JetProducers/python/hepTopTaggerV2_cff.py @@ -5,7 +5,8 @@ from RecoJets.JetProducers.PFJetParameters_cfi import * # CHS -chsForHTT = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) +from CommonTools.ParticleFlow.pfCHS_cff import pfCHS +chsForHTT = pfCHS.clone() # Schedule HEPTopTagger hepTopTaggerV2 = cms.EDProducer( From c2dbd7ad64d2d9aae162ba6f5f16e5e53b2594dc Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 28 May 2021 17:10:28 +0200 Subject: [PATCH 02/19] fix CHS config --- CommonTools/ParticleFlow/python/pfCHS_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py index c1912df9720de..10cafabe7570b 100644 --- a/CommonTools/ParticleFlow/python/pfCHS_cff.py +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -1,6 +1,6 @@ import FWCore.ParameterSet.Config as cms from CommonTools.ParticleFlow.pfNoPileUpJME_cff import adapt, pfPileUpJME -from PhysicsTools.PatAlgos.sortedPackedPrimaryVertices_cfi import sortedPackedPrimaryVertices +from CommonTools.RecoAlgos.sortedPackedPrimaryVertices_cfi import sortedPackedPrimaryVertices packedPrimaryVertexAssociationJME = sortedPackedPrimaryVertices.clone( produceSortedVertices = False, From 7b70199c3bcd1bf710855d60e6244fb011496dfc Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 28 May 2021 17:10:40 +0200 Subject: [PATCH 03/19] merge with CMSSW_12 --- PhysicsTools/PatAlgos/python/slimming/lostTracks_cfi.py | 2 +- RecoBTag/ONNXRuntime/python/pfParticleNetAK4_cff.py | 2 +- RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/lostTracks_cfi.py b/PhysicsTools/PatAlgos/python/slimming/lostTracks_cfi.py index 93f75eb1cc3f8..2da39f09701e7 100644 --- a/PhysicsTools/PatAlgos/python/slimming/lostTracks_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/lostTracks_cfi.py @@ -1,5 +1,5 @@ import FWCore.ParameterSet.Config as cms -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation from PhysicsTools.PatAlgos.slimming.packedPFCandidates_cfi import packedPFCandidates lostTracks = cms.EDProducer("PATLostTracks", diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNetAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNetAK4_cff.py index 8392793825a27..03c789b10f5eb 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNetAK4_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNetAK4_cff.py @@ -19,7 +19,7 @@ ) from CommonTools.PileupAlgos.Puppi_cff import puppi -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation # This task is not used, useful only if we run it from RECO jets (RECO/AOD) pfParticleNetAK4Task = cms.Task(puppi, primaryVertexAssociation, pfParticleNetAK4TagInfos, diff --git a/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py b/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py index d60b42b44c057..cad96af9c5a7c 100644 --- a/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py +++ b/RecoBTag/ONNXRuntime/python/pfParticleNet_cff.py @@ -34,7 +34,7 @@ ) from CommonTools.PileupAlgos.Puppi_cff import puppi -from PhysicsTools.PatAlgos.slimming.primaryVertexAssociation_cfi import primaryVertexAssociation +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation # This task is not used, useful only if we run it from RECO jets (RECO/AOD) pfParticleNetTask = cms.Task(puppi, primaryVertexAssociation, pfParticleNetTagInfos, From c46498e5d7841308ebde9c19611b12cc7da217b4 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 2 Jun 2021 18:51:56 +0200 Subject: [PATCH 04/19] fix reminiaod workflows --- .../PatUtils/python/tools/runMETCorrectionsAndUncertainties.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index a0505f5ad0886..efdaa35135190 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -1606,7 +1606,7 @@ def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, pos getattr(process, "primaryVertexAssociationJME"+postfix).particles = pfCandCollection getattr(process, "pfPileUpJME"+postfix).PFCandidates = "tmpPFCandCollPtr"+postfix getattr(process, "pfNoPileUpJME"+postfix).bottomCollection = "tmpPFCandCollPtr"+postfix - getattr(process, "pfNoPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociationJME'+postfix+':original' + getattr(process, "pfPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociationJME'+postfix+':original' pfCandColl = "pfNoPileUpJME"+postfix patMetModuleSequence += getattr(process, "tmpPFCandCollPtr"+postfix) patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix) From 38a9510652eac31c3fd74eba1c8bab192bb93b3d Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Thu, 3 Jun 2021 00:11:25 +0200 Subject: [PATCH 05/19] fix heavy ion workflow --- CommonTools/PileupAlgos/python/Puppi_cff.py | 8 +++++--- RecoMET/Configuration/python/RecoPFMET_cff.py | 3 ++- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/CommonTools/PileupAlgos/python/Puppi_cff.py b/CommonTools/PileupAlgos/python/Puppi_cff.py index b3dfc16923d9c..f1749609bcea3 100644 --- a/CommonTools/PileupAlgos/python/Puppi_cff.py +++ b/CommonTools/PileupAlgos/python/Puppi_cff.py @@ -99,10 +99,12 @@ ) ) +from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA +pp_on_AA.toModify(puppi, algos = []) +from Configuration.ProcessModifiers.run2_miniAOD_pp_on_AA_103X_cff import run2_miniAOD_pp_on_AA_103X +run2_miniAOD_pp_on_AA_103X.toModify(puppi,useVertexAssociation = False) # because the association is only run on cleandParticleFlow + puppiNoLep = puppi.clone( puppiNoLep = True, PtMaxPhotons = 20. ) - -from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA -pp_on_AA.toModify(puppi, algos = []) diff --git a/RecoMET/Configuration/python/RecoPFMET_cff.py b/RecoMET/Configuration/python/RecoPFMET_cff.py index 89b4afad19d63..22d0e7d178747 100644 --- a/RecoMET/Configuration/python/RecoPFMET_cff.py +++ b/RecoMET/Configuration/python/RecoPFMET_cff.py @@ -3,11 +3,12 @@ ##____________________________________________________________________________|| from RecoMET.METProducers.pfMet_cfi import * from RecoMET.METProducers.pfChMet_cfi import * +from CommonTools.ParticleFlow.pfNoPileUpJME_cff import goodOfflinePrimaryVertices, primaryVertexAssociationJME from CommonTools.PileupAlgos.Puppi_cff import puppiNoLep from RecoMET.METProducers.pfMetPuppi_cfi import * ##____________________________________________________________________________|| -recoPFMETTask = cms.Task(pfMet , particleFlowForChargedMET , pfChMet, puppiNoLep, pfMetPuppi) +recoPFMETTask = cms.Task(pfMet , particleFlowForChargedMET , goodOfflinePrimaryVertices, primaryVertexAssociationJME, pfChMet, puppiNoLep, pfMetPuppi) recoPFMET = cms.Sequence(recoPFMETTask) ##____________________________________________________________________________|| From 393614368a0527dd81f92ba944906821b3b38e7a Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Tue, 22 Jun 2021 17:26:04 +0200 Subject: [PATCH 06/19] allow to disable use of vertex fit --- .../test/recomputePuppiOnMiniAOD.py | 33 +++++++++++++++++-- .../interface/PrimaryVertexAssignment.h | 4 ++- .../python/sortedPFPrimaryVertices_cfi.py | 1 + .../python/sortedPrimaryVertices_cfi.py | 1 + .../RecoAlgos/src/PrimaryVertexAssignment.cc | 6 ++-- 5 files changed, 38 insertions(+), 7 deletions(-) diff --git a/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py index 5a799908344e1..5628b60de9425 100644 --- a/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py +++ b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py @@ -28,7 +28,7 @@ # Input source process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/h/hinzmann/stable_13TeV/jetmet/mtd/CMSSW_11_1_8/src/25202.0_TTbar_13+TTbar_13+DIGIUP15_PU25+RECOUP15_PU25+HARVESTUP15_PU25+NANOUP15_PU25/step3_inMINIAODSIM.root'), + fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/h/hinzmann/stable_13TeV/jetmet/mtd/CMSSW_12_0_0_pre3/src/25202.0_TTbar_13+TTbar_13+DIGIUP15_PU25+RECOUP15_PU25+HARVESTUP15_PU25+NANOUP15_PU25/step3_inMINIAODSIM.root'), secondaryFileNames = cms.untracked.vstring() ) @@ -85,8 +85,35 @@ from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc', '') -from CommonTools.PileupAlgos.customizePuppiTune_cff import UpdatePuppiTune_MC -UpdatePuppiTune_MC(process) +# Rerun PUPPI MET and ak4 jets (but not ak8) +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask +task = getPatAlgosToolsTask(process) +from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD +makePuppiesFromMiniAOD(process,True) +process.puppi.useExistingWeights = False +process.puppiNoLep.useExistingWeights = False +from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD +runMetCorAndUncFromMiniAOD(process,isData=False,metType="Puppi",postfix="Puppi",jetFlavor="AK4PFPuppi",recoMetFromPFCs=True) +from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer +addToProcessAndTask('patPuppiJetSpecificProducer', patPuppiJetSpecificProducer.clone(src=cms.InputTag("patJetsPuppi")), process, task) +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection +updateJetCollection( + process, + labelName = 'PuppiJetSpecific', + jetSource = cms.InputTag('patJetsPuppi'), +) +process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ] +addToProcessAndTask('slimmedJetsPuppi', process.updatedPatJetsPuppiJetSpecific.clone(), process, task) +del process.updatedPatJetsPuppiJetSpecific +process.puppiSequence = cms.Sequence(process.puppiMETSequence+process.fullPatMetSequencePuppi+process.patPuppiJetSpecificProducer+process.slimmedJetsPuppi) + +# Example how to not use vertex fit for track-vertex-association, but only dz +#process.packedPrimaryVertexAssociationJME.assignment.useVertexFit = False +#process.packedPrimaryVertexAssociationJME.assignment.maxDzSigForPrimaryAssignment = 5.0 +#process.packedPrimaryVertexAssociationJME.assignment.maxDzForPrimaryAssignment = 0.1 +#process.packedPrimaryVertexAssociationJME.assignment.maxDzErrorForPrimaryAssignment = 0.05 +#process.packedPrimaryVertexAssociationJME.assignment.OnlyUseFirstDz = False +#process.pfCHS.vertexAssociationQuality = 6 # Path and EndPath definitions process.puppi_step = cms.Path(process.puppiSequence) diff --git a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h index ac62013cc66c0..d84c7356d2bbc 100644 --- a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h +++ b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h @@ -42,6 +42,7 @@ class PrimaryVertexAssignment { maxDxySigForNotReconstructedPrimary_(iConfig.getParameter("maxDxySigForNotReconstructedPrimary")), maxDxyForNotReconstructedPrimary_(iConfig.getParameter("maxDxyForNotReconstructedPrimary")), useTiming_(iConfig.getParameter("useTiming")), + useVertexFit_(iConfig.getParameter("useVertexFit")), preferHighRanked_(iConfig.getParameter("preferHighRanked")), fNumOfPUVtxsForCharged_(iConfig.getParameter("NumOfPUVtxsForCharged")), fDzCutForChargedFromPUVtxs_(iConfig.getParameter("DzCutForChargedFromPUVtxs")), @@ -112,7 +113,7 @@ class PrimaryVertexAssignment { else return chargedHadronVertex( vertices, - (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose) ? pfcand.vertexRef().key() : -1, + (useVertexFit_ && (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose)) ? pfcand.vertexRef().key() : -1, &pfcand.pseudoTrack(), time, timeResolution, @@ -149,6 +150,7 @@ class PrimaryVertexAssignment { double maxDxySigForNotReconstructedPrimary_; double maxDxyForNotReconstructedPrimary_; bool useTiming_; + bool useVertexFit_; bool preferHighRanked_; int fNumOfPUVtxsForCharged_; double fDzCutForChargedFromPUVtxs_; diff --git a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py index 2b67ed5dc0ae6..1e446422fb1e1 100644 --- a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py @@ -18,6 +18,7 @@ maxDxySigForNotReconstructedPrimary = cms.double(2), #in AND with next maxDxyForNotReconstructedPrimary = cms.double(0.01), #in AND with prev useTiming = cms.bool(False), + useVertexFit = cms.bool(True), preferHighRanked = cms.bool(False), #options used in PUPPI diff --git a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py index 901c85e9d1760..57be0713ca862 100644 --- a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py @@ -18,6 +18,7 @@ maxDxySigForNotReconstructedPrimary = cms.double(2), #in AND with next maxDxyForNotReconstructedPrimary = cms.double(0.01), #in AND with prev useTiming = cms.bool(False), + useVertexFit = cms.bool(True), preferHighRanked = cms.bool(False), #options used in PUPPI diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 6ef1d658a8973..11d2785c8e159 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -52,7 +52,7 @@ std::pair PrimaryVertexAssignment::charge if (preferHighRanked_) { for (IV iv = vertices.begin(); iv != vertices.end(); ++iv) { int ivtx = iv - vertices.begin(); - if (iVertex == ivtx) + if (useVertexFit_ && (iVertex == ivtx)) return std::pair(ivtx, PrimaryVertexAssignment::UsedInFit); double dz = std::abs(track->dz(iv->position())); @@ -68,11 +68,11 @@ std::pair PrimaryVertexAssignment::charge } // recover cases where the primary vertex is split - if ((iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && + if (useVertexFit_ && (iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && (std::abs(track->dz(vertices.at(0).position())) < fDzCutForChargedFromPUVtxs_)) return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); - if (iVertex >= 0) + if (useVertexFit_ && (iVertex >= 0)) return std::pair(iVertex, PrimaryVertexAssignment::UsedInFit); double distmin = std::numeric_limits::max(); From 556d75de24d83d454f1129043e3286cd3963e184 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 11 Aug 2021 14:10:53 +0200 Subject: [PATCH 07/19] comments from Andrea --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 88 ++++++++++++++++--- CommonTools/ParticleFlow/plugins/PFPileUp.h | 71 --------------- .../ParticleFlow/plugins/PFnoPileUp.cc | 45 ---------- CommonTools/ParticleFlow/plugins/PFnoPileUp.h | 48 ---------- CommonTools/ParticleFlow/python/pfCHS_cff.py | 2 +- .../ParticleFlow/python/pfNoPileUpJME_cff.py | 2 +- .../PileupAlgos/plugins/PuppiProducer.cc | 18 ++-- CommonTools/PileupAlgos/python/Puppi_cff.py | 10 +-- .../interface/PrimaryVertexAssignment.h | 4 +- .../python/sortedPackedPrimaryVertices_cfi.py | 18 ++-- .../RecoAlgos/src/PrimaryVertexAssignment.cc | 50 ++++++----- 11 files changed, 128 insertions(+), 228 deletions(-) delete mode 100644 CommonTools/ParticleFlow/plugins/PFPileUp.h delete mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUp.cc delete mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUp.h diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index b8b599fbbd9f1..bfc6720dff437 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -1,4 +1,23 @@ -#include "CommonTools/ParticleFlow/plugins/PFPileUp.h" +#ifndef PhysicsTools_PFCandProducer_PFPileUp_ +#define PhysicsTools_PFCandProducer_PFPileUp_ + +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/Association.h" + +#include "CommonTools/ParticleFlow/interface/PFPileUpAlgo.h" #include "DataFormats/ParticleFlowCandidate/interface/PileUpPFCandidate.h" #include "DataFormats/ParticleFlowCandidate/interface/PileUpPFCandidateFwd.h" @@ -6,7 +25,6 @@ #include "FWCore/Framework/interface/ESHandle.h" -// #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "FWCore/Utilities/interface/Exception.h" #include "FWCore/Framework/interface/EventSetup.h" @@ -14,6 +32,55 @@ using namespace std; using namespace edm; using namespace reco; +/**\class PFPileUp +\brief Identifies pile-up candidates from a collection of PFCandidates, and +produces the corresponding collection of PileUpCandidates. + +\author Colin Bernet +\date february 2008 +\updated Florian Beaudette 30/03/2012 + +*/ + +class PFPileUp : public edm::stream::EDProducer<> { +public: + typedef std::vector> PFCollection; + typedef edm::View PFView; + typedef std::vector PFCollectionByValue; + typedef edm::Association CandToVertex; + + explicit PFPileUp(const edm::ParameterSet&); + + ~PFPileUp() override; + + void produce(edm::Event&, const edm::EventSetup&) override; + +private: + PFPileUpAlgo pileUpAlgo_; + + /// PFCandidates to be analyzed + edm::EDGetTokenT tokenPFCandidates_; + /// fall-back token + edm::EDGetTokenT tokenPFCandidatesView_; + + /// vertices + edm::EDGetTokenT tokenVertices_; + + /// enable PFPileUp selection + bool enable_; + + /// verbose ? + bool verbose_; + + /// use the closest z vertex if a track is not in a vertex + bool checkClosestZVertex_; + + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; + bool fUseVertexAssociation; + int vertexAssociationQuality_; +}; + PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates")); tokenPFCandidatesView_ = mayConsume(iConfig.getParameter("PFCandidates")); @@ -102,18 +169,14 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { } if (fUseVertexAssociation) { - edm::Handle> assoHandle; - iEvent.getByToken(tokenVertexAssociation_, assoHandle); - const edm::Association* associatedPV = assoHandle.product(); - edm::Handle> assoQualityHandle; - iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); - const edm::ValueMap* associationQuality = assoQualityHandle.product(); + const edm::Association associatedPV = iEvent.get(tokenVertexAssociation_); + const edm::ValueMap associationQuality = iEvent.get(tokenVertexAssociationQuality_); PFCollection pfCandidatesFromPU; - for (unsigned i = 0; i < (*pfCandidatesRef).size(); i++) { - const reco::VertexRef& PVOrig = (*associatedPV)[(*pfCandidatesRef)[i]]; - int quality = (*associationQuality)[(*pfCandidatesRef)[i]]; + for (auto& p : (*pfCandidatesRef)) { + const reco::VertexRef& PVOrig = associatedPV[p]; + int quality = associationQuality[p]; if (PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_)) - pfCandidatesFromPU.push_back((*pfCandidatesRef)[i]); + pfCandidatesFromPU.push_back(p); } pOutput->insert(pOutput->end(), pfCandidatesFromPU.begin(), pfCandidatesFromPU.end()); } else { @@ -132,3 +195,4 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { iEvent.put(std::move(pOutput)); // iEvent.put(std::move(pOutputByValue)); } +#endif diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.h b/CommonTools/ParticleFlow/plugins/PFPileUp.h deleted file mode 100644 index 07e114c1d8f9e..0000000000000 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.h +++ /dev/null @@ -1,71 +0,0 @@ -#ifndef PhysicsTools_PFCandProducer_PFPileUp_ -#define PhysicsTools_PFCandProducer_PFPileUp_ - -// system include files -#include -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/Common/interface/Association.h" - -#include "CommonTools/ParticleFlow/interface/PFPileUpAlgo.h" - -/**\class PFPileUp -\brief Identifies pile-up candidates from a collection of PFCandidates, and -produces the corresponding collection of PileUpCandidates. - -\author Colin Bernet -\date february 2008 -\updated Florian Beaudette 30/03/2012 - -*/ - -class PFPileUp : public edm::stream::EDProducer<> { -public: - typedef std::vector> PFCollection; - typedef edm::View PFView; - typedef std::vector PFCollectionByValue; - typedef edm::Association CandToVertex; - - explicit PFPileUp(const edm::ParameterSet&); - - ~PFPileUp() override; - - void produce(edm::Event&, const edm::EventSetup&) override; - -private: - PFPileUpAlgo pileUpAlgo_; - - /// PFCandidates to be analyzed - edm::EDGetTokenT tokenPFCandidates_; - /// fall-back token - edm::EDGetTokenT tokenPFCandidatesView_; - - /// vertices - edm::EDGetTokenT tokenVertices_; - - /// enable PFPileUp selection - bool enable_; - - /// verbose ? - bool verbose_; - - /// use the closest z vertex if a track is not in a vertex - bool checkClosestZVertex_; - - edm::EDGetTokenT tokenVertexAssociation_; - edm::EDGetTokenT> tokenVertexAssociationQuality_; - bool fUseVertexAssociation; - int vertexAssociationQuality_; -}; - -#endif diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc deleted file mode 100644 index 0bd240110be12..0000000000000 --- a/CommonTools/ParticleFlow/plugins/PFnoPileUp.cc +++ /dev/null @@ -1,45 +0,0 @@ -#include "CommonTools/ParticleFlow/plugins/PFnoPileUp.h" - -#include "DataFormats/VertexReco/interface/Vertex.h" - -#include "FWCore/Framework/interface/ESHandle.h" - -// #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Utilities/interface/Exception.h" -#include "FWCore/Framework/interface/EventSetup.h" - -using namespace std; -using namespace edm; -using namespace reco; - -PFnoPileUp::PFnoPileUp(const edm::ParameterSet& iConfig) { - tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); - vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); - tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); - tokenVertexAssociationQuality_ = - consumes>(iConfig.getParameter("vertexAssociation")); - produces>(); -} - -PFnoPileUp::~PFnoPileUp() {} - -void PFnoPileUp::produce(Event& iEvent, const EventSetup& iSetup) { - unique_ptr> pOutput(new edm::PtrVector); - Handle candidateView; - iEvent.getByToken(tokenCandidatesView_, candidateView); - edm::Handle> assoHandle; - iEvent.getByToken(tokenVertexAssociation_, assoHandle); - const edm::Association* associatedPV = assoHandle.product(); - edm::Handle> assoQualityHandle; - iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); - const edm::ValueMap* associationQuality = assoQualityHandle.product(); - for (unsigned i = 0; i < candidateView->size(); i++) { - const reco::VertexRef& PVOrig = (*associatedPV)[candidateView->ptrAt(i)]; - int quality = (*associationQuality)[candidateView->ptrAt(i)]; - if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) - pOutput->push_back(candidateView->ptrAt(i)); - } - iEvent.put(std::move(pOutput)); -} - -DEFINE_FWK_MODULE(PFnoPileUp); \ No newline at end of file diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUp.h b/CommonTools/ParticleFlow/plugins/PFnoPileUp.h deleted file mode 100644 index 412dd326252c7..0000000000000 --- a/CommonTools/ParticleFlow/plugins/PFnoPileUp.h +++ /dev/null @@ -1,48 +0,0 @@ -#ifndef CommonTools_ParticleFlow_PFnoPileUp_ -#define CommonTools_ParticleFlow_PFnoPileUp_ - -// system include files -#include -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "DataFormats/Candidate/interface/Candidate.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/Common/interface/Association.h" - -/**\class PFnoPileUp -\brief Identifies pile-up candidates from a collection of Candidates, and -produces the corresponding collection of NoPileUpCandidates. - -\author Andreas Hinzmann -\date May 2021 - -*/ - -class PFnoPileUp : public edm::stream::EDProducer<> { -public: - typedef edm::View CandidateView; - typedef edm::Association CandToVertex; - - explicit PFnoPileUp(const edm::ParameterSet&); - - ~PFnoPileUp() override; - - void produce(edm::Event&, const edm::EventSetup&) override; - -private: - edm::EDGetTokenT tokenCandidatesView_; - edm::EDGetTokenT tokenVertices_; - edm::EDGetTokenT tokenVertexAssociation_; - edm::EDGetTokenT> tokenVertexAssociationQuality_; - int vertexAssociationQuality_; -}; - -#endif diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py index 10cafabe7570b..b455aec07ef9f 100644 --- a/CommonTools/ParticleFlow/python/pfCHS_cff.py +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -9,7 +9,7 @@ ) adapt(packedPrimaryVertexAssociationJME) -pfCHS = cms.EDProducer("PFnoPileUp", +pfCHS = cms.EDProducer("PFnoPileUpPacked", candidates = cms.InputTag("packedPFCandidates"), vertexAssociationQuality = pfPileUpJME.vertexAssociationQuality, vertexAssociation = cms.InputTag("packedPrimaryVertexAssociationJME","original") diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index 445e08283b952..caad529298bd3 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -26,7 +26,7 @@ def adapt(primaryVertexAssociationJME): pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', useVertexAssociation = True, vertexAssociationQuality = 7, - vertexAssociation = cms.InputTag('primaryVertexAssociationJME','original'), + vertexAssociation = ('primaryVertexAssociationJME','original'), ) pfNoPileUpJME = _pfNoPileUp.clone(topCollection = 'pfPileUpJME', bottomCollection = 'particleFlowPtrs' ) diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc index 4543064dbb12a..3490a006578ee 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc @@ -87,15 +87,11 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { iEvent.getByToken(tokenVertices_, hVertexProduct); const reco::VertexCollection* pvCol = hVertexProduct.product(); - edm::Handle> assoHandle; - const edm::Association* associatedPV = nullptr; - edm::Handle> assoQualityHandle; - const edm::ValueMap* associationQuality = nullptr; + edm::Association associatedPV; + edm::ValueMap associationQuality; if ((fUseVertexAssociation) && (!fUseExistingWeights)) { - iEvent.getByToken(tokenVertexAssociation_, assoHandle); - associatedPV = assoHandle.product(); - iEvent.getByToken(tokenVertexAssociationQuality_, assoQualityHandle); - associationQuality = assoQualityHandle.product(); + associatedPV = iEvent.get(tokenVertexAssociation_); + associationQuality = iEvent.get(tokenVertexAssociationQuality_); } double puProxyValue = 0.; @@ -113,7 +109,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { //Fill the reco objects fRecoObjCollection.clear(); fRecoObjCollection.reserve(pfCol->size()); - size_t ic = 0; + int ic = 0; for (auto const& aPF : *pfCol) { RecoObj pReco; pReco.pt = aPF.pt(); @@ -131,8 +127,8 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { const pat::PackedCandidate* lPack = dynamic_cast(&aPF); if (fUseVertexAssociation) { - const reco::VertexRef& PVOrig = (*associatedPV)[reco::CandidatePtr(hPFProduct, ic)]; - int quality = (*associationQuality)[reco::CandidatePtr(hPFProduct, ic)]; + const reco::VertexRef& PVOrig = associatedPV[reco::CandidatePtr(hPFProduct, ic)]; + int quality = associationQuality[reco::CandidatePtr(hPFProduct, ic)]; if (PVOrig.isNonnull() && (quality >= vertexAssociationQuality_)) { closestVtx = PVOrig.get(); pVtxId = PVOrig.key(); diff --git a/CommonTools/PileupAlgos/python/Puppi_cff.py b/CommonTools/PileupAlgos/python/Puppi_cff.py index f1749609bcea3..b2e6b5f015ac1 100644 --- a/CommonTools/PileupAlgos/python/Puppi_cff.py +++ b/CommonTools/PileupAlgos/python/Puppi_cff.py @@ -32,10 +32,10 @@ PtMaxCharged = 20., PtMaxNeutralsStartSlope = 20., useVertexAssociation = True, - vertexAssociationQuality = cms.int32(6), - vertexAssociation = cms.InputTag('primaryVertexAssociationJME','original'), - #candName = cms.string('packedPFCandidates'), - #vertexName = cms.string('offlineSlimmedPrimaryVertices'), + vertexAssociationQuality = 6, + vertexAssociation = ('primaryVertexAssociationJME','original'), + #candName = 'packedPFCandidates', + #vertexName = 'offlineSlimmedPrimaryVertices', clonePackedCands = False, # should only be set to True for MiniAOD algos = { 0: dict( @@ -102,7 +102,7 @@ from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(puppi, algos = []) from Configuration.ProcessModifiers.run2_miniAOD_pp_on_AA_103X_cff import run2_miniAOD_pp_on_AA_103X -run2_miniAOD_pp_on_AA_103X.toModify(puppi,useVertexAssociation = False) # because the association is only run on cleandParticleFlow +run2_miniAOD_pp_on_AA_103X.toModify(puppi,useVertexAssociation = False) # because the association is only run on cleanedParticleFlow puppiNoLep = puppi.clone( puppiNoLep = True, diff --git a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h index d84c7356d2bbc..388fd1567a977 100644 --- a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h +++ b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h @@ -113,7 +113,9 @@ class PrimaryVertexAssignment { else return chargedHadronVertex( vertices, - (useVertexFit_ && (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose)) ? pfcand.vertexRef().key() : -1, + (useVertexFit_ && (pfcand.pvAssociationQuality() >= pat::PackedCandidate::UsedInFitLoose)) + ? pfcand.vertexRef().key() + : -1, &pfcand.pseudoTrack(), time, timeResolution, diff --git a/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py index 7b4bf97166295..9a9b171db5bf4 100644 --- a/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py @@ -3,13 +3,13 @@ sortedPackedPrimaryVertices = cms.EDProducer("PackedCandidatePrimaryVertexSorter", sorting = cms.PSet(), assignment = sortedPFPrimaryVertices.assignment, - particles = cms.InputTag("packedPFCandidates"), - vertices= cms.InputTag("offlineSlimmedPrimaryVertices"), - jets= cms.InputTag("slimmedJets"), - qualityForPrimary = cms.int32(3), - usePVMET = cms.bool(True), - produceAssociationToOriginalVertices = cms.bool(True), - produceSortedVertices = cms.bool(True), - producePileUpCollection = cms.bool(True), - produceNoPileUpCollection = cms.bool(True), + particles = cms.InputTag("packedPFCandidates"), + vertices= cms.InputTag("offlineSlimmedPrimaryVertices"), + jets= cms.InputTag("slimmedJets"), + qualityForPrimary = cms.int32(3), + usePVMET = cms.bool(True), + produceAssociationToOriginalVertices = cms.bool(True), + produceSortedVertices = cms.bool(True), + producePileUpCollection = cms.bool(True), + produceNoPileUpCollection = cms.bool(True), ) diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 11d2785c8e159..7515cb6f42583 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -104,28 +104,30 @@ std::pair PrimaryVertexAssignment::charge } } - // first use "closest in Z" with tight cuts (targetting primary particles) - const float add_cov = vtxIdMinSignif >= 0 ? vertices[vtxIdMinSignif].covariance(2, 2) : 0.f; - const float dzE = sqrt(track->dzError() * track->dzError() + add_cov); - if (!fOnlyUseFirstDz_ and vtxIdMinSignif >= 0 and - (dzmin < maxDzForPrimaryAssignment_ and dzmin / dzE < maxDzSigForPrimaryAssignment_ and - track->dzError() < maxDzErrorForPrimaryAssignment_) and - (!useTime or dtmin / timeReso < maxDtSigForPrimaryAssignment_)) { - iVertex = vtxIdMinSignif; - } - - // consider only distances to first vertex for association of pileup vertices (originally used in PUPPI) - if ((fOnlyUseFirstDz_) && (vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_)) - iVertex = ((std::abs(track->dz(vertices.at(0).position())) < maxDzForPrimaryAssignment_ and - std::abs(track->dz(vertices.at(0).position())) / dzE < maxDzSigForPrimaryAssignment_ and - track->dzError() < maxDzErrorForPrimaryAssignment_) and - (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) - ? 0 - : vtxIdMinSignif; - // protect high pT particles from association to pileup vertices and assign them to the first vertex - if ((fPtMaxCharged_ > 0) && (vtxIdMinSignif >= 0) && (track->pt() > fPtMaxCharged_)) + if ((fPtMaxCharged_ > 0) && (vtxIdMinSignif >= 0) && (track->pt() > fPtMaxCharged_)) { iVertex = 0; + } else { + // first use "closest in Z" with tight cuts (targetting primary particles) + const float add_cov = vtxIdMinSignif >= 0 ? vertices[vtxIdMinSignif].covariance(2, 2) : 0.f; + const float dzE = sqrt(track->dzError() * track->dzError() + add_cov); + if (!fOnlyUseFirstDz_) { + if (vtxIdMinSignif >= 0 and + (dzmin < maxDzForPrimaryAssignment_ and dzmin / dzE < maxDzSigForPrimaryAssignment_ and + track->dzError() < maxDzErrorForPrimaryAssignment_) and + (!useTime or dtmin / timeReso < maxDtSigForPrimaryAssignment_)) + iVertex = vtxIdMinSignif; + } else { + // consider only distances to first vertex for association of pileup vertices (originally used in PUPPI) + if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_)) + iVertex = ((std::abs(track->dz(vertices.at(0).position())) < maxDzForPrimaryAssignment_ and + std::abs(track->dz(vertices.at(0).position())) / dzE < maxDzSigForPrimaryAssignment_ and + track->dzError() < maxDzErrorForPrimaryAssignment_) and + (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) + ? 0 + : vtxIdMinSignif; + } + } if (iVertex >= 0) return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); @@ -133,14 +135,14 @@ std::pair PrimaryVertexAssignment::charge // if track not assigned yet, it could be a b-decay secondary , use jet axis dist criterion // first find the closest jet within maxJetDeltaR_ int jetIdx = -1; - double minDeltaR = maxJetDeltaR_; + double minDeltaR2 = maxJetDeltaR_ * maxJetDeltaR_; for (edm::View::const_iterator ij = jets.begin(); ij != jets.end(); ++ij) { if (ij->pt() < minJetPt_) continue; // skip jets below the jet Pt threshold - double deltaR = reco::deltaR(*ij, *track); - if (deltaR < minDeltaR and track->dzError() < maxDzErrorForPrimaryAssignment_) { - minDeltaR = deltaR; + double deltaR2 = reco::deltaR2(*ij, *track); + if (deltaR2 < minDeltaR2 and track->dzError() < maxDzErrorForPrimaryAssignment_) { + minDeltaR2 = deltaR2; jetIdx = std::distance(jets.begin(), ij); } } From 6c855891394252c4e4bbb370c23bbef137a9be23 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 11 Aug 2021 17:16:28 +0200 Subject: [PATCH 08/19] add back lost file --- .../ParticleFlow/plugins/PFnoPileUpPacked.cc | 97 +++++++++++++++++++ 1 file changed, 97 insertions(+) create mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc new file mode 100644 index 0000000000000..45c402185b37c --- /dev/null +++ b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc @@ -0,0 +1,97 @@ +#ifndef CommonTools_ParticleFlow_PFnoPileUpPacked_ +#define CommonTools_ParticleFlow_PFnoPileUpPacked_ + +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/Association.h" + +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Framework/interface/EventSetup.h" + +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +using namespace std; +using namespace edm; +using namespace reco; + + +/**\class PFnoPileUpPacked +\brief Identifies pile-up candidates from a collection of Candidates, and +produces the corresponding collection of NoPileUpCandidates. + +\author Andreas Hinzmann +\date May 2021 + +*/ + +class PFnoPileUpPacked : public edm::stream::EDProducer<> { +public: + typedef edm::View CandidateView; + typedef edm::Association CandToVertex; + + explicit PFnoPileUpPacked(const edm::ParameterSet&); + + ~PFnoPileUpPacked() override = default; + + void produce(edm::Event&, const edm::EventSetup&) override; + + static void fillDescriptions(edm::ConfigurationDescriptions & descriptions); + +private: + edm::EDGetTokenT tokenCandidatesView_; + edm::EDGetTokenT tokenVertices_; + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; + int vertexAssociationQuality_; +}; + + +PFnoPileUpPacked::PFnoPileUpPacked(const edm::ParameterSet& iConfig) { + tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); + vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); + tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); + tokenVertexAssociationQuality_ = + consumes>(iConfig.getParameter("vertexAssociation")); + produces>(); +} + +void PFnoPileUpPacked::produce(Event& iEvent, const EventSetup& iSetup) { + unique_ptr> pOutput(new edm::PtrVector); + Handle candidateView; + iEvent.getByToken(tokenCandidatesView_, candidateView); + const edm::Association associatedPV = iEvent.get(tokenVertexAssociation_); + const edm::ValueMap associationQuality = iEvent.get(tokenVertexAssociationQuality_); + for (auto p : candidateView->ptrs()) { + const reco::VertexRef& PVOrig = associatedPV[p]; + int quality = associationQuality[p]; + if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) + pOutput->push_back(p); + } + iEvent.put(std::move(pOutput)); +} + +void PFnoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions & descriptions) { + edm::ParameterSetDescription desc; + desc.add("candidates", edm::InputTag("packedPFCandidates")); + desc.add("vertexAssociationQuality", 7); + desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME","original")); + descriptions.add("produceMuons", desc); +} + +DEFINE_FWK_MODULE(PFnoPileUpPacked); +#endif \ No newline at end of file From 5e94e09adaec3a06021041d662841164dbb3c1bf Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 11 Aug 2021 17:33:46 +0200 Subject: [PATCH 09/19] code format and code checks --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 4 ++-- .../ParticleFlow/plugins/PFnoPileUpPacked.cc | 22 +++++++++---------- .../RecoAlgos/plugins/PrimaryVertexSorter.h | 5 +++-- 3 files changed, 15 insertions(+), 16 deletions(-) diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index bfc6720dff437..cdd1e11e1d930 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -169,8 +169,8 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { } if (fUseVertexAssociation) { - const edm::Association associatedPV = iEvent.get(tokenVertexAssociation_); - const edm::ValueMap associationQuality = iEvent.get(tokenVertexAssociationQuality_); + const edm::Association& associatedPV = iEvent.get(tokenVertexAssociation_); + const edm::ValueMap& associationQuality = iEvent.get(tokenVertexAssociationQuality_); PFCollection pfCandidatesFromPU; for (auto& p : (*pfCandidatesRef)) { const reco::VertexRef& PVOrig = associatedPV[p]; diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc index 45c402185b37c..b035017b953e0 100644 --- a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc +++ b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc @@ -29,7 +29,6 @@ using namespace std; using namespace edm; using namespace reco; - /**\class PFnoPileUpPacked \brief Identifies pile-up candidates from a collection of Candidates, and produces the corresponding collection of NoPileUpCandidates. @@ -50,7 +49,7 @@ class PFnoPileUpPacked : public edm::stream::EDProducer<> { void produce(edm::Event&, const edm::EventSetup&) override; - static void fillDescriptions(edm::ConfigurationDescriptions & descriptions); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: edm::EDGetTokenT tokenCandidatesView_; @@ -60,7 +59,6 @@ class PFnoPileUpPacked : public edm::stream::EDProducer<> { int vertexAssociationQuality_; }; - PFnoPileUpPacked::PFnoPileUpPacked(const edm::ParameterSet& iConfig) { tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); @@ -74,9 +72,9 @@ void PFnoPileUpPacked::produce(Event& iEvent, const EventSetup& iSetup) { unique_ptr> pOutput(new edm::PtrVector); Handle candidateView; iEvent.getByToken(tokenCandidatesView_, candidateView); - const edm::Association associatedPV = iEvent.get(tokenVertexAssociation_); - const edm::ValueMap associationQuality = iEvent.get(tokenVertexAssociationQuality_); - for (auto p : candidateView->ptrs()) { + const edm::Association& associatedPV = iEvent.get(tokenVertexAssociation_); + const edm::ValueMap& associationQuality = iEvent.get(tokenVertexAssociationQuality_); + for (const auto& p : candidateView->ptrs()) { const reco::VertexRef& PVOrig = associatedPV[p]; int quality = associationQuality[p]; if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) @@ -85,12 +83,12 @@ void PFnoPileUpPacked::produce(Event& iEvent, const EventSetup& iSetup) { iEvent.put(std::move(pOutput)); } -void PFnoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions & descriptions) { - edm::ParameterSetDescription desc; - desc.add("candidates", edm::InputTag("packedPFCandidates")); - desc.add("vertexAssociationQuality", 7); - desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME","original")); - descriptions.add("produceMuons", desc); +void PFnoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("candidates", edm::InputTag("packedPFCandidates")); + desc.add("vertexAssociationQuality", 7); + desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME", "original")); + descriptions.add("produceMuons", desc); } DEFINE_FWK_MODULE(PFnoPileUpPacked); diff --git a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h index fa78ebf5de8d6..e4e8e5b98cc4e 100644 --- a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h +++ b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h @@ -313,7 +313,8 @@ inline void PrimaryVertexSorter>::doConsumesForTi } template <> -inline void PrimaryVertexSorter>::doConsumesForTiming(const edm::ParameterSet& iConfig) {} +inline void PrimaryVertexSorter>::doConsumesForTiming( + const edm::ParameterSet& iConfig) {} template <> inline bool PrimaryVertexSorter>::needsProductsForTiming() { @@ -353,7 +354,7 @@ inline std::pair PrimaryVertexSorter -std::pair PrimaryVertexSorter>::runAlgo( +inline std::pair PrimaryVertexSorter>::runAlgo( const reco::VertexCollection& vertices, const pat::PackedCandidate& pf, const edm::ValueMap* trackTimeTag, From 8ef33596911b5d97ba05a99820a1a8faebe6652c Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 11 Aug 2021 17:36:39 +0200 Subject: [PATCH 10/19] remove nano import --- CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py | 1 - 1 file changed, 1 deletion(-) diff --git a/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py index 5628b60de9425..8825604bf18c1 100644 --- a/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py +++ b/CommonTools/PileupAlgos/test/recomputePuppiOnMiniAOD.py @@ -17,7 +17,6 @@ process.load('SimGeneral.MixingModule.mixNoPU_cfi') process.load('Configuration.StandardSequences.GeometryRecoDB_cff') process.load('Configuration.StandardSequences.MagneticField_cff') -process.load('PhysicsTools.NanoAOD.nano_cff') process.load('Configuration.StandardSequences.EndOfProcess_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') From ff72b04c3280cb4a3283a6880394724715cb529c Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Thu, 12 Aug 2021 14:44:31 +0200 Subject: [PATCH 11/19] remove ifdefs --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 4 ---- CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc | 6 +----- 2 files changed, 1 insertion(+), 9 deletions(-) diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index cdd1e11e1d930..c144c18e9bd24 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -1,6 +1,3 @@ -#ifndef PhysicsTools_PFCandProducer_PFPileUp_ -#define PhysicsTools_PFCandProducer_PFPileUp_ - // system include files #include #include @@ -195,4 +192,3 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { iEvent.put(std::move(pOutput)); // iEvent.put(std::move(pOutputByValue)); } -#endif diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc index b035017b953e0..649e17e49d58c 100644 --- a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc +++ b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc @@ -1,6 +1,3 @@ -#ifndef CommonTools_ParticleFlow_PFnoPileUpPacked_ -#define CommonTools_ParticleFlow_PFnoPileUpPacked_ - // system include files #include #include @@ -91,5 +88,4 @@ void PFnoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions& descript descriptions.add("produceMuons", desc); } -DEFINE_FWK_MODULE(PFnoPileUpPacked); -#endif \ No newline at end of file +DEFINE_FWK_MODULE(PFnoPileUpPacked); \ No newline at end of file From 4f83c43fef2cfd0ba9655b8fdd3a84f4d54db33a Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Mon, 16 Aug 2021 11:40:17 +0200 Subject: [PATCH 12/19] remove PFPileUp from SealModule --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 1 + CommonTools/ParticleFlow/plugins/SealModule.cc | 2 -- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index c144c18e9bd24..35b328035eda6 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -192,3 +192,4 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { iEvent.put(std::move(pOutput)); // iEvent.put(std::move(pOutputByValue)); } +DEFINE_FWK_MODULE(PFPileUp); diff --git a/CommonTools/ParticleFlow/plugins/SealModule.cc b/CommonTools/ParticleFlow/plugins/SealModule.cc index eb561b1381c31..134fee6951bf8 100644 --- a/CommonTools/ParticleFlow/plugins/SealModule.cc +++ b/CommonTools/ParticleFlow/plugins/SealModule.cc @@ -1,7 +1,6 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "CommonTools/ParticleFlow/plugins/PFMET.h" -#include "CommonTools/ParticleFlow/plugins/PFPileUp.h" #include "CommonTools/ParticleFlow/plugins/PFCandidateFwdPtrCollectionFilter.h" #include "CommonTools/ParticleFlow/plugins/PFJetFwdPtrProducer.h" #include "CommonTools/ParticleFlow/plugins/PFTauFwdPtrProducer.h" @@ -9,7 +8,6 @@ #include "CommonTools/ParticleFlow/plugins/DeltaBetaWeights.h" DEFINE_FWK_MODULE(PFMET); -DEFINE_FWK_MODULE(PFPileUp); DEFINE_FWK_MODULE(PFCandidateFwdPtrCollectionStringFilter); DEFINE_FWK_MODULE(PFCandidateFwdPtrCollectionPdgIdFilter); From 67c5d8e730e45e34cfd96059b884e58835f74a66 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 20 Aug 2021 12:33:32 +0200 Subject: [PATCH 13/19] comments from Jacobo --- .../ParticleFlow/plugins/PFnoPileUpPacked.cc | 91 ------------------- CommonTools/ParticleFlow/python/pfCHS_cff.py | 9 +- .../PileupAlgos/plugins/PuppiProducer.cc | 8 +- CommonTools/PileupAlgos/python/Puppi_cff.py | 2 - .../interface/PrimaryVertexAssignment.h | 6 +- .../RecoAlgos/src/PrimaryVertexAssignment.cc | 34 +++---- .../runMETCorrectionsAndUncertainties.py | 2 +- 7 files changed, 29 insertions(+), 123 deletions(-) delete mode 100644 CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc diff --git a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc deleted file mode 100644 index 649e17e49d58c..0000000000000 --- a/CommonTools/ParticleFlow/plugins/PFnoPileUpPacked.cc +++ /dev/null @@ -1,91 +0,0 @@ -// system include files -#include -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "DataFormats/Candidate/interface/Candidate.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/Common/interface/Association.h" - -#include "DataFormats/VertexReco/interface/Vertex.h" - -#include "FWCore/Utilities/interface/Exception.h" -#include "FWCore/Framework/interface/EventSetup.h" - -#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" -#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" - -using namespace std; -using namespace edm; -using namespace reco; - -/**\class PFnoPileUpPacked -\brief Identifies pile-up candidates from a collection of Candidates, and -produces the corresponding collection of NoPileUpCandidates. - -\author Andreas Hinzmann -\date May 2021 - -*/ - -class PFnoPileUpPacked : public edm::stream::EDProducer<> { -public: - typedef edm::View CandidateView; - typedef edm::Association CandToVertex; - - explicit PFnoPileUpPacked(const edm::ParameterSet&); - - ~PFnoPileUpPacked() override = default; - - void produce(edm::Event&, const edm::EventSetup&) override; - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - edm::EDGetTokenT tokenCandidatesView_; - edm::EDGetTokenT tokenVertices_; - edm::EDGetTokenT tokenVertexAssociation_; - edm::EDGetTokenT> tokenVertexAssociationQuality_; - int vertexAssociationQuality_; -}; - -PFnoPileUpPacked::PFnoPileUpPacked(const edm::ParameterSet& iConfig) { - tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); - vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); - tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); - tokenVertexAssociationQuality_ = - consumes>(iConfig.getParameter("vertexAssociation")); - produces>(); -} - -void PFnoPileUpPacked::produce(Event& iEvent, const EventSetup& iSetup) { - unique_ptr> pOutput(new edm::PtrVector); - Handle candidateView; - iEvent.getByToken(tokenCandidatesView_, candidateView); - const edm::Association& associatedPV = iEvent.get(tokenVertexAssociation_); - const edm::ValueMap& associationQuality = iEvent.get(tokenVertexAssociationQuality_); - for (const auto& p : candidateView->ptrs()) { - const reco::VertexRef& PVOrig = associatedPV[p]; - int quality = associationQuality[p]; - if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) - pOutput->push_back(p); - } - iEvent.put(std::move(pOutput)); -} - -void PFnoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - desc.add("candidates", edm::InputTag("packedPFCandidates")); - desc.add("vertexAssociationQuality", 7); - desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME", "original")); - descriptions.add("produceMuons", desc); -} - -DEFINE_FWK_MODULE(PFnoPileUpPacked); \ No newline at end of file diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py index b455aec07ef9f..23dba83b7fa79 100644 --- a/CommonTools/ParticleFlow/python/pfCHS_cff.py +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -9,8 +9,7 @@ ) adapt(packedPrimaryVertexAssociationJME) -pfCHS = cms.EDProducer("PFnoPileUpPacked", - candidates = cms.InputTag("packedPFCandidates"), - vertexAssociationQuality = pfPileUpJME.vertexAssociationQuality, - vertexAssociation = cms.InputTag("packedPrimaryVertexAssociationJME","original") - ) +from CommonTools.ParticleFlow.pfNoPileUpPacked_cfi import pfNoPileUpPacked as _pfNoPileUpPacked +pfCHS = _pfNoPileUpPacked.clone( + vertexAssociationQuality=pfPileUpJME.vertexAssociationQuality +) diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc index 3490a006578ee..a04967339319e 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc @@ -109,7 +109,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { //Fill the reco objects fRecoObjCollection.clear(); fRecoObjCollection.reserve(pfCol->size()); - int ic = 0; + int iCand = 0; for (auto const& aPF : *pfCol) { RecoObj pReco; pReco.pt = aPF.pt(); @@ -127,8 +127,8 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { const pat::PackedCandidate* lPack = dynamic_cast(&aPF); if (fUseVertexAssociation) { - const reco::VertexRef& PVOrig = associatedPV[reco::CandidatePtr(hPFProduct, ic)]; - int quality = associationQuality[reco::CandidatePtr(hPFProduct, ic)]; + const reco::VertexRef& PVOrig = associatedPV[reco::CandidatePtr(hPFProduct, iCand)]; + int quality = associationQuality[reco::CandidatePtr(hPFProduct, iCand)]; if (PVOrig.isNonnull() && (quality >= vertexAssociationQuality_)) { closestVtx = PVOrig.get(); pVtxId = PVOrig.key(); @@ -263,7 +263,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { } fRecoObjCollection.push_back(pReco); - ic++; + iCand++; } fPuppiContainer->initialize(fRecoObjCollection); diff --git a/CommonTools/PileupAlgos/python/Puppi_cff.py b/CommonTools/PileupAlgos/python/Puppi_cff.py index b2e6b5f015ac1..9943d59afe49b 100644 --- a/CommonTools/PileupAlgos/python/Puppi_cff.py +++ b/CommonTools/PileupAlgos/python/Puppi_cff.py @@ -34,8 +34,6 @@ useVertexAssociation = True, vertexAssociationQuality = 6, vertexAssociation = ('primaryVertexAssociationJME','original'), - #candName = 'packedPFCandidates', - #vertexName = 'offlineSlimmedPrimaryVertices', clonePackedCands = False, # should only be set to True for MiniAOD algos = { 0: dict( diff --git a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h index 388fd1567a977..011ee2ecee2d2 100644 --- a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h +++ b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h @@ -91,7 +91,7 @@ class PrimaryVertexAssignment { } if (pfcand.gsfTrackRef().isNull()) { if (pfcand.trackRef().isNull()) - return std::pair(-1, PrimaryVertexAssignment::Unassigned); + return {-1, PrimaryVertexAssignment::Unassigned}; else return chargedHadronVertex(vertices, pfcand.trackRef(), time, timeResolution, jets, builder); } @@ -109,7 +109,7 @@ class PrimaryVertexAssignment { timeResolution = pfcand.timeError(); } if (!pfcand.hasTrackDetails()) - return std::pair(-1, PrimaryVertexAssignment::Unassigned); + return {-1, PrimaryVertexAssignment::Unassigned}; else return chargedHadronVertex( vertices, @@ -135,7 +135,7 @@ class PrimaryVertexAssignment { timeResolution = (*trackTimeResoTag)[chcand.track()]; } if (chcand.track().isNull()) - return std::pair(-1, PrimaryVertexAssignment::Unassigned); + return {-1, PrimaryVertexAssignment::Unassigned}; return chargedHadronVertex(vertices, chcand.track(), time, timeResolution, jets, builder); } diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 7515cb6f42583..c6b56788acd8f 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -53,7 +53,7 @@ std::pair PrimaryVertexAssignment::charge for (IV iv = vertices.begin(); iv != vertices.end(); ++iv) { int ivtx = iv - vertices.begin(); if (useVertexFit_ && (iVertex == ivtx)) - return std::pair(ivtx, PrimaryVertexAssignment::UsedInFit); + return {ivtx, PrimaryVertexAssignment::UsedInFit}; double dz = std::abs(track->dz(iv->position())); double dt = std::abs(time - iv->t()); @@ -62,18 +62,19 @@ std::pair PrimaryVertexAssignment::charge if ((dz < maxDzForPrimaryAssignment_ or dz / track->dzError() < maxDzSigForPrimaryAssignment_) and (!useTimeVtx or dt / timeReso < maxDtSigForPrimaryAssignment_)) { - return std::pair(ivtx, PrimaryVertexAssignment::PrimaryDz); + return {ivtx, PrimaryVertexAssignment::PrimaryDz}; } } } + auto firstVertexDz = std::abs(track->dz(vertices.at(0).position())); // recover cases where the primary vertex is split if (useVertexFit_ && (iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && - (std::abs(track->dz(vertices.at(0).position())) < fDzCutForChargedFromPUVtxs_)) - return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); + firstVertexDz < fDzCutForChargedFromPUVtxs_) + return {iVertex, PrimaryVertexAssignment::PrimaryDz}; if (useVertexFit_ && (iVertex >= 0)) - return std::pair(iVertex, PrimaryVertexAssignment::UsedInFit); + return {iVertex, PrimaryVertexAssignment::UsedInFit}; double distmin = std::numeric_limits::max(); double dzmin = std::numeric_limits::max(); @@ -120,17 +121,17 @@ std::pair PrimaryVertexAssignment::charge } else { // consider only distances to first vertex for association of pileup vertices (originally used in PUPPI) if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_)) - iVertex = ((std::abs(track->dz(vertices.at(0).position())) < maxDzForPrimaryAssignment_ and - std::abs(track->dz(vertices.at(0).position())) / dzE < maxDzSigForPrimaryAssignment_ and - track->dzError() < maxDzErrorForPrimaryAssignment_) and - (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) - ? 0 - : vtxIdMinSignif; + iVertex = + ((firstVertexDz < maxDzForPrimaryAssignment_ and firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ and + track->dzError() < maxDzErrorForPrimaryAssignment_) and + (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) + ? 0 + : vtxIdMinSignif; } } if (iVertex >= 0) - return std::pair(iVertex, PrimaryVertexAssignment::PrimaryDz); + return {iVertex, PrimaryVertexAssignment::PrimaryDz}; // if track not assigned yet, it could be a b-decay secondary , use jet axis dist criterion // first find the closest jet within maxJetDeltaR_ @@ -170,20 +171,19 @@ std::pair PrimaryVertexAssignment::charge } } if (iVertex >= 0) - return std::pair(iVertex, PrimaryVertexAssignment::BTrack); + return {iVertex, PrimaryVertexAssignment::BTrack}; // if the track is not compatible with other PVs but is compatible with the BeamSpot, we may simply have not reco'ed the PV! // we still point it to the closest in Z, but flag it as possible orphan-primary if (!vertices.empty() && std::abs(track->dxy(vertices[0].position())) < maxDxyForNotReconstructedPrimary_ && std::abs(track->dxy(vertices[0].position()) / track->dxyError()) < maxDxySigForNotReconstructedPrimary_) - return std::pair(vtxIdMinSignif, - PrimaryVertexAssignment::NotReconstructedPrimary); + return {vtxIdMinSignif, PrimaryVertexAssignment::NotReconstructedPrimary}; //FIXME: here we could better handle V0s and NucInt // all other tracks could be non-B secondaries and we just attach them with closest Z if (vtxIdMinSignif >= 0) - return std::pair(vtxIdMinSignif, PrimaryVertexAssignment::OtherDz); + return {vtxIdMinSignif, PrimaryVertexAssignment::OtherDz}; //If for some reason even the dz failed (when?) we consider the track not assigned - return std::pair(-1, PrimaryVertexAssignment::Unassigned); + return {-1, PrimaryVertexAssignment::Unassigned}; } diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index efdaa35135190..739cc55562a12 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -1696,7 +1696,7 @@ def miniAODConfigurationPre(self, process, patMetModuleSequence, pfCandCollectio ##adding the necessary chs and track met configuration task = getPatAlgosToolsTask(process) - from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME + from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME addToProcessAndTask("packedPrimaryVertexAssociationJME",packedPrimaryVertexAssociationJME.clone(), process, task) patMetModuleSequence += getattr(process, "packedPrimaryVertexAssociationJME") addToProcessAndTask("pfCHS", pfCHS.clone(), process, task) From 763b616c290a810a981b7c8ab8dd03afc95f9826 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 20 Aug 2021 16:10:31 +0200 Subject: [PATCH 14/19] fix implementation of vertex split recovery --- CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index c6b56788acd8f..12e3d601c2faf 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -71,7 +71,7 @@ std::pair PrimaryVertexAssignment::charge // recover cases where the primary vertex is split if (useVertexFit_ && (iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && firstVertexDz < fDzCutForChargedFromPUVtxs_) - return {iVertex, PrimaryVertexAssignment::PrimaryDz}; + return {0, PrimaryVertexAssignment::PrimaryDz}; if (useVertexFit_ && (iVertex >= 0)) return {iVertex, PrimaryVertexAssignment::UsedInFit}; From ceac155982d17753da5b9788da0a0e432b8c88c2 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 20 Aug 2021 16:17:01 +0200 Subject: [PATCH 15/19] add renamed file --- .../ParticleFlow/plugins/PFNoPileUpPacked.cc | 91 +++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc diff --git a/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc new file mode 100644 index 0000000000000..d6ef1ad458c61 --- /dev/null +++ b/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc @@ -0,0 +1,91 @@ +// system include files +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/Association.h" + +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Framework/interface/EventSetup.h" + +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +using namespace std; +using namespace edm; +using namespace reco; + +/**\class PFNoPileUpPacked +\brief Identifies pile-up candidates from a collection of Candidates, and +produces the corresponding collection of NoPileUpCandidates. + +\author Andreas Hinzmann +\date May 2021 + +*/ + +class PFNoPileUpPacked : public edm::stream::EDProducer<> { +public: + typedef edm::View CandidateView; + typedef edm::Association CandToVertex; + + explicit PFNoPileUpPacked(const edm::ParameterSet&); + + ~PFNoPileUpPacked() override = default; + + void produce(edm::Event&, const edm::EventSetup&) override; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + edm::EDGetTokenT tokenCandidatesView_; + edm::EDGetTokenT tokenVertices_; + edm::EDGetTokenT tokenVertexAssociation_; + edm::EDGetTokenT> tokenVertexAssociationQuality_; + int vertexAssociationQuality_; +}; + +PFNoPileUpPacked::PFNoPileUpPacked(const edm::ParameterSet& iConfig) { + tokenCandidatesView_ = consumes(iConfig.getParameter("candidates")); + vertexAssociationQuality_ = iConfig.getParameter("vertexAssociationQuality"); + tokenVertexAssociation_ = consumes(iConfig.getParameter("vertexAssociation")); + tokenVertexAssociationQuality_ = + consumes>(iConfig.getParameter("vertexAssociation")); + produces>(); +} + +void PFNoPileUpPacked::produce(Event& iEvent, const EventSetup& iSetup) { + unique_ptr> pOutput(new edm::PtrVector); + Handle candidateView; + iEvent.getByToken(tokenCandidatesView_, candidateView); + const edm::Association& associatedPV = iEvent.get(tokenVertexAssociation_); + const edm::ValueMap& associationQuality = iEvent.get(tokenVertexAssociationQuality_); + for (const auto& p : candidateView->ptrs()) { + const reco::VertexRef& PVOrig = associatedPV[p]; + int quality = associationQuality[p]; + if (!(PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_))) + pOutput->push_back(p); + } + iEvent.put(std::move(pOutput)); +} + +void PFNoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("candidates", edm::InputTag("packedPFCandidates")); + desc.add("vertexAssociationQuality", 7); + desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME", "original")); + descriptions.add("produceMuons", desc); +} + +DEFINE_FWK_MODULE(PFNoPileUpPacked); \ No newline at end of file From 818d5316aaee219c0ba0c30f38908b2096ada86c Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Mon, 23 Aug 2021 10:37:16 +0200 Subject: [PATCH 16/19] fix crash --- CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 12e3d601c2faf..f5e983ef0857c 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -67,7 +67,9 @@ std::pair PrimaryVertexAssignment::charge } } - auto firstVertexDz = std::abs(track->dz(vertices.at(0).position())); + double firstVertexDz = std::numeric_limits::max(); + if (vertices.size() > 0) + firstVertexDz = std::abs(track->dz(vertices.at(0).position())); // recover cases where the primary vertex is split if (useVertexFit_ && (iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && firstVertexDz < fDzCutForChargedFromPUVtxs_) From 5ba3a3962d0860eb8588db7d5c889058aa7bc725 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Mon, 23 Aug 2021 10:39:42 +0200 Subject: [PATCH 17/19] code check --- CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index f5e983ef0857c..230a336d4d4e3 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -68,7 +68,7 @@ std::pair PrimaryVertexAssignment::charge } double firstVertexDz = std::numeric_limits::max(); - if (vertices.size() > 0) + if (!vertices.empty()) firstVertexDz = std::abs(track->dz(vertices.at(0).position())); // recover cases where the primary vertex is split if (useVertexFit_ && (iVertex > 0) && (iVertex <= fNumOfPUVtxsForCharged_) && From 74a797538c36dcce682351262de3f240b409499b Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 25 Aug 2021 12:17:32 +0200 Subject: [PATCH 18/19] fix filldescriptions label --- CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc b/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc index d6ef1ad458c61..5a94c6cd3bb0b 100644 --- a/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc +++ b/CommonTools/ParticleFlow/plugins/PFNoPileUpPacked.cc @@ -85,7 +85,7 @@ void PFNoPileUpPacked::fillDescriptions(edm::ConfigurationDescriptions& descript desc.add("candidates", edm::InputTag("packedPFCandidates")); desc.add("vertexAssociationQuality", 7); desc.add("vertexAssociation", edm::InputTag("packedPrimaryVertexAssociationJME", "original")); - descriptions.add("produceMuons", desc); + descriptions.addWithDefaultLabel(desc); } DEFINE_FWK_MODULE(PFNoPileUpPacked); \ No newline at end of file From d216e83ddb3f0bae19a77ad33479a84f72d162a5 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Mon, 6 Sep 2021 13:17:20 +0200 Subject: [PATCH 19/19] comments from Maria --- PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py | 7 +++++-- PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py | 3 ++- .../python/tools/runMETCorrectionsAndUncertainties.py | 2 +- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py index 27a1bea045697..2d26c02350157 100644 --- a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py @@ -12,7 +12,8 @@ def makePuppies( process ): def makePuppiesFromMiniAOD( process, createScheduledSequence=False ): task = getPatAlgosToolsTask(process) - process.load('CommonTools.ParticleFlow.pfCHS_cff') + from CommonTools.ParticleFlow.pfCHS_cff import packedPrimaryVertexAssociationJME + setattr(process, "packedPrimaryVertexAssociationJME", packedPrimaryVertexAssociationJME.clone()) task.add(process.packedPrimaryVertexAssociationJME) process.load('CommonTools.PileupAlgos.Puppi_cff') task.add(process.puppi) @@ -30,5 +31,7 @@ def makePuppiesFromMiniAOD( process, createScheduledSequence=False ): #making a sequence for people running the MET tool in scheduled mode if createScheduledSequence: - puppiMETSequence = cms.Sequence(process.packedPrimaryVertexAssociationJME*process.puppi*process.puppiNoLep) + puppiMETTask = cms.Task(process.packedPrimaryVertexAssociationJME, process.puppi, process.puppiNoLep) + setattr(process, "puppiMETTask", puppiMETTask) + puppiMETSequence = cms.Sequence(puppiMETTask) setattr(process, "puppiMETSequence", puppiMETSequence) diff --git a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py index f39e4b0a90c16..01d00edfec39b 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py @@ -283,8 +283,9 @@ def addRecoJetCollection(self, # elif recoJetInfo.jetPUMethod == "chs": from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME + self.addProcessAndTask(proc, "packedPrimaryVertexAssociationJME", packedPrimaryVertexAssociationJME.clone()) + self.prerequisites.append("packedPrimaryVertexAssociationJME") self.addProcessAndTask(proc, pfCand, pfCHS.clone()) - self.prerequisites.append(process.packedPrimaryVertexAssociationJME) self.prerequisites.append(pfCand) # # PUPPI diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index 739cc55562a12..a37b20ba73048 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -915,7 +915,7 @@ def getMETUncertainties(self, process, metType, metModName, electronCollection, # PFPhotons : #------------ pfPhotons = cms.EDFilter("CandPtrSelector", - src = pfCandCollection, + src = pfCandCollection if self._parameters["Puppi"].value or not self._parameters["onMiniAOD"].value else cms.InputTag("pfCHS"), cut = cms.string("abs(pdgId) = 22") ) addToProcessAndTask("pfPhotons"+postfix, pfPhotons, process, task)