diff --git a/RecoLocalMuon/RPCRecHit/plugins/TracktoRPC.cc b/RecoLocalMuon/RPCRecHit/plugins/TracktoRPC.cc
index 068334e06dc80..e47f6e8079547 100644
--- a/RecoLocalMuon/RPCRecHit/plugins/TracktoRPC.cc
+++ b/RecoLocalMuon/RPCRecHit/plugins/TracktoRPC.cc
@@ -59,9 +59,9 @@ TracktoRPC::TracktoRPC(const edm::ParameterSet &iConfig, const edm::InputTag &tr
       cscMapToken_(iC.esConsumes()),
       propagatorToken_(iC.esConsumes(edm::ESInputTag("", "SteppingHelixPropagatorAny"))) {
   if (tracklabel.label().find("cosmic") == 0)
-    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(iConfig);
+    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(iConfig, iC);
   else if (tracklabel.label().find("globalCosmic") == 0)
-    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(iConfig);
+    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(iConfig, iC);
   else
     theTrackTransformer = std::make_unique<TrackTransformer>(iConfig, iC);
 }
diff --git a/TrackingTools/PatternTools/plugins/TSCBLBuilderWithPropagatorESProducer.cc b/TrackingTools/PatternTools/plugins/TSCBLBuilderWithPropagatorESProducer.cc
index eff0c6853bd34..735670f50b6a2 100644
--- a/TrackingTools/PatternTools/plugins/TSCBLBuilderWithPropagatorESProducer.cc
+++ b/TrackingTools/PatternTools/plugins/TSCBLBuilderWithPropagatorESProducer.cc
@@ -31,52 +31,33 @@ class TSCBLBuilderWithPropagatorESProducer : public edm::ESProducer {
 
 private:
   // ----------member data ---------------------------
-  edm::ParameterSet pset_;
+  edm::ESGetToken<Propagator, TrackingComponentsRecord> propToken_;
+  const std::string myName_;
+  const std::string propName_;
 };
 
-//
-// constants, enums and typedefs
-//
-
-//
-// static data member definitions
-//
-
 //
 // constructors and destructor
 //
-TSCBLBuilderWithPropagatorESProducer::TSCBLBuilderWithPropagatorESProducer(const edm::ParameterSet& p) {
-  //the following line is needed to tell the framework what
-  // data is being produced
-  std::string myName = p.getParameter<std::string>("ComponentName");
-  pset_ = p;
-  setWhatProduced(this, myName);
-
+TSCBLBuilderWithPropagatorESProducer::TSCBLBuilderWithPropagatorESProducer(const edm::ParameterSet& p)
+    : myName_(p.getParameter<std::string>("ComponentName")), propName_(p.getParameter<std::string>("Propagator")) {
+  auto cc = setWhatProduced(this, myName_);
   //now do what ever other initialization is needed
+  propToken_ = cc.consumes(edm::ESInputTag{"", propName_});
 }
 
-TSCBLBuilderWithPropagatorESProducer::~TSCBLBuilderWithPropagatorESProducer() {
-  // do anything here that needs to be done at desctruction time
-  // (e.g. close files, deallocate resources etc.)
-}
+TSCBLBuilderWithPropagatorESProducer::~TSCBLBuilderWithPropagatorESProducer() = default;
 
 //
 // member functions
 //
-
 // ------------ method called to produce the data  ------------
 TSCBLBuilderWithPropagatorESProducer::ReturnType TSCBLBuilderWithPropagatorESProducer::produce(
     const TrackingComponentsRecord& iRecord) {
   using namespace edm::es;
-  std::string propname = pset_.getParameter<std::string>("Propagator");
-
-  edm::ESHandle<Propagator> theProp;
-  iRecord.get(propname, theProp);
-
-  const Propagator* pro = theProp.product();
 
+  const Propagator* pro = &iRecord.get(propToken_);
   auto pTSCBLBuilderWithPropagator = std::make_unique<TSCBLBuilderWithPropagator>(*pro);
-
   return pTSCBLBuilderWithPropagator;
 }
 
diff --git a/TrackingTools/TrackAssociator/test/CaloMatchingExample.cc b/TrackingTools/TrackAssociator/test/CaloMatchingExample.cc
index cb3b13760bd03..732d7975f8681 100644
--- a/TrackingTools/TrackAssociator/test/CaloMatchingExample.cc
+++ b/TrackingTools/TrackAssociator/test/CaloMatchingExample.cc
@@ -19,7 +19,7 @@
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
@@ -79,7 +79,7 @@
 
 #include "CLHEP/Random/Random.h"
 
-class CaloMatchingExample : public edm::EDAnalyzer {
+class CaloMatchingExample : public edm::one::EDAnalyzer<> {
 public:
   explicit CaloMatchingExample(const edm::ParameterSet&);
   virtual ~CaloMatchingExample() {
@@ -91,6 +91,8 @@ class CaloMatchingExample : public edm::EDAnalyzer {
   virtual void analyze(const edm::Event&, const edm::EventSetup&);
 
 private:
+  const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> caloGeomToken_;
+
   TrackDetectorAssociator trackAssociator_;
   bool useEcal_;
   bool useHcal_;
@@ -140,7 +142,7 @@ class CaloMatchingExample : public edm::EDAnalyzer {
   TrackAssociatorParameters parameters_;
 };
 
-CaloMatchingExample::CaloMatchingExample(const edm::ParameterSet& iConfig) {
+CaloMatchingExample::CaloMatchingExample(const edm::ParameterSet& iConfig) : caloGeomToken_(esConsumes()) {
   CLHEP::HepRandom::createInstance();
   file_ = new TFile(iConfig.getParameter<std::string>("outputfile").c_str(), "recreate");
   tree_ = new TTree("calomatch", "calomatch");
@@ -197,8 +199,7 @@ void CaloMatchingExample::analyze(const edm::Event& iEvent, const edm::EventSetu
   using namespace edm;
 
   // calo geometry
-  edm::ESHandle<CaloGeometry> geometry;
-  iSetup.get<CaloGeometryRecord>().get(geometry);
+  const auto& geometry = iSetup.getHandle(caloGeomToken_);
   if (!geometry.isValid())
     throw cms::Exception("FatalError") << "Unable to find CaloGeometryRecord in event!\n";
 
diff --git a/TrackingTools/TrackAssociator/test/TestTrackAssociator.cc b/TrackingTools/TrackAssociator/test/TestTrackAssociator.cc
index 699b7d1e37018..48a63e78cf563 100644
--- a/TrackingTools/TrackAssociator/test/TestTrackAssociator.cc
+++ b/TrackingTools/TrackAssociator/test/TestTrackAssociator.cc
@@ -21,7 +21,7 @@
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
@@ -79,7 +79,7 @@
 #include "DataFormats/MuonReco/interface/Muon.h"
 #include "DataFormats/MuonReco/interface/MuonFwd.h"
 
-class TestTrackAssociator : public edm::EDAnalyzer {
+class TestTrackAssociator : public edm::one::EDAnalyzer<> {
 public:
   explicit TestTrackAssociator(const edm::ParameterSet&);
   virtual ~TestTrackAssociator() {}
diff --git a/TrackingTools/TrackRefitter/interface/TrackTransformerForCosmicMuons.h b/TrackingTools/TrackRefitter/interface/TrackTransformerForCosmicMuons.h
index 4742ae48eda0a..48208432496f6 100644
--- a/TrackingTools/TrackRefitter/interface/TrackTransformerForCosmicMuons.h
+++ b/TrackingTools/TrackRefitter/interface/TrackTransformerForCosmicMuons.h
@@ -19,21 +19,21 @@
  *  modified for zed ordering by N. Kypreos - UF <nicholas.theodore.kypreos@cern.ch> 
  */
 
-#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
-
-#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
-
-#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
-
-#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
-
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Framework/interface/ESHandle.h"
-
 #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
+#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
 #include "MagneticField/Engine/interface/MagneticField.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
+#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
+#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
+#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
-
-#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
+#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
+#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"
 
 namespace edm {
   class ParameterSet;
@@ -52,7 +52,7 @@ class Trajectory;
 class TrackTransformerForCosmicMuons : public TrackTransformerBase {
 public:
   /// Constructor
-  TrackTransformerForCosmicMuons(const edm::ParameterSet&);
+  TrackTransformerForCosmicMuons(const edm::ParameterSet&, edm::ConsumesCollector);
 
   /// Destructor
   ~TrackTransformerForCosmicMuons() override;
@@ -85,6 +85,17 @@ class TrackTransformerForCosmicMuons : public TrackTransformerBase {
 
 protected:
 private:
+  const edm::ESGetToken<Propagator, TrackingComponentsRecord> theIOpropToken;
+  const edm::ESGetToken<Propagator, TrackingComponentsRecord> theOIpropToken;
+  const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> thGlobTrackGeoToken;
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> theMFToken;
+  const edm::ESGetToken<TrajectoryFitter, TrajectoryFitter::Record> theIOFitterToken;
+  const edm::ESGetToken<TrajectoryFitter, TrajectoryFitter::Record> theOIFitterToken;
+  const edm::ESGetToken<TrajectorySmoother, TrajectoryFitter::Record> theIOSmootherToken;
+  const edm::ESGetToken<TrajectorySmoother, TrajectoryFitter::Record> theOISmootherToken;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theTkRecHitBuildToken;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theMuonRecHitBuildToken;
+
   edm::ESHandle<Propagator> thePropagatorIO;
   edm::ESHandle<Propagator> thePropagatorOI;
 
diff --git a/TrackingTools/TrackRefitter/interface/TrackTransformerForGlobalCosmicMuons.h b/TrackingTools/TrackRefitter/interface/TrackTransformerForGlobalCosmicMuons.h
index 277122229e361..459c14e7fd8d6 100644
--- a/TrackingTools/TrackRefitter/interface/TrackTransformerForGlobalCosmicMuons.h
+++ b/TrackingTools/TrackRefitter/interface/TrackTransformerForGlobalCosmicMuons.h
@@ -13,17 +13,19 @@
  *  \author R. Bellan - CERN <riccardo.bellan@cern.ch>
  */
 
-#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
-
-#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
-
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Framework/interface/ESHandle.h"
-
 #include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
+#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
 #include "MagneticField/Engine/interface/MagneticField.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+#include "TrackingTools/TrackRefitter/interface/RefitDirection.h"
+#include "TrackingTools/TrackRefitter/interface/TrackTransformerBase.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
-
-#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
+#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
+#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"
 
 namespace edm {
   class ParameterSet;
@@ -43,7 +45,7 @@ class TrackerTopology;
 class TrackTransformerForGlobalCosmicMuons : public TrackTransformerBase {
 public:
   /// Constructor
-  TrackTransformerForGlobalCosmicMuons(const edm::ParameterSet&);
+  TrackTransformerForGlobalCosmicMuons(const edm::ParameterSet&, edm::ConsumesCollector);
 
   /// Destructor
   ~TrackTransformerForGlobalCosmicMuons() override;
@@ -77,6 +79,18 @@ class TrackTransformerForGlobalCosmicMuons : public TrackTransformerBase {
 
 protected:
 private:
+  const edm::ESGetToken<Propagator, TrackingComponentsRecord> theIOpropToken;
+  const edm::ESGetToken<Propagator, TrackingComponentsRecord> theOIpropToken;
+  const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> thGlobTrackGeoToken;
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> theMFToken;
+  const edm::ESGetToken<TrajectoryFitter, TrajectoryFitter::Record> theIOFitterToken;
+  const edm::ESGetToken<TrajectoryFitter, TrajectoryFitter::Record> theOIFitterToken;
+  const edm::ESGetToken<TrajectorySmoother, TrajectoryFitter::Record> theIOSmootherToken;
+  const edm::ESGetToken<TrajectorySmoother, TrajectoryFitter::Record> theOISmootherToken;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theTkRecHitBuildToken;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> theMuonRecHitBuildToken;
+  const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> theTopologyToken;
+
   edm::ESHandle<Propagator> thePropagatorIO;
   edm::ESHandle<Propagator> thePropagatorOI;
 
diff --git a/TrackingTools/TrackRefitter/plugins/TracksToTrajectories.cc b/TrackingTools/TrackRefitter/plugins/TracksToTrajectories.cc
index f9f79afb3286c..ea0309ad1ce53 100644
--- a/TrackingTools/TrackRefitter/plugins/TracksToTrajectories.cc
+++ b/TrackingTools/TrackRefitter/plugins/TracksToTrajectories.cc
@@ -75,9 +75,10 @@ TracksToTrajectories::TracksToTrajectories(const ParameterSet& parameterSet, con
   if (type == "Default")
     theTrackTransformer = std::make_unique<TrackTransformer>(trackTransformerParam, consumesCollector());
   else if (type == "GlobalCosmicMuonsForAlignment")
-    theTrackTransformer = std::make_unique<TrackTransformerForGlobalCosmicMuons>(trackTransformerParam);
+    theTrackTransformer =
+        std::make_unique<TrackTransformerForGlobalCosmicMuons>(trackTransformerParam, consumesCollector());
   else if (type == "CosmicMuonsForAlignment")
-    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(trackTransformerParam);
+    theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(trackTransformerParam, consumesCollector());
   else {
     throw cms::Exception("TracksToTrajectories")
         << "The selected algorithm does not exist"
diff --git a/TrackingTools/TrackRefitter/src/TrackTransformerForCosmicMuons.cc b/TrackingTools/TrackRefitter/src/TrackTransformerForCosmicMuons.cc
index 863ba24050a26..413a08994f84b 100644
--- a/TrackingTools/TrackRefitter/src/TrackTransformerForCosmicMuons.cc
+++ b/TrackingTools/TrackRefitter/src/TrackTransformerForCosmicMuons.cc
@@ -31,12 +31,21 @@ using namespace std;
 using namespace edm;
 
 /// Constructor
-TrackTransformerForCosmicMuons::TrackTransformerForCosmicMuons(const ParameterSet& parameterSet) {
-  theTrackerRecHitBuilderName = parameterSet.getParameter<string>("TrackerRecHitBuilder");
-  theMuonRecHitBuilderName = parameterSet.getParameter<string>("MuonRecHitBuilder");
-
+TrackTransformerForCosmicMuons::TrackTransformerForCosmicMuons(const ParameterSet& parameterSet,
+                                                               edm::ConsumesCollector iC)
+    : theIOpropToken(iC.esConsumes(edm::ESInputTag("", "SmartPropagatorRK"))),
+      theOIpropToken(iC.esConsumes(edm::ESInputTag("", "SmartPropagatorRKOpposite"))),
+      thGlobTrackGeoToken(iC.esConsumes()),
+      theMFToken(iC.esConsumes()),
+      theIOFitterToken(iC.esConsumes(edm::ESInputTag("", "KFFitterForRefitInsideOut"))),
+      theOIFitterToken(iC.esConsumes(edm::ESInputTag("", "KFSmootherForRefitInsideOut"))),
+      theIOSmootherToken(iC.esConsumes(edm::ESInputTag("", "KFFitterForRefitOutsideIn"))),
+      theOISmootherToken(iC.esConsumes(edm::ESInputTag("", "KFSmootherForRefitOutsideIn"))),
+      theTkRecHitBuildToken(
+          iC.esConsumes(edm::ESInputTag("", parameterSet.getParameter<string>("TrackerRecHitBuilder")))),
+      theMuonRecHitBuildToken(
+          iC.esConsumes(edm::ESInputTag("", parameterSet.getParameter<string>("MuonRecHitBuilder")))) {
   theRPCInTheFit = parameterSet.getParameter<bool>("RefitRPCHits");
-
   theCacheId_TC = theCacheId_GTG = theCacheId_MG = theCacheId_TRH = 0;
 }
 
@@ -46,18 +55,18 @@ TrackTransformerForCosmicMuons::~TrackTransformerForCosmicMuons() {}
 void TrackTransformerForCosmicMuons::setServices(const EventSetup& setup) {
   const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
-  setup.get<TrajectoryFitter::Record>().get("KFFitterForRefitInsideOut", theFitterIO);
-  setup.get<TrajectoryFitter::Record>().get("KFSmootherForRefitInsideOut", theSmootherIO);
-  setup.get<TrajectoryFitter::Record>().get("KFFitterForRefitOutsideIn", theFitterOI);
-  setup.get<TrajectoryFitter::Record>().get("KFSmootherForRefitOutsideIn", theSmootherOI);
+  theFitterIO = setup.getHandle(theIOFitterToken);
+  theFitterOI = setup.getHandle(theOIFitterToken);
+  theSmootherIO = setup.getHandle(theIOSmootherToken);
+  theSmootherOI = setup.getHandle(theOISmootherToken);
 
   unsigned long long newCacheId_TC = setup.get<TrackingComponentsRecord>().cacheIdentifier();
 
   if (newCacheId_TC != theCacheId_TC) {
     LogTrace(metname) << "Tracking Component changed!";
     theCacheId_TC = newCacheId_TC;
-    setup.get<TrackingComponentsRecord>().get("SmartPropagatorRK", thePropagatorIO);
-    setup.get<TrackingComponentsRecord>().get("SmartPropagatorRKOpposite", thePropagatorOI);
+    thePropagatorIO = setup.getHandle(theIOpropToken);
+    thePropagatorOI = setup.getHandle(theOIpropToken);
   }
 
   // Global Tracking Geometry
@@ -65,7 +74,7 @@ void TrackTransformerForCosmicMuons::setServices(const EventSetup& setup) {
   if (newCacheId_GTG != theCacheId_GTG) {
     LogTrace(metname) << "GlobalTrackingGeometry changed!";
     theCacheId_GTG = newCacheId_GTG;
-    setup.get<GlobalTrackingGeometryRecord>().get(theTrackingGeometry);
+    theTrackingGeometry = setup.getHandle(thGlobTrackGeoToken);
   }
 
   // Magfield Field
@@ -73,7 +82,7 @@ void TrackTransformerForCosmicMuons::setServices(const EventSetup& setup) {
   if (newCacheId_MG != theCacheId_MG) {
     LogTrace(metname) << "Magnetic Field changed!";
     theCacheId_MG = newCacheId_MG;
-    setup.get<IdealMagneticFieldRecord>().get(theMGField);
+    theMGField = setup.getHandle(theMFToken);
   }
 
   // Transient Rechit Builders
@@ -81,8 +90,8 @@ void TrackTransformerForCosmicMuons::setServices(const EventSetup& setup) {
   if (newCacheId_TRH != theCacheId_TRH) {
     theCacheId_TRH = newCacheId_TRH;
     LogTrace(metname) << "TransientRecHitRecord changed!";
-    setup.get<TransientRecHitRecord>().get(theTrackerRecHitBuilderName, theTrackerRecHitBuilder);
-    setup.get<TransientRecHitRecord>().get(theMuonRecHitBuilderName, theMuonRecHitBuilder);
+    theTrackerRecHitBuilder = setup.getHandle(theTkRecHitBuildToken);
+    theMuonRecHitBuilder = setup.getHandle(theMuonRecHitBuildToken);
   }
 }
 
diff --git a/TrackingTools/TrackRefitter/src/TrackTransformerForGlobalCosmicMuons.cc b/TrackingTools/TrackRefitter/src/TrackTransformerForGlobalCosmicMuons.cc
index 0b64a32004464..d3ff9a8a5f244 100644
--- a/TrackingTools/TrackRefitter/src/TrackTransformerForGlobalCosmicMuons.cc
+++ b/TrackingTools/TrackRefitter/src/TrackTransformerForGlobalCosmicMuons.cc
@@ -1,45 +1,44 @@
 #include "TrackingTools/TrackRefitter/interface/TrackTransformerForGlobalCosmicMuons.h"
 
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/MessageLogger/interface/MessageLogger.h"
-
-#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
-#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
-#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"
-#include "TrackingTools/PatternTools/interface/TrajectorySmoother.h"
-
-#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
-#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
-#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
-#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
-#include "TrackingTools/PatternTools/interface/Trajectory.h"
-#include "TrackingTools/GeomPropagators/interface/Propagator.h"
-
-#include "DataFormats/TrackReco/interface/Track.h"
-#include "DataFormats/TrackReco/interface/TrackFwd.h"
 #include "DataFormats/DetId/interface/DetId.h"
-
 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
 #include "DataFormats/MuonDetId/interface/DTWireId.h"
-#include "DataFormats/MuonDetId/interface/RPCDetId.h"
 #include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
-
+#include "DataFormats/MuonDetId/interface/RPCDetId.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
+#include "TrackingTools/GeomPropagators/interface/Propagator.h"
+#include "TrackingTools/PatternTools/interface/Trajectory.h"
+#include "TrackingTools/PatternTools/interface/TrajectorySmoother.h"
+#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
+#include "TrackingTools/TransientTrack/interface/TransientTrack.h"
+#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
 
 using namespace std;
 using namespace edm;
 
 /// Constructor
-TrackTransformerForGlobalCosmicMuons::TrackTransformerForGlobalCosmicMuons(const ParameterSet& parameterSet) {
-  theTrackerRecHitBuilderName = parameterSet.getParameter<string>("TrackerRecHitBuilder");
-  theMuonRecHitBuilderName = parameterSet.getParameter<string>("MuonRecHitBuilder");
-
+TrackTransformerForGlobalCosmicMuons::TrackTransformerForGlobalCosmicMuons(const ParameterSet& parameterSet,
+                                                                           edm::ConsumesCollector iC)
+    : theIOpropToken(iC.esConsumes(edm::ESInputTag("", "SmartPropagatorRK"))),
+      theOIpropToken(iC.esConsumes(edm::ESInputTag("", "SmartPropagatorRKOpposite"))),
+      thGlobTrackGeoToken(iC.esConsumes()),
+      theMFToken(iC.esConsumes()),
+      theIOFitterToken(iC.esConsumes(edm::ESInputTag("", "KFFitterForRefitInsideOut"))),
+      theOIFitterToken(iC.esConsumes(edm::ESInputTag("", "KFSmootherForRefitInsideOut"))),
+      theIOSmootherToken(iC.esConsumes(edm::ESInputTag("", "KFFitterForRefitOutsideIn"))),
+      theOISmootherToken(iC.esConsumes(edm::ESInputTag("", "KFSmootherForRefitOutsideIn"))),
+      theTkRecHitBuildToken(
+          iC.esConsumes(edm::ESInputTag("", parameterSet.getParameter<string>("TrackerRecHitBuilder")))),
+      theMuonRecHitBuildToken(
+          iC.esConsumes(edm::ESInputTag("", parameterSet.getParameter<string>("MuonRecHitBuilder")))),
+      theTopologyToken(iC.esConsumes()) {
   theRPCInTheFit = parameterSet.getParameter<bool>("RefitRPCHits");
-
   theCacheId_TC = theCacheId_GTG = theCacheId_MG = theCacheId_TRH = 0;
   theSkipStationDT = parameterSet.getParameter<int>("SkipStationDT");
   theSkipStationCSC = parameterSet.getParameter<int>("SkipStationCSC");
@@ -55,18 +54,18 @@ TrackTransformerForGlobalCosmicMuons::~TrackTransformerForGlobalCosmicMuons() {}
 void TrackTransformerForGlobalCosmicMuons::setServices(const EventSetup& setup) {
   const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
-  setup.get<TrajectoryFitter::Record>().get("KFFitterForRefitInsideOut", theFitterIO);
-  setup.get<TrajectoryFitter::Record>().get("KFSmootherForRefitInsideOut", theSmootherIO);
-  setup.get<TrajectoryFitter::Record>().get("KFFitterForRefitOutsideIn", theFitterOI);
-  setup.get<TrajectoryFitter::Record>().get("KFSmootherForRefitOutsideIn", theSmootherOI);
+  theFitterIO = setup.getHandle(theIOFitterToken);
+  theFitterOI = setup.getHandle(theOIFitterToken);
+  theSmootherIO = setup.getHandle(theIOSmootherToken);
+  theSmootherOI = setup.getHandle(theOISmootherToken);
 
   unsigned long long newCacheId_TC = setup.get<TrackingComponentsRecord>().cacheIdentifier();
 
   if (newCacheId_TC != theCacheId_TC) {
     LogTrace(metname) << "Tracking Component changed!";
     theCacheId_TC = newCacheId_TC;
-    setup.get<TrackingComponentsRecord>().get("SmartPropagatorRK", thePropagatorIO);
-    setup.get<TrackingComponentsRecord>().get("SmartPropagatorRKOpposite", thePropagatorOI);
+    thePropagatorIO = setup.getHandle(theIOpropToken);
+    thePropagatorOI = setup.getHandle(theOIpropToken);
   }
 
   // Global Tracking Geometry
@@ -74,7 +73,7 @@ void TrackTransformerForGlobalCosmicMuons::setServices(const EventSetup& setup)
   if (newCacheId_GTG != theCacheId_GTG) {
     LogTrace(metname) << "GlobalTrackingGeometry changed!";
     theCacheId_GTG = newCacheId_GTG;
-    setup.get<GlobalTrackingGeometryRecord>().get(theTrackingGeometry);
+    theTrackingGeometry = setup.getHandle(thGlobTrackGeoToken);
   }
 
   // Magfield Field
@@ -82,7 +81,7 @@ void TrackTransformerForGlobalCosmicMuons::setServices(const EventSetup& setup)
   if (newCacheId_MG != theCacheId_MG) {
     LogTrace(metname) << "Magnetic Field changed!";
     theCacheId_MG = newCacheId_MG;
-    setup.get<IdealMagneticFieldRecord>().get(theMGField);
+    theMGField = setup.getHandle(theMFToken);
   }
 
   // Transient Rechit Builders
@@ -90,14 +89,12 @@ void TrackTransformerForGlobalCosmicMuons::setServices(const EventSetup& setup)
   if (newCacheId_TRH != theCacheId_TRH) {
     theCacheId_TRH = newCacheId_TRH;
     LogTrace(metname) << "TransientRecHitRecord changed!";
-    setup.get<TransientRecHitRecord>().get(theTrackerRecHitBuilderName, theTrackerRecHitBuilder);
-    setup.get<TransientRecHitRecord>().get(theMuonRecHitBuilderName, theMuonRecHitBuilder);
+    theTrackerRecHitBuilder = setup.getHandle(theTkRecHitBuildToken);
+    theMuonRecHitBuilder = setup.getHandle(theMuonRecHitBuildToken);
   }
 
   //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHand;
-  setup.get<TrackerTopologyRcd>().get(tTopoHand);
-  tTopo_ = tTopoHand.product();
+  tTopo_ = &setup.getData(theTopologyToken);
 }
 
 TransientTrackingRecHit::ConstRecHitContainer TrackTransformerForGlobalCosmicMuons::getTransientRecHits(
diff --git a/TrackingTools/TrackRefitter/test/TrackReader.cc b/TrackingTools/TrackRefitter/test/TrackReader.cc
index 79879bb474111..464a48b094717 100644
--- a/TrackingTools/TrackRefitter/test/TrackReader.cc
+++ b/TrackingTools/TrackRefitter/test/TrackReader.cc
@@ -1,66 +1,79 @@
-#include "TrackingTools/TrackRefitter/test/TrackReader.h"
+/** \class TrackReader
+ *  No description available.
+ *
+ *  \author R. Bellan - INFN Torino <riccardo.bellan@cern.ch>
+ */
 
+// Base Class Headers
+#include "DataFormats/Common/interface/Handle.h"
+#include "DataFormats/DetId/interface/DetId.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
-#include "DataFormats/Common/interface/Handle.h"
-
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
-
-#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/InputTag.h"
 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
+#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
+#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
+#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
+#include "TrackingTools/PatternTools/interface/Trajectory.h"
+#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
-#include "TrackingTools/PatternTools/interface/Trajectory.h"
-#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h"
-#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
-
-#include "DataFormats/TrackReco/interface/Track.h"
-#include "DataFormats/TrackReco/interface/TrackFwd.h"
-#include "DataFormats/DetId/interface/DetId.h"
 
 #include "TFile.h"
 #include "TH1F.h"
 
-using namespace std;
-using namespace edm;
+#include <vector>
 
-#include "FWCore/PluginManager/interface/ModuleDef.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
+class TrackReader : public edm::one::EDAnalyzer<> {
+public:
+  typedef std::vector<Trajectory> Trajectories;
 
-DEFINE_FWK_MODULE(TrackReader);
+public:
+  /// Constructor
+  TrackReader(const edm::ParameterSet& pset);
 
-/// Constructor
-TrackReader::TrackReader(const ParameterSet& parameterSet) {
-  theInputLabel = parameterSet.getParameter<InputTag>("InputLabel");
+  /// Destructor
+  virtual ~TrackReader();
 
-  theTrackerRecHitBuilderName = parameterSet.getParameter<string>("TrackerRecHitBuilder");
-  theMuonRecHitBuilderName = parameterSet.getParameter<string>("MuonRecHitBuilder");
-}
+  void analyze(const edm::Event& event, const edm::EventSetup& eventSetup);
 
-/// Destructor
-TrackReader::~TrackReader() {}
+protected:
+  //  void printTrackRecHits(const reco::Track &, edm::ESHandle<GlobalTrackingGeometry>) const;
 
-// Operations
-void TrackReader::beginJob() {}
+private:
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> trackerBuilderToken_;
+  const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> muonBuilderToken_;
+  edm::InputTag theInputLabel;
+};
 
-void TrackReader::endJob() {}
+/// Constructor
+TrackReader::TrackReader(const edm::ParameterSet& parameterSet)
+    : trackerBuilderToken_(
+          esConsumes(edm::ESInputTag("", parameterSet.getParameter<std::string>("TrackerRecHitBuilder")))),
+      muonBuilderToken_(esConsumes(edm::ESInputTag("", parameterSet.getParameter<std::string>("MuonRecHitBuilder")))) {
+  theInputLabel = parameterSet.getParameter<edm::InputTag>("InputLabel");
+}
 
-void TrackReader::analyze(const Event& event, const EventSetup& setup) {
-  edm::ESHandle<TransientTrackingRecHitBuilder> theTrackerRecHitBuilder;
-  edm::ESHandle<TransientTrackingRecHitBuilder> theMuonRecHitBuilder;
+/// Destructor
+TrackReader::~TrackReader() = default;
 
-  setup.get<TransientRecHitRecord>().get(theTrackerRecHitBuilderName, theTrackerRecHitBuilder);
-  setup.get<TransientRecHitRecord>().get(theMuonRecHitBuilderName, theMuonRecHitBuilder);
+void TrackReader::analyze(const edm::Event& event, const edm::EventSetup& setup) {
+  const TransientTrackingRecHitBuilder* theTrackerRecHitBuilder = &setup.getData(trackerBuilderToken_);
+  const TransientTrackingRecHitBuilder* theMuonRecHitBuilder = &setup.getData(muonBuilderToken_);
 
   const std::string metname = "Reco|TrackingTools|TrackReader";
 
   // Get the RecTrack collection from the event
-  Handle<reco::TrackCollection> tracks;
+  edm::Handle<reco::TrackCollection> tracks;
   event.getByLabel(theInputLabel, tracks);
 
   for (reco::TrackCollection::const_iterator track = tracks->begin(); track != tracks->end(); ++track) {
@@ -80,3 +93,8 @@ void TrackReader::analyze(const Event& event, const EventSetup& setup) {
     }
   }
 }
+
+#include "FWCore/PluginManager/interface/ModuleDef.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(TrackReader);
diff --git a/TrackingTools/TrackRefitter/test/TrackReader.h b/TrackingTools/TrackRefitter/test/TrackReader.h
deleted file mode 100644
index 341cdef59f1f5..0000000000000
--- a/TrackingTools/TrackRefitter/test/TrackReader.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef TrackingTools_TrackRefitter_TrackReader_H
-#define TrackingTools_TrackRefitter_TrackReader_H
-
-/** \class TrackReader
- *  No description available.
- *
- *  \author R. Bellan - INFN Torino <riccardo.bellan@cern.ch>
- */
-// Base Class Headers
-#include "FWCore/Framework/interface/EDAnalyzer.h"
-#include "FWCore/Framework/interface/ESHandle.h"
-#include "FWCore/Utilities/interface/InputTag.h"
-#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
-
-namespace edm {
-  class ParameterSet;
-  class Event;
-  class EventSetup;
-}  // namespace edm
-
-namespace reco {
-  class Track;
-}
-
-class TFile;
-class TH1F;
-class TH2F;
-class Trajectory;
-
-#include <vector>
-
-class TrackReader : public edm::EDAnalyzer {
-public:
-  typedef std::vector<Trajectory> Trajectories;
-
-public:
-  /// Constructor
-  TrackReader(const edm::ParameterSet& pset);
-
-  /// Destructor
-  virtual ~TrackReader();
-
-  void analyze(const edm::Event& event, const edm::EventSetup& eventSetup);
-
-  // Operations
-  void beginJob();
-  void endJob();
-
-protected:
-  //  void printTrackRecHits(const reco::Track &, edm::ESHandle<GlobalTrackingGeometry>) const;
-
-private:
-  edm::InputTag theInputLabel;
-
-  std::string theTrackerRecHitBuilderName;
-  std::string theMuonRecHitBuilderName;
-};
-#endif
diff --git a/TrackingTools/TrackRefitter/test/TrajectoryReader.cc b/TrackingTools/TrackRefitter/test/TrajectoryReader.cc
index 2f707ebd52d6f..bfff8818871b6 100644
--- a/TrackingTools/TrackRefitter/test/TrajectoryReader.cc
+++ b/TrackingTools/TrackRefitter/test/TrajectoryReader.cc
@@ -1,45 +1,88 @@
-#include "TrackingTools/TrackRefitter/test/TrajectoryReader.h"
-
+/** \class TrajectoryReader
+ *  No description available.
+ *
+ *  \author R. Bellan - INFN Torino <riccardo.bellan@cern.ch>
+ */
+// Base Class Headers
+#include "DataFormats/Common/interface/Handle.h"
+#include "DataFormats/DetId/interface/DetId.h"
+#include "DataFormats/TrackReco/interface/Track.h"
+#include "DataFormats/TrackReco/interface/TrackFwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/EventSetup.h"
-#include "DataFormats/Common/interface/Handle.h"
-
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
-
-#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/InputTag.h"
 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
+#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
+#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
+#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
+#include "TrackingTools/PatternTools/interface/Trajectory.h"
 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
-#include "TrackingTools/PatternTools/interface/Trajectory.h"
-#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
 #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
 
-#include "DataFormats/TrackReco/interface/Track.h"
-#include "DataFormats/TrackReco/interface/TrackFwd.h"
-#include "DataFormats/DetId/interface/DetId.h"
-
 #include "TFile.h"
 #include "TH1F.h"
 
-using namespace std;
-using namespace edm;
+#include <vector>
 
-#include "FWCore/PluginManager/interface/ModuleDef.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
+class TrajectoryReader : public edm::one::EDAnalyzer<> {
+public:
+  typedef std::vector<Trajectory> Trajectories;
 
-DEFINE_FWK_MODULE(TrajectoryReader);
+public:
+  /// Constructor
+  TrajectoryReader(const edm::ParameterSet &pset);
+
+  /// Destructor
+  virtual ~TrajectoryReader();
+
+  void analyze(const edm::Event &event, const edm::EventSetup &eventSetup);
+
+  // Operations
+  void beginJob();
+  void endJob();
+
+protected:
+  void printTrajectoryRecHits(const Trajectory &, edm::ESHandle<GlobalTrackingGeometry>) const;
+  void printTrackRecHits(const reco::Track &, edm::ESHandle<GlobalTrackingGeometry>) const;
+
+private:
+  const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> theGlobGeomToken;
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> theMFToken;
+
+  edm::EDGetTokenT<Trajectories> theTrajToken;
+  edm::EDGetTokenT<reco::TrackCollection> theTrackToken;
+  edm::EDGetTokenT<TrajTrackAssociationCollection> theAssocToken;
+
+  edm::InputTag theInputLabel;
+  TFile *theFile;
+  std::string theRootFileName;
+
+  TH1F *hDPtIn;
+  TH1F *hDPtOut;
+  TH1F *hSuccess;
+  TH1F *hNHitLost;
+  TH1F *hFractionHitLost;
+};
 
 /// Constructor
-TrajectoryReader::TrajectoryReader(const ParameterSet& pset) {
-  theInputLabel = pset.getParameter<InputTag>("InputLabel");
-  theRootFileName = pset.getUntrackedParameter<string>("rootFileName");
+TrajectoryReader::TrajectoryReader(const edm::ParameterSet &pset)
+    : theGlobGeomToken(esConsumes()), theMFToken(esConsumes()) {
+  theInputLabel = pset.getParameter<edm::InputTag>("InputLabel");
+
+  theTrajToken = consumes<Trajectories>(theInputLabel), theTrackToken = consumes<reco::TrackCollection>(theInputLabel),
+  theAssocToken = consumes<TrajTrackAssociationCollection>(theInputLabel);
+
+  theRootFileName = pset.getUntrackedParameter<std::string>("rootFileName");
 }
 
 /// Destructor
-TrajectoryReader::~TrajectoryReader() {}
+TrajectoryReader::~TrajectoryReader() = default;
 
 // Operations
 void TrajectoryReader::beginJob() {
@@ -67,8 +110,8 @@ void TrajectoryReader::endJob() {
   theFile->Close();
 }
 
-void TrajectoryReader::printTrajectoryRecHits(const Trajectory& trajectory,
-                                              ESHandle<GlobalTrackingGeometry> trackingGeometry) const {
+void TrajectoryReader::printTrajectoryRecHits(const Trajectory &trajectory,
+                                              edm::ESHandle<GlobalTrackingGeometry> trackingGeometry) const {
   const std::string metname = "Reco|TrackingTools|TrajectoryReader";
 
   TransientTrackingRecHit::ConstRecHitContainer rechits = trajectory.recHits();
@@ -78,16 +121,16 @@ void TrajectoryReader::printTrajectoryRecHits(const Trajectory& trajectory,
   for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator recHit = rechits.begin(); recHit != rechits.end();
        ++recHit)
     if ((*recHit)->isValid()) {
-      const GeomDet* geomDet = trackingGeometry->idToDet((*recHit)->geographicalId());
+      const GeomDet *geomDet = trackingGeometry->idToDet((*recHit)->geographicalId());
       double r = geomDet->surface().position().perp();
       double z = geomDet->toGlobal((*recHit)->localPosition()).z();
       LogTrace(metname) << i++ << " r: " << r << " z: " << z << " " << geomDet->toGlobal((*recHit)->localPosition())
-                        << endl;
+                        << std::endl;
     }
 }
 
-void TrajectoryReader::printTrackRecHits(const reco::Track& track,
-                                         ESHandle<GlobalTrackingGeometry> trackingGeometry) const {
+void TrajectoryReader::printTrackRecHits(const reco::Track &track,
+                                         edm::ESHandle<GlobalTrackingGeometry> trackingGeometry) const {
   const std::string metname = "Reco|TrackingTools|TrajectoryReader";
 
   LogTrace(metname) << "Valid RecHits: " << track.found() << " invalid RecHits: " << track.lost();
@@ -95,52 +138,50 @@ void TrajectoryReader::printTrackRecHits(const reco::Track& track,
   int i = 0;
   for (trackingRecHit_iterator recHit = track.recHitsBegin(); recHit != track.recHitsEnd(); ++recHit)
     if ((*recHit)->isValid()) {
-      const GeomDet* geomDet = trackingGeometry->idToDet((*recHit)->geographicalId());
+      const GeomDet *geomDet = trackingGeometry->idToDet((*recHit)->geographicalId());
       double r = geomDet->surface().position().perp();
       double z = geomDet->surface().position().z();
       LogTrace(metname) << i++ << " GeomDet position r: " << r << " z: " << z;
     }
 }
 
-void TrajectoryReader::analyze(const Event& event, const EventSetup& eventSetup) {
+void TrajectoryReader::analyze(const edm::Event &event, const edm::EventSetup &eventSetup) {
   // Global Tracking Geometry
-  ESHandle<GlobalTrackingGeometry> trackingGeometry;
-  eventSetup.get<GlobalTrackingGeometryRecord>().get(trackingGeometry);
+  const GlobalTrackingGeometry *trackingGeometry = &eventSetup.getData(theGlobGeomToken);
 
   // Magfield Field
-  ESHandle<MagneticField> magField;
-  eventSetup.get<IdealMagneticFieldRecord>().get(magField);
+  const MagneticField *magField = &eventSetup.getData(theMFToken);
 
   const std::string metname = "Reco|TrackingTools|TrajectoryReader";
 
   // Get the RecTrack collection from the event
-  Handle<reco::TrackCollection> tracks;
-  event.getByLabel(theInputLabel.label(), tracks);
+  const reco::TrackCollection tracks = event.get(theTrackToken);
 
-  if (tracks->empty())
+  if (tracks.empty())
     return;
 
   // Get the Trajectory collection from the event
-  Handle<Trajectories> trajectories;
-  event.getByLabel(theInputLabel, trajectories);
+  const Trajectories trajectories = event.get(theTrajToken);
 
   LogTrace(metname) << "looking at: " << theInputLabel;
 
   LogTrace(metname) << "All trajectories";
-  for (Trajectories::const_iterator trajectory = trajectories->begin(); trajectory != trajectories->end(); ++trajectory)
-    printTrajectoryRecHits(*trajectory, trackingGeometry);
+  for (const auto &trajectory : trajectories) {
+    printTrajectoryRecHits(trajectory, trackingGeometry);
+  }
 
   LogTrace(metname) << "All tracks";
-  for (reco::TrackCollection::const_iterator tr = tracks->begin(); tr != tracks->end(); ++tr)
-    printTrackRecHits(*tr, trackingGeometry);
+  for (const auto &tr : tracks) {
+    printTrackRecHits(tr, trackingGeometry);
+  }
 
-  Handle<TrajTrackAssociationCollection> assoMap;
-  event.getByLabel(theInputLabel, assoMap);
+  const TrajTrackAssociationCollection assoMap = event.get(theAssocToken);
 
   LogTrace(metname) << "Association";
-  for (TrajTrackAssociationCollection::const_iterator it = assoMap->begin(); it != assoMap->end(); ++it) {
-    const Ref<vector<Trajectory> > traj = it->key;
-    const reco::TrackRef tk = it->val;
+  //for (TrajTrackAssociationCollection::const_iterator it = assoMap.begin(); it != assoMap.end(); ++it) {
+  for (const auto &it : assoMap) {
+    const edm::Ref<std::vector<Trajectory> > traj = it.key;
+    const reco::TrackRef tk = it.val;
 
     printTrackRecHits(*tk, trackingGeometry);
     printTrajectoryRecHits(*traj, trackingGeometry);
@@ -159,8 +200,8 @@ void TrajectoryReader::analyze(const Event& event, const EventSetup& eventSetup)
     hFractionHitLost->Fill(double(diff) / track.recHitsSize());
   }
 
-  int traj_size = trajectories->size();
-  int track_size = tracks->size();
+  int traj_size = trajectories.size();
+  int track_size = tracks.size();
 
   if (traj_size != track_size) {
     LogTrace(metname) << "Mismatch between the # of Tracks (" << track_size << ") and the # of Trajectories! ("
@@ -169,3 +210,8 @@ void TrajectoryReader::analyze(const Event& event, const EventSetup& eventSetup)
   } else
     hSuccess->Fill(1);
 }
+
+#include "FWCore/PluginManager/interface/ModuleDef.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(TrajectoryReader);
diff --git a/TrackingTools/TrackRefitter/test/TrajectoryReader.h b/TrackingTools/TrackRefitter/test/TrajectoryReader.h
deleted file mode 100644
index 94c4a696cc326..0000000000000
--- a/TrackingTools/TrackRefitter/test/TrajectoryReader.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef TrackingTools_TrackRefitter_TrajectoryReader_H
-#define TrackingTools_TrackRefitter_TrajectoryReader_H
-
-/** \class TrajectoryReader
- *  No description available.
- *
- *  \author R. Bellan - INFN Torino <riccardo.bellan@cern.ch>
- */
-// Base Class Headers
-#include "FWCore/Framework/interface/EDAnalyzer.h"
-#include "FWCore/Framework/interface/ESHandle.h"
-#include "FWCore/Utilities/interface/InputTag.h"
-#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
-
-namespace edm {
-  class ParameterSet;
-  class Event;
-  class EventSetup;
-}  // namespace edm
-
-namespace reco {
-  class Track;
-}
-
-class TFile;
-class TH1F;
-class TH2F;
-class Trajectory;
-
-#include <vector>
-
-class TrajectoryReader : public edm::EDAnalyzer {
-public:
-  typedef std::vector<Trajectory> Trajectories;
-
-public:
-  /// Constructor
-  TrajectoryReader(const edm::ParameterSet &pset);
-
-  /// Destructor
-  virtual ~TrajectoryReader();
-
-  void analyze(const edm::Event &event, const edm::EventSetup &eventSetup);
-
-  // Operations
-  void beginJob();
-  void endJob();
-
-protected:
-  void printTrajectoryRecHits(const Trajectory &, edm::ESHandle<GlobalTrackingGeometry>) const;
-  void printTrackRecHits(const reco::Track &, edm::ESHandle<GlobalTrackingGeometry>) const;
-
-private:
-  edm::InputTag theInputLabel;
-  TFile *theFile;
-  std::string theRootFileName;
-
-  TH1F *hDPtIn;
-  TH1F *hDPtOut;
-  TH1F *hSuccess;
-  TH1F *hNHitLost;
-  TH1F *hFractionHitLost;
-};
-#endif
diff --git a/TrackingTools/TrajectoryCleaning/test/TrajectoryCleanerAnalyzer.cc b/TrackingTools/TrajectoryCleaning/test/TrajectoryCleanerAnalyzer.cc
index 239f916bab0f5..7c4702e37e6f4 100644
--- a/TrackingTools/TrajectoryCleaning/test/TrajectoryCleanerAnalyzer.cc
+++ b/TrackingTools/TrajectoryCleaning/test/TrajectoryCleanerAnalyzer.cc
@@ -20,54 +20,45 @@
 #include <memory>
 
 // user include files
-#include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDAnalyzer.h"
-
-#include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
-
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
-
-#include "TrackingTools/TrajectoryCleaning/interface/TrajectoryCleaner.h"
 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
+#include "TrackingTools/TrajectoryCleaning/interface/TrajectoryCleaner.h"
 
-class TrajectoryCleanerAnalyzer : public edm::EDAnalyzer {
+class TrajectoryCleanerAnalyzer : public edm::one::EDAnalyzer<> {
 public:
   explicit TrajectoryCleanerAnalyzer(const edm::ParameterSet&);
   ~TrajectoryCleanerAnalyzer();
 
 private:
-  virtual void beginJob();
   virtual void analyze(const edm::Event&, const edm::EventSetup&);
-  virtual void endJob();
-
+  std::vector<edm::ESGetToken<TrajectoryCleaner, TrajectoryCleaner::Record>> cleanerTokens;
   std::vector<std::string> cleanerNames;
 };
 
 TrajectoryCleanerAnalyzer::TrajectoryCleanerAnalyzer(const edm::ParameterSet& iConfig) {
-  cleanerNames = iConfig.getParameter<std::vector<std::string> >("cleanerNames");
+  cleanerNames = iConfig.getParameter<std::vector<std::string>>("cleanerNames");
+  for (unsigned int i = 0; i != cleanerNames.size(); i++) {
+    cleanerTokens[i] = esConsumes(edm::ESInputTag{"", cleanerNames[i]});
+  }
 }
 
-TrajectoryCleanerAnalyzer::~TrajectoryCleanerAnalyzer() {}
+TrajectoryCleanerAnalyzer::~TrajectoryCleanerAnalyzer() = default;
 
 void TrajectoryCleanerAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
   using namespace edm;
 
-  edm::ESHandle<TrajectoryCleaner> pTC;
   edm::LogInfo("TrajectoryCleanerAnalyzer")
       << " I am happy to try and get: " << cleanerNames.size() << " TrajectoryFilter from TrajectoryCleaner::Record";
   for (unsigned int i = 0; i != cleanerNames.size(); i++) {
-    iSetup.get<TrajectoryCleaner::Record>().get(cleanerNames[i], pTC);
-    edm::LogInfo("TrajectoryCleanerAnalyzer") << "I was able to create: " << cleanerNames[i];
+    const TrajectoryCleaner* pTC = &iSetup.getData(cleanerTokens[i]);
+    edm::LogInfo("TrajectoryCleanerAnalyzer") << "I was able to create: " << cleanerNames[i] << " pointer: " << pTC;
   }
 }
 
-// ------------ method called once each job just before starting event loop  ------------
-void TrajectoryCleanerAnalyzer::beginJob() {}
-
-// ------------ method called once each job just after ending the event loop  ------------
-void TrajectoryCleanerAnalyzer::endJob() {}
-
 //define this as a plug-in
 DEFINE_FWK_MODULE(TrajectoryCleanerAnalyzer);
diff --git a/TrackingTools/TrajectoryFiltering/test/TrajectoryFilterAnalyzer.cc b/TrackingTools/TrajectoryFiltering/test/TrajectoryFilterAnalyzer.cc
index c1ff1478d519a..1b11b8223b636 100644
--- a/TrackingTools/TrajectoryFiltering/test/TrajectoryFilterAnalyzer.cc
+++ b/TrackingTools/TrajectoryFiltering/test/TrajectoryFilterAnalyzer.cc
@@ -21,7 +21,7 @@
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
 
 #include "FWCore/Framework/interface/Event.h"
 #include "FWCore/Framework/interface/MakerMacros.h"
@@ -32,16 +32,13 @@
 #include "TrackingTools/TrajectoryFiltering/interface/TrajectoryFilter.h"
 #include "TrackingTools/TrajectoryFiltering/interface/TrajectoryFilterFactory.h"
 
-class TrajectoryFilterAnalyzer : public edm::EDAnalyzer {
+class TrajectoryFilterAnalyzer : public edm::one::EDAnalyzer<> {
 public:
   explicit TrajectoryFilterAnalyzer(const edm::ParameterSet&);
   ~TrajectoryFilterAnalyzer();
 
 private:
-  virtual void beginJob();
   virtual void analyze(const edm::Event&, const edm::EventSetup&);
-  virtual void endJob();
-
   std::vector<std::unique_ptr<TrajectoryFilter>> filters;
 };
 
@@ -59,15 +56,9 @@ TrajectoryFilterAnalyzer::TrajectoryFilterAnalyzer(const edm::ParameterSet& iCon
   }
 }
 
-TrajectoryFilterAnalyzer::~TrajectoryFilterAnalyzer() {}
+TrajectoryFilterAnalyzer::~TrajectoryFilterAnalyzer() = default;
 
 void TrajectoryFilterAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {}
 
-// ------------ method called once each job just before starting event loop  ------------
-void TrajectoryFilterAnalyzer::beginJob() {}
-
-// ------------ method called once each job just after ending the event loop  ------------
-void TrajectoryFilterAnalyzer::endJob() {}
-
 //define this as a plug-in
 DEFINE_FWK_MODULE(TrajectoryFilterAnalyzer);
diff --git a/TrackingTools/TransientTrack/test/TransientTrackBuilderTest.cc b/TrackingTools/TransientTrack/test/TransientTrackBuilderTest.cc
index 477256a04b8f0..bf1d22e203f04 100644
--- a/TrackingTools/TransientTrack/test/TransientTrackBuilderTest.cc
+++ b/TrackingTools/TransientTrack/test/TransientTrackBuilderTest.cc
@@ -1,38 +1,37 @@
-#include <memory>
-
-#include "FWCore/Framework/interface/Frameworkfwd.h"
-#include "FWCore/Framework/interface/EDAnalyzer.h"
 #include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/one/EDAnalyzer.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
-
-#include "FWCore/Framework/interface/ESHandle.h"
-
-#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
-#include "TrackingTools/Records/interface/TransientTrackRecord.h"
 #include "MagneticField/Engine/interface/MagneticField.h"
+#include "TrackingTools/Records/interface/TransientTrackRecord.h"
+#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
 
+#include <memory>
 #include <iostream>
 #include <string>
 
 using namespace edm;
 
-class TransientTrackBuilderTest : public edm::EDAnalyzer {
+class TransientTrackBuilderTest : public edm::one::EDAnalyzer<> {
 public:
-  TransientTrackBuilderTest(const edm::ParameterSet& pset) { conf_ = pset; }
+  TransientTrackBuilderTest(const edm::ParameterSet& pset)
+      : ttkToken_(esConsumes(edm::ESInputTag{"", "TransientTrackBuilder"})) {}
 
-  ~TransientTrackBuilderTest() {}
+  ~TransientTrackBuilderTest() = default;
 
   virtual void analyze(const edm::Event& event, const edm::EventSetup& setup) {
     using namespace std;
 
-    cout << " Asking for the TransientTrackBuilder with name TransientTrackBuilder\n";
-    edm::ESHandle<TransientTrackBuilder> theB;
-    setup.get<TransientTrackRecord>().get("TransientTrackBuilder", theB);
+    edm::LogPrint("TrackerTrackBuilderTest")
+        << " Asking for the TransientTrackBuilder with name TransientTrackBuilder\n";
+    const TransientTrackBuilder* theB = &setup.getData(ttkToken_);
 
-    cout << " Got a " << typeid(*theB).name() << endl;
-    cout << "Field at origin (in Testla): " << (*theB).field()->inTesla(GlobalPoint(0., 0., 0.)) << endl;
+    edm::LogPrint("TrackerTrackBuilderTest") << " Got a " << typeid(*theB).name() << endl;
+    edm::LogPrint("TrackerTrackBuilderTest")
+        << "Field at origin (in Testla): " << (*theB).field()->inTesla(GlobalPoint(0., 0., 0.)) << endl;
   }
 
 private:
-  edm::ParameterSet conf_;
+  const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> ttkToken_;
 };