PUPPI jets in RECO

CommonTools/PileupAlgos/plugins/PuppiProducer.cc

@@ -41,21 +41,22 @@ PuppiProducer::PuppiProducer(const edm::ParameterSet& iConfig) {
   tokenPFCandidates_ = consumes<CandidateView>(iConfig.getParameter<edm::InputTag>("candName"));
   tokenVertices_ = consumes<VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexName"));
 
-  produces<edm::ValueMap<float>>();
-  produces<edm::ValueMap<LorentzVector>>();
-  produces<edm::ValueMap<reco::CandidatePtr>>();
+  ptokenPupOut_ = produces<edm::ValueMap<float>>();
+  ptokenP4PupOut_ = produces<edm::ValueMap<LorentzVector>>();
+  ptokenValues_ = produces<edm::ValueMap<reco::CandidatePtr>>();
 
   if (fUseExistingWeights || fClonePackedCands)
-    produces<pat::PackedCandidateCollection>();
-  else
-    produces<reco::PFCandidateCollection>();
+    ptokenPackedPuppiCandidates_ = produces<pat::PackedCandidateCollection>();
+  else {
+    ptokenPuppiCandidates_ = produces<reco::PFCandidateCollection>();
+  }
 
   if (fPuppiDiagnostics) {
-    produces<double>("PuppiNAlgos");
-    produces<std::vector<double>>("PuppiRawAlphas");
-    produces<std::vector<double>>("PuppiAlphas");
-    produces<std::vector<double>>("PuppiAlphasMed");
-    produces<std::vector<double>>("PuppiAlphasRms");
+    ptokenNalgos_ = produces<double>("PuppiNAlgos");
+    ptokenRawAlphas_ = produces<std::vector<double>>("PuppiRawAlphas");
+    ptokenAlphas_ = produces<std::vector<double>>("PuppiAlphas");
+    ptokenAlphasMed_ = produces<std::vector<double>>("PuppiAlphasMed");
+    ptokenAlphasRms_ = produces<std::vector<double>>("PuppiAlphasRms");
   }
 }
 // ------------------------------------------------------------------------------------------
@@ -238,8 +239,8 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   }
 
   //Fill it into the event
-  std::unique_ptr<edm::ValueMap<float>> lPupOut(new edm::ValueMap<float>());
-  edm::ValueMap<float>::Filler lPupFiller(*lPupOut);
+  edm::ValueMap<float> lPupOut;
+  edm::ValueMap<float>::Filler lPupFiller(lPupOut);
   lPupFiller.insert(hPFProduct, lWeights.begin(), lWeights.end());
   lPupFiller.fill();
 
@@ -252,9 +253,10 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   // Since the size of the ValueMap must be equal to the input collection, we need
   // to search the "puppi" particles to find a match for each input. If none is found,
   // the input is set to have a four-vector of 0,0,0,0
-  fPuppiCandidates.reset(new PFOutputCollection);
-  fPackedPuppiCandidates.reset(new PackedOutputCollection);
-  std::unique_ptr<edm::ValueMap<LorentzVector>> p4PupOut(new edm::ValueMap<LorentzVector>());
+  PFOutputCollection fPuppiCandidates;
+  PackedOutputCollection fPackedPuppiCandidates;
+
+  edm::ValueMap<LorentzVector> p4PupOut;
   LorentzVectorCollection puppiP4s;
   std::vector<reco::CandidatePtr> values(hPFProduct->size());
 
@@ -263,6 +265,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
     ++iCand;
     std::unique_ptr<pat::PackedCandidate> pCand;
     std::unique_ptr<reco::PFCandidate> pfCand;
+
     if (fUseExistingWeights || fClonePackedCands) {
       const pat::PackedCandidate* cand = dynamic_cast<const pat::PackedCandidate*>(&aCand);
       if (!cand)
@@ -274,6 +277,7 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
       pfCand.reset(new reco::PFCandidate(cand ? *cand : reco::PFCandidate(aCand.charge(), aCand.p4(), id)));
     }
 
+    // Here, we are using new weights computed and putting them in the packed candidates.
     if (fClonePackedCands && (!fUseExistingWeights)) {
       if (fPuppiForLeptons)
         pCand->setPuppiWeight(pCand->puppiWeight(), lWeights[iCand]);
@@ -286,58 +290,62 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
                           lWeights[iCand] * aCand.pz(),
                           lWeights[iCand] * aCand.energy());
 
+    // Here, we are using existing weights, or we're using packed candidates.
+    // That is, whether or not we recomputed the weights, we store the
+    // source candidate appropriately, and set the p4 of the packed candidate.
     if (fUseExistingWeights || fClonePackedCands) {
       pCand->setP4(puppiP4s.back());
       pCand->setSourceCandidatePtr(aCand.sourceCandidatePtr(0));
-      fPackedPuppiCandidates->push_back(*pCand);
+      fPackedPuppiCandidates.push_back(*pCand);
     } else {
       pfCand->setP4(puppiP4s.back());
       pfCand->setSourceCandidatePtr(aCand.sourceCandidatePtr(0));
-      fPuppiCandidates->push_back(*pfCand);
+      fPuppiCandidates.push_back(*pfCand);
     }
   }
 
   //Compute the modified p4s
-  edm::ValueMap<LorentzVector>::Filler p4PupFiller(*p4PupOut);
+  edm::ValueMap<LorentzVector>::Filler p4PupFiller(p4PupOut);
   p4PupFiller.insert(hPFProduct, puppiP4s.begin(), puppiP4s.end());
   p4PupFiller.fill();
 
-  iEvent.put(std::move(lPupOut));
-  iEvent.put(std::move(p4PupOut));
+  iEvent.emplace(ptokenPupOut_, lPupOut);
+  iEvent.emplace(ptokenP4PupOut_, p4PupOut);
   if (fUseExistingWeights || fClonePackedCands) {
-    edm::OrphanHandle<pat::PackedCandidateCollection> oh = iEvent.put(std::move(fPackedPuppiCandidates));
+    edm::OrphanHandle<pat::PackedCandidateCollection> oh =
+        iEvent.emplace(ptokenPackedPuppiCandidates_, fPackedPuppiCandidates);
     for (unsigned int ic = 0, nc = oh->size(); ic < nc; ++ic) {
       reco::CandidatePtr pkref(oh, ic);
       values[ic] = pkref;
     }
   } else {
-    edm::OrphanHandle<reco::PFCandidateCollection> oh = iEvent.put(std::move(fPuppiCandidates));
+    edm::OrphanHandle<reco::PFCandidateCollection> oh = iEvent.emplace(ptokenPuppiCandidates_, fPuppiCandidates);
     for (unsigned int ic = 0, nc = oh->size(); ic < nc; ++ic) {
       reco::CandidatePtr pkref(oh, ic);
       values[ic] = pkref;
     }
   }
-  std::unique_ptr<edm::ValueMap<reco::CandidatePtr>> pfMap_p(new edm::ValueMap<reco::CandidatePtr>());
-  edm::ValueMap<reco::CandidatePtr>::Filler filler(*pfMap_p);
+  edm::ValueMap<reco::CandidatePtr> pfMap_p;
+  edm::ValueMap<reco::CandidatePtr>::Filler filler(pfMap_p);
   filler.insert(hPFProduct, values.begin(), values.end());
   filler.fill();
-  iEvent.put(std::move(pfMap_p));
+  iEvent.emplace(ptokenValues_, pfMap_p);
 
   //////////////////////////////////////////////
   if (fPuppiDiagnostics && !fUseExistingWeights) {
     // all the different alphas per particle
     // THE alpha per particle
-    std::unique_ptr<std::vector<double>> theAlphas(new std::vector<double>(fPuppiContainer->puppiAlphas()));
-    std::unique_ptr<std::vector<double>> theAlphasMed(new std::vector<double>(fPuppiContainer->puppiAlphasMed()));
-    std::unique_ptr<std::vector<double>> theAlphasRms(new std::vector<double>(fPuppiContainer->puppiAlphasRMS()));
-    std::unique_ptr<std::vector<double>> alphas(new std::vector<double>(fPuppiContainer->puppiRawAlphas()));
-    std::unique_ptr<double> nalgos(new double(fPuppiContainer->puppiNAlgos()));
+    std::vector<double> theAlphas(fPuppiContainer->puppiAlphas());
+    std::vector<double> theAlphasMed(fPuppiContainer->puppiAlphasMed());
+    std::vector<double> theAlphasRms(fPuppiContainer->puppiAlphasRMS());
+    std::vector<double> alphas(fPuppiContainer->puppiRawAlphas());
+    double nalgos(fPuppiContainer->puppiNAlgos());
 
-    iEvent.put(std::move(alphas), "PuppiRawAlphas");
-    iEvent.put(std::move(nalgos), "PuppiNAlgos");
-    iEvent.put(std::move(theAlphas), "PuppiAlphas");
-    iEvent.put(std::move(theAlphasMed), "PuppiAlphasMed");
-    iEvent.put(std::move(theAlphasRms), "PuppiAlphasRms");
+    iEvent.emplace(ptokenRawAlphas_, alphas);
+    iEvent.emplace(ptokenNalgos_, nalgos);
+    iEvent.emplace(ptokenAlphas_, theAlphas);
+    iEvent.emplace(ptokenAlphasMed_, theAlphasMed);
+    iEvent.emplace(ptokenAlphasRms_, theAlphasRms);
   }
 }
 

CommonTools/PileupAlgos/plugins/PuppiProducer.h

@@ -42,6 +42,19 @@ class PuppiProducer : public edm::stream::EDProducer<> {
 
   edm::EDGetTokenT<CandidateView> tokenPFCandidates_;
   edm::EDGetTokenT<VertexCollection> tokenVertices_;
+  edm::EDGetTokenT<PuppiContainer> tokenPuppiContainer_;
+  edm::EDGetTokenT<PFOutputCollection> tokenPuppiCandidates_;
+  edm::EDGetTokenT<PackedOutputCollection> tokenPackedPuppiCandidates_;
+  edm::EDPutTokenT<edm::ValueMap<float>> ptokenPupOut_;
+  edm::EDPutTokenT<edm::ValueMap<LorentzVector>> ptokenP4PupOut_;
+  edm::EDPutTokenT<edm::ValueMap<reco::CandidatePtr>> ptokenValues_;
+  edm::EDPutTokenT<pat::PackedCandidateCollection> ptokenPackedPuppiCandidates_;
+  edm::EDPutTokenT<reco::PFCandidateCollection> ptokenPuppiCandidates_;
+  edm::EDPutTokenT<double> ptokenNalgos_;
+  edm::EDPutTokenT<std::vector<double>> ptokenRawAlphas_;
+  edm::EDPutTokenT<std::vector<double>> ptokenAlphas_;
+  edm::EDPutTokenT<std::vector<double>> ptokenAlphasMed_;
+  edm::EDPutTokenT<std::vector<double>> ptokenAlphasRms_;
   std::string fPuppiName;
   std::string fPFName;
   std::string fPVName;
@@ -61,7 +74,5 @@ class PuppiProducer : public edm::stream::EDProducer<> {
   double fVtxZCut;
   std::unique_ptr<PuppiContainer> fPuppiContainer;
   std::vector<RecoObj> fRecoObjCollection;
-  std::unique_ptr<PFOutputCollection> fPuppiCandidates;
-  std::unique_ptr<PackedOutputCollection> fPackedPuppiCandidates;
 };
 #endif

DQM/Physics/python/B2GDQM_cfi.py

@@ -13,10 +13,9 @@
 
     jetLabels = cms.VInputTag(
         'ak4PFJets',
-        'ak4PFJetsCHS',
-        'ak8PFJetsCHS',
-        'ak8PFJetsCHSSoftDrop',
-        'cmsTopTagPFJetsCHS'
+        'ak4PFJetsPuppi',
+        'ak8PFJetsPuppi',
+        'ak8PFJetsPuppiSoftDrop'
         ),
     jetPtMins = cms.vdouble(
         50.,
@@ -27,11 +26,11 @@
         ),
     pfMETCollection          = cms.InputTag("pfMet"),
 
-    cmsTagLabel = cms.InputTag("cmsTopTagPFJetsCHS"),
+    sdjetLabel = cms.InputTag("ak8PFJetsPuppiSoftDrop"),
     muonSrc = cms.InputTag("muons"),
     electronSrc = cms.InputTag("gedGsfElectrons"),
 
-    allHadPtCut = cms.double(400.0),
+    allHadPtCut = cms.double(380.0),             # Edit in 2019: Lower pt cut slightly because this now selects groomed jet pt
     allHadRapidityCut = cms.double(1.0),
     allHadDeltaPhiCut = cms.double( pi / 2.0),
 

DQM/Physics/python/ExoticaDQM_cfi.py

@@ -19,7 +19,7 @@
     pfJetCollection          = cms.InputTag('ak4PFJetsCHS'),
     jetCorrector             = cms.InputTag('ak4PFL1FastL2L3Corrector'),
 
-    DiJetPFJetCollection     = cms.VInputTag('ak4PFJetsCHS','ak8PFJetsCHS'),
+    DiJetPFJetCollection     = cms.VInputTag('ak4PFJetsCHS','ak8PFJetsPuppi'),
 
     caloMETCollection        = cms.InputTag("caloMetM"),
     pfMETCollection          = cms.InputTag("pfMet"),