From b5d0e83fe0bec144c6aff5d543f3355d5f0c52bd Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Wed, 24 Sep 2025 14:30:42 +0200 Subject: [PATCH 01/24] Add modules to rekey PF candidates of PATObjects and VertexCompositeCandidates --- .../PatCandidates/interface/Electron.h | 2 + DataFormats/PatCandidates/interface/Muon.h | 2 + DataFormats/PatCandidates/interface/Photon.h | 2 + .../plugins/PATElectronCandidatesRekeyer.cc | 80 ++++++++++++ .../plugins/PATJetCandidatesRekeyer.cc | 100 +++++++++++++++ .../plugins/PATMuonCandidatesRekeyer.cc | 77 ++++++++++++ .../plugins/PATObjectPuppiIsolationUpdater.cc | 114 ++++++++++++++++++ .../plugins/PATPackedCandidateUpdater.cc | 69 +++++++++++ .../plugins/PATPhotonCandidatesRekeyer.cc | 78 ++++++++++++ .../plugins/PATTauCandidatesRekeyer.cc | 102 ++++++++++++++++ ...ertexCompositeCandidateDaughtersRekeyer.cc | 80 ++++++++++++ 11 files changed, 706 insertions(+) create mode 100644 PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc create mode 100644 PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc create mode 100644 PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc diff --git a/DataFormats/PatCandidates/interface/Electron.h b/DataFormats/PatCandidates/interface/Electron.h index 860a470c142cf..177fa0bd7fc13 100644 --- a/DataFormats/PatCandidates/interface/Electron.h +++ b/DataFormats/PatCandidates/interface/Electron.h @@ -47,6 +47,7 @@ namespace reco { // Class definition namespace pat { class PATElectronSlimmer; + class PATElectronCandidatesRekeyer; class Electron : public Lepton { public: @@ -269,6 +270,7 @@ namespace pat { } friend class PATElectronSlimmer; + friend class PATElectronCandidatesRekeyer; protected: /// init impact parameter defaults (for use in a constructor) diff --git a/DataFormats/PatCandidates/interface/Muon.h b/DataFormats/PatCandidates/interface/Muon.h index 144985c46534e..a9054c8927350 100644 --- a/DataFormats/PatCandidates/interface/Muon.h +++ b/DataFormats/PatCandidates/interface/Muon.h @@ -47,6 +47,7 @@ namespace reco { namespace pat { class PATMuonSlimmer; + class PATMuonCandidatesRekeyer; class Muon : public Lepton { public: @@ -272,6 +273,7 @@ namespace pat { friend std::ostream& reco::operator<<(std::ostream& out, const pat::Muon& obj); friend class PATMuonSlimmer; + friend class PATMuonCandidatesRekeyer; float pfEcalEnergy() const { return pfEcalEnergy_; } void setPfEcalEnergy(float pfEcalEnergy) { pfEcalEnergy_ = pfEcalEnergy; } diff --git a/DataFormats/PatCandidates/interface/Photon.h b/DataFormats/PatCandidates/interface/Photon.h index 4f661bf68c632..4ce2d99821825 100644 --- a/DataFormats/PatCandidates/interface/Photon.h +++ b/DataFormats/PatCandidates/interface/Photon.h @@ -42,6 +42,7 @@ namespace reco { // Class definition namespace pat { class PATPhotonSlimmer; + class PATPhotonCandidatesRekeyer; class Photon : public PATObject { public: @@ -328,6 +329,7 @@ namespace pat { reco::CandidatePtr sourceCandidatePtr(size_type i) const override; friend class PATPhotonSlimmer; + friend class PATPhotonCandidatesRekeyer; protected: // ---- for content embedding ---- diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc new file mode 100644 index 0000000000000..38288580e79ed --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -0,0 +1,80 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATElectronCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATElectronCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATElectronCandidatesRekeyer::PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig): + + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces>(); + +} + +PATElectronCandidatesRekeyer::~PATElectronCandidatesRekeyer() {} + +void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()){ + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), + keys.begin(), keys.end() + ); + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); + } else { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewHandle.id()); + } + } + iEvent.put(std::move(outPtrP)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATElectronCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc new file mode 100644 index 0000000000000..6c23550b59c4d --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -0,0 +1,100 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATJetCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATJetCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + // std::string subjetLabel_; + }; +} // namespace pat + +using namespace pat; + +PATJetCandidatesRekeyer::PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig): + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces>(); + produces>("tagInfos"); +} + +PATJetCandidatesRekeyer::~PATJetCandidatesRekeyer() {} + +void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + edm::RefProd> h_tagInfosOut = iEvent.getRefBeforePut>("tagInfos"); + auto tagInfosOut = std::make_unique>(); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + // + // + // + for (std::vector::const_iterator ibegin = (*src).begin(), iend = (*src).end(), ijet = ibegin; ijet != iend; ++ijet) { + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(), iinfoEnd = ijet->tagInfosFwdPtr().end(), iinfo = iinfoBegin;iinfo != iinfoEnd;++iinfo) { + tagInfosOut->push_back(**iinfo); + } + } + + edm::OrphanHandle> oh_tagInfosOut = iEvent.put(std::move(tagInfosOut), "tagInfos"); + + // + // + // + unsigned int tagInfoIndex = 0; + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + reco::CompositePtrCandidate::daughters old = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + for (const auto & dauItr : old) { + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle,dauItr.key())); + } + + // Copy the tag infos + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), iinfo = iinfoBegin; iinfo != iinfoEnd; ++iinfo) { + // Update the "forward" bit of the FwdPtr to point at the new collection. + // ptr to "this" info in the global list + edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); + outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); + ++tagInfoIndex; + } + } + + iEvent.put(std::move(outPtrP)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATJetCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..aabfdb568df81 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -0,0 +1,77 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATMuonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATMuonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATMuonCandidatesRekeyer::PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig): + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces>(); +} + +PATMuonCandidatesRekeyer::~PATMuonCandidatesRekeyer() {} + +void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + // + std::vector keys; + for (size_t ic = 0; ic < outPtrP->back().numberOfSourceCandidatePtrs(); ++ic) { + const reco::CandidatePtr& candPtr = outPtrP->back().sourceCandidatePtr(ic); + if (candPtr.isNonnull()){ + keys.push_back(candPtr.key()); + } + } + if(keys.size() == 1){ + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewCandViewHandle,keys[0]); + } + } + + iEvent.put(std::move(outPtrP)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATMuonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc new file mode 100644 index 0000000000000..5efe785148e4a --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc @@ -0,0 +1,114 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/Muon.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + template + class PATObjectPuppiIsolationUpdater : public edm::stream::EDProducer<> { + public: + explicit PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig); + ~PATObjectPuppiIsolationUpdater() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + //PUPPI isolation tokens + edm::EDGetTokenT> PUPPIIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_photons_; + //PUPPINoLeptons isolation tokens + edm::EDGetTokenT> PUPPINoLeptonsIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_photons_; + }; +} // namespace pat + +using namespace pat; + +template +PATObjectPuppiIsolationUpdater::PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig): + src_(consumes>(iConfig.getParameter("src"))){ + PUPPIIsolation_charged_hadrons_ = consumes>(iConfig.getParameter("puppiIsolationChargedHadrons")); + PUPPIIsolation_neutral_hadrons_ = consumes>(iConfig.getParameter("puppiIsolationNeutralHadrons")); + PUPPIIsolation_photons_ = consumes>(iConfig.getParameter("puppiIsolationPhotons")); + if constexpr (std::is_same::value || std::is_same::value){ + PUPPINoLeptonsIsolation_charged_hadrons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationChargedHadrons")); + PUPPINoLeptonsIsolation_neutral_hadrons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationNeutralHadrons")); + PUPPINoLeptonsIsolation_photons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationPhotons")); + } + produces>(); +} + +template +PATObjectPuppiIsolationUpdater::~PATObjectPuppiIsolationUpdater() {} + +template +void PATObjectPuppiIsolationUpdater::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + //value maps for puppi isolation + edm::Handle> PUPPIIsolation_charged_hadrons; + edm::Handle> PUPPIIsolation_neutral_hadrons; + edm::Handle> PUPPIIsolation_photons; + //value maps for puppiNoLeptons isolation + edm::Handle> PUPPINoLeptonsIsolation_charged_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_neutral_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_photons; + + //puppi + iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons); + iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons); + iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons); + //puppiNoLeptons + + if constexpr (std::is_same::value || std::is_same::value){ + iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + edm::Ptr objPtr(src,i); + + outPtrP->back().setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[objPtr], + (*PUPPIIsolation_neutral_hadrons)[objPtr], + (*PUPPIIsolation_photons)[objPtr]); + + if constexpr (std::is_same::value || std::is_same::value){ + outPtrP->back().setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_neutral_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_photons)[objPtr]); + } + } + iEvent.put(std::move(outPtrP)); +} + +typedef PATObjectPuppiIsolationUpdater PATElectronPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATPhotonPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATMuonPuppiIsolationUpdater; + +#include "FWCore/Framework/interface/MakerMacros.h" + + +DEFINE_FWK_MODULE(PATElectronPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATPhotonPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATMuonPuppiIsolationUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc new file mode 100644 index 0000000000000..5b10cf9604b09 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc @@ -0,0 +1,69 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/Common/interface/ValueMap.h" + +namespace pat { + class PATPackedCandidateUpdater : public edm::stream::EDProducer<> { + public: + explicit PATPackedCandidateUpdater(const edm::ParameterSet&); + ~PATPackedCandidateUpdater() override {} + + void produce(edm::Event&, const edm::EventSetup&) override; + + private: + edm::EDGetTokenT> candsToken_; + + bool updatePuppiWeights_; + edm::EDGetTokenT> puppiWeightToken_; + edm::EDGetTokenT> puppiWeightNoLepToken_; + }; +} // namespace pat + +using namespace pat; + +PATPackedCandidateUpdater::PATPackedCandidateUpdater(const edm::ParameterSet& iConfig): + candsToken_(consumes>(iConfig.getParameter("src"))), + updatePuppiWeights_(iConfig.getParameter("updatePuppiWeights")), + puppiWeightToken_(consumes>(iConfig.getParameter("puppiWeight"))), + puppiWeightNoLepToken_(consumes>(iConfig.getParameter("puppiWeightNoLep"))){ + produces>(); +} + +void PATPackedCandidateUpdater::produce(edm::Event& iEvent, const edm::EventSetup&) { + edm::Handle> cands; + iEvent.getByToken(candsToken_, cands); + + edm::Handle> puppiWeight; + edm::Handle> puppiWeightNoLep; + if (updatePuppiWeights_){ + iEvent.getByToken(puppiWeightToken_, puppiWeight); + iEvent.getByToken(puppiWeightNoLepToken_, puppiWeightNoLep); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(cands->size()); + + for (size_t ic = 0; ic < cands->size(); ++ic) { + + // copy original pat::PackedCandidate and append to vector + outPtrP->emplace_back((*cands)[ic]); + + // Retrieve puppi weights from edm::ValueMap + pat::PackedCandidateRef pkref(cands, ic); + + if (updatePuppiWeights_){ + float puppiWeightVal = (*puppiWeight)[pkref]; + float puppiWeightNoLepVal = (*puppiWeightNoLep)[pkref]; + outPtrP->back().setPuppiWeight(puppiWeightVal, puppiWeightNoLepVal); + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPackedCandidateUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..eb9046a3e15ec --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -0,0 +1,78 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATPhotonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATPhotonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATPhotonCandidatesRekeyer::PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig): + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces>(); +} + +PATPhotonCandidatesRekeyer::~PATPhotonCandidatesRekeyer() {} + +void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()){ + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), + keys.begin(), keys.end() + ); + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); + } else { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewHandle.id()); + } + } + iEvent.put(std::move(outPtrP)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPhotonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc new file mode 100644 index 0000000000000..f56b1d046f214 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -0,0 +1,102 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Tau.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATTauCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATTauCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATTauCandidatesRekeyer::PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig): + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces>(); + +} + +PATTauCandidatesRekeyer::~PATTauCandidatesRekeyer() {} + +void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + reco::CandidatePtrVector signalChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalChargedHadrCands()) { + signalChHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setSignalChargedHadrCands(signalChHPtrs); + + reco::CandidatePtrVector signalNHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalNeutrHadrCands()) { + signalNHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setSignalNeutralHadrCands(signalNHPtrs); + + reco::CandidatePtrVector signalGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalGammaCands()) { + signalGammaPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setSignalGammaCands(signalGammaPtrs); + + reco::CandidatePtrVector isolationChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationChargedHadrCands()) { + isolationChHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setIsolationChargedHadrCands(isolationChHPtrs); + + reco::CandidatePtrVector isolationNHPtrs; + + for (const reco::CandidatePtr &p : outPtrP->back().isolationNeutrHadrCands()) { + isolationNHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setIsolationNeutralHadrCands(isolationNHPtrs); + + reco::CandidatePtrVector isolationGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationGammaCands()) { + isolationGammaPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + } + outPtrP->back().setIsolationGammaCands(isolationGammaPtrs); + } + iEvent.put(std::move(outPtrP)); +} + + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATTauCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc new file mode 100644 index 0000000000000..913c2f2eebd5a --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -0,0 +1,80 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidateFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class VertexCompositeCandidateDaughtersRekeyer : public edm::stream::EDProducer<> { + public: + explicit VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig); + ~VertexCompositeCandidateDaughtersRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT src_; + edm::EDGetTokenT pcOriToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +VertexCompositeCandidateDaughtersRekeyer::VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig): + src_(consumes(iConfig.getParameter("src"))), + pcOriToken_(consumes(iConfig.getParameter("packedPFCandidatesOri"))), + pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + produces(); +} + +VertexCompositeCandidateDaughtersRekeyer::~VertexCompositeCandidateDaughtersRekeyer() {} + +void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle src; + iEvent.getByToken(src_, src); + + edm::Handle pcOriHandle; + iEvent.getByToken(pcOriToken_, pcOriHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original object and append to vector + outPtrP->emplace_back((*src)[i]); + + std::vector daughters = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + + for (const reco::CandidatePtr &dau : daughters) { + // + // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection + // This is needed because the CandidatePtr can point to a candidate in lostTracks collection + // + if (dau.id() == pcOriHandle.id()){ + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle,dau.key())); + }else{ + outPtrP->back().addDaughter(dau); + } + } + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(VertexCompositeCandidateDaughtersRekeyer); \ No newline at end of file From 026c148d6085e94230927edfe4f403f49ffa67a2 Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Wed, 24 Sep 2025 14:32:02 +0200 Subject: [PATCH 02/24] Explicitly use packedPFCandidates created in previous process --- .../PatAlgos/python/tools/jetTools.py | 28 +++++++++---------- .../tools/puppiJetMETReclusteringTools.py | 28 +++++++++---------- 2 files changed, 28 insertions(+), 28 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 9ae1075dc9cba..9a5ae0db70130 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -255,7 +255,7 @@ def setupPuppiForPackedPF(process, useExistingWeights=True, postfix=''): if not hasattr(process, puppiLabel): addToProcessAndTask(puppiLabel, puppi.clone( useExistingWeights = useExistingWeights, - candName = 'packedPFCandidates', + candName = 'packedPFCandidates::@skipCurrentProcess', vertexName = 'offlineSlimmedPrimaryVertices'), process, task) puppiNoLepLabel = puppiLabel+'NoLep' @@ -408,7 +408,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # Setup the PUPPI ValueMap that will consumed by the TagInfo producers. puppi_value_map = "puppi" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] acceptedTagInfos = list() @@ -651,7 +651,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -680,7 +680,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip, max_sip3dsig_for_flip = svSource, False, -1. # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -710,7 +710,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -739,7 +739,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] vertex_associator = cms.InputTag("") else: @@ -786,7 +786,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfDeepBoostedJetTagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) if 'updated' not in jetSource.value().lower(): raise ValueError("Invalid jet collection: %s. pfDeepBoostedJetTagInfos only supports running via updateJetCollection." % jetSource.value()) @@ -811,7 +811,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfParticleNetTagInfos' or btagInfo == 'pfGlobalParticleTransformerAK8TagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -841,7 +841,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou secondary_vertices = svSource flip_ip_sign = False sip3dSigMax = -1 - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -877,7 +877,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiCentralTagInfos.clone( @@ -893,7 +893,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiForwardTagInfos.clone( @@ -911,7 +911,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSCentralTagInfos.clone( @@ -927,7 +927,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSForwardTagInfos.clone( @@ -941,7 +941,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK8TagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK8TagInfos.clone( diff --git a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py index fa04c124df112..bf535302ae743 100644 --- a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py +++ b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py @@ -8,7 +8,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -37,7 +37,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi # process.load("RecoJets.JetProducers.ak4PFJets_cfi") task.add(process.ak4PFJetsPuppi) - process.ak4PFJetsPuppi.src = pfLabel + process.ak4PFJetsPuppi.src = pfInputTag process.ak4PFJetsPuppi.srcWeights = puppiLabel from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX @@ -62,7 +62,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("ak4PFJetsPuppi"), algo = "ak", rParam = 0.4, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -96,7 +96,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi from PhysicsTools.PatAlgos.slimming.slimmedJets_cfi import slimmedJets addToProcessAndTask('slimmedJetsPuppiNoDeepTags', slimmedJets.clone( src = "selectedPatJetsPuppi", - packedPFCandidates = pfLabel, + packedPFCandidates = pfInputTag, dropDaughters = "0", rekeyDaughters = "0", ), @@ -108,7 +108,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("slimmedJetsPuppiNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -155,7 +155,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -188,7 +188,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task.add(process.ak8PFJetsPuppiSoftDrop) # AK8 jet constituents for softdrop - process.ak8PFJetsPuppi.src = pfLabel + process.ak8PFJetsPuppi.src = pfInputTag process.ak8PFJetsPuppi.srcWeights = puppiLabel # AK8 jet constituents for softdrop @@ -223,7 +223,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("ak8PFJetsPuppi"), algo = "ak", rParam = 0.8, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -269,7 +269,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr labelName = "AK8PFPuppiSoftDrop", jetSource = cms.InputTag("ak8PFJetsPuppiSoftDrop"), btagDiscriminators = ["None"], - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -291,7 +291,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr rParam = 0.8, # needed for subjet flavor clustering explicitJTA = True, # needed for subjet b tagging svClustering = True, # needed for subjet b tagging - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -381,7 +381,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags", cms.EDProducer("PATJetSlimmer", src = cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropSubjets"), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, dropJetVars = cms.string("1"), dropDaughters = cms.string("0"), rekeyDaughters = cms.string("0"), @@ -402,7 +402,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -430,7 +430,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr 'SoftDropPuppi' ), fixDaughters = cms.bool(False), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, ), process, task ) @@ -455,7 +455,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8NoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), From b299d7fe6db4f2ced9251138347dff7a2001fdd5 Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Wed, 24 Sep 2025 14:32:49 +0200 Subject: [PATCH 03/24] First customization configurations for reMiniFromMini workflow --- .../slimming/miniAODFromMiniAOD_tools.py | 250 ++++++++++++++++++ 1 file changed, 250 insertions(+) create mode 100644 PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py new file mode 100644 index 0000000000000..254f56ab1e454 --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -0,0 +1,250 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask + +def miniAODFromMiniAOD_customizeCommon(process): + + task = getPatAlgosToolsTask(process) + + ########################################################################### + # Update packedPFCandidates with the recomputed puppi weights + ########################################################################### + addToProcessAndTask("packedPFCandidates", cms.EDProducer("PATPackedCandidateUpdater", + src = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + updatePuppiWeights = cms.bool(True), + puppiWeight = cms.InputTag("packedpuppi"), + puppiWeightNoLep = cms.InputTag("packedpuppiNoLep"), + ), + process, task + ) + + ########################################################################### + # Recompute Puppi Isolation for muons, electrons and photons + ########################################################################### + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPI as _muonIsolationMiniAODPUPPI + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPINoLeptons as _muonIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('muonPUPPIIsolation', _muonIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('muonPUPPINoLeptonsIsolation', _muonIsolationMiniAODPUPPINoLeptons.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedMuonsUpdatedPuppiIsolation', cms.EDProducer('PATMuonPuppiIsolationUpdater', + src = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + ), + process, task + ) + + from RecoEgamma.EgammaIsolationAlgos.egmPhotonIsolationPUPPI_cff import egmPhotonIsolationMiniAODPUPPI as _egmPhotonPUPPIIsolationForPhotons + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPI as _egmElectronIsolationMiniAODPUPPI + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPINoLeptons as _egmElectronIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('egmPhotonPUPPIIsolation', _egmPhotonPUPPIIsolationForPhotons.clone( + srcToIsolate = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPIIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPINoLeptonsIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedPhotonsUpdatedPuppiIsolation', cms.EDProducer('PATPhotonPuppiIsolationUpdater', + src = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-"), + puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-"), + puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-"), + ), + process, task + ) + + addToProcessAndTask('slimmedElectronsUpdatedPuppiIsolation', cms.EDProducer('PATElectronPuppiIsolationUpdater', + src = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), + ), + process, task + ) + + ########################################################################### + # Rekey jet constituents + ########################################################################### + addToProcessAndTask("slimmedJets", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJets", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsPuppiPreRekey", process.slimmedJetsPuppi.clone(), process, task) + del process.slimmedJetsPuppi + + addToProcessAndTask("slimmedJetsPuppi", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsPuppiPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsAK8PreRekey", process.slimmedJetsAK8.clone(), process, task) + del process.slimmedJetsAK8 + + addToProcessAndTask("slimmedJetsAK8", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsAK8PreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey", + process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour.clone(), + process, + task + ) + del process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey tau constituents + ########################################################################### + addToProcessAndTask("slimmedTaus", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag("slimmedTaus", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedTausBoosted", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag("slimmedTausBoosted", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey candidates in electrons, photons and muons + ########################################################################### + addToProcessAndTask("slimmedElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedElectronsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLowPtElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedLowPtElectrons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedPhotons", cms.EDProducer("PATPhotonCandidatesRekeyer", + src = cms.InputTag("slimmedPhotonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + + addToProcessAndTask("slimmedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedMuonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedDisplacedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedDisplacedMuons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey daughters of secondary vertices + ########################################################################### + addToProcessAndTask("slimmedKshortVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedKshortVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLambdaVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedLambdaVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedSecondaryVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedSecondaryVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + return process + +def miniAODFromMiniAOD_customizeData(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_Data + process = puppiJetMETReclusterFromMiniAOD_Data(process) + return process + +def miniAODFromMiniAOD_customizeMC(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_MC + process = puppiJetMETReclusterFromMiniAOD_MC(process) + return process + +def miniAODFromMiniAOD_customizeAllData(process): + process = miniAODFromMiniAOD_customizeData(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process + +def miniAODFromMiniAOD_customizeAllMC(process): + process = miniAODFromMiniAOD_customizeMC(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process From 70f135ad8011abb81683a57b1c7e2c21109818e1 Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Wed, 24 Sep 2025 15:41:24 +0200 Subject: [PATCH 04/24] Specify packedPFCandidates collection for MET recomputation --- .../PatAlgos/python/tools/puppiJetMETReclusteringTools.py | 1 + 1 file changed, 1 insertion(+) diff --git a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py index bf535302ae743..71e13f349d319 100644 --- a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py +++ b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py @@ -131,6 +131,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi runMetCorAndUncFromMiniAOD(process, isData=not(runOnMC), jetCollUnskimmed="slimmedJetsPuppi", + pfCandColl=pfInputTag, metType="Puppi", postfix="Puppi", jetFlavor="AK4PFPuppi", From 574643ab6799101d5e83c765183d2007d8053e37 Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Wed, 24 Sep 2025 21:21:59 +0200 Subject: [PATCH 05/24] Revert modification in setupPuppiForPackedPF(), set Puppi producers to use original packedPFCandidates collection in miniAODFromMiniAOD_customizeCommon() --- .../PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py | 6 ++++++ PhysicsTools/PatAlgos/python/tools/jetTools.py | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py index 254f56ab1e454..19881c1ec3395 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -5,6 +5,12 @@ def miniAODFromMiniAOD_customizeCommon(process): task = getPatAlgosToolsTask(process) + ########################################################################### + # Set puppi producers to use the original packedPFCandidate collection + ########################################################################### + process.packedpuppi.candName = 'packedPFCandidates::@skipCurrentProcess' + process.packedpuppiNoLep.candName = 'packedPFCandidates::@skipCurrentProcess' + ########################################################################### # Update packedPFCandidates with the recomputed puppi weights ########################################################################### diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 9a5ae0db70130..a38c70840397a 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -255,7 +255,7 @@ def setupPuppiForPackedPF(process, useExistingWeights=True, postfix=''): if not hasattr(process, puppiLabel): addToProcessAndTask(puppiLabel, puppi.clone( useExistingWeights = useExistingWeights, - candName = 'packedPFCandidates::@skipCurrentProcess', + candName = 'packedPFCandidates', vertexName = 'offlineSlimmedPrimaryVertices'), process, task) puppiNoLepLabel = puppiLabel+'NoLep' From 1ba913bc31879f32e6cd233d08bf3ff704a777fa Mon Sep 17 00:00:00 2001 From: Nurfikri Norjoharuddeen Date: Thu, 25 Sep 2025 00:17:01 +0200 Subject: [PATCH 06/24] Apply code-format patches --- .../plugins/PATElectronCandidatesRekeyer.cc | 18 ++++---- .../plugins/PATJetCandidatesRekeyer.cc | 36 ++++++++++------ .../plugins/PATMuonCandidatesRekeyer.cc | 18 ++++---- .../plugins/PATObjectPuppiIsolationUpdater.cc | 43 +++++++++++-------- .../plugins/PATPackedCandidateUpdater.cc | 19 ++++---- .../plugins/PATPhotonCandidatesRekeyer.cc | 16 +++---- .../plugins/PATTauCandidatesRekeyer.cc | 23 +++++----- ...ertexCompositeCandidateDaughtersRekeyer.cc | 16 ++++--- 8 files changed, 100 insertions(+), 89 deletions(-) diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc index 38288580e79ed..4fbc40957c2de 100644 --- a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -30,13 +30,14 @@ namespace pat { using namespace pat; -PATElectronCandidatesRekeyer::PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig): +PATElectronCandidatesRekeyer::PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig) + : - src_(consumes>(iConfig.getParameter("src"))), - pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces>(); - } PATElectronCandidatesRekeyer::~PATElectronCandidatesRekeyer() {} @@ -59,13 +60,11 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c outPtrP->emplace_back((*src)[i]); std::vector keys; - for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()){ + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { keys.push_back(ref.key()); }; outPtrP->back().setAssociatedPackedPFCandidates( - edm::RefProd(pcNewHandle), - keys.begin(), keys.end() - ); + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); if (keys.size() == 1) { outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); } else { @@ -75,6 +74,5 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c iEvent.put(std::move(outPtrP)); } - #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PATElectronCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc index 6c23550b59c4d..00d8bd30911c8 100644 --- a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -30,10 +30,11 @@ namespace pat { using namespace pat; -PATJetCandidatesRekeyer::PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig): - src_(consumes>(iConfig.getParameter("src"))), - pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ +PATJetCandidatesRekeyer::PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces>(); produces>("tagInfos"); } @@ -50,8 +51,9 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const edm::Handle pcNewHandle; iEvent.getByToken(pcNewToken_, pcNewHandle); - edm::RefProd> h_tagInfosOut = iEvent.getRefBeforePut>("tagInfos"); - auto tagInfosOut = std::make_unique>(); + edm::RefProd> h_tagInfosOut = + iEvent.getRefBeforePut>("tagInfos"); + auto tagInfosOut = std::make_unique>(); auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); @@ -59,8 +61,13 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // // // - for (std::vector::const_iterator ibegin = (*src).begin(), iend = (*src).end(), ijet = ibegin; ijet != iend; ++ijet) { - for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(), iinfoEnd = ijet->tagInfosFwdPtr().end(), iinfo = iinfoBegin;iinfo != iinfoEnd;++iinfo) { + for (std::vector::const_iterator ibegin = (*src).begin(), iend = (*src).end(), ijet = ibegin; ijet != iend; + ++ijet) { + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(), + iinfoEnd = ijet->tagInfosFwdPtr().end(), + iinfo = iinfoBegin; + iinfo != iinfoEnd; + ++iinfo) { tagInfosOut->push_back(**iinfo); } } @@ -78,16 +85,20 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const reco::CompositePtrCandidate::daughters old = outPtrP->back().daughterPtrVector(); outPtrP->back().clearDaughters(); - for (const auto & dauItr : old) { - outPtrP->back().addDaughter(edm::Ptr(pcNewHandle,dauItr.key())); + for (const auto &dauItr : old) { + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle, dauItr.key())); } // Copy the tag infos - for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), iinfo = iinfoBegin; iinfo != iinfoEnd; ++iinfo) { + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfo = iinfoBegin; + iinfo != iinfoEnd; + ++iinfo) { // Update the "forward" bit of the FwdPtr to point at the new collection. // ptr to "this" info in the global list edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); - outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); + outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); ++tagInfoIndex; } } @@ -95,6 +106,5 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const iEvent.put(std::move(outPtrP)); } - #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PATJetCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc index aabfdb568df81..f8d7737d2215a 100644 --- a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -30,10 +30,11 @@ namespace pat { using namespace pat; -PATMuonCandidatesRekeyer::PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig): - src_(consumes>(iConfig.getParameter("src"))), - pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ +PATMuonCandidatesRekeyer::PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces>(); } @@ -59,19 +60,18 @@ void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // std::vector keys; for (size_t ic = 0; ic < outPtrP->back().numberOfSourceCandidatePtrs(); ++ic) { - const reco::CandidatePtr& candPtr = outPtrP->back().sourceCandidatePtr(ic); - if (candPtr.isNonnull()){ + const reco::CandidatePtr &candPtr = outPtrP->back().sourceCandidatePtr(ic); + if (candPtr.isNonnull()) { keys.push_back(candPtr.key()); } } - if(keys.size() == 1){ - outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewCandViewHandle,keys[0]); + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewCandViewHandle, keys[0]); } } iEvent.put(std::move(outPtrP)); } - #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PATMuonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc index 5efe785148e4a..3358cd8bfc2ca 100644 --- a/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc +++ b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc @@ -38,15 +38,21 @@ namespace pat { using namespace pat; template -PATObjectPuppiIsolationUpdater::PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig): - src_(consumes>(iConfig.getParameter("src"))){ - PUPPIIsolation_charged_hadrons_ = consumes>(iConfig.getParameter("puppiIsolationChargedHadrons")); - PUPPIIsolation_neutral_hadrons_ = consumes>(iConfig.getParameter("puppiIsolationNeutralHadrons")); - PUPPIIsolation_photons_ = consumes>(iConfig.getParameter("puppiIsolationPhotons")); - if constexpr (std::is_same::value || std::is_same::value){ - PUPPINoLeptonsIsolation_charged_hadrons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationChargedHadrons")); - PUPPINoLeptonsIsolation_neutral_hadrons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationNeutralHadrons")); - PUPPINoLeptonsIsolation_photons_ = consumes>(iConfig.getParameter("puppiNoLeptonsIsolationPhotons")); +PATObjectPuppiIsolationUpdater::PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))) { + PUPPIIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationChargedHadrons")); + PUPPIIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationNeutralHadrons")); + PUPPIIsolation_photons_ = + consumes>(iConfig.getParameter("puppiIsolationPhotons")); + if constexpr (std::is_same::value || std::is_same::value) { + PUPPINoLeptonsIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationChargedHadrons")); + PUPPINoLeptonsIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationNeutralHadrons")); + PUPPINoLeptonsIsolation_photons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationPhotons")); } produces>(); } @@ -74,7 +80,7 @@ void PATObjectPuppiIsolationUpdater::produce(edm::Event &iEvent, edm::EventSe iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons); //puppiNoLeptons - if constexpr (std::is_same::value || std::is_same::value){ + if constexpr (std::is_same::value || std::is_same::value) { iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons); iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons); iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons); @@ -87,28 +93,27 @@ void PATObjectPuppiIsolationUpdater::produce(edm::Event &iEvent, edm::EventSe // copy original pat object and append to vector outPtrP->emplace_back((*src)[i]); - edm::Ptr objPtr(src,i); + edm::Ptr objPtr(src, i); outPtrP->back().setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[objPtr], - (*PUPPIIsolation_neutral_hadrons)[objPtr], - (*PUPPIIsolation_photons)[objPtr]); + (*PUPPIIsolation_neutral_hadrons)[objPtr], + (*PUPPIIsolation_photons)[objPtr]); - if constexpr (std::is_same::value || std::is_same::value){ + if constexpr (std::is_same::value || std::is_same::value) { outPtrP->back().setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[objPtr], - (*PUPPINoLeptonsIsolation_neutral_hadrons)[objPtr], - (*PUPPINoLeptonsIsolation_photons)[objPtr]); + (*PUPPINoLeptonsIsolation_neutral_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_photons)[objPtr]); } } iEvent.put(std::move(outPtrP)); } typedef PATObjectPuppiIsolationUpdater PATElectronPuppiIsolationUpdater; -typedef PATObjectPuppiIsolationUpdater PATPhotonPuppiIsolationUpdater; -typedef PATObjectPuppiIsolationUpdater PATMuonPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATPhotonPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATMuonPuppiIsolationUpdater; #include "FWCore/Framework/interface/MakerMacros.h" - DEFINE_FWK_MODULE(PATElectronPuppiIsolationUpdater); DEFINE_FWK_MODULE(PATPhotonPuppiIsolationUpdater); DEFINE_FWK_MODULE(PATMuonPuppiIsolationUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc index 5b10cf9604b09..a81ca166b133f 100644 --- a/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc +++ b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc @@ -7,7 +7,7 @@ #include "DataFormats/Common/interface/ValueMap.h" namespace pat { - class PATPackedCandidateUpdater : public edm::stream::EDProducer<> { + class PATPackedCandidateUpdater : public edm::stream::EDProducer<> { public: explicit PATPackedCandidateUpdater(const edm::ParameterSet&); ~PATPackedCandidateUpdater() override {} @@ -21,15 +21,15 @@ namespace pat { edm::EDGetTokenT> puppiWeightToken_; edm::EDGetTokenT> puppiWeightNoLepToken_; }; -} // namespace pat +} // namespace pat using namespace pat; -PATPackedCandidateUpdater::PATPackedCandidateUpdater(const edm::ParameterSet& iConfig): - candsToken_(consumes>(iConfig.getParameter("src"))), - updatePuppiWeights_(iConfig.getParameter("updatePuppiWeights")), - puppiWeightToken_(consumes>(iConfig.getParameter("puppiWeight"))), - puppiWeightNoLepToken_(consumes>(iConfig.getParameter("puppiWeightNoLep"))){ +PATPackedCandidateUpdater::PATPackedCandidateUpdater(const edm::ParameterSet& iConfig) + : candsToken_(consumes>(iConfig.getParameter("src"))), + updatePuppiWeights_(iConfig.getParameter("updatePuppiWeights")), + puppiWeightToken_(consumes>(iConfig.getParameter("puppiWeight"))), + puppiWeightNoLepToken_(consumes>(iConfig.getParameter("puppiWeightNoLep"))) { produces>(); } @@ -39,7 +39,7 @@ void PATPackedCandidateUpdater::produce(edm::Event& iEvent, const edm::EventSetu edm::Handle> puppiWeight; edm::Handle> puppiWeightNoLep; - if (updatePuppiWeights_){ + if (updatePuppiWeights_) { iEvent.getByToken(puppiWeightToken_, puppiWeight); iEvent.getByToken(puppiWeightNoLepToken_, puppiWeightNoLep); } @@ -48,14 +48,13 @@ void PATPackedCandidateUpdater::produce(edm::Event& iEvent, const edm::EventSetu outPtrP->reserve(cands->size()); for (size_t ic = 0; ic < cands->size(); ++ic) { - // copy original pat::PackedCandidate and append to vector outPtrP->emplace_back((*cands)[ic]); // Retrieve puppi weights from edm::ValueMap pat::PackedCandidateRef pkref(cands, ic); - if (updatePuppiWeights_){ + if (updatePuppiWeights_) { float puppiWeightVal = (*puppiWeight)[pkref]; float puppiWeightNoLepVal = (*puppiWeightNoLep)[pkref]; outPtrP->back().setPuppiWeight(puppiWeightVal, puppiWeightNoLepVal); diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc index eb9046a3e15ec..bb4043cfe9e13 100644 --- a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -30,10 +30,11 @@ namespace pat { using namespace pat; -PATPhotonCandidatesRekeyer::PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig): - src_(consumes>(iConfig.getParameter("src"))), - pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ +PATPhotonCandidatesRekeyer::PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces>(); } @@ -57,13 +58,11 @@ void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup con outPtrP->emplace_back((*src)[i]); std::vector keys; - for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()){ + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { keys.push_back(ref.key()); }; outPtrP->back().setAssociatedPackedPFCandidates( - edm::RefProd(pcNewHandle), - keys.begin(), keys.end() - ); + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); if (keys.size() == 1) { outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); } else { @@ -73,6 +72,5 @@ void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup con iEvent.put(std::move(outPtrP)); } - #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PATPhotonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc index f56b1d046f214..af0925de48459 100644 --- a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -30,12 +30,12 @@ namespace pat { using namespace pat; -PATTauCandidatesRekeyer::PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig): - src_(consumes>(iConfig.getParameter("src"))), - pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ +PATTauCandidatesRekeyer::PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces>(); - } PATTauCandidatesRekeyer::~PATTauCandidatesRekeyer() {} @@ -59,44 +59,43 @@ void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const reco::CandidatePtrVector signalChHPtrs; for (const reco::CandidatePtr &p : outPtrP->back().signalChargedHadrCands()) { - signalChHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + signalChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setSignalChargedHadrCands(signalChHPtrs); reco::CandidatePtrVector signalNHPtrs; for (const reco::CandidatePtr &p : outPtrP->back().signalNeutrHadrCands()) { - signalNHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + signalNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setSignalNeutralHadrCands(signalNHPtrs); reco::CandidatePtrVector signalGammaPtrs; for (const reco::CandidatePtr &p : outPtrP->back().signalGammaCands()) { - signalGammaPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + signalGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setSignalGammaCands(signalGammaPtrs); reco::CandidatePtrVector isolationChHPtrs; for (const reco::CandidatePtr &p : outPtrP->back().isolationChargedHadrCands()) { - isolationChHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + isolationChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setIsolationChargedHadrCands(isolationChHPtrs); reco::CandidatePtrVector isolationNHPtrs; for (const reco::CandidatePtr &p : outPtrP->back().isolationNeutrHadrCands()) { - isolationNHPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + isolationNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setIsolationNeutralHadrCands(isolationNHPtrs); reco::CandidatePtrVector isolationGammaPtrs; for (const reco::CandidatePtr &p : outPtrP->back().isolationGammaCands()) { - isolationGammaPtrs.push_back(edm::Ptr(pcNewHandle,p.key())); + isolationGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); } outPtrP->back().setIsolationGammaCands(isolationGammaPtrs); } iEvent.put(std::move(outPtrP)); } - #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PATTauCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc index 913c2f2eebd5a..fd24a8750b143 100644 --- a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -32,10 +32,12 @@ namespace pat { using namespace pat; -VertexCompositeCandidateDaughtersRekeyer::VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig): - src_(consumes(iConfig.getParameter("src"))), - pcOriToken_(consumes(iConfig.getParameter("packedPFCandidatesOri"))), - pcNewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))){ +VertexCompositeCandidateDaughtersRekeyer::VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes(iConfig.getParameter("src"))), + pcOriToken_( + consumes(iConfig.getParameter("packedPFCandidatesOri"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { produces(); } @@ -66,9 +68,9 @@ void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm:: // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection // This is needed because the CandidatePtr can point to a candidate in lostTracks collection // - if (dau.id() == pcOriHandle.id()){ - outPtrP->back().addDaughter(edm::Ptr(pcNewHandle,dau.key())); - }else{ + if (dau.id() == pcOriHandle.id()) { + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle, dau.key())); + } else { outPtrP->back().addDaughter(dau); } } From 09fba89cf0266fb4bcb83f956330b823d2f413ad Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 7 Oct 2025 12:51:56 +0200 Subject: [PATCH 07/24] streamlining of PAT configuration --- .../Applications/python/ConfigBuilder.py | 29 ++++++-------- .../StandardSequences/python/PATMC_cff.py | 15 -------- .../StandardSequences/python/PAT_cff.py | 6 ++- .../python/slimming/isolatedTracks_cfi.py | 6 +-- .../python/slimming/metFilterPaths_cff.py | 38 +++++++++++++------ .../PatAlgos/python/slimming/miniAOD_tools.py | 23 +++-------- 6 files changed, 52 insertions(+), 65 deletions(-) delete mode 100644 Configuration/StandardSequences/python/PATMC_cff.py diff --git a/Configuration/Applications/python/ConfigBuilder.py b/Configuration/Applications/python/ConfigBuilder.py index 5fbd200704d0f..e25dd9dc66057 100644 --- a/Configuration/Applications/python/ConfigBuilder.py +++ b/Configuration/Applications/python/ConfigBuilder.py @@ -1098,7 +1098,7 @@ def define_Configs(self): self.VALIDATIONDefaultSeq='' self.ENDJOBDefaultSeq='endOfProcess' self.REPACKDefaultSeq='DigiToRawRepack' - self.PATDefaultSeq='miniAOD' + self.PATDefaultSeq='patTask' self.PATGENDefaultSeq='miniGEN' #TODO: Check based of file input self.NANODefaultSeq='nanoSequence' @@ -1118,7 +1118,6 @@ def define_Configs(self): if self._options.isMC==True: self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_cff" self.RECODefaultCFF="Configuration/StandardSequences/Reconstruction_cff" - self.PATDefaultCFF="Configuration/StandardSequences/PATMC_cff" self.PATGENDefaultCFF="Configuration/StandardSequences/PATGEN_cff" self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineMC_cff" self.ALCADefaultCFF="Configuration/StandardSequences/AlCaRecoStreamsMC_cff" @@ -1745,12 +1744,6 @@ def prepare_RAW2DIGI(self, stepSpec = "RawToDigi"): self.scheduleSequence(_raw2digiSeq,'raw2digi_step') return - def prepare_PATFILTER(self, stepSpec = None): - self.loadAndRemember("PhysicsTools/PatAlgos/slimming/metFilterPaths_cff") - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import allMetFilterPaths - for filt in allMetFilterPaths: - self.schedule.append(getattr(self.process,'Flag_'+filt)) - def prepare_L1HwVal(self, stepSpec = 'L1HwVal'): ''' Enrich the schedule with L1 HW validation ''' self.loadDefaultOrSpecifiedCFF(stepSpec,self.L1HwValDefaultCFF) @@ -1822,18 +1815,20 @@ def prepare_RECOBEFMIX(self, stepSpec = "reconstruction"): self.scheduleSequence(_recobefmixSeq,'reconstruction_befmix_step') return - def prepare_PAT(self, stepSpec = "miniAOD"): + def prepare_PAT(self, stepSpec = "patTask"): ''' Enrich the schedule with PAT ''' - self.prepare_PATFILTER(self) - self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) - self.labelsToAssociate.append('patTask') + _,pat_sequence,pat_cff = self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) + ## handle the noise filters as Flag_* path that were loaded + for existing_path,path_ in self.process.paths_().items(): + if existing_path.startswith('Flag_'): + print(f'scheduling {existing_path} as part of PAT configuration') + self.schedule.append( path_ ) + + self.labelsToAssociate.append(pat_sequence) if self._options.isData: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllData") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllData") else: - if self._options.fast: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMCFastSim") - else: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMC") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllMC") if self._options.hltProcess: self._customise_coms.append( f'process.patTrigger.processName = "{self._options.hltProcess}"') diff --git a/Configuration/StandardSequences/python/PATMC_cff.py b/Configuration/StandardSequences/python/PATMC_cff.py deleted file mode 100644 index 7927523f55a75..0000000000000 --- a/Configuration/StandardSequences/python/PATMC_cff.py +++ /dev/null @@ -1,15 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -from PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff import * -from PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff import * -from PhysicsTools.PatAlgos.slimming.slimming_cff import * -from RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi import * - -patTask = cms.Task( - patCandidatesTask, - selectedPatCandidatesTask, - slimmingTask, - bunchSpacingProducer -) - -miniAOD=cms.Sequence() diff --git a/Configuration/StandardSequences/python/PAT_cff.py b/Configuration/StandardSequences/python/PAT_cff.py index 7927523f55a75..5d0fe3f406e17 100644 --- a/Configuration/StandardSequences/python/PAT_cff.py +++ b/Configuration/StandardSequences/python/PAT_cff.py @@ -12,4 +12,8 @@ bunchSpacingProducer ) -miniAOD=cms.Sequence() +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +## include cms.Path defined from event filters +from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import * diff --git a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py index 11d9c9b6ba500..79aad38a83734 100644 --- a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py @@ -76,7 +76,5 @@ from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(isolatedTracks, useHighPurity = True) -def miniAOD_customizeIsolatedTracksFastSim(process): - """Switch off dE/dx hit info on fast sim, as it's not available""" - process.isolatedTracks.saveDeDxHitInfo = False - return process +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toModify(isolatedTracks, saveDeDxHitInfo = False) diff --git a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py index 12a44d34a4f97..0d4ae47037028 100644 --- a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py @@ -44,19 +44,35 @@ Flag_trkPOG_logErrorTooManyClusters = cms.Path(~logErrorTooManyClusters) #add your new path here!! -allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', - 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', - 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', - 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] +#allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', +# 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', +# 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', +# 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] +"""Replace some MET filters that don't work in FastSim with trivial bools""" +_fake_bool = cms.EDFilter("HLTBool", result=cms.bool(True)) +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toReplaceWith( CSCTightHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHaloTrkMuUnvetoFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHalo2015Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalSuperTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( HcalStripHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( manystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( toomanystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( logErrorTooManyClusters, _fake_bool.clone( result = False)) +#for X in CSCTightHaloFilter, CSCTightHaloTrkMuUnvetoFilter,CSCTightHalo2015Filter,globalTightHalo2016Filter,globalSuperTightHalo2016Filter,HcalStripHaloFilter: +# fastSim.toReplaceWith( X, fake_bool.clone( result = True)) +#for X in manystripclus53X, toomanystripclus53X, logErrorTooManyClusters: +# fastSim.toReplaceWith( X, fake_bool.clone( result = False)) -def miniAOD_customizeMETFiltersFastSim(process): - """Replace some MET filters that don't work in FastSim with trivial bools""" - for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True))) - for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False))) - return process +#def miniAOD_customizeMETFiltersFastSim(process): +# """Replace some MET filters that don't work in FastSim with trivial bools"" +# for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter': +# process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True))) +# for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters': +# process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False))) +# return process from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith( Flag_trkPOG_manystripclus53X, cms.Path() ) diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index f2bb6cb2316ce..35585827a11e1 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -655,6 +655,12 @@ def miniAOD_customizeMC(process): pp_on_AA.toModify(process, removeJECsForMC) pp_on_AA.toReplaceWith(task,task.copyAndExclude([process.slimmedGenJetsFlavourInfos])) + from Configuration.Eras.Modifier_fastSim_cff import fastSim + fastSim.toModify(process.patMuons, addTriggerMatching = False) + fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) + fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) + fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) + fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) def miniAOD_customizeOutput(out): from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import MiniAODOverrideBranchesSplitLevel @@ -704,20 +710,3 @@ def miniAOD_customizeAllMC(process): miniAOD_customizeCommon(process) miniAOD_customizeMC(process) return process - -def miniAOD_customizeAllMCFastSim(process): - miniAOD_customizeCommon(process) - miniAOD_customizeMC(process) - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import miniAOD_customizeMETFiltersFastSim - process = miniAOD_customizeMETFiltersFastSim(process) - from PhysicsTools.PatAlgos.slimming.isolatedTracks_cfi import miniAOD_customizeIsolatedTracksFastSim - process = miniAOD_customizeIsolatedTracksFastSim(process) - process.patMuons.addTriggerMatching = False - # Disable pixelClusterTagInfos in FastSim (no siPixelCluster available) - from Configuration.Eras.Modifier_fastSim_cff import fastSim - fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) - fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - - return process From da17bba854f48c726159a56aa9c90b0f3c60857f Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 7 Oct 2025 12:53:21 +0200 Subject: [PATCH 08/24] re-mini configuration, on top of Fikri's customisation --- .../StandardSequences/python/REMINI_cff.py | 7 +++++ .../slimming/miniAODFromMiniAOD_tools.py | 26 +++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 Configuration/StandardSequences/python/REMINI_cff.py diff --git a/Configuration/StandardSequences/python/REMINI_cff.py b/Configuration/StandardSequences/python/REMINI_cff.py new file mode 100644 index 0000000000000..6f0a979dc67d9 --- /dev/null +++ b/Configuration/StandardSequences/python/REMINI_cff.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +patAlgosToolsTask = cms.Task() + +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllData as miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllMC as miniAOD_customizeAllMC + diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py index 19881c1ec3395..241edaa0ba672 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -233,6 +233,32 @@ def miniAODFromMiniAOD_customizeCommon(process): process, task ) + mini_output = None + for out_name in process.outputModules_().keys(): + if out_name.startswith('MINIAOD'): + mini_output = getattr(process, out_name) + break + if mini_output: + for new_collection_to_keep in ['packedPFCandidates', + 'slimmedJets', + 'slimmedJetsPuppi', + 'slimmedJetsAK8', + 'slimmedJetsAK8PFPuppiSoftDropPacked_SubJets', + 'slimmedMETsPuppi', + 'slimmedTaus', + 'slimmedTausBoosted', + 'slimmedElectrons', + 'slimmedMuons', + 'slimmedPhotons', + 'slimmedLowPtElectrons', + 'slimmedKshortVertices', + 'slimmedLambdaVertices', + 'slimmedSecondaryVertices']: + new_collection_to_keep += '_*' if not '_' in new_collection_to_keep else '' + mini_output.outputCommands += [ + f'drop *_{new_collection_to_keep}_*', + f'keep *_{new_collection_to_keep}_{process.name_()}'] + return process def miniAODFromMiniAOD_customizeData(process): From 6c38aaf6c0050e219b47ff18e445aed69291ac44 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 7 Oct 2025 14:39:47 +0200 Subject: [PATCH 09/24] clean old code --- .../PatAlgos/python/slimming/metFilterPaths_cff.py | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py index 0d4ae47037028..177a21b731b78 100644 --- a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py @@ -61,18 +61,6 @@ fastSim.toReplaceWith( manystripclus53X, _fake_bool.clone( result = False)) fastSim.toReplaceWith( toomanystripclus53X, _fake_bool.clone( result = False)) fastSim.toReplaceWith( logErrorTooManyClusters, _fake_bool.clone( result = False)) -#for X in CSCTightHaloFilter, CSCTightHaloTrkMuUnvetoFilter,CSCTightHalo2015Filter,globalTightHalo2016Filter,globalSuperTightHalo2016Filter,HcalStripHaloFilter: -# fastSim.toReplaceWith( X, fake_bool.clone( result = True)) -#for X in manystripclus53X, toomanystripclus53X, logErrorTooManyClusters: -# fastSim.toReplaceWith( X, fake_bool.clone( result = False)) - -#def miniAOD_customizeMETFiltersFastSim(process): -# """Replace some MET filters that don't work in FastSim with trivial bools"" -# for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter': -# process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True))) -# for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters': -# process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False))) -# return process from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith( Flag_trkPOG_manystripclus53X, cms.Path() ) From 7ced6f83eac0c65412ae1693cffdc2c0844cbafe Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 7 Oct 2025 15:15:39 +0200 Subject: [PATCH 10/24] shadow inexiting modules in HI config --- .../PatAlgos/python/slimming/miniAOD_tools.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index 35585827a11e1..bd50695a3e77d 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -656,11 +656,16 @@ def miniAOD_customizeMC(process): pp_on_AA.toReplaceWith(task,task.copyAndExclude([process.slimmedGenJetsFlavourInfos])) from Configuration.Eras.Modifier_fastSim_cff import fastSim - fastSim.toModify(process.patMuons, addTriggerMatching = False) - fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) - fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) + if hasattr(process, 'patMuons'): + fastSim.toModify(process.patMuons, addTriggerMatching = False) + if hasattr(process, 'patJets'): + fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) + if hasattr(process, 'slimmedJetsNoDeepFlavour'): + fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) + if hasattr(process, 'updatedPatJetsSlimmedDeepFlavour'): + fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) + if hasattr(process, "updatedPatJetsTransientCorrectedSlimmedDeepFlavour"): + fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) def miniAOD_customizeOutput(out): from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import MiniAODOverrideBranchesSplitLevel From 6c63a377135c8d7438588df695a2fdfa99c7b754 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 7 Oct 2025 17:32:35 +0200 Subject: [PATCH 11/24] fix filter modules in tagging mode in case of fastSim configruation --- .../python/jetMETDQMOfflineSource_cff.py | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py index d92b4a5e59a4f..d8fcb47ab0fd3 100644 --- a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py +++ b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py @@ -9,12 +9,21 @@ from RecoJets.JetProducers.QGTagger_cfi import * from RecoMET.METFilters.metFilters_cff import* -HcalStripHaloFilterDQM=HcalStripHaloFilter.clone(taggingMode = True) -CSCTightHaloFilterDQM=CSCTightHaloFilter.clone(taggingMode = True) -CSCTightHalo2015FilterDQM=CSCTightHalo2015Filter.clone(taggingMode = True) -eeBadScFilterDQM=eeBadScFilter.clone(taggingMode = True) -EcalDeadCellTriggerPrimitiveFilterDQM=EcalDeadCellTriggerPrimitiveFilter.clone(taggingMode = True) -EcalDeadCellBoundaryEnergyFilterDQM=EcalDeadCellBoundaryEnergyFilter.clone(taggingMode = True) + +## interferes with fastSim sequence that replaced these modules by an HLTBool module +## is it sufficient to have them scheduled with cms.ignore, and not need for tagging mode? +def clone_in_tagging_mode( m ): + if hasattr( m , 'taggingMode'): + return m.clone(taggingMode = True) + else: + return m.clone() + +HcalStripHaloFilterDQM = clone_in_tagging_mode( HcalStripHaloFilter ) +CSCTightHaloFilterDQM = clone_in_tagging_mode( CSCTightHaloFilter ) +CSCTightHalo2015FilterDQM = clone_in_tagging_mode( CSCTightHalo2015Filter ) +eeBadScFilterDQM = clone_in_tagging_mode( eeBadScFilter ) +EcalDeadCellTriggerPrimitiveFilterDQM = clone_in_tagging_mode( EcalDeadCellTriggerPrimitiveFilter ) +EcalDeadCellBoundaryEnergyFilterDQM = clone_in_tagging_mode( EcalDeadCellBoundaryEnergyFilter ) pileupJetIdCalculatorDQM=pileupJetIdCalculator.clone( jets = "ak4PFJets", From bc5a3895d7c3a0fa7656bbea82f4d058a70d6a82 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 10:54:22 +0200 Subject: [PATCH 12/24] run2 106X mini input limitations --- .../python/run2_miniAOD_miniAODUL_cff.py | 6 ++ .../slimming/miniAODFromMiniAOD_tools.py | 67 ++++++++++++++++--- 2 files changed, 62 insertions(+), 11 deletions(-) create mode 100644 Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py diff --git a/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py new file mode 100644 index 0000000000000..2830b81edf5cc --- /dev/null +++ b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# ultra-legacy (during LS2) Run-2 MINIAOD + +run2_miniAOD_miniAODUL = cms.Modifier() diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py index 241edaa0ba672..1505d6657c774 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -153,19 +153,53 @@ def miniAODFromMiniAOD_customizeCommon(process): ########################################################################### # Rekey tau constituents ########################################################################### - addToProcessAndTask("slimmedTaus", cms.EDProducer("PATTauCandidatesRekeyer", - src = cms.InputTag("slimmedTaus", processName=cms.InputTag.skipCurrentProcess()), - packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), - ), - process, task - ) + from Configuration.ProcessModifiers.run2_miniAOD_miniAODUL_cff import run2_miniAOD_miniAODUL + import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig + taus_to_use = 'slimmedTaus::@skipCurrentProcess' + idsToRun_for_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_taus, idsToAdd=["deepTau2018v2p5"]) + if idsToRun_for_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + taus_from_mini = taus_to_use + taus_to_use = 'slimmedTausUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=taus_from_mini, + updatedTauName=taus_to_use, + postfix="M2M", + toKeep=idsToRun_for_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskM2M, getattr(process, taus_to_use)) + addToProcessAndTask("slimmedTaus", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag(taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + boosted_taus_to_use = 'slimmedTausBoosted::@skipCurrentProcess' + idsToRun_for_boosted_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_boosted_taus, idsToAdd=["mvaIso", "mvaIsoNewDM", "mvaIsoDR0p3", "againstEle", "boostedDeepTauRunIIv2p0"]) + if idsToRun_for_boosted_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + boosted_taus_from_mini = boosted_taus_to_use + boosted_taus_to_use = 'slimmedTausBoostedUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=boosted_taus_from_mini, + updatedTauName=boosted_taus_to_use, + postfix="BoostedM2M", + toKeep=idsToRun_for_boosted_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskBoostedM2M, getattr(process, boosted_taus_to_use)) + addToProcessAndTask("slimmedTausBoosted", cms.EDProducer("PATTauCandidatesRekeyer", - src = cms.InputTag("slimmedTausBoosted", processName=cms.InputTag.skipCurrentProcess()), - packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), - ), - process, task - ) + src = cms.InputTag(boosted_taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) ########################################################################### # Rekey candidates in electrons, photons and muons @@ -233,6 +267,17 @@ def miniAODFromMiniAOD_customizeCommon(process): process, task ) + + _modified_run2_task = task.copyAndExclude([getattr(process,thisone) for thisone in ['slimmedDisplacedMuons']]) + from PhysicsTools.PatAlgos.patRefitVertexProducer_cfi import patRefitVertexProducer + process.offlineSlimmedPrimaryVerticesWithBS = patRefitVertexProducer.clone( + srcVertices = "offlineSlimmedPrimaryVertices", + ) + + _modified_run2_task.add( process.offlineSlimmedPrimaryVerticesWithBS ) + run2_miniAOD_miniAODUL.toReplaceWith( + task, _modified_run2_task) + mini_output = None for out_name in process.outputModules_().keys(): if out_name.startswith('MINIAOD'): From 8c971302155be6f50b8ff5d40ead66413e02e188 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 12:18:59 +0200 Subject: [PATCH 13/24] M2M test workflows. A2M UL workflows --- .../PyReleaseValidation/python/relval_nano.py | 48 +++++++++++++++++-- 1 file changed, 44 insertions(+), 4 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index 482c01834a52d..543893298ac81 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -79,23 +79,47 @@ def next(self, index: int = None) -> None: '--customise': '"Configuration/DataProcessing/Utils.addMonitoring"' }]) _HARVEST_mc = merge([_HARVEST_nano, {'--mc': ''}]) +## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF under a proc-Modifier +_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', + '--process': 'M2M'} steps['HRV_NANO_mc'] = _HARVEST_mc steps['HRV_NANO_data'] = _HARVEST_data ################################################################ # 10.6 INPUT and workflows +steps['TTbarAOD10.6_UL16APV'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECOAPV-106X_mcRun2_asymptotic_preVFP_v8-v2/AODSIM')} +steps['MINI_mc10.6ul16APV'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_preVFP']]) +steps['M2M_mc10.6ul16APV'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16APV']]) +steps['TTbarMINIAOD10.6_UL16APVv2'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODAPVv2-106X_mcRun2_asymptotic_preVFP_v11-v2/MINIAODSIM')} +steps['NANO_mc10.6ul16APVv2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', + '--conditions': 'auto:run2_mc'}, + _NANO_mc]) +steps['TTbarAOD10.6_UL16'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECO-106X_mcRun2_asymptotic_v13-v2/AODSIM')} +steps['MINI_mc10.6ul16'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_postVFP']]) +steps['M2M_mc10.6ul16'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16']]) steps['TTbarMINIAOD10.6_UL16v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODv2-106X_mcRun2_asymptotic_v17-v2/MINIAODSIM')} steps['NANO_mc10.6ul16v2'] = merge([{'--era': 'Run2_2016,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_mc'}, _NANO_mc]) # 2017 looking Monte-Carlo: two versions in 10.6 +steps['TTbarAOD10.6_UL17'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17RECO-106X_mc2017_realistic_v6-v2/AODSIM')} +steps['MINI_mc10.6ul17'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2017UL']]) +steps['M2M_mc10.6ul17'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul17']]) steps['TTbarMINIAOD10.6_UL17v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17MiniAODv2-106X_mc2017_realistic_v9-v2/MINIAODSIM')} steps['NANO_mc10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:phase1_2017_realistic'}, _NANO_mc]) +steps['TTbarAOD10.6_UL18'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18RECO-106X_upgrade2018_realistic_v11_L1v1-v2/AODSIM')} +steps['MINI_mc10.6ul18'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2018UL']]) +steps['M2M_mc10.6ul18'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul18']]) steps['TTbarMINIAOD10.6_UL18v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18MiniAODv2-106X_upgrade2018_realistic_v16_L1v1-v2/MINIAODSIM')} steps['NANO_mc10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', @@ -400,6 +424,7 @@ def next(self, index: int = None) -> None: ######## 2500.0xxx ######## # Run2, 10_6_X MiniAOD input (current recommendation for 2016--2018) workflows[_wfn()] = ['NANOmc106Xul16v2', ['TTbarMINIAOD10.6_UL16v2', 'NANO_mc10.6ul16v2', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmc106Xul16APVv2', ['TTbarMINIAOD10.6_UL16APVv2', 'NANO_mc10.6ul16APVv2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul17v2', ['TTbarMINIAOD10.6_UL17v2', 'NANO_mc10.6ul17v2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul18v2', ['TTbarMINIAOD10.6_UL18v2', 'NANO_mc10.6ul18v2', 'HRV_NANO_mc']] @@ -410,10 +435,15 @@ def next(self, index: int = None) -> None: # Run2, 10_6_X AOD, reMINI+reNANO _wfn.subnext() -workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbar_13_reminiaod2016UL_preVFP_INPUT', 'REMINIAOD_mc2016UL_preVFP', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbar_13_reminiaod2016UL_postVFP_INPUT', 'REMINIAOD_mc2016UL_postVFP', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcPreUL16APVreMINI', ['TTbar_13_reminiaod2016UL_preVFP_INPUT', 'REMINIAOD_mc2016UL_preVFP', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcPreUL16reMINI', ['TTbar_13_reminiaod2016UL_postVFP_INPUT', 'REMINIAOD_mc2016UL_postVFP', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcPreUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcPreUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa + +workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbarAOD10.6_UL18', 'MINI_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] _wfn.subnext() workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV_NANO_data']] # noqa @@ -421,6 +451,16 @@ def next(self, index: int = None) -> None: workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV_NANO_data']] # noqa workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV_NANO_data']] # noqa +_wfn.subnext() +workflows[_wfn()] = ['NANOmcUL16APVMini2Mini', ['TTbarMINIAOD10.6_UL16APVv2', 'M2M_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16Mini2Mini', ['TTbarMINIAOD10.6_UL16v2', 'M2M_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] + + +_wfn.subnext() +## M2M for data + _wfn.next(1) ######## 2500.1xxx ######## # Run3, 13_0_X input (current recommendation for 2022--2023) From 52b2549377d6b25700c83b2694f20cba85d435d1 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 13:01:23 +0200 Subject: [PATCH 14/24] use range whereever possible --- .../plugins/PATElectronCandidatesRekeyer.cc | 10 +++------- .../PatAlgos/plugins/PATJetCandidatesRekeyer.cc | 17 ++++++----------- .../plugins/PATMuonCandidatesRekeyer.cc | 4 ++-- .../plugins/PATPhotonCandidatesRekeyer.cc | 4 ++-- .../PatAlgos/plugins/PATTauCandidatesRekeyer.cc | 4 ++-- .../VertexCompositeCandidateDaughtersRekeyer.cc | 12 ++++-------- 6 files changed, 19 insertions(+), 32 deletions(-) diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc index 4fbc40957c2de..e9c460f061980 100644 --- a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -55,9 +55,9 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (size_t i = 0; i < src->size(); ++i) { + for (const auto &obj : *src){ // copy original pat object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); std::vector keys; for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { @@ -65,11 +65,7 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c }; outPtrP->back().setAssociatedPackedPFCandidates( edm::RefProd(pcNewHandle), keys.begin(), keys.end()); - if (keys.size() == 1) { - outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); - } else { - outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewHandle.id()); - } + outPtrP->back().refToOrig_ = (keys.size() == 1) ? outPtrP->back().sourceCandidatePtr(0) : reco::CandidatePtr(pcNewHandle.id()); } iEvent.put(std::move(outPtrP)); } diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc index 00d8bd30911c8..2b06d0a095683 100644 --- a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -61,14 +61,9 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // // // - for (std::vector::const_iterator ibegin = (*src).begin(), iend = (*src).end(), ijet = ibegin; ijet != iend; - ++ijet) { - for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = ijet->tagInfosFwdPtr().begin(), - iinfoEnd = ijet->tagInfosFwdPtr().end(), - iinfo = iinfoBegin; - iinfo != iinfoEnd; - ++iinfo) { - tagInfosOut->push_back(**iinfo); + for (const auto & jet : *src){ + for (const auto & info : jet.tagInfosFwdPtr()){ + tagInfosOut->push_back(*info); } } @@ -79,9 +74,9 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // unsigned int tagInfoIndex = 0; - for (size_t i = 0; i < src->size(); ++i) { + for (const auto & obj : *src){ // copy original pat object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); reco::CompositePtrCandidate::daughters old = outPtrP->back().daughterPtrVector(); outPtrP->back().clearDaughters(); @@ -91,7 +86,7 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // Copy the tag infos for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), - iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), iinfo = iinfoBegin; iinfo != iinfoEnd; ++iinfo) { diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc index f8d7737d2215a..db3d7b4756ff2 100644 --- a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -53,9 +53,9 @@ void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (size_t i = 0; i < src->size(); ++i) { + for (const auto & obj : *src){ // copy original pat object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); // std::vector keys; diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc index bb4043cfe9e13..a3a9e577718d7 100644 --- a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -53,9 +53,9 @@ void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup con auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (size_t i = 0; i < src->size(); ++i) { + for (const auto & obj : *src){ // copy original pat object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); std::vector keys; for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc index af0925de48459..c6605d3e961c2 100644 --- a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -53,9 +53,9 @@ void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (size_t i = 0; i < src->size(); ++i) { + for (const auto & obj : *src){ // copy original pat object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); reco::CandidatePtrVector signalChHPtrs; for (const reco::CandidatePtr &p : outPtrP->back().signalChargedHadrCands()) { diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc index fd24a8750b143..9babadd34f287 100644 --- a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -56,9 +56,9 @@ void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm:: auto outPtrP = std::make_unique(); outPtrP->reserve(src->size()); - for (size_t i = 0; i < src->size(); ++i) { + for (const auto & obj : *src){ // copy original object and append to vector - outPtrP->emplace_back((*src)[i]); + outPtrP->emplace_back(obj); std::vector daughters = outPtrP->back().daughterPtrVector(); outPtrP->back().clearDaughters(); @@ -68,15 +68,11 @@ void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm:: // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection // This is needed because the CandidatePtr can point to a candidate in lostTracks collection // - if (dau.id() == pcOriHandle.id()) { - outPtrP->back().addDaughter(edm::Ptr(pcNewHandle, dau.key())); - } else { - outPtrP->back().addDaughter(dau); - } + outPtrP->back().addDaughter( (dau.id() == pcOriHandle.id()) ? edm::Ptr(pcNewHandle, dau.key()) : dau); } } iEvent.put(std::move(outPtrP)); } #include "FWCore/Framework/interface/MakerMacros.h" -DEFINE_FWK_MODULE(VertexCompositeCandidateDaughtersRekeyer); \ No newline at end of file +DEFINE_FWK_MODULE(VertexCompositeCandidateDaughtersRekeyer); From af42698307062aa46efdeb95efbe793a41533046 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 13:06:30 +0200 Subject: [PATCH 15/24] code formatting --- .../PatAlgos/plugins/PATElectronCandidatesRekeyer.cc | 5 +++-- PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc | 8 ++++---- PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc | 2 +- .../PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc | 2 +- PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc | 2 +- .../plugins/VertexCompositeCandidateDaughtersRekeyer.cc | 5 +++-- 6 files changed, 13 insertions(+), 11 deletions(-) diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc index e9c460f061980..975615a429b9b 100644 --- a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -55,7 +55,7 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (const auto &obj : *src){ + for (const auto &obj : *src) { // copy original pat object and append to vector outPtrP->emplace_back(obj); @@ -65,7 +65,8 @@ void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup c }; outPtrP->back().setAssociatedPackedPFCandidates( edm::RefProd(pcNewHandle), keys.begin(), keys.end()); - outPtrP->back().refToOrig_ = (keys.size() == 1) ? outPtrP->back().sourceCandidatePtr(0) : reco::CandidatePtr(pcNewHandle.id()); + outPtrP->back().refToOrig_ = + (keys.size() == 1) ? outPtrP->back().sourceCandidatePtr(0) : reco::CandidatePtr(pcNewHandle.id()); } iEvent.put(std::move(outPtrP)); } diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc index 2b06d0a095683..7f15584816700 100644 --- a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -61,8 +61,8 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // // // - for (const auto & jet : *src){ - for (const auto & info : jet.tagInfosFwdPtr()){ + for (const auto &jet : *src) { + for (const auto &info : jet.tagInfosFwdPtr()) { tagInfosOut->push_back(*info); } } @@ -74,7 +74,7 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // unsigned int tagInfoIndex = 0; - for (const auto & obj : *src){ + for (const auto &obj : *src) { // copy original pat object and append to vector outPtrP->emplace_back(obj); @@ -86,7 +86,7 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const // Copy the tag infos for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), - iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), iinfo = iinfoBegin; iinfo != iinfoEnd; ++iinfo) { diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc index db3d7b4756ff2..618819d397416 100644 --- a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -53,7 +53,7 @@ void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (const auto & obj : *src){ + for (const auto &obj : *src) { // copy original pat object and append to vector outPtrP->emplace_back(obj); diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc index a3a9e577718d7..9ff9da5d8d96e 100644 --- a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -53,7 +53,7 @@ void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup con auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (const auto & obj : *src){ + for (const auto &obj : *src) { // copy original pat object and append to vector outPtrP->emplace_back(obj); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc index c6605d3e961c2..4e24987bf7efb 100644 --- a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -53,7 +53,7 @@ void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const auto outPtrP = std::make_unique>(); outPtrP->reserve(src->size()); - for (const auto & obj : *src){ + for (const auto &obj : *src) { // copy original pat object and append to vector outPtrP->emplace_back(obj); diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc index 9babadd34f287..ae06de789e168 100644 --- a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -56,7 +56,7 @@ void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm:: auto outPtrP = std::make_unique(); outPtrP->reserve(src->size()); - for (const auto & obj : *src){ + for (const auto &obj : *src) { // copy original object and append to vector outPtrP->emplace_back(obj); @@ -68,7 +68,8 @@ void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm:: // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection // This is needed because the CandidatePtr can point to a candidate in lostTracks collection // - outPtrP->back().addDaughter( (dau.id() == pcOriHandle.id()) ? edm::Ptr(pcNewHandle, dau.key()) : dau); + outPtrP->back().addDaughter((dau.id() == pcOriHandle.id()) ? edm::Ptr(pcNewHandle, dau.key()) + : dau); } } iEvent.put(std::move(outPtrP)); From 75569c8944c66b14ff447ea791793a307feef43f Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 13:18:00 +0200 Subject: [PATCH 16/24] a range here too --- PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc index 7f15584816700..eb08526dba27e 100644 --- a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -85,15 +85,11 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const } // Copy the tag infos - for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), - iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), - iinfo = iinfoBegin; - iinfo != iinfoEnd; - ++iinfo) { + for (const auto &info : outPtrP->back().tagInfosFwdPtr()) { // Update the "forward" bit of the FwdPtr to point at the new collection. // ptr to "this" info in the global list edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); - outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); + outPtrP->back().updateFwdTagInfoFwdPtr(tagInfoIndex, outPtr); ++tagInfoIndex; } } From f8fd039beb65238002865190dec388cbb2db4266 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 14:43:56 +0200 Subject: [PATCH 17/24] use variable --- PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc index eb08526dba27e..7f15584816700 100644 --- a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -85,11 +85,15 @@ void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const } // Copy the tag infos - for (const auto &info : outPtrP->back().tagInfosFwdPtr()) { + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfo = iinfoBegin; + iinfo != iinfoEnd; + ++iinfo) { // Update the "forward" bit of the FwdPtr to point at the new collection. // ptr to "this" info in the global list edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); - outPtrP->back().updateFwdTagInfoFwdPtr(tagInfoIndex, outPtr); + outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); ++tagInfoIndex; } } From 1a552c663f0266d78a299a9b1228931b0d463aeb Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 15:55:14 +0200 Subject: [PATCH 18/24] enable Mini-to-mini on pre14.2 postUL MINI input --- .../python/run3_miniAOD_miniAODpre142X_cff.py | 6 ++++++ .../PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py | 3 +++ 2 files changed, 9 insertions(+) create mode 100644 Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py diff --git a/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py new file mode 100644 index 0000000000000..c069e482dbab0 --- /dev/null +++ b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# Run-3 MINIAOD produced prior to 14.2 release + +run3_miniAOD_miniAODpre142X = cms.Modifier() diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py index 1505d6657c774..e31901239dfd4 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -154,6 +154,7 @@ def miniAODFromMiniAOD_customizeCommon(process): # Rekey tau constituents ########################################################################### from Configuration.ProcessModifiers.run2_miniAOD_miniAODUL_cff import run2_miniAOD_miniAODUL + from Configuration.ProcessModifiers.run3_miniAOD_miniAODpre142X_cff import run3_miniAOD_miniAODpre142X import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig taus_to_use = 'slimmedTaus::@skipCurrentProcess' idsToRun_for_taus = cms.PSet(idsToAdd=cms.vstring()) @@ -182,6 +183,8 @@ def miniAODFromMiniAOD_customizeCommon(process): idsToRun_for_boosted_taus = cms.PSet(idsToAdd=cms.vstring()) run2_miniAOD_miniAODUL.toModify( idsToRun_for_boosted_taus, idsToAdd=["mvaIso", "mvaIsoNewDM", "mvaIsoDR0p3", "againstEle", "boostedDeepTauRunIIv2p0"]) + run3_miniAOD_miniAODpre142X.toModify( + idsToRun_for_boosted_taus, idsToAdd=["boostedDeepTauRunIIv2p0"]) if idsToRun_for_boosted_taus.idsToAdd: if not hasattr(process,'tauTask'): process.tauTask = cms.Task() boosted_taus_from_mini = boosted_taus_to_use From 2f221c71ada3aaa3013914a641d3c975a9d41498 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Thu, 9 Oct 2025 16:22:03 +0200 Subject: [PATCH 19/24] more Mini from Mini test workflows, and fix to harvesting of the appropriate step --- .../PyReleaseValidation/python/relval_nano.py | 60 +++++++++++++------ 1 file changed, 42 insertions(+), 18 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index 543893298ac81..d07ec6358820e 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -79,11 +79,20 @@ def next(self, index: int = None) -> None: '--customise': '"Configuration/DataProcessing/Utils.addMonitoring"' }]) _HARVEST_mc = merge([_HARVEST_nano, {'--mc': ''}]) -## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF under a proc-Modifier -_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', +## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF +## the dqm sequence DQM:@miniAODDQM will not function on M2M, because it requires AOD-bound collections TBF +#_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', +# '--process': 'M2M'} +_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask', + '--eventcontent' : 'MINIAODSIM', + '--datatier' : 'MINIAODSIM', '--process': 'M2M'} steps['HRV_NANO_mc'] = _HARVEST_mc +steps['HRV3_NANO_mc'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_mc]) steps['HRV_NANO_data'] = _HARVEST_data +steps['HRV3_NANO_data'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_data]) ################################################################ # 10.6 INPUT and workflows @@ -148,6 +157,7 @@ def next(self, index: int = None) -> None: ################################################################ # Run2UL re-MINI/NANO +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD steps['NANO_mc_UL16APVreMINI'] = merge([{'--era': 'Run2_2016_HIPM', '--conditions': 'auto:run2_mc_pre_vfp'}, _NANO_mc]) @@ -178,10 +188,21 @@ def next(self, index: int = None) -> None: # 13.0 workflows steps['TTbarMINIAOD13.0'] = {'INPUT': InputInfo( location='STD', dataSet='/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer23MiniAODv4-130X_mcRun3_2023_realistic_v14-v2/MINIAODSIM')} - +steps['M2M_mc13.0'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic', '--procModifier': 'run3_miniAOD_miniAODpre142X'}, + steps['M2M_mc10.6ul18']]) steps['NANO_mc13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:phase1_2023_realistic'}, _NANO_mc]) - +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD +steps['NANO_mc_reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'}, + _NANO_mc]) +#steps['NANO_mc_S22reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S22EEreMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fit GT +# _NANO_mc]) +#steps['NANO_mc_S23BPixreMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fix GT +# _NANO_mc]) # 13.0 workflows -- data steps['MuonEG2023MINIAOD13.0'] = {'INPUT': InputInfo(location='STD', ls={368489: [[46, 546]]}, @@ -440,22 +461,22 @@ def next(self, index: int = None) -> None: workflows[_wfn()] = ['NANOmcPreUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa workflows[_wfn()] = ['NANOmcPreUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbarAOD10.6_UL18', 'MINI_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbarAOD10.6_UL18', 'MINI_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] _wfn.subnext() -workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] # noqa _wfn.subnext() -workflows[_wfn()] = ['NANOmcUL16APVMini2Mini', ['TTbarMINIAOD10.6_UL16APVv2', 'M2M_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL16Mini2Mini', ['TTbarMINIAOD10.6_UL16v2', 'M2M_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] -workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16APVMini2Mini', ['TTbarMINIAOD10.6_UL16APVv2', 'M2M_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16Mini2Mini', ['TTbarMINIAOD10.6_UL16v2', 'M2M_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] _wfn.subnext() @@ -469,6 +490,9 @@ def next(self, index: int = None) -> None: _wfn.subnext() workflows[_wfn()] = ['NANOdata130Xrun3', ['MuonEG2023MINIAOD13.0', 'NANO_data13.0', 'HRV_NANO_data']] +_wfn.subnext() +workflows[_wfn()] = ['NANOmc23Mini2Mini', ['TTbarMINIAOD13.0', 'M2M_mc13.0', 'NANO_mc_reMINI', 'HRV3_NANO_mc']] + # POG/PAG custom NANOs, MC _wfn.subnext() @@ -528,11 +552,11 @@ def next(self, index: int = None) -> None: # MINIv6+NANOv15, MC _wfn.subnext() -workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV3_NANO_mc']] # noqa # MINIv6+NANOv15, data _wfn.subnext() -workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV3_NANO_data']] # noqa _wfn.next(3) ######## 2500.3xxx ######## From c0069ea3a56e10b31cd8c227a0caf397c480377c Mon Sep 17 00:00:00 2001 From: jean-roch Date: Fri, 10 Oct 2025 00:41:10 +0200 Subject: [PATCH 20/24] remove irrelevant tests as per @ftorrresd --- Configuration/PyReleaseValidation/python/relval_nano.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index d07ec6358820e..ede86142a0346 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -456,11 +456,6 @@ def next(self, index: int = None) -> None: # Run2, 10_6_X AOD, reMINI+reNANO _wfn.subnext() -workflows[_wfn()] = ['NANOmcPreUL16APVreMINI', ['TTbar_13_reminiaod2016UL_preVFP_INPUT', 'REMINIAOD_mc2016UL_preVFP', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcPreUL16reMINI', ['TTbar_13_reminiaod2016UL_postVFP_INPUT', 'REMINIAOD_mc2016UL_postVFP', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcPreUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcPreUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa - workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] From 18c67c3f2c718197439c619f3167ad89cc1860ca Mon Sep 17 00:00:00 2001 From: jean-roch Date: Fri, 10 Oct 2025 01:18:03 +0200 Subject: [PATCH 21/24] add Mini from mini workflows for run2 UL data --- Configuration/PyReleaseValidation/python/relval_nano.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index ede86142a0346..c45138058b1fa 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -138,12 +138,14 @@ def next(self, index: int = None) -> None: # HIPM_UL2016_MiniAODv2 campaign is CMSSW_10_6_25 steps['MuonEG2016MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2016E-HIPM_UL2016_MiniAODv2-v2/MINIAOD')} +steps['M2M_data10.6ul16'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) steps['NANO_data10.6ul16v2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) # UL2017_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2017MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2017F-UL2017_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul17'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) steps['NANO_data10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -151,6 +153,7 @@ def next(self, index: int = None) -> None: # UL2018_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2018MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2018D-UL2018_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul18'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) steps['NANO_data10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -473,9 +476,10 @@ def next(self, index: int = None) -> None: workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] - _wfn.subnext() -## M2M for data +workflows[_wfn()] = ['NANOdataUL16Mini2Mini', ['MuonEG2016MINIAOD10.6v2', 'M2M_data10.6ul16', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL17Mini2Mini', ['MuonEG2017MINIAOD10.6v2', 'M2M_data10.6ul17', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL18Mini2Mini', ['MuonEG2018MINIAOD10.6v2', 'M2M_data10.6ul18', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] _wfn.next(1) ######## 2500.1xxx ######## From 6e062cfd73d7c14af14aef079f6e716ebb7472c2 Mon Sep 17 00:00:00 2001 From: jean-roch Date: Fri, 10 Oct 2025 01:41:41 +0200 Subject: [PATCH 22/24] MIMI typo --- .../PyReleaseValidation/python/relval_nano.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index c45138058b1fa..341e7684a229f 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -81,9 +81,9 @@ def next(self, index: int = None) -> None: _HARVEST_mc = merge([_HARVEST_nano, {'--mc': ''}]) ## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF ## the dqm sequence DQM:@miniAODDQM will not function on M2M, because it requires AOD-bound collections TBF -#_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', +#_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', # '--process': 'M2M'} -_MIMI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask', +_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask', '--eventcontent' : 'MINIAODSIM', '--datatier' : 'MINIAODSIM', '--process': 'M2M'} @@ -99,7 +99,7 @@ def next(self, index: int = None) -> None: steps['TTbarAOD10.6_UL16APV'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECOAPV-106X_mcRun2_asymptotic_preVFP_v8-v2/AODSIM')} steps['MINI_mc10.6ul16APV'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_preVFP']]) -steps['M2M_mc10.6ul16APV'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16APV']]) +steps['M2M_mc10.6ul16APV'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16APV']]) steps['TTbarMINIAOD10.6_UL16APVv2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODAPVv2-106X_mcRun2_asymptotic_preVFP_v11-v2/MINIAODSIM')} steps['NANO_mc10.6ul16APVv2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', @@ -108,7 +108,7 @@ def next(self, index: int = None) -> None: steps['TTbarAOD10.6_UL16'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECO-106X_mcRun2_asymptotic_v13-v2/AODSIM')} steps['MINI_mc10.6ul16'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_postVFP']]) -steps['M2M_mc10.6ul16'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16']]) +steps['M2M_mc10.6ul16'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16']]) steps['TTbarMINIAOD10.6_UL16v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODv2-106X_mcRun2_asymptotic_v17-v2/MINIAODSIM')} steps['NANO_mc10.6ul16v2'] = merge([{'--era': 'Run2_2016,run2_nanoAOD_106Xv2', @@ -118,7 +118,7 @@ def next(self, index: int = None) -> None: steps['TTbarAOD10.6_UL17'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17RECO-106X_mc2017_realistic_v6-v2/AODSIM')} steps['MINI_mc10.6ul17'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2017UL']]) -steps['M2M_mc10.6ul17'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul17']]) +steps['M2M_mc10.6ul17'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul17']]) steps['TTbarMINIAOD10.6_UL17v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17MiniAODv2-106X_mc2017_realistic_v9-v2/MINIAODSIM')} steps['NANO_mc10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', @@ -128,7 +128,7 @@ def next(self, index: int = None) -> None: steps['TTbarAOD10.6_UL18'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18RECO-106X_upgrade2018_realistic_v11_L1v1-v2/AODSIM')} steps['MINI_mc10.6ul18'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2018UL']]) -steps['M2M_mc10.6ul18'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul18']]) +steps['M2M_mc10.6ul18'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul18']]) steps['TTbarMINIAOD10.6_UL18v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18MiniAODv2-106X_upgrade2018_realistic_v16_L1v1-v2/MINIAODSIM')} steps['NANO_mc10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', @@ -138,14 +138,14 @@ def next(self, index: int = None) -> None: # HIPM_UL2016_MiniAODv2 campaign is CMSSW_10_6_25 steps['MuonEG2016MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2016E-HIPM_UL2016_MiniAODv2-v2/MINIAOD')} -steps['M2M_data10.6ul16'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) +steps['M2M_data10.6ul16'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) steps['NANO_data10.6ul16v2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) # UL2017_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2017MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2017F-UL2017_MiniAODv2-v1/MINIAOD')} -steps['M2M_data10.6ul17'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) +steps['M2M_data10.6ul17'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) steps['NANO_data10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -153,7 +153,7 @@ def next(self, index: int = None) -> None: # UL2018_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2018MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2018D-UL2018_MiniAODv2-v1/MINIAOD')} -steps['M2M_data10.6ul18'] = merge([_MIMI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) +steps['M2M_data10.6ul18'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) steps['NANO_data10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) From 514a8cabfbefc74e3a5cfef9ddd5e7e11010c78d Mon Sep 17 00:00:00 2001 From: jean-roch Date: Fri, 10 Oct 2025 01:42:34 +0200 Subject: [PATCH 23/24] add 23 data Mini to Mini, rename step for Summer23 --- .../PyReleaseValidation/python/relval_nano.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index 341e7684a229f..640a7568aa049 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -191,12 +191,12 @@ def next(self, index: int = None) -> None: # 13.0 workflows steps['TTbarMINIAOD13.0'] = {'INPUT': InputInfo( location='STD', dataSet='/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer23MiniAODv4-130X_mcRun3_2023_realistic_v14-v2/MINIAODSIM')} -steps['M2M_mc13.0'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic', '--procModifier': 'run3_miniAOD_miniAODpre142X'}, +steps['M2M_mc13.0s23'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic', '--procModifier': 'run3_miniAOD_miniAODpre142X'}, steps['M2M_mc10.6ul18']]) steps['NANO_mc13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:phase1_2023_realistic'}, _NANO_mc]) ## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD -steps['NANO_mc_reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'}, +steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'}, _NANO_mc]) #steps['NANO_mc_S22reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT # _NANO_mc]) @@ -214,10 +214,11 @@ def next(self, index: int = None) -> None: steps['ScoutingPFRun32022RAW13.0'] = {'INPUT': InputInfo( dataSet='/ScoutingPFRun3/Run2022D-v1/RAW', label='2022D', events=100000, location='STD', ls=Run2022D)} - +steps['M2M_data13.0'] = merge([_MINI_from_MINI, {'--era': 'Run3', '--conditions': 'auto:run3_data', '--procModifier': 'run3_miniAOD_miniAODpre142X'}]) steps['NANO_data13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, _NANO_data]) - +steps['NANO_data_23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:run3_data'}, + _NANO_data]) steps['NANO_data13.0_prompt'] = merge([{'-s': 'NANO:@Prompt,DQM:@nanoAODDQM', '-n': '1000'}, steps['NANO_data13.0']]) @@ -490,7 +491,10 @@ def next(self, index: int = None) -> None: workflows[_wfn()] = ['NANOdata130Xrun3', ['MuonEG2023MINIAOD13.0', 'NANO_data13.0', 'HRV_NANO_data']] _wfn.subnext() -workflows[_wfn()] = ['NANOmc23Mini2Mini', ['TTbarMINIAOD13.0', 'M2M_mc13.0', 'NANO_mc_reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmc23Mini2Mini', ['TTbarMINIAOD13.0', 'M2M_mc13.0s23', 'NANO_mc_S23reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdata23Mini2Mini', ['MuonEG2023MINIAOD13.0', 'M2M_data13.0', 'NANO_data_23reMINI', 'HRV3_NANO_data']] # POG/PAG custom NANOs, MC _wfn.subnext() From 8e9096d6848a9b3700f1ee53fee3672b5bebd9af Mon Sep 17 00:00:00 2001 From: jean-roch Date: Tue, 14 Oct 2025 22:06:03 +0200 Subject: [PATCH 24/24] use --data option and MINIAOD when it comes to data. --- .../PyReleaseValidation/python/relval_nano.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index 5505c0766afb7..4a77aa9f11379 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -87,6 +87,10 @@ def next(self, index: int = None) -> None: '--eventcontent' : 'MINIAODSIM', '--datatier' : 'MINIAODSIM', '--process': 'M2M'} +_MINI_from_MINI_data = merge([{'--data': '', + '--eventcontent' : 'MINIAOD', + '--datatier' : 'MINIAOD'}, + _MINI_from_MINI]) steps['HRV_NANO_mc'] = _HARVEST_mc steps['HRV3_NANO_mc'] = merge([{'--filein':'file:step3_inDQM.root'}, _HARVEST_mc]) @@ -138,14 +142,14 @@ def next(self, index: int = None) -> None: # HIPM_UL2016_MiniAODv2 campaign is CMSSW_10_6_25 steps['MuonEG2016MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2016E-HIPM_UL2016_MiniAODv2-v2/MINIAOD')} -steps['M2M_data10.6ul16'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) +steps['M2M_data10.6ul16'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) steps['NANO_data10.6ul16v2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) # UL2017_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2017MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2017F-UL2017_MiniAODv2-v1/MINIAOD')} -steps['M2M_data10.6ul17'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) +steps['M2M_data10.6ul17'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) steps['NANO_data10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -153,7 +157,7 @@ def next(self, index: int = None) -> None: # UL2018_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2018MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2018D-UL2018_MiniAODv2-v1/MINIAOD')} -steps['M2M_data10.6ul18'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) +steps['M2M_data10.6ul18'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) steps['NANO_data10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -234,7 +238,7 @@ def next(self, index: int = None) -> None: steps['ScoutingPFMonitor_Run2023D_RAW_130X'] = {'INPUT': InputInfo( dataSet='/ScoutingPFMonitor/Run2023D-v1/RAW', label='2023D', events=100000, location='STD', ls=Run2023D)} -steps['M2M_data13.0'] = merge([_MINI_from_MINI, {'--era': 'Run3', '--conditions': 'auto:run3_data', '--procModifier': 'run3_miniAOD_miniAODpre142X'}]) +steps['M2M_data13.0'] = merge([_MINI_from_MINI_data, {'--era': 'Run3', '--conditions': 'auto:run3_data', '--procModifier': 'run3_miniAOD_miniAODpre142X'}]) steps['NANO_data13.0'] = merge([{'--era': 'Run3_2023,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, _NANO_data]) steps['NANO_data_23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:run3_data'},