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)