diff --git a/CommonTools/RecoAlgos/plugins/TrackFromPackedCandidateProducer.cc b/CommonTools/RecoAlgos/plugins/TrackFromPackedCandidateProducer.cc
new file mode 100644
index 0000000000000..41680e70f0a24
--- /dev/null
+++ b/CommonTools/RecoAlgos/plugins/TrackFromPackedCandidateProducer.cc
@@ -0,0 +1,76 @@
+/** \class TrackProducer
+ *  Produce Tracks from TrackCandidates
+ *  
+*/
+//
+// Original Author:  Olga Kodolova,40 R-A12,+41227671273,
+//         Created:  Fri Feb 19 10:14:02 CET 2010
+//
+//
+
+// system include files
+#include <memory>
+// user include files
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/Utilities/interface/isFinite.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+
+class TrackFromPackedCandidateProducer : public edm::global::EDProducer<> {
+public:
+  /// Constructor
+  explicit TrackFromPackedCandidateProducer(const edm::ParameterSet& iConfig);
+
+  /// fill descriptions
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+  /// Implementation of produce method
+  void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
+
+private:
+  const edm::EDGetTokenT<std::vector<pat::PackedCandidate> > tokenPFCandidates_;
+};
+
+TrackFromPackedCandidateProducer::TrackFromPackedCandidateProducer(const edm::ParameterSet& iConfig)
+    : tokenPFCandidates_(
+          consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("PFCandidates"))) {
+  produces<reco::TrackCollection>();
+}
+
+void TrackFromPackedCandidateProducer::fillDescriptions(edm::ConfigurationDescriptions& iDescriptions) {
+  edm::ParameterSetDescription desc;
+  desc.add<edm::InputTag>("PFCandidates");
+  iDescriptions.addWithDefaultLabel(desc);
+}
+
+void TrackFromPackedCandidateProducer::produce(edm::StreamID theStreamID,
+                                               edm::Event& theEvent,
+                                               const edm::EventSetup& setup) const {
+  //
+  // create empty output collections
+  //
+  auto outputTColl = std::make_unique<reco::TrackCollection>();
+  auto const pfCandidates = theEvent.get(tokenPFCandidates_);
+  outputTColl->reserve(pfCandidates.size());
+
+  for (auto const& pf : pfCandidates) {
+    if (pf.hasTrackDetails()) {
+      const reco::Track& mytrack = pf.pseudoTrack();
+      using namespace edm;
+      if (isNotFinite(mytrack.pt()) || isNotFinite(mytrack.eta()) || isNotFinite(mytrack.phi()))
+        continue;
+      outputTColl->push_back(mytrack);
+    }
+  }
+  //put everything in the event
+  theEvent.put(std::move(outputTColl));
+}
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(TrackFromPackedCandidateProducer);
diff --git a/RecoJets/JetPlusTracks/plugins/BuildFile.xml b/RecoJets/JetPlusTracks/plugins/BuildFile.xml
index 5df0b2b2f814c..4ce25968bfeca 100644
--- a/RecoJets/JetPlusTracks/plugins/BuildFile.xml
+++ b/RecoJets/JetPlusTracks/plugins/BuildFile.xml
@@ -5,6 +5,8 @@
   <use name="DataFormats/Common"/>
   <use name="DataFormats/EgammaCandidates"/>
   <use name="DataFormats/JetReco"/>
+  <use name="DataFormats/CaloTowers"/>
+  <use name="DataFormats/PatCandidates"/>
   <use name="DataFormats/Math"/>
   <use name="DataFormats/MuonReco"/>
   <use name="DataFormats/TrackReco"/>
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc
new file mode 100644
index 0000000000000..ea92e512f6c83
--- /dev/null
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackAddonSeedProducer.cc
@@ -0,0 +1,187 @@
+// -*- C++ -*-
+//
+// Package:    JetPlusTracks
+// Class:      JetPlusTrackAddonSeedProducer
+//
+/**\class JetPlusTrackAddonSeedProducer JetPlusTrackAddonSeedProducer.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 <memory>
+
+// user include files
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/Utilities/interface/InputTag.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include "DataFormats/JetReco/interface/CaloJetCollection.h"
+#include "DataFormats/JetReco/interface/CaloJet.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/PatCandidates/interface/PackedCandidate.h"
+#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
+
+#include "DataFormats/Math/interface/deltaPhi.h"
+#include "DataFormats/Math/interface/deltaR.h"
+
+#include <string>
+
+using namespace std;
+class JetPlusTrackAddonSeedProducer : public edm::stream::EDProducer<> {
+public:
+  explicit JetPlusTrackAddonSeedProducer(const edm::ParameterSet&);
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+  void produce(edm::Event&, const edm::EventSetup&) override;
+
+private:
+  const double dRcone_;
+  const bool usePAT_;
+  const edm::EDGetTokenT<edm::View<reco::CaloJet> > input_jets_token_;
+  const edm::EDGetTokenT<edm::View<reco::TrackJet> > input_trackjets_token_;
+  const edm::EDGetTokenT<reco::VertexCollection> input_vertex_token_;
+  const edm::EDGetTokenT<std::vector<pat::PackedCandidate> > tokenPFCandidates_;
+  const edm::EDGetTokenT<CaloTowerCollection> input_ctw_token_;
+};
+
+JetPlusTrackAddonSeedProducer::JetPlusTrackAddonSeedProducer(const edm::ParameterSet& iConfig)
+    : dRcone_(iConfig.getParameter<double>("dRcone")),
+      usePAT_(iConfig.getParameter<bool>("UsePAT")),
+      input_jets_token_(consumes<edm::View<reco::CaloJet> >(iConfig.getParameter<edm::InputTag>("srcCaloJets"))),
+      input_trackjets_token_(consumes<edm::View<reco::TrackJet> >(iConfig.getParameter<edm::InputTag>("srcTrackJets"))),
+      input_vertex_token_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("srcPVs"))),
+      tokenPFCandidates_(consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("PFCandidates"))),
+      input_ctw_token_(consumes<CaloTowerCollection>(iConfig.getParameter<edm::InputTag>("towerMaker"))) {
+  //register your products
+  produces<reco::CaloJetCollection>();
+}
+
+void JetPlusTrackAddonSeedProducer::fillDescriptions(edm::ConfigurationDescriptions& iDescriptions) {
+  edm::ParameterSetDescription desc;
+  desc.add<double>("dRcone", 0.4);
+  desc.add<bool>("UsePAT", false);
+  desc.add<edm::InputTag>("srcCaloJets", edm::InputTag("ak4CaloJets"));
+  desc.add<edm::InputTag>("srcTrackJets", edm::InputTag("ak4TrackJets"));
+  desc.add<edm::InputTag>("srcPVs", edm::InputTag("primaryVertex"));
+  desc.add<edm::InputTag>("PFCandidates", edm::InputTag("PFCandidates"));
+  desc.add<edm::InputTag>("towerMaker", edm::InputTag("towerMaker"));
+  iDescriptions.addWithDefaultLabel(desc);
+}
+
+// ------------ method called to produce the data  ------------
+void JetPlusTrackAddonSeedProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  using namespace edm;
+  // get stuff from Event
+  auto const& jets = iEvent.get(input_jets_token_);
+  auto const& jetsTrackJets = iEvent.get(input_trackjets_token_);
+  auto pCaloOut = std::make_unique<reco::CaloJetCollection>();
+
+  for (auto const& jet : jetsTrackJets) {
+    int iflag = 0;
+    for (auto const& oldjet : jets) {
+      double dr2 = deltaR2(jet, oldjet);
+      if (dr2 < dRcone_ * 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_) {
+      auto const& pfCandidates = iEvent.get(tokenPFCandidates_);
+      for (auto const& pf : pfCandidates) {
+        double dr2 = deltaR2(jet, pf);
+        if (dr2 > dRcone_ * dRcone_)
+          continue;
+        // jetconstit
+        caloen = caloen + pf.energy() * pf.caloFraction();
+        hadinho += 0.;
+        if (std::abs(pf.eta()) <= 1.4) {
+          hadinhb += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+          emineb += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+        } else if (std::abs(pf.eta()) < 3.) {
+          hadinhe += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+          eminee += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+        } else {
+          hadinhf += pf.energy() * pf.caloFraction() * pf.hcalFraction();
+          eminhf += pf.energy() * pf.caloFraction() * (1. - pf.hcalFraction());
+        }
+        ncand++;
+      }  // pfcandidates
+    } else {
+      auto const& cts = iEvent.get(input_ctw_token_);
+      for (auto const& ct : cts) {
+        double dr2 = deltaR2(jet, ct);
+        if (dr2 > dRcone_ * dRcone_)
+          continue;
+        caloen = caloen + ct.energy();
+        hadinho += ct.energyInHO();
+        hadinhb += ct.energyInHB();
+        hadinhe += ct.energyInHE();
+        hadinhf += 0.5 * ct.energyInHF();
+        emineb += ct.energy() - ct.energyInHB() - ct.energyInHO();
+        eminee += ct.energy() - ct.energyInHE();
+        eminhf += 0.5 * ct.energyInHF();
+        ncand++;
+      }
+    }
+    eefraction = (emineb + eminee) / caloen;
+    hhfraction = (hadinhb + hadinhe + hadinhf + hadinho) / caloen;
+
+    double trackp = jet.p();
+    if (caloen <= 0.)
+      caloen = 0.001;
+    math::XYZTLorentzVector pcalo4(caloen * jet.p4() / trackp);
+    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
+  iEvent.put(std::move(pCaloOut));
+}
+
+//define this as a plug-in
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(JetPlusTrackAddonSeedProducer);
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.cc
index d5177e8b9e7a4..58c4a8be8f77a 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 <fstream>
 #include <vector>
 #include <iomanip>
@@ -21,6 +23,7 @@ using namespace jpt;
 //
 JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC)
     : verbose_(pset.getParameter<bool>("Verbose")),
+      usePAT_(pset.getParameter<bool>("UsePAT")),
       vectorial_(pset.getParameter<bool>("VectorialCorrection")),
       vecResponse_(pset.getParameter<bool>("UseResponseInVecCorr")),
       useInConeTracks_(pset.getParameter<bool>("UseInConeTracks")),
@@ -40,10 +43,16 @@ JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm:
       muons_(pset.getParameter<edm::InputTag>("Muons")),
       electrons_(pset.getParameter<edm::InputTag>("Electrons")),
       electronIds_(pset.getParameter<edm::InputTag>("ElectronIds")),
+      patmuons_(pset.getParameter<edm::InputTag>("PatMuons")),
+      patelectrons_(pset.getParameter<edm::InputTag>("PatElectrons")),
       trackQuality_(reco::TrackBase::qualityByName(pset.getParameter<std::string>("TrackQuality"))),
       response_(Map(pset.getParameter<std::string>("ResponseMap"), verbose_)),
       efficiency_(Map(pset.getParameter<std::string>("EfficiencyMap"), verbose_)),
       leakage_(Map(pset.getParameter<std::string>("LeakageMap"), verbose_)),
+      muonPtmatch_(pset.getParameter<double>("muonPtmatch")),
+      muonEtamatch_(pset.getParameter<double>("muonEtamatch")),
+      muonPhimatch_(pset.getParameter<double>("muonPhimatch")),
+      electronDRmatch_(pset.getParameter<double>("electronDRmatch")),
       pionMass_(0.140),
       muonMass_(0.105),
       elecMass_(0.000511),
@@ -90,15 +99,52 @@ JetPlusTrackCorrector::JetPlusTrackCorrector(const edm::ParameterSet& pset, edm:
 
   input_jetTracksAtVertex_token_ = iC.consumes<reco::JetTracksAssociation::Container>(jetTracksAtVertex_);
   input_jetTracksAtCalo_token_ = iC.consumes<reco::JetTracksAssociation::Container>(jetTracksAtCalo_);
-  inut_reco_muons_token_ = iC.consumes<RecoMuons>(muons_);
   input_pvCollection_token_ = iC.consumes<reco::VertexCollection>(srcPVs_);
+
+  input_reco_muons_token_ = iC.consumes<RecoMuons>(muons_);
   input_reco_elecs_token_ = iC.consumes<RecoElectrons>(electrons_);
   input_reco_elec_ids_token_ = iC.consumes<RecoElectronIds>(electronIds_);
+  if (usePAT_) {
+    input_pat_muons_token_ = iC.consumes<pat::MuonCollection>(patmuons_);
+    input_pat_elecs_token_ = iC.consumes<pat::ElectronCollection>(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();
+  matchTracks(fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs);
+  if (!usePAT_) {
+    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;
+}
 
 // -----------------------------------------------------------------------------
 //
@@ -111,8 +157,6 @@ double JetPlusTrackCorrector::correction(const reco::Jet& fJet,
                                          MatchedTracks& muons,
                                          MatchedTracks& elecs,
                                          bool& validMatches) {
-  //  std::cout<<" JetPlusTrackCorrector::correction "<<std::endl;
-
   theResponseOfChargedWithEff = 0.;
   theResponseOfChargedWithoutEff = 0.;
   theSumPtWithEff = 0.;
@@ -135,10 +179,6 @@ double JetPlusTrackCorrector::correction(const reco::Jet& fJet,
     return 1.;
   }
 
-  //  std::cout<<" Jet can be corrected "<<std::endl;
-
-  // std::cout<<" Tracks are matched "<<std::endl;
-
   // Debug
   if (verbose_) {
     edm::LogInfo("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
@@ -189,20 +229,6 @@ double JetPlusTrackCorrector::correction(const reco::Jet& fJet,
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
-  //   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 <<" "<<
-  theSumPtWithoutEff <<" "<<
-  theSumEnergyWithEff <<" "<<
-  theSumEnergyWithoutEff <<std::endl;
-*/
-
   // Return energy correction
   return scale;
 }
@@ -223,9 +249,25 @@ double JetPlusTrackCorrector::correction(const reco::Particle::LorentzVector& je
 
 // -----------------------------------------------------------------------------
 //
+void JetPlusTrackCorrector::matchTracks(const reco::Jet& fJet,
+                                        const edm::Event& event,
+                                        const edm::EventSetup& setup,
+                                        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);
+
+  return;
+}
+
 bool JetPlusTrackCorrector::matchTracks(const reco::Jet& fJet,
                                         const edm::Event& event,
-                                        const edm::EventSetup& setup,  //@@ required by method in derived class
+                                        const edm::EventSetup& setup,
                                         jpt::MatchedTracks& pions,
                                         jpt::MatchedTracks& muons,
                                         jpt::MatchedTracks& elecs) {
@@ -233,8 +275,6 @@ bool JetPlusTrackCorrector::matchTracks(const reco::Jet& fJet,
   JetTracks jet_tracks;
   bool ok = jetTrackAssociation(fJet, event, setup, jet_tracks);
 
-  // std::cout<<"JetPlusTrackCorrector::matchTracks, JetTrackAssociation ok="<<ok<<std::endl;
-
   if (!ok) {
     return false;
   }
@@ -265,8 +305,6 @@ bool JetPlusTrackCorrector::jetTrackAssociation(const reco::Jet& fJet,
 
   // Check if labels are given
   if (!jetTracksAtVertex_.label().empty() && !jetTracksAtCalo_.label().empty()) {
-    //std::cout<<" Try to associate with splitting "<< std::endl;
-
     return jtaUsingEventData(fJet, event, trks);
   } else {
     edm::LogWarning("PatJPTCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
@@ -299,15 +337,16 @@ bool JetPlusTrackCorrector::jtaUsingEventData(const reco::Jet& fJet, const edm::
     return false;
   }
 
-  // std::cout<<" JetPlusTrackCorrector::jtaUsingEventData::here "<<jetSplitMerge_<<std::endl;
-
   // Retrieve jet-tracks association for given jet
   const reco::JetTracksAssociation::Container jtV = *(jetTracksAtVertex.product());
   TrackRefs excluded;
+  TrackRefs relocate;
   if (jetSplitMerge_ < 0) {
     trks.vertex_ = reco::JetTracksAssociation::getValue(jtV, fJet);
   } else {
     rebuildJta(fJet, jtV, trks.vertex_, excluded);
+    rebuildJta(fJet, jtV, relocate, excluded);
+    trks.vertex_ = relocate;
   }
 
   // Check if any tracks are associated to jet at vertex
@@ -338,23 +377,18 @@ bool JetPlusTrackCorrector::jtaUsingEventData(const reco::Jet& fJet, const edm::
     excludeJta(fJet, jtC, trks.caloFace_, excluded);
   }
 
-  //   std::cout<<" JTA:Tracks in vertex "<<trks.vertex_.size()<<" in calo "<<trks.caloFace_.size()<<std::endl;
-
-  // Successful
   return true;
 }
 
 // -----------------------------------------------------------------------------
 //
 bool JetPlusTrackCorrector::getMuons(const edm::Event& event, edm::Handle<RecoMuons>& reco_muons) const {
-  event.getByToken(inut_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;
-  }
+  event.getByToken(input_reco_muons_token_, reco_muons);
+  return true;
+}
+
+bool JetPlusTrackCorrector::getMuons(const edm::Event& event, edm::Handle<pat::MuonCollection>& pat_muons) const {
+  event.getByToken(input_pat_muons_token_, pat_muons);
   return true;
 }
 
@@ -380,24 +414,40 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
 
   // Get RECO muons
   edm::Handle<RecoMuons> reco_muons;
+  edm::Handle<pat::MuonCollection> pat_muons;
   bool found_reco_muons = true;
+  bool found_pat_muons = true;
   if (useMuons_) {
-    getMuons(event, reco_muons);
+    if (!usePAT_) {
+      getMuons(event, reco_muons);
+    } else {
+      getMuons(event, pat_muons);
+      found_reco_muons = false;
+    }
   }
 
   // Get RECO electrons and their ids
   edm::Handle<RecoElectrons> reco_elecs;
+  edm::Handle<pat::ElectronCollection> pat_elecs;
   edm::Handle<RecoElectronIds> reco_elec_ids;
   bool found_reco_elecs = true;
+  bool found_pat_elecs = true;
   if (useElecs_) {
-    getElectrons(event, reco_elecs, reco_elec_ids);
+    if (!usePAT_) {
+      getElectrons(event, reco_elecs, reco_elec_ids);
+    } else {
+      getElectrons(event, pat_elecs);
+      found_reco_elecs = false;
+    }
   }
 
   // Check RECO products found
   if (!found_reco_muons || !found_reco_elecs) {
-    edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
-                                           << " Unable to access RECO collections for muons and electrons";
-    return;
+    if (!found_pat_muons || !found_pat_elecs) {
+      edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
+                                             << " Unable to access RECO collections for muons and electrons";
+      return;
+    }
   }
 
   // Identify pions/muons/electrons that are "in/in" and "in/out"
@@ -405,8 +455,6 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
     TrackRefs::const_iterator itrk = jet_tracks.vertex_.begin();
     TrackRefs::const_iterator jtrk = jet_tracks.vertex_.end();
 
-    //    std::cout<<" Print theSumPtForBeta "<<theSumPtForBeta<<std::endl;
-
     double theSumPtForBetaOld = theSumPtForBeta;
 
     for (; itrk != jtrk; ++itrk) {
@@ -417,8 +465,6 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
 
       const reco::TrackBaseRef ttr1(*itrk);
 
-      //      std::cout<<" Size of PV "<<pvCollection->size()<<std::endl;
-
       int numpv = 0;
 
       int itrack_belong = -1;
@@ -428,35 +474,36 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
         std::vector<reco::TrackBaseRef>::const_iterator rr = find((*iv).tracks_begin(), (*iv).tracks_end(), ttr1);
         if (rr != (*iv).tracks_end()) {
           itrack_belong++;
-          //          std::cout<<" Numpv "<<numpv<<std::endl;
           break;
         }
 
       }  // all vertices
 
-      //      std::cout<<" Track in PV "<<itrack_belong<<" "<<numpv<<std::endl;
-
       if (numpv > 1 && itrack_belong == 0) {
-        //       std::cout<<" Drop track "<<std::endl;
         continue;
       }
 
-      // std::cout<<" we take it "<<numpv<<" "<<itrack_belong<<std::endl;
-
       if (failTrackQuality(itrk)) {
         continue;
       }
 
-      //     std::cout<<" Track accepted "<<std::endl;
-
       TrackRefs::iterator it = jet_tracks.caloFace_.end();
       bool found = findTrack(jet_tracks, itrk, it);
+      bool muaccept = false;
+      bool eleaccept = false;
+      if (found_reco_muons)
+        muaccept = matchMuons(itrk, reco_muons);
+      else if (found_pat_muons) {
+        muaccept = matchMuons(itrk, pat_muons);
+      }
+      if (found_reco_elecs)
+        eleaccept = matchElectrons(itrk, reco_elecs, reco_elec_ids);
+      else if (found_pat_elecs) {
+        eleaccept = matchElectrons(itrk, pat_elecs);
+      }
 
-      //       std::cout<<"JetPlusTrackCorrector::matchTracks:  jet_tracks.caloFace_.size()="<<jet_tracks.caloFace_.size()
-      //                <<" found = "<<found<<std::endl;
-
-      bool is_muon = useMuons_ && matchMuons(itrk, reco_muons);
-      bool is_ele = useElecs_ && matchElectrons(itrk, reco_elecs, reco_elec_ids);
+      bool is_muon = useMuons_ && muaccept;
+      bool is_ele = useElecs_ && eleaccept;
 
       if (found) {
         if (is_muon) {
@@ -473,8 +520,6 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
           elecs.inVertexOutOfCalo_.push_back(*itrk);
         } else {
           pions.inVertexOutOfCalo_.push_back(*itrk);
-          //         std::cout<<"JetPlusTrackCorrector::matchTracks: pions.inVertexOutOfCalo_.push_back(*itrk), size="
-          //                  <<pions.inVertexOutOfCalo_.size() <<std::endl;
         }
       }
     }
@@ -496,8 +541,21 @@ void JetPlusTrackCorrector::matchTracks(const JetTracks& jet_tracks,
       bool found = findTrack(pions, muons, elecs, itrk);
 
       if (!found) {
-        bool is_muon = useMuons_ && matchMuons(itrk, reco_muons);
-        bool is_ele = useElecs_ && matchElectrons(itrk, reco_elecs, reco_elec_ids);
+        bool muaccept = false;
+        bool eleaccept = false;
+        if (found_reco_muons)
+          muaccept = matchMuons(itrk, reco_muons);
+        else if (found_pat_muons) {
+          muaccept = matchMuons(itrk, pat_muons);
+        }
+        if (found_reco_elecs)
+          eleaccept = matchElectrons(itrk, reco_elecs, reco_elec_ids);
+        else if (found_pat_elecs) {
+          eleaccept = matchElectrons(itrk, pat_elecs);
+        }
+
+        bool is_muon = useMuons_ && muaccept;
+        bool is_ele = useElecs_ && eleaccept;
 
         if (is_muon) {
           muons.outOfVertexInCalo_.push_back(*itrk);
@@ -535,30 +593,19 @@ bool JetPlusTrackCorrector::getElectrons(const edm::Event& event,
                                          edm::Handle<RecoElectrons>& reco_elecs,
                                          edm::Handle<RecoElectronIds>& reco_elec_ids) const {
   event.getByToken(input_reco_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;
-  }
   event.getByToken(input_reco_elec_ids_token_, reco_elec_ids);
-  if (!reco_elec_ids.isValid() || reco_elec_ids.failedToGet()) {
-    edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
-                                           << " Invalid handle to reco::GsfElectron collection"
-                                           << " with InputTag (label:instance:process) \"" << electronIds_.label()
-                                           << ":" << electronIds_.instance() << ":" << electronIds_.process() << "\"";
-    return false;
-  }
+  return true;
+}
+
+bool JetPlusTrackCorrector::getElectrons(const edm::Event& event,
+                                         edm::Handle<pat::ElectronCollection>& pat_elecs) const {
+  event.getByToken(input_pat_elecs_token_, pat_elecs);
   return true;
 }
 
 // -----------------------------------------------------------------------------
 //
 bool JetPlusTrackCorrector::failTrackQuality(TrackRefs::const_iterator& itrk) const {
-  //  if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; }
-  //  else { return false; }
-
   bool retcode = false;
 
   if (useTrackQuality_ && !(*itrk)->quality(trackQuality_)) {
@@ -622,14 +669,6 @@ bool JetPlusTrackCorrector::tracksInCalo(const MatchedTracks& pions,
 //
 JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection(const P4& jet, const MatchedTracks& pions) {
   P4 corr_pions;
-  /*
-  std::cout<<" pionCorrection::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
-  theResponseOfChargedWithoutEff <<" "<<
-  theSumPtWithEff <<" "<<
-  theSumPtWithoutEff <<" "<<
-  theSumEnergyWithEff <<" "<<
-  theSumEnergyWithoutEff <<std::endl;
-*/
 
   // In-cone
 
@@ -771,7 +810,6 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::jetDirFromTracks(const P4& corr
     TrackRefs::iterator jtrk = pions.inVertexInCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
-      //      tracks_present = true;
       tracks_present_inin = true;
     }
   }
@@ -781,7 +819,6 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::jetDirFromTracks(const P4& corr
     TrackRefs::iterator jtrk = pions.inVertexOutOfCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
-      //      tracks_present = true;
     }
   }
 
@@ -850,18 +887,6 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr(const P4& jet,
   // Correction to be applied to jet 4-momentum
   P4 correction;
 
-  /*
-  std::cout<<" >>>>> Jet "<<jet.pt()<<" "<<jet.eta()<<" "<<jet.phi()<<" Number of tracks "<<tracks.size()<<" Pions? "<<is_pion<<" InVert "<<in_cone_at_vertex<<
-  " InCalo "<<in_cone_at_calo_face<<std::endl;
-  
-  std::cout<<" calculateCorr Start::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
-  theResponseOfChargedWithoutEff <<" "<<
-  theSumPtWithEff <<" "<<
-  theSumPtWithoutEff <<" "<<
-  theSumEnergyWithEff <<" "<<
-  theSumEnergyWithoutEff <<std::endl;
-*/
-
   // Reset efficiency container
   eff.reset();
 
@@ -979,14 +1004,6 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr(const P4& jet,
     theSumEnergyWithEff += theSumEnergy;
     theSumEnergyWithoutEff += theSumEnergy;
   }
-  /*
-  std::cout<<" calculateCorr End::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
-  theResponseOfChargedWithoutEff <<" "<<
-  theSumPtWithEff <<" "<<
-  theSumPtWithoutEff <<" "<<
-  theSumEnergyWithEff <<" "<<
-  theSumEnergyWithoutEff <<std::endl;
-*/
   return correction;
 }
 
@@ -1051,14 +1068,6 @@ JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionEfficiency(const P4& jet,
   theResponseOfChargedWithEff += theSumResp;
   theSumPtWithEff += theSumPt;
   theSumEnergyWithEff += theSumEnergy;
-  /*      
-      std::cout<<" Efficiency correction End::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
-      theResponseOfChargedWithoutEff <<" "<<
-      theSumPtWithEff <<" "<<
-      theSumPtWithoutEff <<" "<<
-      theSumEnergyWithEff <<" "<<
-      theSumEnergyWithoutEff <<std::endl;
-*/
   return correction;
 }
 
@@ -1086,7 +1095,25 @@ bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk, const ed
       return false;
     }
 
-    if (*itrk == imuon->innerTrack()) {
+    if (*itrk == imuon->innerTrack())
+      return true;
+  }
+
+  return false;
+}
+
+bool JetPlusTrackCorrector::matchMuons(TrackRefs::const_iterator& itrk,
+                                       const edm::Handle<pat::MuonCollection>& muons) const {
+  if (muons->empty()) {
+    return false;
+  }
+
+  for (auto const& muon : *muons) {
+    if (muon.innerTrack().isNull() == 1)
+      continue;
+    if (std::abs((**itrk).pt() - muon.innerTrack()->pt()) < muonPtmatch_ &&
+        std::abs((**itrk).eta() - muon.innerTrack()->eta()) < muonEtamatch_ &&
+        std::abs(reco::deltaPhi((**itrk).phi(), muon.innerTrack()->phi())) < muonPhimatch_) {
       return true;
     }
   }
@@ -1103,13 +1130,10 @@ bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk,
     return false;
   }
 
-  double deltaR = 999.;
   double deltaRMIN = 999.;
 
   uint32_t electron_index = 0;
-  RecoElectrons::const_iterator ielec = elecs->begin();
-  RecoElectrons::const_iterator jelec = elecs->end();
-  for (; ielec != jelec; ++ielec) {
+  for (auto const& ielec : *elecs) {
     edm::Ref<RecoElectrons> electron_ref(elecs, electron_index);
     electron_index++;
 
@@ -1118,21 +1142,28 @@ bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk,
     }  //@@ Check for null value
 
     // DR matching b/w electron and track
-    double deltaphi = fabs(ielec->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;
+    auto dR2 = deltaR2(ielec, **itrk);
+    if (dR2 < deltaRMIN) {
+      deltaRMIN = dR2;
     }
   }
+  return deltaRMIN < electronDRmatch_ * electronDRmatch_;
+}
 
-  if (deltaR < 0.02)
-    return true;
-  else
+bool JetPlusTrackCorrector::matchElectrons(TrackRefs::const_iterator& itrk,
+                                           const edm::Handle<pat::ElectronCollection>& elecs) const {
+  if (elecs->empty()) {
     return false;
+  }
+
+  double deltaRMIN = 999.;
+  for (auto const& ielec : *elecs) {
+    auto dR2 = deltaR2(ielec, **itrk);
+    if (dR2 < deltaRMIN) {
+      deltaRMIN = dR2;
+    }
+  }
+  return deltaRMIN < electronDRmatch_ * electronDRmatch_;
 }
 
 // -----------------------------------------------------------------------------
@@ -1141,8 +1172,6 @@ void JetPlusTrackCorrector::rebuildJta(const reco::Jet& fJet,
                                        const JetTracksAssociations& jtV0,
                                        TrackRefs& tracksthis,
                                        TrackRefs& Excl) const {
-  // std::cout<<" NEW1 Merge/Split schema "<<jetSplitMerge_<<std::endl;
-
   tracksthis = reco::JetTracksAssociation::getValue(jtV0, fJet);
 
   if (jetSplitMerge_ < 0)
@@ -1154,8 +1183,6 @@ void JetPlusTrackCorrector::rebuildJta(const reco::Jet& fJet,
   TrackRefs tracks = tracksthis;
   tracksthis.clear();
 
-  //  std::cout<<" Size of initial vector "<<tracks.size()<<" "<<fJet.et()<<" "<<fJet.eta()<<" "<<fJet.phi()<<std::endl;
-
   int tr = 0;
 
   double jetEta = fJet.eta();
@@ -1192,13 +1219,10 @@ void JetPlusTrackCorrector::rebuildJta(const reco::Jet& fJet,
         flag = 0;
 
       if (flag == 0) {
-        //std::cout<<" Track belong to another jet also "<<dR2<<" "<<
-        //(*ii)->et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "<<scalethis<<" "<<scale<<" "<<flag<<std::endl;
         break;
       }
     }
 
-    //std::cout<<" Track "<<tr<<" "<<flag<<" "<<dR2this<<" "<<dR2check<<" Jet "<<fJet.eta()<<" "<< fJet.phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<std::endl;
     if (flag == 1) {
       tracksthis.push_back(*it);
     } else {
@@ -1206,7 +1230,6 @@ void JetPlusTrackCorrector::rebuildJta(const reco::Jet& fJet,
     }
   }
 
-  //std::cout<<" The new size of tracks "<<tracksthis.size()<<" Excludede "<<Excl.size()<<std::endl;
   return;
 }
 
@@ -1216,8 +1239,6 @@ void JetPlusTrackCorrector::excludeJta(const reco::Jet& fJet,
                                        const JetTracksAssociations& jtV0,
                                        TrackRefs& tracksthis,
                                        const TrackRefs& Excl) const {
-  //std::cout<<" NEW2" << std::endl;
-
   tracksthis = reco::JetTracksAssociation::getValue(jtV0, fJet);
   if (Excl.empty())
     return;
@@ -1227,20 +1248,13 @@ void JetPlusTrackCorrector::excludeJta(const reco::Jet& fJet,
   TrackRefs tracks = tracksthis;
   tracksthis.clear();
 
-  //std::cout<<" Size of initial vector "<<tracks.size()<<" "<<fJet.et()<<" "<<fJet.eta()<<" "<<fJet.phi()<<std::endl;
-
   for (TrackRefs::iterator it = tracks.begin(); it != tracks.end(); it++) {
-    //std::cout<<" Track at calo surface "
-    //<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<std::endl;
     TrackRefs::iterator itold = find(Excl.begin(), Excl.end(), (*it));
     if (itold == Excl.end()) {
       tracksthis.push_back(*it);
     }
-    //else { std::cout<<"Exclude "<<(**it).eta()<<" "<<(**it).phi()<<std::endl; }
   }
 
-  //std::cout<<" Size of calo tracks "<<tracksthis.size()<<std::endl;
-
   return;
 }
 
@@ -1256,10 +1270,6 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   double mScale = 1.;
   double NewResponse = fJet.energy();
 
-  //std::cout<<"---JetPlusTrackCorrector::correctAA, Jet initial: NewResponse="<<NewResponse <<" et = "<<fJet.et()
-  //         <<" pt= "<<fJet.pt()<<" eta="<<fJet.eta()<<" phi="<<fJet.phi() <<" ja="<<ja
-  //        <<" trBgOutOfVertex="<<trBgOutOfVertex.size()<< " trBgOutOfCalo="<<trBgOutOfCalo.size()<<std::endl;
-
   if (trBgOutOfVertex.empty())
     return mScale;
   double EnergyOfBackgroundCharged = 0.;
@@ -1268,14 +1278,9 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   //
   // calculate the mean response
   //
-  //     double MeanResponseOfBackgroundCharged = 0.;
-  //     double MeanEnergyOfBackgroundCharged   = 0.;
 
   //================= EnergyOfBackgroundCharged ==================>
   for (reco::TrackRefVector::iterator iBgtV = trBgOutOfVertex.begin(); iBgtV != trBgOutOfVertex.end(); iBgtV++) {
-    // Temporary solution>>>>>> Remove tracks with pt>50 GeV
-    //   if( (**iBgtV).pt() >= 50. ) continue;
-    //response_.value(ieta,ipt);
     double eta = fabs((**iBgtV).eta());
     double pt = fabs((**iBgtV).pt());
     uint32_t ieta = response_.etaBin(eta);
@@ -1284,17 +1289,9 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
     if (fabs(fJet.eta() - (**iBgtV).eta()) > mConeSize)
       continue;
 
-    //      // Check bins (not for mips)
-    //         if ( ieta >= response_.nEtaBins() ) { continue; }
-    //	 if ( ipt >= response_.nPtBins() ) { ipt = response_.nPtBins() - 1; }
-
     double echarBg = sqrt((**iBgtV).px() * (**iBgtV).px() + (**iBgtV).py() * (**iBgtV).py() +
                           (**iBgtV).pz() * (**iBgtV).pz() + 0.14 * 0.14);
 
-    //	 ResponseOfBackgroundCharged += echarBg*response_.value(ieta,ipt)/efficiency_.value(ieta,ipt);
-
-    //	 std::cout<<" Efficiency of bg tracks "<<efficiency_.value(ieta,ipt)<<std::endl;
-
     EnergyOfBackgroundCharged += echarBg / efficiency_.value(ieta, ipt);
 
   }  // Energy BG tracks
@@ -1302,9 +1299,6 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   //============= ResponseOfBackgroundCharged =======================>
 
   for (reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) {
-    // Temporary solution>>>>>> Remove tracks with pt>50 GeV
-    //   if( (**iBgtC).pt() >= 50. ) continue;
-    //response_.value(ieta,ipt);
     double eta = fabs((**iBgtC).eta());
     double pt = fabs((**iBgtC).pt());
     uint32_t ieta = response_.etaBin(eta);
@@ -1326,8 +1320,6 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
 
     ResponseOfBackgroundCharged += echarBg * response_.value(ieta, ipt) / efficiency_.value(ieta, ipt);
 
-    //       std::cout<<" Efficiency of bg tracks "<<efficiency_.value(ieta,ipt)<<std::endl;
-
   }  // Response of BG tracks
 
   //=================================================================>
@@ -1341,9 +1333,6 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   double pz = 0.;
 
   for (reco::TrackRefVector::const_iterator it = pioninout.begin(); it != pioninout.end(); it++) {
-    //          std::cout<<" Track in out, size= "<<pioninout.size()<<" p= "<<(*it)->p()<<" pt= "<<(*it)->pt()
-    //                   <<" eta=  "<<(*it)->eta()<<" phi= "<<(*it)->phi()<<std::endl;
-
     px += (*it)->px();
     py += (*it)->py();
     pz += (*it)->pz();
@@ -1358,9 +1347,6 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   double pz_in = 0.;
 
   for (reco::TrackRefVector::const_iterator it = pioninin.begin(); it != pioninin.end(); it++) {
-    //          std::cout<<" Track in in, size= "<<pioninin.size()<<" p= "<<(*it)->p()<<" pt= "<<(*it)->pt()
-    //                   <<" eta= "<<(*it)->eta()<<" phi= "<<(*it)->phi()<<std::endl;
-
     px_in += (*it)->px();
     py_in += (*it)->py();
     pz_in += (*it)->pz();
@@ -1370,25 +1356,16 @@ double JetPlusTrackCorrector::correctAA(const reco::Jet& fJet,
   //===================================================================>
 
   //=>
-  //    double SquareEtaRingWithoutJets = 4*(M_PI*mConeSize - mConeSize*mConeSize);
   double SquareEtaRingWithoutJets = ja;
 
-  //   std::cout<<"---SquareEtaRingWithoutJets="<<SquareEtaRingWithoutJets<<std::endl;
-
   EnergyOfBackgroundCharged = EnergyOfBackgroundCharged / SquareEtaRingWithoutJets;
   ResponseOfBackgroundCharged = ResponseOfBackgroundCharged / SquareEtaRingWithoutJets;
-  //    NumberOfBackgroundCharged   = NumberOfBackgroundCharged/SquareEtaRingWithoutJets;
 
   EnergyOfBackgroundCharged = M_PI * mConeSize * mConeSize * EnergyOfBackgroundCharged;
   ResponseOfBackgroundCharged = M_PI * mConeSize * mConeSize * ResponseOfBackgroundCharged;
-  //    NumberOfBackgroundCharged   = M_PI*mConeSize*mConeSize*NumberOfBackgroundCharged;
 
   NewResponse = NewResponse - EnergyOfBackgroundCharged + ResponseOfBackgroundCharged;
 
-  //      std::cout<<"====JetPlusTrackCorrector, Old response=fJet.energy()"<<fJet.energy()
-  //               <<" EnergyOfBackgroundCharged="<<EnergyOfBackgroundCharged
-  //               <<" ResponseOfBackgroundCharged="<<ResponseOfBackgroundCharged
-
   mScale = NewResponse / fJet.energy();
   if (mScale < 0.)
     mScale = 0.;
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h
index daa0d68cfc3eb..9425d6f7cb852 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackCorrector.h
@@ -19,6 +19,9 @@
 #include "DataFormats/TrackReco/interface/TrackFwd.h"
 #include "DataFormats/VertexReco/interface/VertexFwd.h"
 #include "DataFormats/VertexReco/interface/Vertex.h"
+#include "DataFormats/PatCandidates/interface/Electron.h"
+#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
+#include "DataFormats/PatCandidates/interface/Muon.h"
 
 #include "boost/range/iterator_range.hpp"
 #include <sstream>
@@ -190,6 +193,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 +260,15 @@ class JetPlusTrackCorrector {
                    jpt::MatchedTracks& muons,
                    jpt::MatchedTracks& elecs);
 
+  void 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 +344,22 @@ class JetPlusTrackCorrector {
   /// Get RECO muons
   bool getMuons(const edm::Event&, edm::Handle<RecoMuons>&) const;
 
+  bool getMuons(const edm::Event&, edm::Handle<pat::MuonCollection>&) const;
+
   /// Get RECO electrons
   bool getElectrons(const edm::Event&, edm::Handle<RecoElectrons>&, edm::Handle<RecoElectronIds>&) const;
 
+  bool getElectrons(const edm::Event&, edm::Handle<pat::ElectronCollection>&) const;
+
   /// Matches tracks to RECO muons
   bool matchMuons(TrackRefs::const_iterator&, const edm::Handle<RecoMuons>&) const;
+  bool matchMuons(TrackRefs::const_iterator&, const edm::Handle<pat::MuonCollection>&) const;
 
   /// Matches tracks to RECO electrons
   bool matchElectrons(TrackRefs::const_iterator&,
                       const edm::Handle<RecoElectrons>&,
                       const edm::Handle<RecoElectronIds>&) const;
+  bool matchElectrons(TrackRefs::const_iterator&, const edm::Handle<pat::ElectronCollection>&) const;
 
   /// Check on track quality
   bool failTrackQuality(TrackRefs::const_iterator&) const;
@@ -368,6 +396,7 @@ class JetPlusTrackCorrector {
 protected:
   // Some general configuration
   bool verbose_;
+  bool usePAT_;
   bool vectorial_;
   bool vecResponse_;
   bool useInConeTracks_;
@@ -392,6 +421,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 +432,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 +459,12 @@ class JetPlusTrackCorrector {
 private:
   edm::EDGetTokenT<reco::JetTracksAssociation::Container> input_jetTracksAtVertex_token_;
   edm::EDGetTokenT<reco::JetTracksAssociation::Container> input_jetTracksAtCalo_token_;
-  edm::EDGetTokenT<RecoMuons> inut_reco_muons_token_;
+  edm::EDGetTokenT<RecoMuons> input_reco_muons_token_;
   edm::EDGetTokenT<reco::VertexCollection> input_pvCollection_token_;
   edm::EDGetTokenT<RecoElectrons> input_reco_elecs_token_;
   edm::EDGetTokenT<RecoElectronIds> input_reco_elec_ids_token_;
+  edm::EDGetTokenT<pat::MuonCollection> input_pat_muons_token_;
+  edm::EDGetTokenT<pat::ElectronCollection> input_pat_elecs_token_;
 };
 
 // ---------- Inline methods ----------
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
index 5ebd0b5878f23..4d41a8b520672 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.cc
@@ -21,8 +21,10 @@
 
 // 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 "RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h"
@@ -30,6 +32,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"
@@ -56,20 +60,29 @@ using namespace jpt;
 //
 JetPlusTrackProducer::JetPlusTrackProducer(const edm::ParameterSet& iConfig) {
   //register your products
-  src = iConfig.getParameter<edm::InputTag>("src");
-  alias = iConfig.getUntrackedParameter<string>("alias");
+  src_ = iConfig.getParameter<edm::InputTag>("src");
+  srcTrackJets_ = iConfig.getParameter<edm::InputTag>("srcTrackJets");
+  alias_ = iConfig.getUntrackedParameter<string>("alias");
   srcPVs_ = iConfig.getParameter<edm::InputTag>("srcPVs");
   vectorial_ = iConfig.getParameter<bool>("VectorialCorrection");
-  useZSP = iConfig.getParameter<bool>("UseZSP");
-  ptCUT = iConfig.getParameter<double>("ptCUT");
+  useZSP_ = iConfig.getParameter<bool>("UseZSP");
+  ptCUT_ = iConfig.getParameter<double>("ptCUT");
+  dRcone_ = iConfig.getParameter<double>("dRcone");
+  usePAT_ = iConfig.getParameter<bool>("UsePAT");
+
   mJPTalgo = new JetPlusTrackCorrector(iConfig, consumesCollector());
-  if (useZSP)
+  if (useZSP_)
     mZSPalgo = new ZSPJPTJetCorrector(iConfig);
 
-  produces<reco::JPTJetCollection>().setBranchAlias(alias);
+  produces<reco::JPTJetCollection>().setBranchAlias(alias_);
+  produces<reco::CaloJetCollection>().setBranchAlias("ak4CaloJetsJPT");
 
-  input_jets_token_ = consumes<edm::View<reco::CaloJet> >(src);
+  input_jets_token_ = consumes<edm::View<reco::CaloJet> >(src_);
+  input_addjets_token_ = consumes<edm::View<reco::CaloJet> >(iConfig.getParameter<edm::InputTag>("srcAddCaloJets"));
+  input_trackjets_token_ = consumes<edm::View<reco::TrackJet> >(srcTrackJets_);
   input_vertex_token_ = consumes<reco::VertexCollection>(srcPVs_);
+  mExtrapolations_ =
+      consumes<std::vector<reco::TrackExtrapolation> >(iConfig.getParameter<edm::InputTag>("extrapolations"));
 }
 
 JetPlusTrackProducer::~JetPlusTrackProducer() {
@@ -80,36 +93,100 @@ JetPlusTrackProducer::~JetPlusTrackProducer() {
 //
 // member functions
 //
+bool sort_by_pt(const reco::JPTJet& a, const reco::JPTJet& b) { return (a.pt() > b.pt()); }
 
 // ------------ method called to produce the data  ------------
 void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   using namespace edm;
 
-  //  std::cout<<" RecoJets::JetPlusTrackProducer::produce "<<std::endl;
-
-  // get stuff from Event
-  edm::Handle<edm::View<reco::CaloJet> > jets_h;
-  iEvent.getByToken(input_jets_token_, jets_h);
+  auto const& jets_h = iEvent.get(input_jets_token_);
+  auto const& addjets_h = iEvent.get(input_addjets_token_);
+  auto const& iExtrapolations = iEvent.get(mExtrapolations_);
+  edm::RefProd<reco::CaloJetCollection> pOut1RefProd = iEvent.getRefBeforePut<reco::CaloJetCollection>();
+  edm::Ref<reco::CaloJetCollection>::key_type idxCaloJet = 0;
 
-  //  auto pOut = std::make_unique<reco::CaloJetCollection>();
   auto pOut = std::make_unique<reco::JPTJetCollection>();
+  auto pOut1 = std::make_unique<reco::CaloJetCollection>();
+
+  double scaleJPT = 1.;
+  for (auto const& jet : iEvent.get(input_trackjets_token_)) {
+    int icalo = -1;
+    int i = 0;
+    for (auto const& oldjet : addjets_h) {
+      double dr2 = deltaR2(jet, oldjet);
+      if (dr2 <= dRcone_ * dRcone_) {
+        icalo = i;
+      }
+      i++;
+    }  // Calojets
+    if (icalo < 0)
+      continue;
+    auto const& mycalo = addjets_h[icalo];
+    std::vector<edm::Ptr<reco::Track> > tracksinjet = jet.tracks();
+    reco::TrackRefVector tracksincalo;
+    reco::TrackRefVector tracksinvert;
+    for (auto const& itrack : tracksinjet) {
+      for (auto const& ixtrp : iExtrapolations) {
+        if (ixtrp.positions().empty())
+          continue;
+        if (usePAT_) {
+          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;
+        } else {
+          if (itrack.id() != ixtrp.track().id() || itrack.key() != ixtrp.track().key())
+            continue;
+        }
+        tracksinvert.push_back(ixtrp.track());
+        reco::TrackBase::Point const& point = ixtrp.positions().at(0);
+        double dr2 = deltaR2(jet, point);
+        if (dr2 <= dRcone_ * dRcone_) {
+          tracksincalo.push_back(ixtrp.track());
+        }
+      }  // Track extrapolations
+    }    // tracks
+
+    const reco::TrackJet& corrected = jet;
+    math::XYZTLorentzVector p4;
+    jpt::MatchedTracks pions;
+    jpt::MatchedTracks muons;
+    jpt::MatchedTracks elecs;
 
-  for (unsigned i = 0; i < jets_h->size(); ++i) {
-    const reco::CaloJet* oldjet = &(*(jets_h->refAt(i)));
+    scaleJPT =
+        mJPTalgo->correction(corrected, mycalo, iEvent, iSetup, tracksinvert, tracksincalo, p4, pions, muons, elecs);
+    if (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<reco::Jet>(myjet);
+      jptspe.mZSPCor = 1.;
+      reco::JPTJet fJet(p4, jet.primaryVertex()->position(), jptspe, mycalo.getJetConstituents());
+      pOut->push_back(fJet);
+      pOut1->push_back(mycalo);
+    }
+  }  // trackjets
 
-    reco::CaloJet corrected = *oldjet;
+  int iJet = 0;
+  for (auto const& oldjet : jets_h) {
+    reco::CaloJet corrected = oldjet;
 
     // ZSP corrections
-
     double factorZSP = 1.;
-    if (useZSP)
+    if (useZSP_)
       factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup);
-
     corrected.scaleEnergy(factorZSP);
 
     // JPT corrections
-
-    double scaleJPT = 1.;
+    scaleJPT = 1.;
 
     math::XYZTLorentzVector p4;
 
@@ -119,13 +196,13 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
     bool ok = false;
 
     if (!vectorial_) {
-      scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, pions, muons, elecs, ok);
+      scaleJPT = mJPTalgo->correction(corrected, oldjet, iEvent, iSetup, pions, muons, elecs, ok);
       p4 = math::XYZTLorentzVector(corrected.px() * scaleJPT,
                                    corrected.py() * scaleJPT,
                                    corrected.pz() * scaleJPT,
                                    corrected.energy() * scaleJPT);
     } else {
-      scaleJPT = mJPTalgo->correction(corrected, *oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok);
+      scaleJPT = mJPTalgo->correction(corrected, oldjet, iEvent, iSetup, p4, pions, muons, elecs, ok);
     }
 
     reco::JPTJet::Specific specific;
@@ -143,8 +220,7 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
     }
 
     // Fill JPT Specific
-    edm::RefToBase<reco::Jet> myjet = (edm::RefToBase<reco::Jet>)jets_h->refAt(i);
-    specific.theCaloJetRef = myjet;
+    specific.theCaloJetRef = edm::RefToBase<reco::Jet>(jets_h.refAt(iJet));
     specific.mZSPCor = factorZSP;
     specific.mResponseOfChargedWithEff = (float)mJPTalgo->getResponseOfChargedWithEff();
     specific.mResponseOfChargedWithoutEff = (float)mJPTalgo->getResponseOfChargedWithoutEff();
@@ -232,8 +308,6 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
     if (mJPTalgo->getSumPtForBeta() > 0.)
       Zch = Zch / mJPTalgo->getSumPtForBeta();
 
-    //     std::cout<<" Zch "<< Zch<<" "<<mJPTalgo->getSumPtForBeta()<<std::endl;
-
     if (ntracks > 0) {
       Pout = sqrt(fabs(Pout2)) / ntracks;
     }
@@ -249,8 +323,6 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
     specific.Pout = Pout;
     specific.Zch = Zch;
 
-    //       std::cout<<" Moments for charged component "<<deR2_Tr<<" "<<deEta2_Tr<<" "<<dePhi2_Tr<<std::endl;
-
     // Create JPT jet
 
     reco::Particle::Point vertex_ = reco::Jet::Point(0, 0, 0);
@@ -262,14 +334,14 @@ void JetPlusTrackProducer::produce(edm::Event& iEvent, const edm::EventSetup& iS
       vertex_ = pvCollection->begin()->position();
 
     reco::JPTJet fJet(p4, vertex_, specific, corrected.getJetConstituents());
-
-    //   fJet.printJet();
+    iJet++;
 
     // Output module
-    if (fJet.pt() > ptCUT)
+    if (fJet.pt() > ptCUT_)
       pOut->push_back(fJet);
   }
-
+  std::sort(pOut->begin(), pOut->end(), sort_by_pt);
+  iEvent.put(std::move(pOut1));
   iEvent.put(std::move(pOut));
 }
 
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h
index b4f167ce4d781..86ea67720c5df 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducer.h
@@ -30,7 +30,9 @@
 #include "ZSPJPTJetCorrector.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 <string>
 
@@ -48,13 +50,19 @@ class JetPlusTrackProducer : public edm::stream::EDProducer<> {
 private:
   JetPlusTrackCorrector* mJPTalgo;
   ZSPJPTJetCorrector* mZSPalgo;
-  edm::InputTag src;
+  edm::InputTag src_;
+  edm::InputTag srcTrackJets_;
   edm::InputTag srcPVs_;
-  std::string alias;
+  std::string alias_;
   bool vectorial_;
-  bool useZSP;
-  double ptCUT;
+  bool useZSP_;
+  bool usePAT_;
+  double ptCUT_;
+  double dRcone_;
 
   edm::EDGetTokenT<edm::View<reco::CaloJet> > input_jets_token_;
+  edm::EDGetTokenT<edm::View<reco::CaloJet> > input_addjets_token_;
+  edm::EDGetTokenT<edm::View<reco::TrackJet> > input_trackjets_token_;
   edm::EDGetTokenT<reco::VertexCollection> input_vertex_token_;
+  edm::EDGetTokenT<std::vector<reco::TrackExtrapolation> > mExtrapolations_;
 };
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
index 50f1f5508fd8e..9025278d77e42 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.cc
@@ -21,8 +21,7 @@
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDProducer.h"
-
+#include "FWCore/Framework/interface/stream/EDProducer.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
 
@@ -113,8 +112,6 @@ JetPlusTrackProducerAA::~JetPlusTrackProducerAA() {
 void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
   using namespace edm;
 
-  //  std::cout<<" RecoJets::JetPlusTrackProducerAA::produce "<<std::endl;
-
   // get stuff from Event
   edm::Handle<edm::View<reco::CaloJet> > jets_h;
   iEvent.getByToken(input_jets_token_, jets_h);
@@ -128,13 +125,9 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
     fTracks.push_back(reco::TrackRef(tracks_h, i));
   }
 
-  //=>
   edm::Handle<std::vector<reco::TrackExtrapolation> > extrapolations_h;
   iEvent.getByToken(input_extrapolations_token_, extrapolations_h);
 
-  //  std::cout<<"JetPlusTrackProducerAA::produce, extrapolations_h="<<extrapolations_h->size()<<std::endl;
-  //=>
-
   auto pOut = std::make_unique<reco::JPTJetCollection>();
 
   reco::JPTJetCollection tmpColl;
@@ -150,8 +143,6 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
     if (useZSP)
       factorZSP = mZSPalgo->correction(corrected, iEvent, iSetup);
 
-    //   std::cout << " UseZSP = "<<useZSP<<std::endl;
-
     corrected.scaleEnergy(factorZSP);
 
     // JPT corrections
@@ -179,10 +170,6 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
     reco::JPTJet::Specific specific;
 
     if (ok) {
-      //    std::cout<<" Size of Pion in-in "<<pions.inVertexInCalo_.size()<<" in-out "<<pions.inVertexOutOfCalo_.size()
-      //             <<" out-in "<<pions.outOfVertexInCalo_.size()<<" Oldjet "<<oldjet->et()<<" factorZSP "<<factorZSP
-      //             <<"  "<<corrected.et()<<" scaleJPT "<<scaleJPT<<" after JPT "<<p4.pt()<<std::endl;
-
       specific.pionsInVertexInCalo = pions.inVertexInCalo_;
       specific.pionsInVertexOutCalo = pions.inVertexOutOfCalo_;
       specific.pionsOutVertexInCalo = pions.outOfVertexInCalo_;
@@ -282,8 +269,6 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
     if (mJPTalgo->getSumPtForBeta() > 0.)
       Zch = Zch / mJPTalgo->getSumPtForBeta();
 
-    //    std::cout<<" Zch "<< Zch<<" "<<mJPTalgo->getSumPtForBeta()<<std::endl;
-
     if (ntracks > 0) {
       Pout = sqrt(fabs(Pout2)) / ntracks;
     }
@@ -338,17 +323,10 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
     }
 
     AreaNonJet[ij1] = 4 * M_PI * mConeSize - nj1 * 4 * mConeSize * mConeSize;
-
-    //      std::cout<<"+++AreaNonJet[ij1]="<<AreaNonJet[ij1]<<" nj1="<<nj1<<std::endl;
   }
 
   //===>
 
-  //  std::cout<<" The size of BG tracks: trBgOutOfVertex= "<<trBgOutOfVertex.size()
-  //           <<" trBgOutOfCalo= "<<trBgOutOfCalo.size()<<std::endl;
-  //
-  //  std::cout<<" The size of JPT jet collection "<<tmpColl.size()<<std::endl;
-
   for (reco::JPTJetCollection::iterator ij = tmpColl.begin(); ij != tmpColl.end(); ij++) {
     // Correct JPTjet for background tracks
 
@@ -357,18 +335,12 @@ void JetPlusTrackProducerAA::produce(edm::Event& iEvent, const edm::EventSetup&
 
     double ja = (AreaNonJet.find(ij))->second;
 
-    //    std::cout<<"+++ ja="<<ja<<" pioninout="<<pioninout.size()<<std::endl;
-
     double factorPU = mJPTalgo->correctAA(*ij, trBgOutOfVertex, mConeSize, pioninin, pioninout, ja, trBgOutOfCalo);
 
     (*ij).scaleEnergy(factorPU);
 
-    //   std::cout<<" FactorPU "<<factorPU<<std::endl;
-
     // Output module
     pOut->push_back(*ij);
-
-    //    std::cout<<" New JPT energy "<<(*ij).et()<<" "<<(*ij).pt()<<" "<<(*ij).eta()<<" "<<(*ij).phi()<<std::endl;
   }
 
   iEvent.put(std::move(pOut));
@@ -387,47 +359,26 @@ reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet(
   for (unsigned t = 0; t < fTracks.size(); ++t) {
     int track_bg = 0;
 
-    // if(!(*fTracks[t]).quality(trackQuality_))
-    // {
-    // cout<<"BG, BAD trackQuality, ptBgV="<<fTracks[t]->pt()<<" etaBgV = "<<fTracks[t]->eta()<<" phiBgV = "<<fTracks[t]->phi()<<endl;
-    // continue;
-    // }
-
     const reco::Track* track = &*(fTracks[t]);
     double trackEta = track->eta();
     double trackPhi = track->phi();
 
-    //  std::cout<<"++++++++++++++++>  track="<<t<<" trackEta="<<trackEta<<" trackPhi="<<trackPhi
-    //           <<" coneSize="<<mConeSize<<std::endl;
-
     //loop on jets
     for (unsigned j = 0; j < fJets.size(); ++j) {
       const reco::Jet* jet = &(fJets[j]);
       double jetEta = jet->eta();
       double jetPhi = jet->phi();
 
-      //  std::cout<<"-jet="<<j<<" jetEt ="<<jet->pt()
-      //  <<" jetE="<<jet->energy()<<" jetEta="<<jetEta<<" jetPhi="<<jetPhi<<std::endl;
-
       if (fabs(jetEta - trackEta) < mConeSize) {
-        double dphiTrackJet = fabs(trackPhi - jetPhi);
-        if (dphiTrackJet > M_PI)
-          dphiTrackJet = 2 * M_PI - dphiTrackJet;
-
+        double dphiTrackJet = deltaPhi(trackPhi, jetPhi);
         if (dphiTrackJet < mConeSize) {
           track_bg = 1;
-          //    std::cout<<"===>>>> Track inside jet at vertex, track_bg="<< track_bg <<" track="<<t<<" jet="<<j
-          //            <<" trackEta="<<trackEta<<" trackPhi="<<trackPhi
-          //            <<" jetEta="<<jetEta<<" jetPhi="<<jetPhi<<std::endl;
         }
       }
     }  //jets
 
     if (track_bg == 0) {
       trBgOutOfVertex.push_back(fTracks[t]);
-
-      //       std::cout<<"------Track outside jet at vertex, track_bg="<< track_bg<<" track="<<t
-      //               <<" trackEta="<<trackEta<<" trackPhi="<<trackPhi <<std::endl;
     }
 
   }  //tracks
@@ -439,35 +390,17 @@ reco::TrackRefVector JetPlusTrackProducerAA::calculateBGtracksJet(
                                                              ixtrp = xtrpBegin;
        ixtrp != xtrpEnd;
        ++ixtrp) {
-    //    std::cout<<"JetPlusTrackProducerAA::calculateBGtracksJet: initial track pt= "<<ixtrp->track()->pt()
-    //             <<" eta= "<<ixtrp->track()->eta()<<" phi="<<ixtrp->track()->phi()
-    //             <<" Valid? "<<ixtrp->isValid().at(0)<<std::endl;
-
-    //if( ixtrp->isValid().at(0) == 0 ) continue;
-    //in DF change in 4.2, all entries are valid.
     nValid++;
 
     reco::TrackRefVector::iterator it = find(trBgOutOfVertex.begin(), trBgOutOfVertex.end(), (*ixtrp).track());
 
     if (it != trBgOutOfVertex.end()) {
       trBgOutOfCalo.push_back(*it);
-
-      //          std::cout<<"+++trBgOutOfCalo, pt= "<<ixtrp->track()->pt()<<" eta= "<<ixtrp->track()->eta()<<" phi="<<ixtrp->track()->phi()
-      //                   <<" Valid? "<<ixtrp->isValid().at(0)<<std::endl;
     }
   }
 
-  //     std::cout<<"calculateBGtracksJet, trBgOutOfCalo="<<trBgOutOfCalo.size()
-  //              <<" trBgOutOfVertex="<<trBgOutOfVertex.size()<<" nValid="<<nValid<<endl;
-  //=====>
-
   return trBgOutOfVertex;
 }
-// ------------ method called once each job just before starting event loop  ------------
-void JetPlusTrackProducerAA::beginJob() {}
-
-// ------------ method called once each job just after ending the event loop  ------------
-void JetPlusTrackProducerAA::endJob() {}
 
 //define this as a plug-in
 //DEFINE_FWK_MODULE(JetPlusTrackProducerAA);
diff --git a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.h b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.h
index d8d07591d49e4..0578e0a5a23fa 100644
--- a/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.h
+++ b/RecoJets/JetPlusTracks/plugins/JetPlusTrackProducerAA.h
@@ -21,7 +21,7 @@
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDProducer.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"
@@ -52,14 +52,11 @@
 // class declaration
 //
 
-class JetPlusTrackProducerAA : public edm::EDProducer {
+class JetPlusTrackProducerAA : public edm::stream::EDProducer<> {
 public:
   explicit JetPlusTrackProducerAA(const edm::ParameterSet&);
   ~JetPlusTrackProducerAA() override;
-  void beginJob() override;
   void produce(edm::Event&, const edm::EventSetup&) override;
-  void endJob() override;
-  ////     reco::TrackRefVector calculateBGtracksJet(reco::JPTJetCollection&, std::vector <reco::TrackRef>&);
 
   reco::TrackRefVector calculateBGtracksJet(reco::JPTJetCollection&,
                                             std::vector<reco::TrackRef>&,
diff --git a/RecoJets/JetPlusTracks/plugins/SimpleZSPJPTJetCorrector.cc b/RecoJets/JetPlusTracks/plugins/SimpleZSPJPTJetCorrector.cc
index 2028f7d1ee92b..397dbd6c39d39 100644
--- a/RecoJets/JetPlusTracks/plugins/SimpleZSPJPTJetCorrector.cc
+++ b/RecoJets/JetPlusTracks/plugins/SimpleZSPJPTJetCorrector.cc
@@ -23,8 +23,6 @@ SimpleZSPJPTJetCorrector::SimpleZSPJPTJetCorrector(const std::string& fDataFile)
   debug_ = false;
   mParameters = new JetCorrectorParameters(fDataFile, "");
 
-  //std::cout<<" Formula "<<((mParameters->definitions()).formula()).c_str()<<std::endl;
-
   mFunc = new TFormula("function", ((mParameters->definitions()).formula()).c_str());
 
   // Read parameters
diff --git a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc
index 12b1b7edfc06a..b90af4e710c57 100644
--- a/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc
+++ b/RecoJets/JetPlusTracks/plugins/ZSPJPTJetCorrector.cc
@@ -34,7 +34,6 @@ ZSPJPTJetCorrector::ZSPJPTJetCorrector(const edm::ParameterSet& fConfig) {
     edm::FileInPath f1(file);
     mSimpleCorrector.push_back(new SimpleZSPJPTJetCorrector(f1.fullPath()));
   }
-  //   cout<<" Size of correctors "<<mSimpleCorrector.size()<<" "<<mSimpleCorrectorOffset.size()<<endl;
 }
 
 ZSPJPTJetCorrector::~ZSPJPTJetCorrector() {}
@@ -45,9 +44,6 @@ double ZSPJPTJetCorrector::correction(const reco::Jet& fJet,
   double b = 1.;
   int nPU = 0;
   if (iPU > 0) {
-    // Look for the Lumi section
-    //     LuminosityBlock lbID = iEvent.getLuminosityBlock();
-    //       cout<<" Not implemented yet "<<iEvent.run()<<endl;
     nPU = setPU();
   } else {
     if (iPU == 0)
diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
index b5c4cbdb590db..3ac026208dd5a 100644
--- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
+++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrectionsAA_cff.py
@@ -1,58 +1,18 @@
 import FWCore.ParameterSet.Config as cms
 
-# keep IC5 association for backward compatibility for external use
-from RecoJets.JetAssociationProducers.ic5JetTracksAssociatorAtVertex_cfi import *
-from RecoJets.JetAssociationProducers.trackExtrapolator_cfi import *
-#JPTtrackExtrapolatorAA = trackExtrapolator.clone()
-trackExtrapolator.trackSrc = cms.InputTag("hiGoodMergedTracks")
-
-# standard associations
-from RecoJets.JetAssociationProducers.iterativeCone5JTA_cff import *
-from RecoJets.JetAssociationProducers.sisCone5JTA_cff import *
-from RecoJets.JetAssociationProducers.kt4JTA_cff import *
-from RecoJets.JetAssociationProducers.ak5JTA_cff import *
-from RecoJets.JetAssociationProducers.ak7JTA_cff import *
 
 # ---------- Tight Electron ID
-
 from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight
 JPTeidTight = eidTight.clone()
 
 
 # ---------- Module definition
 from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import *
-
-JetPlusTrackZSPCorJetIconePu5 = cms.EDProducer(
-    "JetPlusTrackProducerAA",
-    cms.PSet(JPTZSPCorrectorICone5),
-    src = cms.InputTag("iterativeConePu5CaloJets"),
-    coneSize = cms.double(0.5),
-    tracks = cms.InputTag("hiGoodMergedTracks"),    
-    tagName = cms.vstring('ZSP_CMSSW332_Iterative_Cone_05_PU0'),
-    tagNameOffset = cms.vstring(),
-    PU = cms.int32(-1),
-    FixedPU = cms.int32(0),
-    UseZSP = cms.bool(False),
-    srcPVs  = cms.InputTag('hiSelectedVertex'),
-    alias = cms.untracked.string('JetPlusTrackZSPCorJetIcone5'),
-#=>
-    extrapolations = cms.InputTag("trackExtrapolator")
-    )
-    
-JetPlusTrackZSPCorJetIconePu5.JetTracksAssociationAtVertex = cms.InputTag("JPTiterativeConePu5JetTracksAssociatorAtVertex")
-JetPlusTrackZSPCorJetIconePu5.JetTracksAssociationAtCaloFace = cms.InputTag("JPTiterativeConePu5JetTracksAssociatorAtCaloFace")
-JetPlusTrackZSPCorJetIconePu5.JetSplitMerge = cms.int32(0)
-JetPlusTrackZSPCorJetIconePu5.UseTrackQuality = cms.bool(False)
-JetPlusTrackZSPCorJetIconePu5.UseMuons = cms.bool(False)
-JetPlusTrackZSPCorJetIconePu5.UseElectrons = cms.bool(False)
-JetPlusTrackZSPCorJetIconePu5.EfficiencyMap = cms.string("CondFormats/JetMETObjects/data/CMSSW_538HI_TrackNonEff.txt")
-JetPlusTrackZSPCorJetIconePu5.UseOutOfVertexTracks = cms.bool(False)
-
-JetPlusTrackZSPCorJetSisconePu5 = cms.EDProducer(
+JetPlusTrackZSPCorJetAntiKtPu4 = cms.EDProducer(
     "JetPlusTrackProducerAA",
-    cms.PSet(JPTZSPCorrectorICone5),
-    src = cms.InputTag("sisConePu5CaloJets"),
-    coneSize = cms.double(0.5),
+    cms.PSet(JPTZSPCorrectorAntiKt4),
+    src = cms.InputTag("akPu4CaloJets"),
+    coneSize = cms.double(0.4),
     tracks = cms.InputTag("hiGoodMergedTracks"),
     tagName = cms.vstring('ZSP_CMSSW332_Iterative_Cone_05_PU0'),
     tagNameOffset = cms.vstring(),
@@ -60,154 +20,47 @@
     FixedPU = cms.int32(0), 
     UseZSP = cms.bool(False),   
     srcPVs  = cms.InputTag('hiSelectedVertex'),
-    alias = cms.untracked.string('JetPlusTrackZSPCorJetSiscone5'),
-#=>
-    extrapolations = cms.InputTag("trackExtrapolator")   
-    )
-
-JetPlusTrackZSPCorJetSisconePu5.JetTracksAssociationAtVertex = cms.InputTag("JPTSisConePu5JetTracksAssociatorAtVertex")
-JetPlusTrackZSPCorJetSisconePu5.JetTracksAssociationAtCaloFace = cms.InputTag("JPTSisConePu5JetTracksAssociatorAtCaloFace")
-JetPlusTrackZSPCorJetSisconePu5.JetSplitMerge = cms.int32(1)
-JetPlusTrackZSPCorJetSisconePu5.UseTrackQuality = cms.bool(False)
-JetPlusTrackZSPCorJetSisconePu5.UseMuons = cms.bool(False)
-JetPlusTrackZSPCorJetSisconePu5.UseElectrons = cms.bool(False)
-JetPlusTrackZSPCorJetSisconePu5.EfficiencyMap = cms.string("CondFormats/JetMETObjects/data/CMSSW_538HI_TrackNonEff.txt")
-JetPlusTrackZSPCorJetSisconePu5.UseOutOfVertexTracks = cms.bool(False)
-
-JetPlusTrackZSPCorJetAntiKtPu5 = cms.EDProducer(
-    "JetPlusTrackProducerAA",
-    cms.PSet(JPTZSPCorrectorICone5),
-    src = cms.InputTag("akPu5CaloJets"),
-    coneSize = cms.double(0.5),
-    tracks = cms.InputTag("hiGoodMergedTracks"),
-    tagName = cms.vstring('ZSP_CMSSW332_Iterative_Cone_05_PU0'),
-    tagNameOffset = cms.vstring(),
-    PU = cms.int32(-1),
-    FixedPU = cms.int32(0), 
-    UseZSP = cms.bool(False),   
-    srcPVs  = cms.InputTag('hiSelectedVertex'),
-    alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt5'),
-#=>
+    alias = cms.untracked.string('JetPlusTrackZSPCorJetAntiKt4'),
     extrapolations = cms.InputTag("trackExtrapolator")
     )
 
-JetPlusTrackZSPCorJetAntiKtPu5.JetTracksAssociationAtVertex = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtVertex")
-JetPlusTrackZSPCorJetAntiKtPu5.JetTracksAssociationAtCaloFace = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtCaloFace")
-
-JetPlusTrackZSPCorJetAntiKtPu5.JetSplitMerge = cms.int32(2)
-JetPlusTrackZSPCorJetAntiKtPu5.UseTrackQuality = cms.bool(False)
-JetPlusTrackZSPCorJetAntiKtPu5.UseMuons = cms.bool(False)
-JetPlusTrackZSPCorJetAntiKtPu5.UseElectron = cms.bool(False)
-JetPlusTrackZSPCorJetAntiKtPu5.EfficiencyMap = cms.string("CondFormats/JetMETObjects/data/CMSSW_538HI_TrackNonEff.txt")
-
-##### Association 
-
-#===> TRACK
-JPTtrackExtrapolatorAA = trackExtrapolator.clone()
-JPTtrackExtrapolatorAA.trackSrc = cms.InputTag("hiGoodMergedTracks")
-JPTtrackExtrapolatorAA.trackQuality = cms.string('highPurity')
-##JPTtrackExtrapolatorAA.trackQuality = cms.string('loose')
-#===>
-
-# IC
-from RecoJets.JetAssociationProducers.iterativeCone5JTA_cff import*
-
-JPTiterativeConePu5JetTracksAssociatorAtVertex = iterativeCone5JetTracksAssociatorAtVertex.clone() 
-JPTiterativeConePu5JetTracksAssociatorAtVertex.jets = cms.InputTag("iterativeConePu5CaloJets")
-JPTiterativeConePu5JetTracksAssociatorAtVertex.tracks = cms.InputTag("hiGoodMergedTracks")
-
-JPTiterativeConePu5JetTracksAssociatorAtCaloFace = iterativeCone5JetTracksAssociatorAtCaloFace.clone()
-JPTiterativeConePu5JetTracksAssociatorAtCaloFace.jets = cms.InputTag("iterativeConePu5CaloJets")
-JPTiterativeConePu5JetTracksAssociatorAtCaloFace.tracks = cms.InputTag("hiGoodMergedTracks")
-
-#===>
-#JPTiterativeConePu5JetTracksAssociatorAtCaloFace.extrapolations = cms.InputTag("JPTtrackExtrapolatorAA")
-#JPTiterativeConePu5JetTracksAssociatorAtCaloFace.trackQuality = cms.string('highPurity')
-#===>
-
-JPTiterativeConePu5JetExtender = iterativeCone5JetExtender.clone() 
-JPTiterativeConePu5JetExtender.jets = cms.InputTag("iterativeConePu5CaloJets")
-JPTiterativeConePu5JetExtender.jet2TracksAtCALO = cms.InputTag("JPTiterativeConePu5JetTracksAssociatorAtCaloFace")
-JPTiterativeConePu5JetExtender.jet2TracksAtVX = cms.InputTag("JPTiterativeConePu5JetTracksAssociatorAtVertex")
-
-# SisCone
-from RecoJets.JetAssociationProducers.sisCone5JTA_cff import*
-
-JPTSisConePu5JetTracksAssociatorAtVertex = sisCone5JetTracksAssociatorAtVertex.clone()
-JPTSisConePu5JetTracksAssociatorAtVertex.jets = cms.InputTag("sisConePu5CaloJets")
-JPTSisConePu5JetTracksAssociatorAtVertex.tracks = cms.InputTag("hiGoodMergedTracks")
-
-JPTSisConePu5JetTracksAssociatorAtCaloFace = sisCone5JetTracksAssociatorAtCaloFace.clone()
-JPTSisConePu5JetTracksAssociatorAtCaloFace.jets = cms.InputTag("sisConePu5CaloJets")
-JPTSisConePu5JetTracksAssociatorAtCaloFace.tracks = cms.InputTag("hiGoodMergedTracks")
-
-JPTSisConePu5JetExtender = sisCone5JetExtender.clone()
-JPTSisConePu5JetExtender.jets = cms.InputTag("sisConePu5CaloJets")
-JPTSisConePu5JetExtender.jet2TracksAtCALO = cms.InputTag("JPTSisConePu5JetTracksAssociatorAtCaloFace")
-JPTSisConePu5JetExtender.jet2TracksAtVX = cms.InputTag("JPTSisConePu5JetTracksAssociatorAtVertex")
-
-# Anti-Kt
-from RecoJets.JetAssociationProducers.ak5JTA_cff import*
-
-JPTAntiKtPu5JetTracksAssociatorAtVertex = ak5JetTracksAssociatorAtVertex.clone()
-JPTAntiKtPu5JetTracksAssociatorAtVertex.jets = cms.InputTag("akPu5CaloJets")
-JPTAntiKtPu5JetTracksAssociatorAtVertex.tracks = cms.InputTag("hiGoodMergedTracks")
-
-JPTAntiKtPu5JetTracksAssociatorAtCaloFace = ak5JetTracksAssociatorAtCaloFace.clone()
-JPTAntiKtPu5JetTracksAssociatorAtCaloFace.jets = cms.InputTag("akPu5CaloJets")
-JPTAntiKtPu5JetTracksAssociatorAtCaloFace.tracks = cms.InputTag("hiGoodMergedTracks")
-
-JPTAntiKtPu5JetExtender = ak5JetExtender.clone()
-JPTAntiKtPu5JetExtender.jets = cms.InputTag("akPu5CaloJets")
-JPTAntiKtPu5JetExtender.jet2TracksAtCALO = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtCaloFace")
-JPTAntiKtPu5JetExtender.jet2TracksAtVX = cms.InputTag("JPTAntiKtPu5JetTracksAssociatorAtVertex")
-
-### ---------- Task, Sequences
-
-# IC5
-
-JPTrecoJetAssociationsIconePu5Task = cms.Task(
-    trackExtrapolator,
-    JPTiterativeConePu5JetTracksAssociatorAtVertex,
-    JPTiterativeConePu5JetTracksAssociatorAtCaloFace,
-    JPTiterativeConePu5JetExtender
-    )
-JPTrecoJetAssociationsIconePu5 = cms.Sequence(JPTrecoJetAssociationsIconePu5Task)
-
-JetPlusTrackCorrectionsIconePu5Task = cms.Task(
-    JPTrecoJetAssociationsIconePu5,
-    JetPlusTrackZSPCorJetIconePu5
-    )
-JetPlusTrackCorrectionsIconePu5 = cms.Sequence(JetPlusTrackCorrectionsIconePu5Task)
-
-# SC5
-
-JPTrecoJetAssociationsSisConePu5Task = cms.Task(
-    trackExtrapolator,
-    JPTSisConePu5JetTracksAssociatorAtVertex,
-    JPTSisConePu5JetTracksAssociatorAtCaloFace,
-    JPTSisConePu5JetExtender
-    )
-JPTrecoJetAssociationsSisConePu5 = cms.Sequence(JPTrecoJetAssociationsSisConePu5Task)
+JetPlusTrackZSPCorJetAntiKtPu4.JetTracksAssociationAtVertex = "JPTAntiKtPu4JetTracksAssociatorAtVertex"
+JetPlusTrackZSPCorJetAntiKtPu4.JetTracksAssociationAtCaloFace = "JPTAntiKtPu4JetTracksAssociatorAtCaloFace"
+JetPlusTrackZSPCorJetAntiKtPu4.JetSplitMerge = 2
+JetPlusTrackZSPCorJetAntiKtPu4.UseTrackQuality = False
+JetPlusTrackZSPCorJetAntiKtPu4.UseMuons = False
+JetPlusTrackZSPCorJetAntiKtPu4.UseElectron = False
+JetPlusTrackZSPCorJetAntiKtPu4.EfficiencyMap = "CondFormats/JetMETObjects/data/CMSSW_538HI_TrackNonEff.txt"
 
-JetPlusTrackCorrectionsSisConePu5Task = cms.Task(
-    JPTrecoJetAssociationsSisConePu5,
-    JetPlusTrackZSPCorJetSisconePu5
-    )
-JetPlusTrackCorrectionsSisConePu5 = cms.Sequence(JetPlusTrackCorrectionsSisConePu5Task)
-
-# Anti-Kt
-
-JPTrecoJetAssociationsAntiKtPu5Task = cms.Task(
-    trackExtrapolator,
-    JPTAntiKtPu5JetTracksAssociatorAtVertex,
-    JPTAntiKtPu5JetTracksAssociatorAtCaloFace,
-    JPTAntiKtPu5JetExtender
-    )
-JPTrecoJetAssociationsAntiKtPu5 = cms.Sequence(JPTrecoJetAssociationsAntiKtPu5Task)
-
-JetPlusTrackCorrectionsAntiKtPu5Task = cms.Task(
-    JPTrecoJetAssociationsAntiKtPu5,
-    JetPlusTrackZSPCorJetAntiKtPu5
+from RecoJets.JetAssociationProducers.trackExtrapolator_cfi import *
+JPTtrackExtrapolatorAA = trackExtrapolator.clone(
+                         trackSrc = "hiGoodMergedTracks",
+                         trackQuality = 'highPurity'
+)
+
+from RecoJets.JetAssociationProducers.ak4JTA_cff import *
+JPTAntiKtPu4JetTracksAssociatorAtVertex = ak4JetTracksAssociatorAtVertex.clone(
+                                          useAssigned = True,
+                                          pvSrc = "hiSelectedVertex",
+                                          jets = "akPu4CaloJets",
+                                          tracks = "hiGoodMergedTracks"
+)
+JPTAntiKtPu4JetTracksAssociatorAtCaloFace = ak4JetTracksAssociatorAtCaloFace.clone(
+                                            jets = "akPu4CaloJets",
+                                            tracks = "hiGoodMergedTracks",
+                                            extrapolations = "JPTtrackExtrapolatorAA"
+)
+ak4JetExtenderJPTPAT = ak4JetExtender.clone(
+                       jets = "akPu4CaloJets",
+                       jet2TracksAtCALO = "JPTAntiKtPu4JetTracksAssociatorAtCaloFace",
+                       jet2TracksAtVX = "JPTAntiKtPu4JetTracksAssociatorAtVertex"
+)
+
+# Task definition
+JetPlusTrackCorrectionsAntiKtPu4Task = cms.Task(
+    JPTtrackExtrapolatorAA,
+    JPTAntiKtPu4JetTracksAssociatorAtVertex,
+    JPTAntiKtPu4JetTracksAssociatorAtCaloFace*
+    JPTAntiKtPu4JetExtender,
+    JetPlusTrackZSPCorJetAntiKtPu4
     )
-JetPlusTrackCorrectionsAntiKtPu5 = cms.Sequence(JetPlusTrackCorrectionsAntiKtPu5Task)
diff --git a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
index adeff742c8e63..8798f0b014810 100644
--- a/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
+++ b/RecoJets/JetPlusTracks/python/JetPlusTrackCorrections_cff.py
@@ -11,15 +11,22 @@
 from RecoEgamma.ElectronIdentification.electronIdSequence_cff import eidTight
 JPTeidTight = eidTight.clone()
 
+# ---------- Seeds from TrackJets
+
+from RecoJets.JetPlusTracks.jetPlusTrackAddonSeedProducer_cfi import *
+
+JetPlusTrackAddonSeedReco = jetPlusTrackAddonSeedProducer.clone()
 
 # ---------- 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'),
+    extrapolations = cms.InputTag("trackExtrapolator"),
     tagName = cms.vstring('ZSP_CMSSW390_Akt_05_PU0'),
     tagNameOffset = cms.vstring(),
     PU = cms.int32(-1),
@@ -27,7 +34,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 +48,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..6766ff80f14ea 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),
+    UsePAT = cms.bool(False),
 
     # 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..686ea4ce29510
--- /dev/null
+++ b/RecoJets/JetPlusTracks/python/PATJetPlusTrackCorrections_cff.py
@@ -0,0 +1,89 @@
+import FWCore.ParameterSet.Config as cms
+# ---------- Add assigned jet-track association
+
+from RecoJets.JetAssociationProducers.trackExtrapolator_cfi import *
+trackExtrapolatorJPTPAT = trackExtrapolator.clone(
+                      trackSrc = "trackFromPackedCandidate",
+                      trackQuality = 'highPurity'
+)
+
+from RecoJets.JetAssociationProducers.ak4JTA_cff import *
+ak4JetTracksAssociatorAtVertexJPTPAT = ak4JetTracksAssociatorAtVertex.clone(
+                                       useAssigned = True,
+                                       pvSrc = "offlineSlimmedPrimaryVertices",
+                                       jets = "slimmedCaloJets",
+                                       tracks = "trackFromPackedCandidate"
+)
+ak4JetTracksAssociatorAtCaloFaceJPTPAT = ak4JetTracksAssociatorAtCaloFace.clone(
+                                         jets = "slimmedCaloJets",
+                                         tracks = "trackFromPackedCandidate",
+                                         extrapolations = "trackExtrapolatorJPTPAT"
+)
+ak4JetExtenderJPTPAT = ak4JetExtender.clone(
+                       jets = "slimmedCaloJets",
+                       jet2TracksAtCALO = "ak4JetTracksAssociatorAtCaloFaceJPTPAT",
+                       jet2TracksAtVX = "ak4JetTracksAssociatorAtVertexJPTPAT"
+)
+
+# ---------- Supported Modules
+
+from CommonTools.RecoAlgos.trackFromPackedCandidateProducer_cfi import *
+trackFromPackedCandidate = trackFromPackedCandidateProducer.clone(PFCandidates = 'packedPFCandidates')
+
+
+from RecoJets.JetPlusTracks.jetPlusTrackAddonSeedProducer_cfi import *
+JetPlusTrackAddonSeedPAT = jetPlusTrackAddonSeedProducer.clone(
+    srcCaloJets = "slimmedCaloJets",
+    srcTrackJets = "ak4TrackJetsJPTPAT",
+    srcPVs = 'offlineSlimmedPrimaryVertices',
+    PFCandidates = 'packedPFCandidates',
+    UsePAT = True
+)
+
+
+from CommonTools.RecoAlgos.TrackWithVertexRefSelector_cfi import *
+trackWithVertexRefSelectorJPTPAT = trackWithVertexRefSelector.clone(
+    vertexTag = 'offlineSlimmedPrimaryVertices',
+    src = 'trackFromPackedCandidate'
+)
+from RecoJets.JetProducers.TracksForJets_cff import *
+trackRefsForJetsJPTPAT = trackRefsForJets.clone(
+    src = 'trackWithVertexRefSelectorJPTPAT'
+)
+from RecoJets.Configuration.RecoTrackJets_cff import *
+ak4TrackJetsJPTPAT = ak4TrackJets.clone(
+    srcPVs = 'offlineSlimmedPrimaryVertices',
+    UseOnlyOnePV = True,
+    src = 'trackRefsForJetsJPTPAT'
+)
+
+# ---------- Module definition
+
+from RecoJets.JetPlusTracks.JetPlusTrackCorrections_cfi import *
+JetPlusTrackZSPCorJetAntiKt4PAT = JetPlusTrackZSPCorJetAntiKt4.clone(
+    JetTracksAssociationAtVertex = 'ak4JetTracksAssociatorAtVertexJPTPAT',
+    JetTracksAssociationAtCaloFace = 'ak4JetTracksAssociatorAtCaloFaceJPTPAT',
+    Muons = 'slimmedMuons',
+    Electrons = 'slimmedElectrons',
+    JetSplitMerge = 2,
+    UsePAT = True
+)
+
+### ---------- Sequences
+
+# Task
+PATJetPlusTrackCorrectionsAntiKt4Task = cms.Task(
+    trackFromPackedCandidate,
+    trackWithVertexRefSelectorJPTPAT,
+    trackRefsForJetsJPTPAT,
+    ak4TrackJetsJPTPAT,
+    JetPlusTrackAddonSeedPAT,
+    trackExtrapolatorJPTPAT,
+    ak4JetTracksAssociatorAtVertexJPTPAT,
+    ak4JetTracksAssociatorAtCaloFaceJPTPAT,
+    ak4JetExtenderJPTPAT,
+    JetPlusTrackZSPCorJetAntiKt4PAT
+    )
+
+PATJetPlusTrackCorrectionsAntiKt4 = cms.Sequence(PATJetPlusTrackCorrectionsAntiKt4Task)
+
diff --git a/RecoJets/JetPlusTracks/test/JetShapeJPTAnalysis_mc_s_sql_qcd_pat2.py b/RecoJets/JetPlusTracks/test/JetShapeJPTAnalysis_mc_s_sql_qcd_pat2.py
new file mode 100644
index 0000000000000..9afbe918c3300
--- /dev/null
+++ b/RecoJets/JetPlusTracks/test/JetShapeJPTAnalysis_mc_s_sql_qcd_pat2.py
@@ -0,0 +1,55 @@
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("RECO4")
+
+process.load('Configuration/StandardSequences/Services_cff')
+process.load('FWCore/MessageService/MessageLogger_cfi')
+process.load("Configuration.StandardSequences.GeometryDB_cff")
+process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
+process.load('Configuration/StandardSequences/Reconstruction_cff')
+process.load('Configuration/StandardSequences/EndOfProcess_cff')
+process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
+process.load('Configuration/EventContent/EventContent_cff')
+process.load('RecoJets.Configuration.RecoJPTJets_cff')
+process.load('JetMETCorrections.Configuration.CorrectedJetProducersAllAlgos_cff')
+process.load('JetMETCorrections.Configuration.CorrectedJetProducers_cff')
+process.load('JetMETCorrections.Configuration.JetCorrectors_cff')
+
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2018_realistic', '')
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(100)
+)
+
+#################################################################  
+
+### For 219, file from RelVal
+process.source = cms.Source("PoolSource",
+   fileNames = cms.untracked.vstring(
+   '/store/relval/CMSSW_10_6_4/RelValProdTTbar_13_pmx25ns/MINIAODSIM/PUpmx25ns_106X_upgrade2018_realistic_v9-v1/10000/87AD30D2-F673-F54C-8974-CB916CC66098.root'
+   )
+)
+process.RECOoutput = cms.OutputModule("PoolOutputModule",
+    outputCommands = cms.untracked.vstring("keep *_JetPlusTrackZSPCorJetAntiKt4PAT_*_*"),
+    fileName = cms.untracked.string('file:jptreco.root')
+)
+
+##########
+process.endjob_step = cms.EndPath(process.endOfProcess)
+process.RECOoutput_step = cms.EndPath(process.RECOoutput)
+
+process.load("RecoJets.JetPlusTracks.PATJetPlusTrackCorrections_cff")
+process.p01=cms.Path(process.PATJetPlusTrackCorrectionsAntiKt4)
+
+process.p1 =cms.Schedule(
+                     process.p01,
+                     process.endjob_step,
+                     process.RECOoutput_step
+)
+
+# Automatic addition of the customisation function from Configuration.DataProcessing.Utils
+from Configuration.DataProcessing.Utils import addMonitoring
+
+#call to customisation function addMonitoring imported from Configuration.DataProcessing.Utils
+process = addMonitoring(process)