diff --git a/RecoJets/JetPlusTracks/plugins/BuildFile.xml b/RecoJets/JetPlusTracks/plugins/BuildFile.xml
index 1c95307fa4c2e..05f892cd2eff8 100644
--- a/RecoJets/JetPlusTracks/plugins/BuildFile.xml
+++ b/RecoJets/JetPlusTracks/plugins/BuildFile.xml
@@ -1,16 +1,25 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc
new file mode 100644
index 0000000000000..2c916fae06a36
--- /dev/null
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc
@@ -0,0 +1,204 @@
+// -*- C++ -*-
+//
+// Package: JetPlusTracks
+// Class: JetPlusTrackProducer
+//
+/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc
+
+ Description: [one line class summary]
+
+ Implementation:
+ [Notes on implementation]
+*/
+//
+// Original Author: Olga Kodolova,40 R-A12,+41227671273,
+// Created: Fri Feb 19 10:14:02 CET 2010
+//
+//
+
+// system include files
+#include
+
+// user include files
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include "RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h"
+#include "DataFormats/JetReco/interface/CaloJetCollection.h"
+#include "DataFormats/JetReco/interface/CaloJet.h"
+#include "DataFormats/JetReco/interface/JPTJetCollection.h"
+#include "DataFormats/JetReco/interface/JPTJet.h"
+#include "DataFormats/JetReco/interface/TrackJetCollection.h"
+#include "DataFormats/JetReco/interface/TrackJet.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/JetReco/interface/Jet.h"
+#include "DataFormats/VertexReco/interface/VertexFwd.h"
+#include "DataFormats/VertexReco/interface/Vertex.h"
+#include "DataFormats/Math/interface/deltaPhi.h"
+#include "DataFormats/Math/interface/deltaR.h"
+
+#include
+
+using namespace std;
+
+//
+// constants, enums and typedefs
+//
+
+//
+// static data member definitions
+//
+
+//
+// constructors and destructor
+//
+JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::ParameterSet& iConfig) {
+ //register your products
+ srcCaloJets = iConfig.getParameter("srcCaloJets");
+ srcTrackJets = iConfig.getParameter("srcTrackJets");
+ srcPVs_ = iConfig.getParameter("srcPVs");
+ ptCUT = iConfig.getParameter("ptCUT");
+ dRcone = iConfig.getParameter("dRcone");
+ usePAT = iConfig.getParameter("UsePAT");
+
+ produces("ak4CaloJetsJPTSeed");
+
+ input_jets_token_ = consumes >(srcCaloJets);
+ input_trackjets_token_ = consumes >(srcTrackJets);
+ input_vertex_token_ = consumes(srcPVs_);
+ tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates"));
+ input_ctw_token_ = consumes(iConfig.getParameter("towerMaker"));
+}
+
+JetPlusTrackAddonSeedProducer::~JetPlusTrackAddonSeedProducer() {
+ // do anything here that needs to be done at desctruction time
+ // (e.g. close files, deallocate resources etc.)
+}
+
+//
+// member functions
+//
+
+// ------------ method called to produce the data ------------
+void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
+ using namespace edm;
+ // get stuff from Event
+ edm::Handle > jets_h;
+ iEvent.getByToken(input_jets_token_, jets_h);
+
+ edm::Handle > jetsTrackJets;
+ iEvent.getByToken(input_trackjets_token_, jetsTrackJets);
+
+ auto pCaloOut = std::make_unique();
+
+ if (jetsTrackJets.isValid()) {
+ if (!jetsTrackJets->empty()) {
+ for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) {
+ const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet)));
+ int iflag = 0;
+ for (unsigned i = 0; i < jets_h->size(); ++i) {
+ const reco::CaloJet* oldjet = &(*(jets_h->refAt(i)));
+ double dr = deltaR(jet->eta(), jet->phi(), oldjet->eta(), oldjet->phi());
+ if (dr < dRcone)
+ iflag = 1;
+ } // Calojets
+
+ if (iflag == 1)
+ continue;
+ double caloen = 0.;
+ double hadinho = 0.;
+ double hadinhb = 0.;
+ double hadinhe = 0.;
+ double hadinhf = 0.;
+ double emineb = 0.;
+ double eminee = 0.;
+ double eminhf = 0.;
+ double eefraction = 0.;
+ double hhfraction = 0.;
+ int ncand = 0;
+
+ if (usePAT) {
+ edm::Handle pfCandidates;
+ iEvent.getByToken(tokenPFCandidates_, pfCandidates);
+ if (!pfCandidates.isValid()) {
+ return;
+ } else {
+ for (unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) {
+ const pat::PackedCandidate& pf = (*pfCandidates)[i];
+ double dr = deltaR(jet->eta(), jet->phi(), pf.eta(), pf.phi());
+ if (dr > dRcone)
+ continue;
+ // jetconstit
+ caloen = caloen + pf.energy() * pf.caloFraction();
+ hadinho += 0.;
+ if (fabs(pf.eta()) <= 1.4)
+ hadinhb += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+ if (fabs(pf.eta()) < 3. && (fabs(pf.eta()) > 3.) > 1.4)
+ hadinhe += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+ if (fabs(pf.eta()) >= 3.)
+ hadinhf += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+ if (fabs(pf.eta()) <= 1.4)
+ emineb += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+ if (fabs(pf.eta()) < 3. && (fabs(pf.eta()) > 3.) > 1.4)
+ eminee += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+ if (fabs(pf.eta()) >= 3.)
+ eminhf += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+ ncand++;
+ } // Calojet
+ }
+ } else {
+ edm::Handle ct;
+ iEvent.getByToken(input_ctw_token_, ct);
+ if (ct.isValid()) {
+ for (CaloTowerCollection::const_iterator it = ct->begin(); it != ct->end(); it++) {
+ double dr = deltaR(jet->eta(), jet->phi(), (*it).eta(), (*it).phi());
+ if (dr > dRcone)
+ continue;
+ caloen = caloen + (*it).energy();
+ hadinho += (*it).energyInHO();
+ hadinhb += (*it).energyInHB();
+ hadinhe += (*it).energyInHE();
+ hadinhf += 0.5 * (*it).energyInHF();
+ emineb += (*it).energy() - (*it).energyInHB();
+ eminee += (*it).energy() - (*it).energyInHE();
+ eminhf += 0.5 * (*it).energyInHF();
+ ncand++;
+ }
+ }
+ }
+ eefraction = (emineb + eminee) / caloen;
+ hhfraction = (hadinhb + hadinhe + hadinhf + hadinho) / caloen;
+
+ double trackp = sqrt(pow(jet->pt(), 2) + pow(jet->pz(), 2));
+ if (caloen <= 0.)
+ caloen = 0.001;
+ math::XYZTLorentzVector pcalo4(
+ caloen * jet->px() / trackp, caloen * jet->py() / trackp, caloen * jet->pz() / trackp, caloen);
+ reco::CaloJet::Specific calospe;
+ calospe.mTowersArea = -1 * ncand;
+ calospe.mHadEnergyInHO = hadinho;
+ calospe.mHadEnergyInHB = hadinhb;
+ calospe.mHadEnergyInHE = hadinhe;
+ calospe.mHadEnergyInHF = hadinhf;
+ calospe.mEmEnergyInEB = emineb;
+ calospe.mEmEnergyInEE = eminee;
+ calospe.mEmEnergyInHF = eminhf;
+ calospe.mEnergyFractionEm = eefraction / caloen;
+ calospe.mEnergyFractionHadronic = hhfraction / caloen;
+
+ reco::CaloJet mycalo(pcalo4, jet->primaryVertex()->position(), calospe);
+ mycalo.setJetArea(M_PI * dRcone * dRcone);
+ pCaloOut->push_back(mycalo);
+
+ } // trackjets
+ } // jets
+ } // There is trackjet collection
+
+ iEvent.put(std::move(pCaloOut), "ak4CaloJetsJPTSeed");
+}
+
+//define this as a plug-in
+DEFINE_FWK_MODULE(JetPlusTrackAddonSeedProducer);
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h
new file mode 100644
index 0000000000000..786d05d5f459a
--- /dev/null
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.h
@@ -0,0 +1,67 @@
+// -*- C++ -*-
+//
+// Package: JetPlusTracks
+// Class: JetPlusTrackProducer
+//
+/**\class JetPlusTrackProducer JetPlusTrackProducer.cc JetPlusTrackProducer.cc
+
+ Description: [one line class summary]
+
+ Implementation:
+ [Notes on implementation]
+*/
+//
+// Original Author: Olga Kodolova,40 R-A12,+41227671273,
+// Created: Fri Feb 19 10:14:02 CET 2010
+//
+//
+
+// system include files
+#include
+
+// user include files
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include "DataFormats/JetReco/interface/CaloJet.h"
+#include "DataFormats/JetReco/interface/TrackJet.h"
+#include "DataFormats/VertexReco/interface/Vertex.h"
+#include "DataFormats/JetReco/interface/TrackExtrapolation.h"
+#include "DataFormats/PatCandidates/interface/Electron.h"
+#include "DataFormats/PatCandidates/interface/Jet.h"
+#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
+#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
+#include "DataFormats/PatCandidates/interface/VIDCutFlowResult.h"
+#include "DataFormats/PatCandidates/interface/Muon.h"
+
+#include
+
+//
+// class declaration
+//
+
+class JetPlusTrackAddonSeedProducer : public edm::stream::EDProducer<> {
+public:
+ explicit JetPlusTrackAddonSeedProducer(const edm::ParameterSet&);
+ ~JetPlusTrackAddonSeedProducer() override;
+ void produce(edm::Event&, const edm::EventSetup&) override;
+
+ // ---------- private data members ---------------------------
+private:
+ edm::InputTag srcCaloJets;
+ edm::InputTag srcTrackJets;
+ edm::InputTag srcPVs_;
+
+ std::string alias;
+ double ptCUT;
+ double dRcone;
+ bool usePAT;
+ edm::EDGetTokenT > input_jets_token_;
+ edm::EDGetTokenT > input_trackjets_token_;
+ edm::EDGetTokenT input_vertex_token_;
+ edm::EDGetTokenT > tokenPFCandidates_;
+ edm::EDGetTokenT input_ctw_token_;
+};
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc
index d5177e8b9e7a4..b887b182a2614 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc
@@ -9,6 +9,8 @@
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/Math/interface/deltaPhi.h"
+#include "DataFormats/Math/interface/deltaR.h"
#include
#include
#include
@@ -21,6 +23,7 @@ using namespace jpt;
//
JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC)
: verbose_(pset.getParameter("Verbose")),
+ usereco_(pset.getParameter("UseReco")),
vectorial_(pset.getParameter("VectorialCorrection")),
vecResponse_(pset.getParameter("UseResponseInVecCorr")),
useInConeTracks_(pset.getParameter("UseInConeTracks")),
@@ -40,10 +43,16 @@ JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm:
muons_(pset.getParameter("Muons")),
electrons_(pset.getParameter("Electrons")),
electronIds_(pset.getParameter("ElectronIds")),
+ patmuons_(pset.getParameter("PatMuons")),
+ patelectrons_(pset.getParameter("PatElectrons")),
trackQuality_(reco::TrackBase::qualityByName(pset.getParameter("TrackQuality"))),
response_(Map(pset.getParameter("ResponseMap"), verbose_)),
efficiency_(Map(pset.getParameter("EfficiencyMap"), verbose_)),
leakage_(Map(pset.getParameter("LeakageMap"), verbose_)),
+ muonPtmatch_(pset.getParameter("muonPtmatch")),
+ muonEtamatch_(pset.getParameter("muonEtamatch")),
+ muonPhimatch_(pset.getParameter("muonPhimatch")),
+ electronDRmatch_(pset.getParameter("electronDRmatch")),
pionMass_(0.140),
muonMass_(0.105),
elecMass_(0.000511),
@@ -90,15 +99,54 @@ JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm:
input_jetTracksAtVertex_token_ = iC.consumes(jetTracksAtVertex_);
input_jetTracksAtCalo_token_ = iC.consumes(jetTracksAtCalo_);
- inut_reco_muons_token_ = iC.consumes(muons_);
input_pvCollection_token_ = iC.consumes(srcPVs_);
+
+ input_reco_muons_token_ = iC.consumes(muons_);
input_reco_elecs_token_ = iC.consumes(electrons_);
input_reco_elec_ids_token_ = iC.consumes(electronIds_);
+
+ input_pat_muons_token_ = iC.consumes(patmuons_);
+ input_pat_elecs_token_ = iC.consumes(patelectrons_);
}
// -----------------------------------------------------------------------------
//
JetPlusTrackCorrector::~JetPlusTrackCorrector() { ; }
+// -----------------------------------------------------------------------------
+//
+
+double JetPlusTrackCorrector::correction(const reco::Jet& fJet,
+ const reco::Jet& fJetcalo,
+ const edm::Event& event,
+ const edm::EventSetup& setup,
+ const reco::TrackRefVector& tracksinvert,
+ const reco::TrackRefVector& tracksincalo,
+ P4& corrected,
+ MatchedTracks& pions,
+ MatchedTracks& muons,
+ MatchedTracks& elecs) {
+ double scale = 1.;
+ corrected = fJet.p4();
+ bool validMatches = matchTracks(fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs);
+ if (!validMatches) {
+ return 1.;
+ }
+ if (usereco_) {
+ if (usePions_) {
+ corrected += pionCorrection(fJet.p4(), pions);
+ }
+ if (useMuons_) {
+ corrected += muonCorrection(fJet.p4(), muons);
+ }
+ if (useElecs_) {
+ corrected += elecCorrection(fJet.p4(), elecs);
+ }
+ } else {
+ corrected += fJetcalo.p4();
+ }
+ scale = checkScale(fJet.p4(), corrected);
+ return scale;
+}
// -----------------------------------------------------------------------------
//
@@ -135,7 +183,7 @@ double JetPlusTrackCorrector::correction(const reco::Jet& fJet,
return 1.;
}
- // std::cout<<" Jet can be corrected "< 0. ? corrected.Et() / fJet.et() : 1.); // << std::endl
edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
}
+ /*
+ std::cout << " mScale= " << scale
+ << " NewResponse " << corrected.energy()
+ << " Jet energy " << fJet.energy()
+ << " event " << event.id().event() << std::endl;
- // std::cout << " mScale= " << scale
- // << " NewResponse " << corrected.energy()
- // << " Jet energy " << fJet.energy()
- // << " event " << event.id().event() << std::endl;
- /*
std::cout<<" Correction::Corrections for jet "<< theResponseOfChargedWithEff <<" "<<
theResponseOfChargedWithoutEff <<" "<<
theSumPtWithEff <<" "<<
@@ -223,18 +273,37 @@ double JetPlusTrackCorrector::correction(const reco::Particle::LorentzVector& je
// -----------------------------------------------------------------------------
//
+bool JetPlusTrackCorrector::matchTracks(const reco::Jet& fJet,
+ const edm::Event& event,
+ const edm::EventSetup& setup, //@@ required by method in derived class
+ const reco::TrackRefVector& tracksinvert,
+ const reco::TrackRefVector& tracksincalo,
+ jpt::MatchedTracks& pions,
+ jpt::MatchedTracks& muons,
+ jpt::MatchedTracks& elecs) {
+ JetTracks jet_tracks;
+ jet_tracks.vertex_ = tracksinvert;
+ jet_tracks.caloFace_ = tracksincalo;
+ matchTracks(jet_tracks, event, pions, muons, elecs);
+ // std::cout << "JetPlusTracks::Number of tracks:"
+ // << " In-cone at Vertex : " << jet_tracks.vertex_.size()
+ // << " In-cone at CaloFace : " << jet_tracks.caloFace_.size()
+ // << std::endl;
+
+ return true;
+}
+
bool JetPlusTrackCorrector::matchTracks(const reco::Jet& fJet,
const edm::Event& event,
const edm::EventSetup& setup, //@@ required by method in derived class
jpt::MatchedTracks& pions,
jpt::MatchedTracks& muons,
jpt::MatchedTracks& elecs) {
+ // std::cout<<" Start JetPlusTrackCorrector::matchTracks "< jetTracksAtVertex;
event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex);
+ //std::cout<<"JetPlusTrackCorrector::jtaUsingEventData" < jetTracksAtCalo;
event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo);
@@ -338,8 +444,7 @@ bool JetPlusTrackCorrector::jtaUsingEventData(const reco::Jet& fJet, const edm::
excludeJta(fJet, jtC, trks.caloFace_, excluded);
}
- // std::cout<<" JTA:Tracks in vertex "<& reco_muons) const {
- event.getByToken(inut_reco_muons_token_, reco_muons);
+ event.getByToken(input_reco_muons_token_, reco_muons);
+ if (!reco_muons.isValid() || reco_muons.failedToGet()) {
+ edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
+ << " Invalid handle to reco::Muon collection"
+ << " with InputTag (label:instance:process) \"" << muons_.label() << ":"
+ << muons_.instance() << ":" << muons_.process() << "\"";
+ return false;
+ }
+ return true;
+}
+
+bool JetPlusTrackCorrector::getMuons(const edm::Event& event, edm::Handle& reco_muons) const {
+ event.getByToken(input_pat_muons_token_, reco_muons);
if (!reco_muons.isValid() || reco_muons.failedToGet()) {
edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
<< " Invalid handle to reco::Muon collection"
@@ -380,24 +497,43 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
// Get RECO muons
edm::Handle reco_muons;
+ edm::Handle pat_muons;
bool found_reco_muons = true;
+ bool found_pat_muons = true;
if (useMuons_) {
- getMuons(event, reco_muons);
+ if (usereco_) {
+ getMuons(event, reco_muons);
+ } else {
+ getMuons(event, pat_muons);
+ found_reco_muons = false;
+ }
}
// Get RECO electrons and their ids
edm::Handle reco_elecs;
+ edm::Handle pat_elecs;
edm::Handle reco_elec_ids;
bool found_reco_elecs = true;
+ bool found_pat_elecs = true;
if (useElecs_) {
- getElectrons(event, reco_elecs, reco_elec_ids);
+ if (usereco_) {
+ getElectrons(event, reco_elecs, reco_elec_ids);
+ } else {
+ getElectrons(event, pat_elecs);
+ found_reco_elecs = false;
+ }
}
+ // std::cout<<" Found elec/muo "<quality(trackQuality_) && theSumPtForBetaOld <= 0.)
theSumPtForBeta += (**itrk).pt();
@@ -417,8 +553,6 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
const reco::TrackBaseRef ttr1(*itrk);
- // std::cout<<" Size of PV "<size()<::const_iterator rr = find((*iv).tracks_begin(), (*iv).tracks_end(), ttr1);
if (rr != (*iv).tracks_end()) {
itrack_belong++;
- // std::cout<<" Numpv "< 1 && itrack_belong == 0) {
- // std::cout<<" Drop track "<& reco_elecs) const {
+ event.getByToken(input_pat_elecs_token_, reco_elecs);
+ if (!reco_elecs.isValid() || reco_elecs.failedToGet()) {
+ edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
+ << " Invalid handle to reco::GsfElectron collection"
+ << " with InputTag (label:instance:process) \"" << electrons_.label() << ":"
+ << electrons_.instance() << ":" << electrons_.process() << "\"";
+ return false;
+ }
+ return true;
+}
+
// -----------------------------------------------------------------------------
//
bool JetPlusTrackCorrector::failTrackQuality(TrackRefs::const_iterator& itrk) const {
@@ -561,19 +757,27 @@ bool JetPlusTrackCorrector::failTrackQuality(TrackRefs::const_iterator& itrk) co
bool retcode = false;
+ // std::cout<<"JetPlusTrackCorrector::failTrackQuality "<< (*itrk)->quality(trackQuality_)<quality(trackQuality_)) {
+ // std::cout<<" Fail quality cut "<ptError() / (*itrk)->pt()) > ptErrorQuality_) {
+ // std::cout<<" Fail pterr "<<(*itrk)->pt()<<" "<<((*itrk)->ptError()/(*itrk)->pt())<<" "<<
+ // ptErrorQuality_<dz(vertex_)) > dzVertexCut_) {
+ //std::cout<<" Fail dz "<dz(vertex_))<<" "<innerTrack()) {
+ if (*itrk == imuon->innerTrack())
+ return true;
+ }
+
+ return false;
+}
+
+bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk,
+ const edm::Handle& muons) const {
+ if (muons->empty()) {
+ return false;
+ }
+
+ pat::MuonCollection::const_iterator imuon = muons->begin();
+ pat::MuonCollection::const_iterator jmuon = muons->end();
+
+ for (; imuon != jmuon; ++imuon) {
+ if (imuon->innerTrack().isNull() == 1)
+ continue;
+ // std::cout<<"JetPlusTrackCorrector::matchMuons::Track "<<(**itrk).pt()<<" "
+ // <<(**itrk).eta()<<" "<<(**itrk).phi()<<" Muon "<<
+ // (*(imuon->innerTrack())).pt()<<" "<< (*(imuon->innerTrack())).eta()<<" "<<
+ // (*(imuon->innerTrack())).phi()<innerTrack())).pt()) < muonPtmatch_ &&
+ fabs((**itrk).eta() - (*(imuon->innerTrack())).eta()) < muonEtamatch_ &&
+ fabs((**itrk).phi() - (*(imuon->innerTrack())).phi()) < muonPhimatch_) {
+ // std::cout<<" Needed muon-track "<<(**itrk).pt()<<" "<<
+ // (**itrk).eta()<<" "<<(**itrk).phi()<phi() - (*itrk)->momentum().phi());
- if (deltaphi > 6.283185308)
- deltaphi -= 6.283185308;
- if (deltaphi > 3.141592654)
- deltaphi = 6.283185308 - deltaphi;
- deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2)));
- if (deltaR < deltaRMIN) {
- deltaRMIN = deltaR;
+
+ dR = deltaR(ielec->eta(), ielec->phi(), (*itrk)->momentum().eta(), (*itrk)->momentum().phi());
+ if (dR < deltaRMIN) {
+ deltaRMIN = dR;
}
}
- if (deltaR < 0.02)
+ if (deltaRMIN < electronDRmatch_)
return true;
else
return false;
}
+bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk,
+ const edm::Handle& elecs) const {
+ if (elecs->empty()) {
+ return false;
+ }
+ // std::cout<<"JetPlusTrackCorrector::matchElectrons "<begin();
+ pat::ElectronCollection::const_iterator jelec = elecs->end();
+ for (; ielec != jelec; ++ielec) {
+ // std::cout<<"Electron "<eta()<<" "<phi()<<" Track "<<(*itrk)->momentum().eta()<<" "<<
+ // (*itrk)->momentum().phi()<<" PT "<pt()<<" "<<(*itrk)->pt()<eta(), ielec->phi(), (*itrk)->momentum().eta(), (*itrk)->momentum().phi());
+ if (dR < deltaRMIN) {
+ deltaRMIN = dR;
+ }
+ }
+ // std::cout<<" matchElectrons:DeltaR "<
@@ -190,6 +195,16 @@ class JetPlusTrackCorrector {
jpt::MatchedTracks& muons,
jpt::MatchedTracks& elecs,
bool& validMatches);
+ double correction(const reco::Jet&,
+ const reco::Jet&,
+ const edm::Event&,
+ const edm::EventSetup&,
+ const reco::TrackRefVector& tracksinvert,
+ const reco::TrackRefVector& tracksincalo,
+ P4&,
+ jpt::MatchedTracks& pions,
+ jpt::MatchedTracks& muons,
+ jpt::MatchedTracks& elecs);
/// Scalar correction method
double correction(const reco::Jet&,
@@ -247,6 +262,15 @@ class JetPlusTrackCorrector {
jpt::MatchedTracks& muons,
jpt::MatchedTracks& elecs);
+ bool matchTracks(const reco::Jet&,
+ const edm::Event&,
+ const edm::EventSetup&,
+ const reco::TrackRefVector& tracksinvert,
+ const reco::TrackRefVector& tracksincalo,
+ jpt::MatchedTracks& pions,
+ jpt::MatchedTracks& muons,
+ jpt::MatchedTracks& elecs);
+
/// Calculates corrections to be applied using pions
P4 pionCorrection(const P4& jet, const jpt::MatchedTracks& pions);
@@ -322,16 +346,22 @@ class JetPlusTrackCorrector {
/// Get RECO muons
bool getMuons(const edm::Event&, edm::Handle&) const;
+ bool getMuons(const edm::Event&, edm::Handle&) const;
+
/// Get RECO electrons
bool getElectrons(const edm::Event&, edm::Handle&, edm::Handle&) const;
+ bool getElectrons(const edm::Event&, edm::Handle&) const;
+
/// Matches tracks to RECO muons
bool matchMuons(TrackRefs::const_iterator&, const edm::Handle&) const;
+ bool matchMuons(TrackRefs::const_iterator&, const edm::Handle&) const;
/// Matches tracks to RECO electrons
bool matchElectrons(TrackRefs::const_iterator&,
const edm::Handle&,
const edm::Handle&) const;
+ bool matchElectrons(TrackRefs::const_iterator&, const edm::Handle&) const;
/// Check on track quality
bool failTrackQuality(TrackRefs::const_iterator&) const;
@@ -368,6 +398,7 @@ class JetPlusTrackCorrector {
protected:
// Some general configuration
bool verbose_;
+ bool usereco_;
bool vectorial_;
bool vecResponse_;
bool useInConeTracks_;
@@ -392,6 +423,8 @@ class JetPlusTrackCorrector {
edm::InputTag muons_;
edm::InputTag electrons_;
edm::InputTag electronIds_;
+ edm::InputTag patmuons_;
+ edm::InputTag patelectrons_;
// Filter tracks by quality
reco::TrackBase::TrackQuality trackQuality_;
@@ -401,6 +434,12 @@ class JetPlusTrackCorrector {
const jpt::Map efficiency_;
const jpt::Map leakage_;
+ // Muon/Electron
+ double muonPtmatch_;
+ double muonEtamatch_;
+ double muonPhimatch_;
+ double electronDRmatch_;
+
// Mass
double pionMass_;
double muonMass_;
@@ -422,10 +461,12 @@ class JetPlusTrackCorrector {
private:
edm::EDGetTokenT input_jetTracksAtVertex_token_;
edm::EDGetTokenT input_jetTracksAtCalo_token_;
- edm::EDGetTokenT inut_reco_muons_token_;
+ edm::EDGetTokenT input_reco_muons_token_;
edm::EDGetTokenT input_pvCollection_token_;
edm::EDGetTokenT input_reco_elecs_token_;
edm::EDGetTokenT input_reco_elec_ids_token_;
+ edm::EDGetTokenT input_pat_muons_token_;
+ edm::EDGetTokenT input_pat_elecs_token_;
};
// ---------- Inline methods ----------
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
index 5ebd0b5878f23..b94792ed4a9f6 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
@@ -30,6 +30,8 @@
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/JetReco/interface/JPTJetCollection.h"
#include "DataFormats/JetReco/interface/JPTJet.h"
+#include "DataFormats/JetReco/interface/TrackJetCollection.h"
+#include "DataFormats/JetReco/interface/TrackJet.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/JetReco/interface/Jet.h"
@@ -57,19 +59,27 @@ using namespace jpt;
JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) {
//register your products
src = iConfig.getParameter("src");
+ srcTrackJets = iConfig.getParameter("srcTrackJets");
alias = iConfig.getUntrackedParameter("alias");
srcPVs_ = iConfig.getParameter("srcPVs");
vectorial_ = iConfig.getParameter("VectorialCorrection");
useZSP = iConfig.getParameter("UseZSP");
ptCUT = iConfig.getParameter("ptCUT");
+ dRcone = iConfig.getParameter("dRcone");
+
mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector());
if (useZSP)
mZSPalgo = new ZSPJPTJetCorrector(iConfig);
produces().setBranchAlias(alias);
+ produces().setBranchAlias("ak4CaloJetsJPT");
input_jets_token_ = consumes >(src);
+ input_addjets_token_ = consumes >(iConfig.getParameter("srcAddCaloJets"));
+ input_trackjets_token_ = consumes >(srcTrackJets);
input_vertex_token_ = consumes(srcPVs_);
+ mExtrapolations =
+ consumes >(iConfig.getParameter("extrapolations"));
}
JetPlusTrackProducer::~JetPlusTrackProducer() {
@@ -80,6 +90,7 @@ JetPlusTrackProducer::~JetPlusTrackProducer() {
//
// member functions
//
+bool sort_by_pt(reco::JPTJet a, reco::JPTJet b) { return (a.pt() > b.pt()); }
// ------------ method called to produce the data ------------
void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
@@ -91,12 +102,111 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
edm::Handle > jets_h;
iEvent.getByToken(input_jets_token_, jets_h);
- // auto pOut = std::make_unique();
+ //JetPlusTrackAddonSeed
+ edm::Handle > addjets_h;
+ iEvent.getByToken(input_addjets_token_, addjets_h);
+
+ //std::cout<<" Additional Calojets "<size()< > jetsTrackJets;
+ iEvent.getByToken(input_trackjets_token_, jetsTrackJets);
+
+ //std::cout<<" Additional Trackjets "<size()< > iExtrapolations;
+ iEvent.getByToken(mExtrapolations, iExtrapolations);
+
+ edm::RefProd pOut1RefProd = iEvent.getRefBeforePut();
+ edm::Ref::key_type idxCaloJet = 0;
+
auto pOut = std::make_unique();
+ auto pOut1 = std::make_unique();
+
+ double scaleJPT = 1.;
+ std::vector theJPTJets;
+ if (jetsTrackJets.isValid()) {
+ if (!jetsTrackJets->empty()) {
+ for (unsigned ijet = 0; ijet < jetsTrackJets->size(); ++ijet) {
+ const reco::TrackJet* jet = &(*(jetsTrackJets->refAt(ijet)));
+ int icalo = -1;
+ if (addjets_h.isValid()) {
+ for (unsigned i = 0; i < addjets_h->size(); ++i) {
+ const reco::CaloJet* oldjet = &(*(addjets_h->refAt(i)));
+ double dr = reco::deltaR(jet->eta(), jet->phi(), oldjet->eta(), oldjet->phi());
+ if (dr <= dRcone) {
+ icalo = i;
+ }
+ } // Calojets
+ }
+ if (icalo < 0)
+ continue;
+ const reco::CaloJet* mycalo = &(*(addjets_h->refAt(icalo)));
+ // std::cout<<" Additional CaloJet "<pt()<<" "<eta()<<
+ // " "<phi()< > tracksinjet = jet->tracks();
+ reco::TrackRefVector tracksincalo;
+ reco::TrackRefVector tracksinvert;
+ for (std::vector >::iterator itrack = tracksinjet.begin(); itrack != tracksinjet.end();
+ itrack++) {
+ for (std::vector::const_iterator xtrpBegin = iExtrapolations->begin(),
+ xtrpEnd = iExtrapolations->end(),
+ ixtrp = xtrpBegin;
+ ixtrp != xtrpEnd;
+ ++ixtrp) {
+ if (ixtrp->positions().empty())
+ continue;
+ double mydphi = deltaPhi(ixtrp->track()->phi(), (**itrack).phi());
+ if (fabs(ixtrp->track()->pt() - (**itrack).pt()) > 0.001 ||
+ fabs(ixtrp->track()->eta() - (**itrack).eta()) > 0.001 || mydphi > 0.001)
+ continue;
+ tracksinvert.push_back(ixtrp->track());
+ reco::TrackBase::Point const& point = ixtrp->positions().at(0);
+ double dr = reco::deltaR(jet->eta(), jet->phi(), point.eta(), point.phi());
+ if (dr <= dRcone) {
+ /*std::cout<<" TrackINcalo "<track());
+ }
+ } // Track extrapolations
+ } // tracks
+
+ reco::TrackJet corrected = *jet;
+ math::XYZTLorentzVector p4;
+ jpt::MatchedTracks pions;
+ jpt::MatchedTracks muons;
+ jpt::MatchedTracks elecs;
+
+ scaleJPT = mJPTalgo->correction(
+ corrected, *mycalo, iEvent, iSetup, tracksinvert, tracksincalo, p4, pions, muons, elecs);
+ // std::cout<<" JetPlusTrackProducer::AddSeedJet "<< (*mycalo).pt()<<" "<< (*mycalo).eta()<<" "<<
+ // (*mycalo).phi()<<" "<<(*mycalo).jetArea()<<" Corr "<<
+ // p4.pt()<<" "< ptCUT) {
+ reco::JPTJet::Specific jptspe;
+ jptspe.pionsInVertexInCalo = pions.inVertexInCalo_;
+ jptspe.pionsInVertexOutCalo = pions.inVertexOutOfCalo_;
+ jptspe.pionsOutVertexInCalo = pions.outOfVertexInCalo_;
+ jptspe.muonsInVertexInCalo = muons.inVertexInCalo_;
+ jptspe.muonsInVertexOutCalo = muons.inVertexOutOfCalo_;
+ jptspe.muonsOutVertexInCalo = muons.outOfVertexInCalo_;
+ jptspe.elecsInVertexInCalo = elecs.inVertexInCalo_;
+ jptspe.elecsInVertexOutCalo = elecs.inVertexOutOfCalo_;
+ jptspe.elecsOutVertexInCalo = elecs.outOfVertexInCalo_;
+ reco::CaloJetRef myjet(pOut1RefProd, idxCaloJet++);
+ jptspe.theCaloJetRef = edm::RefToBase(myjet);
+ jptspe.mZSPCor = 1.;
+ reco::JPTJet fJet(p4, jet->primaryVertex()->position(), jptspe, mycalo->getJetConstituents());
+ pOut->push_back(fJet);
+ pOut1->push_back(*mycalo);
+ theJPTJets.push_back(fJet);
+ }
+ } // trackjets
+ } // jets
+ } // There is trackjet collection
+
+ // std::cout<<" Size of the addition "<size()<<" "<size()<size(); ++i) {
const reco::CaloJet* oldjet = &(*(jets_h->refAt(i)));
-
reco::CaloJet corrected = *oldjet;
// ZSP corrections
@@ -104,12 +214,10 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
double factorZSP = 1.;
if (useZSP)
factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup);
-
corrected.scaleEnergy(factorZSP);
// JPT corrections
-
- double scaleJPT = 1.;
+ scaleJPT = 1.;
math::XYZTLorentzVector p4;
@@ -124,8 +232,14 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
corrected.py() * scaleJPT,
corrected.pz() * scaleJPT,
corrected.energy() * scaleJPT);
+ // std::cout<<" JetPlusTrackProducer "<< (*oldjet).pt()<<" "
+ // << (*oldjet).eta()<<" "<< (*oldjet).phi()<<
+ // " "<correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok);
+ // std::cout<<" JetPlusTrackProducer::mainpart "<< (*oldjet).pt()<<" "<< (*oldjet).eta()<<" "<<
+ // (*oldjet).phi()<<" "<<(*oldjet).jetArea()<<" Corr "<<
+ // p4.pt()<<" "<push_back(fJet);
}
+ std::sort(pOut->begin(), pOut->end(), sort_by_pt);
+ //std::cout<<"Size of the additional jets "<size()<
@@ -49,12 +51,17 @@ class JetPlusTrackProducer : public edm::stream::EDProducer<> {
JetPlusTrackCorrector* mJPTalgo;
ZSPJPTJetCorrector* mZSPalgo;
edm::InputTag src;
+ edm::InputTag srcTrackJets;
edm::InputTag srcPVs_;
std::string alias;
bool vectorial_;
bool useZSP;
double ptCUT;
+ double dRcone;
edm::EDGetTokenT > input_jets_token_;
+ edm::EDGetTokenT > input_addjets_token_;
+ edm::EDGetTokenT > input_trackjets_token_;
edm::EDGetTokenT input_vertex_token_;
+ edm::EDGetTokenT > mExtrapolations;
};
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
index 50f1f5508fd8e..419aab016346e 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
@@ -410,10 +410,7 @@ reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet(
// <<" jetE="<energy()<<" jetEta="<>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<
+// user include files
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "TrackingTools/GeomPropagators/interface/Propagator.h"
+#include "TrackingTools/PatternTools/interface/Trajectory.h"
+
+#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
+
+#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
+
+#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "Geometry/Records/interface/TrackerTopologyRcd.h"
+#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
+
+TrackFromPFProducer::TrackFromPFProducer(const edm::ParameterSet& iConfig) {
+ tokenPFCandidates_ = consumes(iConfig.getParameter("PFCandidates"));
+ tokenPFCandidatesLostTracks_ =
+ consumes(iConfig.getParameter("PFCandidatesLostTracks"));
+ produces("tracksFromPF");
+}
+
+void TrackFromPFProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) {
+ //
+ // create empty output collections
+ //
+ auto outputTColl = std::make_unique();
+
+ // std::cout<<" TrackFromPFProducer::produce "< pfCandidates;
+ theEvent.getByToken(tokenPFCandidates_, pfCandidates);
+
+ for (unsigned int i = 0, n = pfCandidates->size(); i < n; ++i) {
+ const pat::PackedCandidate& pf = (*pfCandidates)[i];
+ if (pf.hasTrackDetails()) {
+ const reco::Track& mytrack = pf.pseudoTrack();
+
+ // std::cout<<" Track "<push_back(mytrack);
+ }
+ //else {
+ // if(pf.charge()>0) std::cout< {
+public:
+ /// Constructor
+ explicit TrackFromPFProducer(const edm::ParameterSet& iConfig);
+
+ /// Implementation of produce method
+ void produce(edm::Event&, const edm::EventSetup&) override;
+
+private:
+ edm::EDGetTokenT > tokenPFCandidates_;
+ edm::EDGetTokenT > tokenPFCandidatesLostTracks_;
+};
+
+#endif
diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
index b5c4cbdb590db..0f541e6b1bf6d 100644
--- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
+++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
@@ -162,52 +162,47 @@
JPTAntiKtPu5JetExtender.jet2TracksAtCALO = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtCaloFace")
JPTAntiKtPu5JetExtender.jet2TracksAtVX = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtVertex")
-### ---------- Task, Sequences
+### ---------- Sequences
# IC5
-JPTrecoJetAssociationsIconePu5Task = cms.Task(
- trackExtrapolator,
- JPTiterativeConePu5JetTracksAssociatorAtVertex,
- JPTiterativeConePu5JetTracksAssociatorAtCaloFace,
+JPTrecoJetAssociationsIconePu5 = cms.Sequence(
+ trackExtrapolator*
+### JPTtrackExtrapolatorAA*
+ JPTiterativeConePu5JetTracksAssociatorAtVertex*
+ JPTiterativeConePu5JetTracksAssociatorAtCaloFace*
JPTiterativeConePu5JetExtender
)
-JPTrecoJetAssociationsIconePu5 = cms.Sequence(JPTrecoJetAssociationsIconePu5Task)
-JetPlusTrackCorrectionsIconePu5Task = cms.Task(
- JPTrecoJetAssociationsIconePu5,
+JetPlusTrackCorrectionsIconePu5 = cms.Sequence(
+ JPTrecoJetAssociationsIconePu5*
JetPlusTrackZSPCorJetIconePu5
)
-JetPlusTrackCorrectionsIconePu5 = cms.Sequence(JetPlusTrackCorrectionsIconePu5Task)
# SC5
-JPTrecoJetAssociationsSisConePu5Task = cms.Task(
- trackExtrapolator,
- JPTSisConePu5JetTracksAssociatorAtVertex,
- JPTSisConePu5JetTracksAssociatorAtCaloFace,
+JPTrecoJetAssociationsSisConePu5 = cms.Sequence(
+ trackExtrapolator*
+ JPTSisConePu5JetTracksAssociatorAtVertex*
+ JPTSisConePu5JetTracksAssociatorAtCaloFace*
JPTSisConePu5JetExtender
)
-JPTrecoJetAssociationsSisConePu5 = cms.Sequence(JPTrecoJetAssociationsSisConePu5Task)
-JetPlusTrackCorrectionsSisConePu5Task = cms.Task(
- JPTrecoJetAssociationsSisConePu5,
+JetPlusTrackCorrectionsSisConePu5 = cms.Sequence(
+ JPTrecoJetAssociationsSisConePu5*
JetPlusTrackZSPCorJetSisconePu5
)
-JetPlusTrackCorrectionsSisConePu5 = cms.Sequence(JetPlusTrackCorrectionsSisConePu5Task)
# Anti-Kt
-JPTrecoJetAssociationsAntiKtPu5Task = cms.Task(
- trackExtrapolator,
- JPTAntiKtPu5JetTracksAssociatorAtVertex,
- JPTAntiKtPu5JetTracksAssociatorAtCaloFace,
+JPTrecoJetAssociationsAntiKtPu5 = cms.Sequence(
+ trackExtrapolator*
+ JPTAntiKtPu5JetTracksAssociatorAtVertex*
+ JPTAntiKtPu5JetTracksAssociatorAtCaloFace*
JPTAntiKtPu5JetExtender
)
-JPTrecoJetAssociationsAntiKtPu5 = cms.Sequence(JPTrecoJetAssociationsAntiKtPu5Task)
-JetPlusTrackCorrectionsAntiKtPu5Task = cms.Task(
- JPTrecoJetAssociationsAntiKtPu5,
+JetPlusTrackCorrectionsAntiKtPu5 = cms.Sequence(
+ JPTrecoJetAssociationsAntiKtPu5*
JetPlusTrackZSPCorJetAntiKtPu5
)
-JetPlusTrackCorrectionsAntiKtPu5 = cms.Sequence(JetPlusTrackCorrectionsAntiKtPu5Task)
diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
index adeff742c8e63..1fd86b805eec5 100644
--- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
+++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
@@ -11,15 +11,30 @@
from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight
JPTeidTight = eidTight.clone()
+# ---------- Seeds from TrackJets
+
+JetPlusTrackAddonSeedReco = cms.EDProducer(
+ "JetPlusTrackAddonSeedProducer",
+ srcCaloJets = cms.InputTag("ak4CaloJets"),
+ srcTrackJets = cms.InputTag("ak4TrackJets"),
+ srcPVs = cms.InputTag('offlinePrimaryVertices'),
+ ptCUT = cms.double(15.),
+ dRcone = cms.double(0.4),
+ PFCandidates = cms.InputTag('packedPFCandidates'),
+ towerMaker = cms.InputTag('towerMaker'),
+ UsePAT = cms.bool(False)
+)
# ---------- Module definition
from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import *
-
JetPlusTrackZSPCorJetAntiKt4 = cms.EDProducer(
"JetPlusTrackProducer",
cms.PSet(JPTZSPCorrectorAntiKt4),
src = cms.InputTag("ak4CaloJets"),
+ srcTrackJets = cms.InputTag("ak4TrackJets"),
+ srcAddCaloJets = cms.InputTag('JetPlusTrackAddonSeedReco:ak4CaloJetsJPTSeed'),
+ extrapolations = cms.InputTag("trackExtrapolator"),
tagName = cms.vstring('ZSP_CMSSW390_Akt_05_PU0'),
tagNameOffset = cms.vstring(),
PU = cms.int32(-1),
@@ -27,7 +42,8 @@
UseZSP = cms.bool(False),
srcPVs = cms.InputTag('offlinePrimaryVertices'),
alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt4'),
- ptCUT = cms.double(15.)
+ ptCUT = cms.double(15.),
+ dRcone = cms.double(0.4)
)
JetPlusTrackZSPCorJetAntiKt4.JetTracksAssociationAtVertex = cms.InputTag("ak4JetTracksAssociatorAtVertexJPT")
@@ -40,6 +56,7 @@
JetPlusTrackCorrectionsAntiKt4Task = cms.Task(
JPTeidTight,
+ JetPlusTrackAddonSeedReco,
ak4JetTracksAssociatorAtVertexJPT,
ak4JetTracksAssociatorAtCaloFace,
JetPlusTrackZSPCorJetAntiKt4
diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py
index d2e66bbef9ef0..a8d2f49e48b71 100644
--- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py
+++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cfi.py
@@ -6,6 +6,7 @@
# General Configuration
Verbose = cms.bool(True),
+ UseReco = cms.bool(True),
# Vectorial corrections
VectorialCorrection = cms.bool(True),
@@ -30,14 +31,20 @@
# Muons
UseMuons = cms.bool(True),
Muons = cms.InputTag("muons"),
-
+ PatMuons = cms.InputTag("slimmedMuons"),
+ muonPtmatch = cms.double(0.1),
+ muonEtamatch = cms.double(0.001),
+ muonPhimatch = cms.double(0.001),
+
# Electrons
UseElectrons = cms.bool(True),
Electrons = cms.InputTag("gedGsfElectrons"),
ElectronIds = cms.InputTag("JPTeidTight"),
+ PatElectrons = cms.InputTag("slimmedElectrons"),
+ electronDRmatch = cms.double(0.02),
# Filtering tracks using quality
- UseTrackQuality = cms.bool(True),
+ UseTrackQuality = cms.bool(False),
TrackQuality = cms.string('highPurity'),
PtErrorQuality = cms.double(0.05),
DzVertexCut = cms.double(0.2),
diff --git a/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py
new file mode 100644
index 0000000000000..be33f6785c73c
--- /dev/null
+++ b/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py
@@ -0,0 +1,87 @@
+import FWCore.ParameterSet.Config as cms
+# ---------- Add assigned jet-track association
+
+from RecoJets.JetAssociationProducers.trackExtrapolator_cfi import *
+trackExtrapolator.trackSrc = cms.InputTag("produceTracks:tracksFromPF")
+trackExtrapolator.trackQuality = cms.string('highPurity')
+
+from RecoJets.JetAssociationProducers.ak4JTA_cff import *
+ak4JetTracksAssociatorAtVertexJPTPAT = ak4JetTracksAssociatorAtVertex.clone()
+ak4JetTracksAssociatorAtVertexJPTPAT.useAssigned = cms.bool(True)
+ak4JetTracksAssociatorAtVertexJPTPAT.pvSrc = cms.InputTag("offlineSlimmedPrimaryVertices")
+ak4JetTracksAssociatorAtVertexJPTPAT.jets = cms.InputTag("slimmedCaloJets")
+ak4JetTracksAssociatorAtVertexJPTPAT.tracks = cms.InputTag("produceTracks:tracksFromPF")
+ak4JetTracksAssociatorAtCaloFaceJPTPAT = ak4JetTracksAssociatorAtCaloFace.clone()
+ak4JetTracksAssociatorAtCaloFaceJPTPAT.jets = cms.InputTag("slimmedCaloJets")
+ak4JetTracksAssociatorAtCaloFaceJPTPAT.tracks = cms.InputTag("produceTracks:tracksFromPF")
+ak4JetExtenderJPTPAT = ak4JetExtender.clone()
+ak4JetExtenderJPTPAT.jets = cms.InputTag("slimmedCaloJets")
+ak4JetExtenderJPTPAT.jet2TracksAtCALO = cms.InputTag("ak4JetTracksAssociatorAtCaloFaceJPTPAT")
+ak4JetExtenderJPTPAT.jet2TracksAtVX = cms.InputTag("ak4JetTracksAssociatorAtVertexJPTPAT")
+
+recoJetAssociationsAntiKt4JPTPAT = cms.Sequence(
+ trackExtrapolator*
+ ak4JetTracksAssociatorAtVertexJPTPAT*
+ ak4JetTracksAssociatorAtCaloFaceJPTPAT*
+ ak4JetExtenderJPTPAT
+)
+
+# ---------- Tight Electron ID
+# commented, needed for CMSSW80X and earlier
+#from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight
+#JPTeidTightPAT = eidTight.clone()
+#from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
+#setupEgammaPostRecoSeq(process,
+# era='2017-Nov17ReReco')
+#
+# ---------- Module definition
+from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import *
+
+JetPlusTrackZSPCorJetAntiKt4PAT = cms.EDProducer(
+ "JetPlusTrackProducer",
+ cms.PSet(JPTZSPCorrectorAntiKt4),
+ src = cms.InputTag("slimmedCaloJets"),
+ srcTrackJets = cms.InputTag("ak4TrackJets"),
+ srcAddCaloJets = cms.InputTag('JetPlusTrackAddonSeedPAT:CaloJetAddonSeed'),
+ extrapolations = cms.InputTag("trackExtrapolator"),
+ tagName = cms.vstring('ZSP_CMSSW390_Akt_05_PU0'),
+ tagNameOffset = cms.vstring(),
+ PU = cms.int32(-1),
+ FixedPU = cms.int32(0),
+ UseZSP = cms.bool(False),
+ srcPVs = cms.InputTag('offlineSlimmedPrimaryVertices'),
+ alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt4'),
+ ptCUT = cms.double(15.),
+ PAT = cms.bool(True)
+ )
+
+JetPlusTrackZSPCorJetAntiKt4PAT.JetTracksAssociationAtVertex = cms.InputTag("ak4JetTracksAssociatorAtVertexJPTPAT")
+JetPlusTrackZSPCorJetAntiKt4PAT.JetTracksAssociationAtCaloFace = cms.InputTag("ak4JetTracksAssociatorAtCaloFaceJPTPAT")
+JetPlusTrackZSPCorJetAntiKt4PAT.Muons = cms.InputTag("slimmedMuons")
+JetPlusTrackZSPCorJetAntiKt4PAT.Electrons = cms.InputTag("slimmedElectrons")
+JetPlusTrackZSPCorJetAntiKt4PAT.JetSplitMerge = cms.int32(2)
+JetPlusTrackZSPCorJetAntiKt4PAT.UseReco = cms.bool(False)
+### ---------- Sequences
+
+#from RecoJets.JetProducers.TracksForJets_cff import *
+#from RecoJets.Configuration.RecoTrackJets_cff import *
+#from CommonTools.RecoAlgos.TrackWithVertexSelector_cfi import *
+#from CommonTools.RecoAlgos.TrackWithVertexSelectorParams_cff import *
+#trackWithVertexSelectorParams.vertexTag = cms.InputTag('offlineSlimmedPrimaryVertices')
+#trackWithVertexSelectorParams.src = cms.InputTag('produceTracks:tracksFromPF')
+
+# Anti-Kt
+
+JetPlusTrackCorrectionsAntiKt4TaskPAT = cms.Task(
+ trackExtrapolator,
+ ak4JetTracksAssociatorAtVertexJPTPAT,
+ ak4JetTracksAssociatorAtCaloFaceJPTPAT,
+ ak4JetExtenderJPTPAT,
+ JetPlusTrackZSPCorJetAntiKt4PAT
+ )
+
+JetPlusTrackCorrectionsAntiKt4PAT = cms.Sequence(JetPlusTrackCorrectionsAntiKt4TaskPAT)
+
+# For backward-compatiblity (but to be deprecated!)
+
+JetPlusTrackCorrectionsPAT = cms.Sequence(JetPlusTrackCorrectionsAntiKt4PAT)