From 01f7cf75af4e368afebfe79086cb35417eb74824 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Thu, 6 Jan 2022 15:36:13 +0100 Subject: [PATCH 1/7] CHS and PUPPI track-vertex-association for Run3 --- .../ParticleFlow/plugins/PFNoPileUpPacked.cc | 91 ------------------- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 8 +- CommonTools/ParticleFlow/python/pfCHS_cff.py | 19 ++-- .../ParticleFlow/python/pfNoPileUpJME_cff.py | 39 ++++---- .../ParticleFlow/python/pfPileUp_cfi.py | 2 + .../PileupAlgos/plugins/PuppiProducer.cc | 15 ++- CommonTools/PileupAlgos/python/Puppi_cff.py | 15 ++- .../interface/PrimaryVertexAssignment.h | 4 +- .../python/sortedPFPrimaryVertices_cfi.py | 2 +- .../python/sortedPrimaryVertices_cfi.py | 2 +- .../RecoAlgos/src/PrimaryVertexAssignment.cc | 16 ++-- .../PatAlgos/python/slimming/miniAOD_tools.py | 1 - .../python/slimming/puppiForMET_cff.py | 7 +- .../python/tools/jetCollectionTools.py | 6 +- .../test/miniAOD/example_jet_and_met.py | 1 - .../runMETCorrectionsAndUncertainties.py | 9 +- RecoMET/Configuration/python/RecoPFMET_cff.py | 3 +- 17 files changed, 73 insertions(+), 167 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 5a94c6cd3bb0b..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.addWithDefaultLabel(desc); -} - -DEFINE_FWK_MODULE(PFNoPileUpPacked); \ No newline at end of file diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index 35b328035eda6..dddc6a6c21d7a 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -76,6 +76,8 @@ class PFPileUp : public edm::stream::EDProducer<> { edm::EDGetTokenT> tokenVertexAssociationQuality_; bool fUseVertexAssociation; int vertexAssociationQuality_; + unsigned int fNumOfPUVtxsForCharged_; + double fDzCutForChargedFromPUVtxs_; }; PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { @@ -91,6 +93,8 @@ PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { tokenVertexAssociationQuality_ = consumes>(iConfig.getParameter("vertexAssociation")); } + fNumOfPUVtxsForCharged_ = iConfig.getParameter("NumOfPUVtxsForCharged"); + fDzCutForChargedFromPUVtxs_ = iConfig.getParameter("DzCutForChargedFromPUVtxs"); enable_ = iConfig.getParameter("Enable"); @@ -172,7 +176,9 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { for (auto& p : (*pfCandidatesRef)) { const reco::VertexRef& PVOrig = associatedPV[p]; int quality = associationQuality[p]; - if (PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_)) + if ((PVOrig.isNonnull() && PVOrig.key() > 0 && PVOrig->ndof() > 4.0 && quality >= vertexAssociationQuality_) && + (!(fNumOfPUVtxsForCharged_ > 0 && !vertices->empty() && PVOrig.key() <= fNumOfPUVtxsForCharged_ && + std::abs(p->vertex().z() - vertices->at(0).z()) < fDzCutForChargedFromPUVtxs_))) pfCandidatesFromPU.push_back(p); } pOutput->insert(pOutput->end(), pfCandidatesFromPU.begin(), pfCandidatesFromPU.end()); diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py index 23dba83b7fa79..4a4ec9817aea7 100644 --- a/CommonTools/ParticleFlow/python/pfCHS_cff.py +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -1,15 +1,10 @@ import FWCore.ParameterSet.Config as cms -from CommonTools.ParticleFlow.pfNoPileUpJME_cff import adapt, pfPileUpJME -from CommonTools.RecoAlgos.sortedPackedPrimaryVertices_cfi import sortedPackedPrimaryVertices +from CommonTools.ParticleFlow.pfNoPileUpJME_cff import primaryVertexAssociationJME -packedPrimaryVertexAssociationJME = sortedPackedPrimaryVertices.clone( - produceSortedVertices = False, - producePileUpCollection = False, - produceNoPileUpCollection = False -) -adapt(packedPrimaryVertexAssociationJME) - -from CommonTools.ParticleFlow.pfNoPileUpPacked_cfi import pfNoPileUpPacked as _pfNoPileUpPacked -pfCHS = _pfNoPileUpPacked.clone( - vertexAssociationQuality=pfPileUpJME.vertexAssociationQuality +pfCHS = cms.EDFilter("CandPtrSelector", + src = cms.InputTag("packedPFCandidates"), + cut = cms.string("fromPV(0)>0"+\ + " || (vertexRef().key<="+str(primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged.value())+" && "+\ + "abs(dz(0))<"+str(primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs.value())+")" + ) ) diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index caad529298bd3..0ed34d5f60065 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -5,35 +5,36 @@ 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 - ) +# The following module implements vertex association for JME. +# It is not run by default to save computing time (but can be run to investigate alternative vertex identification criteria). +# Instead its parameters are used as input to faster implementations in pfPileUpJME and pfCHS and puppi. primaryVertexAssociationJME = primaryVertexAssociation.clone(vertices = 'goodOfflinePrimaryVertices') -adapt(primaryVertexAssociationJME) +primaryVertexAssociationJME.assignment.maxDzSigForPrimaryAssignment = 1e10 +primaryVertexAssociationJME.assignment.maxDzForPrimaryAssignment = 0.3 +primaryVertexAssociationJME.assignment.maxDzErrorForPrimaryAssignment = 1e10 +primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged = 2 +primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs = 0.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 + ) pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', useVertexAssociation = True, vertexAssociationQuality = 7, - vertexAssociation = ('primaryVertexAssociationJME','original'), + vertexAssociation = ('primaryVertexAssociation','original'), + NumOfPUVtxsForCharged = primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged, + DzCutForChargedFromPUVtxs = primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs, ) 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 025d6479ad2eb..c29b37d6738cb 100644 --- a/CommonTools/ParticleFlow/python/pfPileUp_cfi.py +++ b/CommonTools/ParticleFlow/python/pfPileUp_cfi.py @@ -12,4 +12,6 @@ useVertexAssociation = cms.bool(False), vertexAssociationQuality = cms.int32(0), vertexAssociation = cms.InputTag(''), + NumOfPUVtxsForCharged = cms.uint32(0), + DzCutForChargedFromPUVtxs = cms.double(0.2), ) diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc index 0d6c3bdfda83b..0c55932e27832 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc @@ -72,6 +72,7 @@ class PuppiProducer : public edm::stream::EDProducer<> { bool fPuppiNoLep; bool fUseFromPVLooseTight; bool fUseDZ; + bool fUseDZforPileup; double fDZCut; double fEtaMinUseDZ; double fPtMaxCharged; @@ -95,6 +96,7 @@ PuppiProducer::PuppiProducer(const edm::ParameterSet& iConfig) { fPuppiNoLep = iConfig.getParameter("puppiNoLep"); fUseFromPVLooseTight = iConfig.getParameter("UseFromPVLooseTight"); fUseDZ = iConfig.getParameter("UseDeltaZCut"); + fUseDZforPileup = iConfig.getParameter("UseDeltaZCutForPileup"); fDZCut = iConfig.getParameter("DeltaZCut"); fEtaMinUseDZ = iConfig.getParameter("EtaMinUseDeltaZ"); fPtMaxCharged = iConfig.getParameter("PtMaxCharged"); @@ -281,8 +283,10 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { pReco.id = 1; else if (std::abs(pReco.eta) > fEtaMaxCharged) pReco.id = 1; - else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ)) - pReco.id = (std::abs(pDZ) < fDZCut) ? 1 : 2; + else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ) && (std::abs(pDZ) < fDZCut)) + pReco.id = 1; + else if ((fUseDZforPileup) && (std::abs(pReco.eta) >= fEtaMinUseDZ) && (std::abs(pDZ) >= fDZCut)) + pReco.id = 2; else if (fUseFromPVLooseTight && tmpFromPV == 1) pReco.id = 2; else if (fUseFromPVLooseTight && tmpFromPV == 2) @@ -322,8 +326,10 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { pReco.id = 1; else if (std::abs(pReco.eta) > fEtaMaxCharged) pReco.id = 1; - else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ)) - pReco.id = (std::abs(pDZ) < fDZCut) ? 1 : 2; + else if ((fUseDZ) && (std::abs(pReco.eta) >= fEtaMinUseDZ) && (std::abs(pDZ) < fDZCut)) + pReco.id = 1; + else if ((fUseDZforPileup) && (std::abs(pReco.eta) >= fEtaMinUseDZ) && (std::abs(pDZ) >= fDZCut)) + pReco.id = 2; else if (fUseFromPVLooseTight && lPack->fromPV() == (pat::PackedCandidate::PVLoose)) pReco.id = 2; else if (fUseFromPVLooseTight && lPack->fromPV() == (pat::PackedCandidate::PVTight)) @@ -489,6 +495,7 @@ void PuppiProducer::fillDescriptions(edm::ConfigurationDescriptions& description desc.add("puppiNoLep", false); desc.add("UseFromPVLooseTight", false); desc.add("UseDeltaZCut", true); + desc.add("UseDeltaZCutForPileup", true); desc.add("DeltaZCut", 0.3); desc.add("EtaMinUseDeltaZ", 0.); desc.add("PtMaxCharged", -1.); diff --git a/CommonTools/PileupAlgos/python/Puppi_cff.py b/CommonTools/PileupAlgos/python/Puppi_cff.py index 9943d59afe49b..e3d50c1510fd1 100644 --- a/CommonTools/PileupAlgos/python/Puppi_cff.py +++ b/CommonTools/PileupAlgos/python/Puppi_cff.py @@ -25,15 +25,16 @@ ) # from cfipython/, generated by PuppiProducer::fillDescriptions +from CommonTools.ParticleFlow.pfNoPileUpJME_cff import primaryVertexAssociationJME import CommonTools.PileupAlgos.PuppiProducer_cfi as _mod puppi = _mod.PuppiProducer.clone( - EtaMinUseDeltaZ = 2.4, - NumOfPUVtxsForCharged = 2, - PtMaxCharged = 20., + UseDeltaZCutForPileup = False, + DeltaZCut = primaryVertexAssociationJME.assignment.maxDzForPrimaryAssignment, + EtaMinUseDeltaZ = primaryVertexAssociationJME.assignment.EtaMinUseDz, + PtMaxCharged = primaryVertexAssociationJME.assignment.PtMaxCharged, + NumOfPUVtxsForCharged = primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged, + DeltaZCutForChargedFromPUVtxs = primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs, PtMaxNeutralsStartSlope = 20., - useVertexAssociation = True, - vertexAssociationQuality = 6, - vertexAssociation = ('primaryVertexAssociationJME','original'), clonePackedCands = False, # should only be set to True for MiniAOD algos = { 0: dict( @@ -99,8 +100,6 @@ 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 cleanedParticleFlow puppiNoLep = puppi.clone( puppiNoLep = True, diff --git a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h index 011ee2ecee2d2..67b29bfcb6406 100644 --- a/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h +++ b/CommonTools/RecoAlgos/interface/PrimaryVertexAssignment.h @@ -44,7 +44,7 @@ class PrimaryVertexAssignment { useTiming_(iConfig.getParameter("useTiming")), useVertexFit_(iConfig.getParameter("useVertexFit")), preferHighRanked_(iConfig.getParameter("preferHighRanked")), - fNumOfPUVtxsForCharged_(iConfig.getParameter("NumOfPUVtxsForCharged")), + fNumOfPUVtxsForCharged_(iConfig.getParameter("NumOfPUVtxsForCharged")), fDzCutForChargedFromPUVtxs_(iConfig.getParameter("DzCutForChargedFromPUVtxs")), fPtMaxCharged_(iConfig.getParameter("PtMaxCharged")), fEtaMinUseDz_(iConfig.getParameter("EtaMinUseDz")), @@ -154,7 +154,7 @@ class PrimaryVertexAssignment { bool useTiming_; bool useVertexFit_; bool preferHighRanked_; - int fNumOfPUVtxsForCharged_; + unsigned int fNumOfPUVtxsForCharged_; double fDzCutForChargedFromPUVtxs_; double fPtMaxCharged_; double fEtaMinUseDz_; diff --git a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py index 1e446422fb1e1..3bbd0ad4697ca 100644 --- a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py @@ -22,7 +22,7 @@ preferHighRanked = cms.bool(False), #options used in PUPPI - NumOfPUVtxsForCharged = cms.int32(-1), + NumOfPUVtxsForCharged = cms.uint32(0), DzCutForChargedFromPUVtxs = cms.double(0.2), PtMaxCharged = cms.double(-1), EtaMinUseDz = cms.double(-1), diff --git a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py index 57be0713ca862..92c387d0dcf1c 100644 --- a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py +++ b/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py @@ -22,7 +22,7 @@ preferHighRanked = cms.bool(False), #options used in PUPPI - NumOfPUVtxsForCharged = cms.int32(-1), + NumOfPUVtxsForCharged = cms.uint32(0), DzCutForChargedFromPUVtxs = cms.double(0.2), PtMaxCharged = cms.double(-1), EtaMinUseDz = cms.double(-1), diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 230a336d4d4e3..4c306b1bb574a 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -71,7 +71,7 @@ std::pair PrimaryVertexAssignment::charge 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_) && + if (useVertexFit_ && (iVertex > 0) && (iVertex <= int(fNumOfPUVtxsForCharged_)) && firstVertexDz < fDzCutForChargedFromPUVtxs_) return {0, PrimaryVertexAssignment::PrimaryDz}; @@ -121,14 +121,12 @@ std::pair PrimaryVertexAssignment::charge (!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 = - ((firstVertexDz < maxDzForPrimaryAssignment_ and firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ and - track->dzError() < maxDzErrorForPrimaryAssignment_) and - (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_)) - ? 0 - : vtxIdMinSignif; + // consider only distances to first vertex for association (originally used in PUPPI) + if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_) and + ((firstVertexDz < maxDzForPrimaryAssignment_ and firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ and + track->dzError() < maxDzErrorForPrimaryAssignment_) and + (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_))) + iVertex = 0; } } diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index f4ee51a85d229..e906592e1d5ea 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -199,7 +199,6 @@ def _add_slimmedMETsNoHF(process): # ================== CHSMET process.load("CommonTools.ParticleFlow.pfCHS_cff") - task.add(process.packedPrimaryVertexAssociationJME) task.add(process.pfCHS) from RecoMET.METProducers.pfMet_cfi import pfMet diff --git a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py index 2d26c02350157..968a1505c78b6 100644 --- a/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/puppiForMET_cff.py @@ -12,26 +12,21 @@ def makePuppies( process ): def makePuppiesFromMiniAOD( process, createScheduledSequence=False ): task = getPatAlgosToolsTask(process) - 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) 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: - puppiMETTask = cms.Task(process.packedPrimaryVertexAssociationJME, process.puppi, process.puppiNoLep) + puppiMETTask = cms.Task(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 01d00edfec39b..066c0ef798575 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py @@ -282,10 +282,8 @@ def addRecoJetCollection(self, # CHS # 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.addProcessAndTask(proc, pfCand, pfCHS.clone( + src = self.pfLabel)) self.prerequisites.append(pfCand) # # PUPPI diff --git a/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py b/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py index 7aa247e8cf60b..d65ed9c3f6651 100644 --- a/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py +++ b/PhysicsTools/PatAlgos/test/miniAOD/example_jet_and_met.py @@ -20,7 +20,6 @@ from RecoMET.METProducers.pfMet_cfi import pfMet 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 diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index 9f29952e5687b..91ff1e59c1d4e 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -1601,13 +1601,14 @@ def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, pos cms.EDProducer("PFCandidateFwdPtrProducer", src = pfCandCollection ), process, task) + addToProcessAndTask('primaryVertexAssociation'+postfix, + process.primaryVertexAssociation.clone(particles = pfCandCollection), process, task) 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, "pfPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociationJME'+postfix+':original' + getattr(process, "pfPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociation'+postfix+':original' pfCandColl = "pfNoPileUpJME"+postfix patMetModuleSequence += getattr(process, "tmpPFCandCollPtr"+postfix) patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix) @@ -1697,9 +1698,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 - addToProcessAndTask("packedPrimaryVertexAssociationJME",packedPrimaryVertexAssociationJME.clone(), process, task) - patMetModuleSequence += getattr(process, "packedPrimaryVertexAssociationJME") + from CommonTools.ParticleFlow.pfCHS_cff import pfCHS addToProcessAndTask("pfCHS", pfCHS.clone(), process, task) from RecoMET.METProducers.pfMet_cfi import pfMet pfMetCHS = pfMet.clone(src = "pfCHS") diff --git a/RecoMET/Configuration/python/RecoPFMET_cff.py b/RecoMET/Configuration/python/RecoPFMET_cff.py index 22d0e7d178747..89b4afad19d63 100644 --- a/RecoMET/Configuration/python/RecoPFMET_cff.py +++ b/RecoMET/Configuration/python/RecoPFMET_cff.py @@ -3,12 +3,11 @@ ##____________________________________________________________________________|| 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 , goodOfflinePrimaryVertices, primaryVertexAssociationJME, pfChMet, puppiNoLep, pfMetPuppi) +recoPFMETTask = cms.Task(pfMet , particleFlowForChargedMET , pfChMet, puppiNoLep, pfMetPuppi) recoPFMET = cms.Sequence(recoPFMETTask) ##____________________________________________________________________________|| From c168e8adb68e8d0e8641cf01db1619d36b12bde8 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Fri, 7 Jan 2022 14:02:08 +0100 Subject: [PATCH 2/7] don't use track vertex association module for CHS, revert back to original PF module --- CommonTools/ParticleFlow/interface/PFPileUpAlgo.h | 4 ++++ CommonTools/ParticleFlow/plugins/PFPileUp.cc | 6 +++--- CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py | 6 +++--- CommonTools/ParticleFlow/src/PFPileUpAlgo.cc | 4 +++- .../python/tools/runMETCorrectionsAndUncertainties.py | 3 --- 5 files changed, 13 insertions(+), 10 deletions(-) diff --git a/CommonTools/ParticleFlow/interface/PFPileUpAlgo.h b/CommonTools/ParticleFlow/interface/PFPileUpAlgo.h index b4c366378c3ee..f0fae9fcf4fb2 100644 --- a/CommonTools/ParticleFlow/interface/PFPileUpAlgo.h +++ b/CommonTools/ParticleFlow/interface/PFPileUpAlgo.h @@ -28,6 +28,8 @@ class PFPileUpAlgo { inline void setVerbose(bool verbose) { verbose_ = verbose; } inline void setCheckClosestZVertex(bool val) { checkClosestZVertex_ = val; } + inline void setNumOfPUVtxsForCharged(unsigned int val) { fNumOfPUVtxsForCharged_ = val; } + inline void setDzCutForChargedFromPUVtxs(double val) { fDzCutForChargedFromPUVtxs_ = val; } const PFCollection& getPFCandidatesFromPU() const { return pfCandidatesFromPU_; } @@ -38,6 +40,8 @@ class PFPileUpAlgo { private: /// use the closest z vertex if a track is not in a vertex bool checkClosestZVertex_; + unsigned int fNumOfPUVtxsForCharged_; + double fDzCutForChargedFromPUVtxs_; /// verbose ? bool verbose_; diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index dddc6a6c21d7a..0ff578d0b86c6 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -109,6 +109,8 @@ PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { // Configure the algo pileUpAlgo_.setVerbose(verbose_); pileUpAlgo_.setCheckClosestZVertex(checkClosestZVertex_); + pileUpAlgo_.setNumOfPUVtxsForCharged(fNumOfPUVtxsForCharged_); + pileUpAlgo_.setDzCutForChargedFromPUVtxs(fDzCutForChargedFromPUVtxs_); //produces(); produces(); @@ -176,9 +178,7 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { for (auto& p : (*pfCandidatesRef)) { const reco::VertexRef& PVOrig = associatedPV[p]; int quality = associationQuality[p]; - if ((PVOrig.isNonnull() && PVOrig.key() > 0 && PVOrig->ndof() > 4.0 && quality >= vertexAssociationQuality_) && - (!(fNumOfPUVtxsForCharged_ > 0 && !vertices->empty() && PVOrig.key() <= fNumOfPUVtxsForCharged_ && - std::abs(p->vertex().z() - vertices->at(0).z()) < fDzCutForChargedFromPUVtxs_))) + if (PVOrig.isNonnull() && (PVOrig.key() > 0) && (quality >= vertexAssociationQuality_)) pfCandidatesFromPU.push_back(p); } pOutput->insert(pOutput->end(), pfCandidatesFromPU.begin(), pfCandidatesFromPU.end()); diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index 0ed34d5f60065..839f1735da55d 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -25,9 +25,8 @@ ) pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', - useVertexAssociation = True, - vertexAssociationQuality = 7, - vertexAssociation = ('primaryVertexAssociation','original'), + Vertices = 'goodOfflinePrimaryVertices', + checkClosestZVertex = False, NumOfPUVtxsForCharged = primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged, DzCutForChargedFromPUVtxs = primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs, ) @@ -35,6 +34,7 @@ bottomCollection = 'particleFlowPtrs' ) pfNoPileUpJMETask = cms.Task( + goodOfflinePrimaryVertices, pfPileUpJME, pfNoPileUpJME ) diff --git a/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc b/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc index 2829ccdd1971b..43f4bb15af508 100644 --- a/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc +++ b/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc @@ -22,7 +22,9 @@ void PFPileUpAlgo::process(const PFCollection& pfCandidates, const reco::VertexC // no associated vertex, or primary vertex // not pile-up - if (ivertex == -1 || ivertex == 0) { + if ((ivertex == -1 || ivertex == 0 || + (fNumOfPUVtxsForCharged_ > 0 && !vertices.empty() && ivertex <= int(fNumOfPUVtxsForCharged_) && + std::abs(cand.vertex().z() - vertices.at(0).z()) < fDzCutForChargedFromPUVtxs_))) { if (verbose_) std::cout << "VTX " << i << " " << *(pfCandidates[i]) << std::endl; pfCandidatesFromVtx_.push_back(pfCandidates[i]); diff --git a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py index 91ff1e59c1d4e..c60856e25f3b4 100644 --- a/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py +++ b/PhysicsTools/PatUtils/python/tools/runMETCorrectionsAndUncertainties.py @@ -1601,14 +1601,11 @@ def ak4JetReclustering(self,process, pfCandCollection, patMetModuleSequence, pos cms.EDProducer("PFCandidateFwdPtrProducer", src = pfCandCollection ), process, task) - addToProcessAndTask('primaryVertexAssociation'+postfix, - process.primaryVertexAssociation.clone(particles = pfCandCollection), process, task) process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff") task.add(process.pfNoPileUpJMETask) configtools.cloneProcessingSnippet(process, getattr(process,"pfNoPileUpJMESequence"), postfix, addToTask = True ) getattr(process, "pfPileUpJME"+postfix).PFCandidates = "tmpPFCandCollPtr"+postfix getattr(process, "pfNoPileUpJME"+postfix).bottomCollection = "tmpPFCandCollPtr"+postfix - getattr(process, "pfPileUpJME"+postfix).vertexAssociation = 'primaryVertexAssociation'+postfix+':original' pfCandColl = "pfNoPileUpJME"+postfix patMetModuleSequence += getattr(process, "tmpPFCandCollPtr"+postfix) patMetModuleSequence += getattr(process, "pfNoPileUpJME"+postfix) From 6a1da9f2d24848330beeb56c183a7b11d8a7695c Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Tue, 11 Jan 2022 19:46:09 +0100 Subject: [PATCH 3/7] implement fill descriptions --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 18 ++++ CommonTools/ParticleFlow/python/pfCHS_cff.py | 7 +- .../ParticleFlow/python/pfPileUp_cfi.py | 17 ---- CommonTools/ParticleFlow/src/PFPileUpAlgo.cc | 2 +- .../RecoAlgos/plugins/PrimaryVertexSorter.h | 84 +++++++++++++++++++ .../python/sortedPFPrimaryVertices_cfi.py | 41 --------- .../python/sortedPackedPrimaryVertices_cfi.py | 15 ---- .../python/sortedPrimaryVertices_cfi.py | 45 ---------- .../RecoAlgos/src/PrimaryVertexAssignment.cc | 10 +-- 9 files changed, 111 insertions(+), 128 deletions(-) delete mode 100644 CommonTools/ParticleFlow/python/pfPileUp_cfi.py delete mode 100644 CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py delete mode 100644 CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py delete mode 100644 CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index 0ff578d0b86c6..d7a4ae706bd05 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -52,6 +52,8 @@ class PFPileUp : public edm::stream::EDProducer<> { void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: PFPileUpAlgo pileUpAlgo_; @@ -198,4 +200,20 @@ void PFPileUp::produce(Event& iEvent, const EventSetup& iSetup) { iEvent.put(std::move(pOutput)); // iEvent.put(std::move(pOutputByValue)); } + +void PFPileUp::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("PFCandidates", edm::InputTag("particleFlowTmpPtrs")); + desc.add("Vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("Enable", true); + desc.addUntracked("verbose", false); + desc.add("checkClosestZVertex", true); + desc.add("useVertexAssociation", false); + desc.add("vertexAssociationQuality", 0); + desc.add("vertexAssociation", edm::InputTag("")); + desc.add("NumOfPUVtxsForCharged", 0); + desc.add("DzCutForChargedFromPUVtxs", .2); + descriptions.add("pfPileUp", desc); +} + DEFINE_FWK_MODULE(PFPileUp); diff --git a/CommonTools/ParticleFlow/python/pfCHS_cff.py b/CommonTools/ParticleFlow/python/pfCHS_cff.py index 4a4ec9817aea7..3f95dd58d30ec 100644 --- a/CommonTools/ParticleFlow/python/pfCHS_cff.py +++ b/CommonTools/ParticleFlow/python/pfCHS_cff.py @@ -3,8 +3,7 @@ pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), - cut = cms.string("fromPV(0)>0"+\ - " || (vertexRef().key<="+str(primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged.value())+" && "+\ - "abs(dz(0))<"+str(primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs.value())+")" - ) + cut = cms.string("fromPV(0)>0 || (vertexRef().key<={} && abs(dz(0))<{})".format( + primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged.value(), + primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs.value())) ) diff --git a/CommonTools/ParticleFlow/python/pfPileUp_cfi.py b/CommonTools/ParticleFlow/python/pfPileUp_cfi.py deleted file mode 100644 index c29b37d6738cb..0000000000000 --- a/CommonTools/ParticleFlow/python/pfPileUp_cfi.py +++ /dev/null @@ -1,17 +0,0 @@ -import FWCore.ParameterSet.Config as cms - - -pfPileUp = cms.EDProducer( - "PFPileUp", - PFCandidates = cms.InputTag("particleFlowTmpPtrs"), - Vertices = cms.InputTag("offlinePrimaryVertices"), - # 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), - useVertexAssociation = cms.bool(False), - vertexAssociationQuality = cms.int32(0), - vertexAssociation = cms.InputTag(''), - NumOfPUVtxsForCharged = cms.uint32(0), - DzCutForChargedFromPUVtxs = cms.double(0.2), - ) diff --git a/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc b/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc index 43f4bb15af508..ca8f6e03cbe85 100644 --- a/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc +++ b/CommonTools/ParticleFlow/src/PFPileUpAlgo.cc @@ -24,7 +24,7 @@ void PFPileUpAlgo::process(const PFCollection& pfCandidates, const reco::VertexC // not pile-up if ((ivertex == -1 || ivertex == 0 || (fNumOfPUVtxsForCharged_ > 0 && !vertices.empty() && ivertex <= int(fNumOfPUVtxsForCharged_) && - std::abs(cand.vertex().z() - vertices.at(0).z()) < fDzCutForChargedFromPUVtxs_))) { + std::abs(cand.vertex().z() - vertices[0].z()) < fDzCutForChargedFromPUVtxs_))) { if (verbose_) std::cout << "VTX " << i << " " << *(pfCandidates[i]) << std::endl; pfCandidatesFromVtx_.push_back(pfCandidates[i]); diff --git a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h index 58fa0c9f8c6eb..5aa1715517109 100644 --- a/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h +++ b/CommonTools/RecoAlgos/plugins/PrimaryVertexSorter.h @@ -46,6 +46,8 @@ class PrimaryVertexSorter : public edm::stream::EDProducer<> { void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: PrimaryVertexAssignment assignmentAlgo_; PrimaryVertexSorting sortingAlgo_; @@ -69,6 +71,8 @@ class PrimaryVertexSorter : public edm::stream::EDProducer<> { bool useMET_; bool useTiming_; + static void fillDescriptionsCommon(edm::ParameterSetDescription& descriptions); + void doConsumesForTiming(const edm::ParameterSet& iConfig); bool needsProductsForTiming(); std::pair runAlgo(const reco::VertexCollection& vertices, @@ -304,6 +308,86 @@ void PrimaryVertexSorter::produce(edm::Event& iEvent, const iEvent.put(std::move(pfCollectionPUOriginalOutput), "originalPileUp"); } +template <> +inline void PrimaryVertexSorter>::fillDescriptions( + edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + fillDescriptionsCommon(desc); + desc.add("trackTimeTag", edm::InputTag("")); + desc.add("trackTimeResoTag", edm::InputTag("")); + desc.add("particles", edm::InputTag("trackRefsForJets")); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("jets", edm::InputTag("ak4CaloJetsForTrk")); + desc.add("produceAssociationToOriginalVertices", false); + desc.add("produceSortedVertices", true); + desc.add("producePileUpCollection", false); + desc.add("produceNoPileUpCollection", false); + descriptions.add("sortedPrimaryVertices", desc); +} + +template <> +inline void PrimaryVertexSorter>::fillDescriptions( + edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + fillDescriptionsCommon(desc); + desc.add("particles", edm::InputTag("particleFlow")); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("jets", edm::InputTag("ak4PFJets")); + desc.add("produceAssociationToOriginalVertices", true); + desc.add("produceSortedVertices", true); + desc.add("producePileUpCollection", true); + desc.add("produceNoPileUpCollection", true); + descriptions.add("sortedPFPrimaryVertices", desc); +} + +template <> +inline void PrimaryVertexSorter>::fillDescriptions( + edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + fillDescriptionsCommon(desc); + desc.add("particles", edm::InputTag("packedPFCandidates")); + desc.add("vertices", edm::InputTag("offlineSlimmedPrimaryVertices")); + desc.add("jets", edm::InputTag("slimmedJets")); + desc.add("produceAssociationToOriginalVertices", true); + desc.add("produceSortedVertices", true); + desc.add("producePileUpCollection", true); + desc.add("produceNoPileUpCollection", true); + descriptions.add("sortedPackedPrimaryVertices", desc); +} + +template +inline void PrimaryVertexSorter::fillDescriptionsCommon(edm::ParameterSetDescription& desc) { + { + edm::ParameterSetDescription psd0; + desc.add("sorting", psd0); + } + { + edm::ParameterSetDescription psd0; + psd0.add("maxDzSigForPrimaryAssignment", 5.0); + psd0.add("maxDzForPrimaryAssignment", 0.1); + psd0.add("maxDzErrorForPrimaryAssignment", 0.05); + psd0.add("maxDtSigForPrimaryAssignment", 3.0); + psd0.add("maxJetDeltaR", 0.5); + psd0.add("minJetPt", 25); + psd0.add("maxDistanceToJetAxis", 0.07); + psd0.add("maxDzForJetAxisAssigment", 0.1); + psd0.add("maxDxyForJetAxisAssigment", 0.1); + psd0.add("maxDxySigForNotReconstructedPrimary", 2); + psd0.add("maxDxyForNotReconstructedPrimary", 0.01); + psd0.add("useTiming", false); + psd0.add("useVertexFit", true); + psd0.add("preferHighRanked", false); + psd0.add("NumOfPUVtxsForCharged", 0); + psd0.add("DzCutForChargedFromPUVtxs", 0.2); + psd0.add("PtMaxCharged", -1); + psd0.add("EtaMinUseDz", -1); + psd0.add("OnlyUseFirstDz", false); + desc.add("assignment", psd0); + } + desc.add("qualityForPrimary", 3); + desc.add("usePVMET", true); +} + template <> inline void PrimaryVertexSorter>::doConsumesForTiming( const edm::ParameterSet& iConfig) { diff --git a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py deleted file mode 100644 index 3bbd0ad4697ca..0000000000000 --- a/CommonTools/RecoAlgos/python/sortedPFPrimaryVertices_cfi.py +++ /dev/null @@ -1,41 +0,0 @@ -import FWCore.ParameterSet.Config as cms -sortedPFPrimaryVertices = cms.EDProducer("PFCandidatePrimaryVertexSorter", - sorting = cms.PSet(), - assignment = cms.PSet( - #cuts to assign primary tracks not used in PV fit based on dZ compatibility - maxDzSigForPrimaryAssignment = cms.double(5.0), # in AND with next - maxDzForPrimaryAssignment = cms.double(0.1), # in AND with prev - maxDzErrorForPrimaryAssignment = cms.double(0.05), # in AND with prev, tracks with uncertainty above 500um cannot tell us which pv they come from - maxDtSigForPrimaryAssignment = cms.double(3.0), # *FIXME* this parameter needs to be double checked before useTiming is switched back on - # cuts used to recover b-tracks if they are closed to jet axis - maxJetDeltaR = cms.double(0.5), - minJetPt = cms.double(25), - maxDistanceToJetAxis = cms.double(0.07), # std cut in b-tag is 700um - maxDzForJetAxisAssigment = cms.double(0.1), # 1mm, because b-track IP is boost invariant - maxDxyForJetAxisAssigment = cms.double(0.1), # 1mm, because b-track IP is boost invariant - - #cuts used to identify primary tracks compatible with beamspot - 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 - NumOfPUVtxsForCharged = cms.uint32(0), - 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"), - jets= cms.InputTag("ak4PFJets"), - 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/sortedPackedPrimaryVertices_cfi.py b/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py deleted file mode 100644 index 9a9b171db5bf4..0000000000000 --- a/CommonTools/RecoAlgos/python/sortedPackedPrimaryVertices_cfi.py +++ /dev/null @@ -1,15 +0,0 @@ -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 deleted file mode 100644 index 92c387d0dcf1c..0000000000000 --- a/CommonTools/RecoAlgos/python/sortedPrimaryVertices_cfi.py +++ /dev/null @@ -1,45 +0,0 @@ -import FWCore.ParameterSet.Config as cms -sortedPrimaryVertices = cms.EDProducer("RecoChargedRefCandidatePrimaryVertexSorter", - sorting = cms.PSet(), - assignment = cms.PSet( - #cuts to assign primary tracks not used in PV fit based on dZ compatibility - maxDzSigForPrimaryAssignment = cms.double(5.0), # in AND with next - maxDzForPrimaryAssignment = cms.double(0.1), # in AND with prev - maxDzErrorForPrimaryAssignment = cms.double(0.05), # in AND with prev, tracks with uncertainty above 500um cannot tell us which pv they come from - maxDtSigForPrimaryAssignment = cms.double(4.0), - # cuts used to recover b-tracks if they are closed to jet axis - maxJetDeltaR = cms.double(0.5), - minJetPt = cms.double(25), - maxDistanceToJetAxis = cms.double(0.07), # std cut in b-tag is 700um - maxDzForJetAxisAssigment = cms.double(0.1), # 1mm, because b-track IP is boost invariant - maxDxyForJetAxisAssigment = cms.double(0.1), # 1mm, because b-track IP is boost invariant - - #cuts used to identify primary tracks compatible with beamspot - 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 - NumOfPUVtxsForCharged = cms.uint32(0), - DzCutForChargedFromPUVtxs = cms.double(0.2), - PtMaxCharged = cms.double(-1), - EtaMinUseDz = cms.double(-1), - OnlyUseFirstDz = cms.bool(False), - ), - particles = cms.InputTag("trackRefsForJets"), - trackTimeTag = cms.InputTag(""), - trackTimeResoTag = cms.InputTag(""), - vertices= cms.InputTag("offlinePrimaryVertices"), -# Jets= cms.InputTag("ak4PFJets"), - jets= cms.InputTag("ak4CaloJetsForTrk"), - qualityForPrimary = cms.int32(3), - usePVMET = cms.bool(True), - produceAssociationToOriginalVertices= cms.bool(False), - produceSortedVertices = cms.bool(True), - producePileUpCollection = cms.bool(False), - produceNoPileUpCollection = cms.bool(False), - -) - diff --git a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc index 4c306b1bb574a..fad6b30333bbd 100644 --- a/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc +++ b/CommonTools/RecoAlgos/src/PrimaryVertexAssignment.cc @@ -69,7 +69,7 @@ std::pair PrimaryVertexAssignment::charge double firstVertexDz = std::numeric_limits::max(); if (!vertices.empty()) - firstVertexDz = std::abs(track->dz(vertices.at(0).position())); + firstVertexDz = std::abs(track->dz(vertices[0].position())); // recover cases where the primary vertex is split if (useVertexFit_ && (iVertex > 0) && (iVertex <= int(fNumOfPUVtxsForCharged_)) && firstVertexDz < fDzCutForChargedFromPUVtxs_) @@ -122,10 +122,10 @@ std::pair PrimaryVertexAssignment::charge iVertex = vtxIdMinSignif; } else { // consider only distances to first vertex for association (originally used in PUPPI) - if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_) and - ((firstVertexDz < maxDzForPrimaryAssignment_ and firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ and - track->dzError() < maxDzErrorForPrimaryAssignment_) and - (!useTime or std::abs(time - vertices.at(0).t()) / timeReso < maxDtSigForPrimaryAssignment_))) + if ((vtxIdMinSignif >= 0) && (std::abs(track->eta()) > fEtaMinUseDz_) && + ((firstVertexDz < maxDzForPrimaryAssignment_ && firstVertexDz / dzE < maxDzSigForPrimaryAssignment_ && + track->dzError() < maxDzErrorForPrimaryAssignment_) && + (!useTime || std::abs(time - vertices[0].t()) / timeReso < maxDtSigForPrimaryAssignment_))) iVertex = 0; } } From 684c8510df31fcf41a5f52af729cc46cb5786cbe Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Wed, 12 Jan 2022 14:45:13 +0100 Subject: [PATCH 4/7] fix pfNoPileup PPonAA configs --- .../Configuration/python/RecoParticleFlow_cff.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py b/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py index d4c6fe1b94f84..4fdd1d9f0dac7 100644 --- a/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py +++ b/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py @@ -97,10 +97,10 @@ e.toModify(particleFlowBlock, useNuclear = cms.bool(False)) - e.toModify(pfNoPileUpIso, enable = cms.bool(False)) - e.toModify(pfPileUpIso, enable = cms.bool(False)) - e.toModify(pfNoPileUp, enable = cms.bool(False)) - e.toModify(pfPileUp, enable = cms.bool(False)) + e.toModify(pfNoPileUpIso, enable = False) + e.toModify(pfPileUpIso, Enable = False) + e.toModify(pfNoPileUp, enable = False) + e.toModify(pfPileUp, Enable = False) # # for MLPF From 38aecdb63bc512cef69723d39a17a6c31569cffe Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Sat, 15 Jan 2022 17:12:03 +0100 Subject: [PATCH 5/7] rename Enable to enable --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 12 ++++-------- CommonTools/ParticleFlow/python/PFBRECO_cff.py | 2 +- .../python/Tools/enablePileUpCorrection.py | 2 +- CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py | 1 - RecoMET/METFilters/test/filters_cfg.py | 4 ++-- .../Configuration/python/RecoParticleFlow_cff.py | 4 ++-- 6 files changed, 10 insertions(+), 15 deletions(-) diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index d7a4ae706bd05..093f6857b70ff 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -98,15 +98,11 @@ PFPileUp::PFPileUp(const edm::ParameterSet& iConfig) { fNumOfPUVtxsForCharged_ = iConfig.getParameter("NumOfPUVtxsForCharged"); fDzCutForChargedFromPUVtxs_ = iConfig.getParameter("DzCutForChargedFromPUVtxs"); - enable_ = iConfig.getParameter("Enable"); + enable_ = iConfig.getParameter("enable"); verbose_ = iConfig.getUntrackedParameter("verbose", false); - if (iConfig.exists("checkClosestZVertex")) { - checkClosestZVertex_ = iConfig.getParameter("checkClosestZVertex"); - } else { - checkClosestZVertex_ = false; - } + checkClosestZVertex_ = iConfig.getParameter("checkClosestZVertex"); // Configure the algo pileUpAlgo_.setVerbose(verbose_); @@ -205,9 +201,9 @@ void PFPileUp::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; desc.add("PFCandidates", edm::InputTag("particleFlowTmpPtrs")); desc.add("Vertices", edm::InputTag("offlinePrimaryVertices")); - desc.add("Enable", true); + desc.add("enable", true); desc.addUntracked("verbose", false); - desc.add("checkClosestZVertex", true); + desc.add("checkClosestZVertex", false); desc.add("useVertexAssociation", false); desc.add("vertexAssociationQuality", 0); desc.add("vertexAssociation", edm::InputTag("")); diff --git a/CommonTools/ParticleFlow/python/PFBRECO_cff.py b/CommonTools/ParticleFlow/python/PFBRECO_cff.py index c88e643fc85de..f4d1ae2d4f87c 100644 --- a/CommonTools/ParticleFlow/python/PFBRECO_cff.py +++ b/CommonTools/ParticleFlow/python/PFBRECO_cff.py @@ -7,7 +7,7 @@ from CommonTools.ParticleFlow.TopProjectors.pfNoPileUp_cfi import * pfPileUpIsoPFBRECO = pfPileUp.clone( PFCandidates = 'particleFlowPtrs' ) from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA -pp_on_AA.toModify(pfPileUpIsoPFBRECO, Enable = False) +pp_on_AA.toModify(pfPileUpIsoPFBRECO, enable = False) pfNoPileUpIsoPFBRECO = pfNoPileUp.clone( topCollection = 'pfPileUpIsoPFBRECO', bottomCollection = 'particleFlowPtrs') diff --git a/CommonTools/ParticleFlow/python/Tools/enablePileUpCorrection.py b/CommonTools/ParticleFlow/python/Tools/enablePileUpCorrection.py index 865dc174f89a8..7f8bb31fefb60 100644 --- a/CommonTools/ParticleFlow/python/Tools/enablePileUpCorrection.py +++ b/CommonTools/ParticleFlow/python/Tools/enablePileUpCorrection.py @@ -7,7 +7,7 @@ def enablePileUpCorrectionInPF2PAT( process, postfix, sequence='PF2PAT'): # pile up subtraction getattr(process,"pfNoPileUp"+postfix).enable = True - getattr(process,"pfPileUp"+postfix).Enable = True + getattr(process,"pfPileUp"+postfix).enable = True getattr(process,"pfPileUp"+postfix).checkClosestZVertex = False getattr(process,"pfPileUp"+postfix).Vertices = 'goodOfflinePrimaryVertices' diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index 839f1735da55d..3c4befdca5399 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -26,7 +26,6 @@ pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', Vertices = 'goodOfflinePrimaryVertices', - checkClosestZVertex = False, NumOfPUVtxsForCharged = primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged, DzCutForChargedFromPUVtxs = primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs, ) diff --git a/RecoMET/METFilters/test/filters_cfg.py b/RecoMET/METFilters/test/filters_cfg.py index 0d3646f7e61d5..f5d8092df8281 100644 --- a/RecoMET/METFilters/test/filters_cfg.py +++ b/RecoMET/METFilters/test/filters_cfg.py @@ -80,9 +80,9 @@ print("====> Configuring usePF2PAT : using AK5PFchs ...") print("See https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU") usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=options.mcInfo, postfix=postfix, jetCorrections=('AK5PFchs', options.jetCorrections)) -getattr(process,"pfPileUp"+postfix).Enable = True +getattr(process,"pfPileUp"+postfix).enable = True getattr(process,"pfPileUp"+postfix).Vertices = 'goodOfflinePrimaryVertices' -getattr(process,"pfPileUp"+postfix).checkClosestZVertex = cms.bool(False) +getattr(process,"pfPileUp"+postfix).checkClosestZVertex = False getattr(process,"pfJets"+postfix).doAreaFastjet = True getattr(process,"pfJets"+postfix).doRhoFastjet = False getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho") diff --git a/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py b/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py index 4fdd1d9f0dac7..7047df0704ae5 100644 --- a/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py +++ b/RecoParticleFlow/Configuration/python/RecoParticleFlow_cff.py @@ -98,9 +98,9 @@ e.toModify(particleFlowBlock, useNuclear = cms.bool(False)) e.toModify(pfNoPileUpIso, enable = False) - e.toModify(pfPileUpIso, Enable = False) + e.toModify(pfPileUpIso, enable = False) e.toModify(pfNoPileUp, enable = False) - e.toModify(pfPileUp, Enable = False) + e.toModify(pfPileUp, enable = False) # # for MLPF From e9cca622c77d51e5915be11ed78999f0cb346f56 Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Sun, 16 Jan 2022 08:07:51 +0100 Subject: [PATCH 6/7] rename Enable to enable --- RecoHI/Configuration/python/Reconstruction_hiPF_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py b/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py index ee53f9d35e293..20c353ae16718 100644 --- a/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py +++ b/RecoHI/Configuration/python/Reconstruction_hiPF_cff.py @@ -87,9 +87,9 @@ particleFlowTmp.usePFConversions = False pfNoPileUpIso.enable = False -pfPileUpIso.Enable = False +pfPileUpIso.enable = False pfNoPileUp.enable = False -pfPileUp.Enable = False +pfPileUp.enable = False particleFlow.Muons = "muons:hiMuons1stStep2muonsMap" From 692bae322932be0d0b0a3ebac7a1bb5752302a4e Mon Sep 17 00:00:00 2001 From: Andreas Hinzmann Date: Mon, 17 Jan 2022 13:36:11 +0100 Subject: [PATCH 7/7] revert checkClosestZVertex default to true --- CommonTools/ParticleFlow/plugins/PFPileUp.cc | 2 +- CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CommonTools/ParticleFlow/plugins/PFPileUp.cc b/CommonTools/ParticleFlow/plugins/PFPileUp.cc index 093f6857b70ff..4313fc3973bf9 100644 --- a/CommonTools/ParticleFlow/plugins/PFPileUp.cc +++ b/CommonTools/ParticleFlow/plugins/PFPileUp.cc @@ -203,7 +203,7 @@ void PFPileUp::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { desc.add("Vertices", edm::InputTag("offlinePrimaryVertices")); desc.add("enable", true); desc.addUntracked("verbose", false); - desc.add("checkClosestZVertex", false); + desc.add("checkClosestZVertex", true); desc.add("useVertexAssociation", false); desc.add("vertexAssociationQuality", 0); desc.add("vertexAssociation", edm::InputTag("")); diff --git a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py index 3c4befdca5399..839f1735da55d 100644 --- a/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py +++ b/CommonTools/ParticleFlow/python/pfNoPileUpJME_cff.py @@ -26,6 +26,7 @@ pfPileUpJME = _pfPileUp.clone(PFCandidates='particleFlowPtrs', Vertices = 'goodOfflinePrimaryVertices', + checkClosestZVertex = False, NumOfPUVtxsForCharged = primaryVertexAssociationJME.assignment.NumOfPUVtxsForCharged, DzCutForChargedFromPUVtxs = primaryVertexAssociationJME.assignment.DzCutForChargedFromPUVtxs, )