diff --git a/Configuration/StandardSequences/python/Reconstruction_cff.py b/Configuration/StandardSequences/python/Reconstruction_cff.py
index e03d228a857fb..5ab8600b08989 100644
--- a/Configuration/StandardSequences/python/Reconstruction_cff.py
+++ b/Configuration/StandardSequences/python/Reconstruction_cff.py
@@ -4,7 +4,7 @@
 from RecoLocalMuon.Configuration.RecoLocalMuon_cff import *
 from RecoLocalCalo.Configuration.RecoLocalCalo_cff import *
 from RecoLocalFastTime.Configuration.RecoLocalFastTime_cff import *
-from RecoMTD.Configuration.RecoMTD_cff import *
+from RecoMTD.Configuration.mtdGlobalReco_cff import *
 from RecoTracker.Configuration.RecoTracker_cff import *
 from RecoParticleFlow.PFClusterProducer.particleFlowCluster_cff import *
 from TrackingTools.Configuration.TrackingTools_cff import *
diff --git a/DataFormats/FTLRecHit/interface/FTLCluster.h b/DataFormats/FTLRecHit/interface/FTLCluster.h
index 541b998ab10f2..d5967e204a9d5 100644
--- a/DataFormats/FTLRecHit/interface/FTLCluster.h
+++ b/DataFormats/FTLRecHit/interface/FTLCluster.h
@@ -14,7 +14,6 @@
 #include <cassert>
 #include <algorithm>
 #include <numeric>
-#include <functional>
 
 #include "DataFormats/DetId/interface/DetId.h"
 
@@ -220,9 +219,8 @@ class FTLCluster {
 
   uint8_t seed_;
 
-  float weighted_sum(const std::vector<float>& weights,
-                     const std::function<float(unsigned int i)>& sumFunc,
-                     const std::function<float(float, float)>& outFunc) const {
+  template <typename SumFunc, typename OutFunc>
+  float weighted_sum(const std::vector<float>& weights, SumFunc&& sumFunc, OutFunc&& outFunc) const {
     float tot = 0;
     float sumW = 0;
     for (unsigned int i = 0; i < weights.size(); ++i) {
@@ -232,7 +230,8 @@ class FTLCluster {
     return outFunc(tot, sumW);
   }
 
-  float weighted_mean(const std::vector<float>& weights, const std::function<float(unsigned int)>& value) const {
+  template <typename Value>
+  float weighted_mean(const std::vector<float>& weights, Value&& value) const {
     auto sumFunc = [&weights, value](unsigned int i) { return weights[i] * value(i); };
     auto outFunc = [](float x, float y) {
       if (y > 0)
@@ -243,7 +242,8 @@ class FTLCluster {
     return weighted_sum(weights, sumFunc, outFunc);
   }
 
-  float weighted_mean_error(const std::vector<float>& weights, const std::function<float(unsigned int)>& err) const {
+  template <typename Err>
+  float weighted_mean_error(const std::vector<float>& weights, Err&& err) const {
     auto sumFunc = [&weights, err](unsigned int i) { return weights[i] * weights[i] * err(i) * err(i); };
     auto outFunc = [](float x, float y) {
       if (y > 0)
diff --git a/DataFormats/FTLRecHit/src/FTLCluster.cc b/DataFormats/FTLRecHit/src/FTLCluster.cc
deleted file mode 100644
index e03a27dfe3de0..0000000000000
--- a/DataFormats/FTLRecHit/src/FTLCluster.cc
+++ /dev/null
@@ -1 +0,0 @@
-#include "DataFormats/FTLRecHit/interface/FTLCluster.h"
diff --git a/RecoLocalFastTime/FTLClusterizer/BuildFile.xml b/RecoLocalFastTime/FTLClusterizer/BuildFile.xml
index d9e4e76522f7a..0f30f7d932d3e 100644
--- a/RecoLocalFastTime/FTLClusterizer/BuildFile.xml
+++ b/RecoLocalFastTime/FTLClusterizer/BuildFile.xml
@@ -3,7 +3,6 @@
 <use name="Geometry/MTDGeometryBuilder"/>
 <use name="DataFormats/Common"/>
 <use name="TrackingTools/TrajectoryState"/>
-<use name="clhep"/>
 <export>
   <lib name="1"/>
 </export>
diff --git a/RecoLocalFastTime/FTLClusterizer/interface/MTDCPEBase.h b/RecoLocalFastTime/FTLClusterizer/interface/MTDCPEBase.h
index 9c3ab1dbcdb75..4330904c84224 100644
--- a/RecoLocalFastTime/FTLClusterizer/interface/MTDCPEBase.h
+++ b/RecoLocalFastTime/FTLClusterizer/interface/MTDCPEBase.h
@@ -57,7 +57,6 @@ class MTDCPEBase : public MTDClusterParameterEstimator {
   inline ReturnType getParameters(const FTLCluster& cl, const GeomDetUnit& det) const override {
     DetParam const& dp = detParam(det);
     ClusterParam cp(cl);
-    setTheClu(dp, cp);
     auto tuple =
         std::make_tuple(localPosition(dp, cp), localError(dp, cp), clusterTime(dp, cp), clusterTimeError(dp, cp));
     return tuple;
@@ -81,8 +80,6 @@ class MTDCPEBase : public MTDClusterParameterEstimator {
   virtual TimeValue clusterTime(DetParam const& dp, ClusterParam& cp) const;
   virtual TimeValueError clusterTimeError(DetParam const& dp, ClusterParam& cp) const;
 
-  void fillDetParams();
-
 protected:
   //---------------------------------------------------------------------------
   //  Data members
@@ -92,8 +89,6 @@ class MTDCPEBase : public MTDClusterParameterEstimator {
   const MTDGeometry& geom_;  // geometry
 
 protected:
-  void setTheClu(DetParam const& dp, ClusterParam& cp) const;
-
   //---------------------------------------------------------------------------
   //  Cluster-level services.
   //---------------------------------------------------------------------------
diff --git a/RecoLocalFastTime/FTLClusterizer/interface/MTDThresholdClusterizer.h b/RecoLocalFastTime/FTLClusterizer/interface/MTDThresholdClusterizer.h
index ccec5694efa9c..aef2252541cb0 100644
--- a/RecoLocalFastTime/FTLClusterizer/interface/MTDThresholdClusterizer.h
+++ b/RecoLocalFastTime/FTLClusterizer/interface/MTDThresholdClusterizer.h
@@ -59,7 +59,7 @@ class MTDThresholdClusterizer : public MTDClusterizerBase {
                   const MTDTopology* topo,
                   FTLClusterCollection& output) override;
 
-  static void fillDescriptions(edm::ParameterSetDescription& desc);
+  static void fillPSetDescription(edm::ParameterSetDescription& desc);
 
 private:
   std::vector<FTLCluster::FTLHitPos> theSeeds;  // cached seed pixels
diff --git a/RecoLocalFastTime/FTLClusterizer/plugins/MTDClusterProducer.cc b/RecoLocalFastTime/FTLClusterizer/plugins/MTDClusterProducer.cc
index a812971066bbe..a0bc522c132bb 100644
--- a/RecoLocalFastTime/FTLClusterizer/plugins/MTDClusterProducer.cc
+++ b/RecoLocalFastTime/FTLClusterizer/plugins/MTDClusterProducer.cc
@@ -74,9 +74,7 @@ MTDClusterProducer::MTDClusterProducer(edm::ParameterSet const& conf)
       etlHits_(consumes<FTLRecHitCollection>(conf.getParameter<edm::InputTag>("srcEndcap"))),
       ftlbInstance_(conf.getParameter<std::string>("BarrelClusterName")),
       ftleInstance_(conf.getParameter<std::string>("EndcapClusterName")),
-      clusterMode_(conf.getParameter<std::string>("ClusterMode")),
-      clusterizer_(nullptr)  // the default, in case we fail to make one
-{
+      clusterMode_(conf.getParameter<std::string>("ClusterMode")) {
   //--- Declare to the EDM what kind of collections we will be making.
   produces<FTLClusterCollection>(ftlbInstance_);
   produces<FTLClusterCollection>(ftleInstance_);
@@ -104,7 +102,7 @@ void MTDClusterProducer::fillDescriptions(edm::ConfigurationDescriptions& descri
   desc.add<std::string>("BarrelClusterName", "FTLBarrel");
   desc.add<std::string>("EndcapClusterName", "FTLEndcap");
   desc.add<std::string>("ClusterMode", "MTDThresholdClusterizer");
-  MTDThresholdClusterizer::fillDescriptions(desc);
+  MTDThresholdClusterizer::fillPSetDescription(desc);
   descriptions.add("mtdClusterProducer", desc);
 }
 
diff --git a/RecoLocalFastTime/FTLClusterizer/src/MTDCPEBase.cc b/RecoLocalFastTime/FTLClusterizer/src/MTDCPEBase.cc
index 1900257c14da9..85d7aec9a379c 100644
--- a/RecoLocalFastTime/FTLClusterizer/src/MTDCPEBase.cc
+++ b/RecoLocalFastTime/FTLClusterizer/src/MTDCPEBase.cc
@@ -18,12 +18,10 @@ using namespace std;
 //  A constructor run for generic and templates
 //
 //-----------------------------------------------------------------------------
-MTDCPEBase::MTDCPEBase(edm::ParameterSet const& conf, const MTDGeometry& geom) : geom_(geom) { fillDetParams(); }
-
-//-----------------------------------------------------------------------------
-//  Fill all variables which are constant for an event (geometry)
-//-----------------------------------------------------------------------------
-void MTDCPEBase::fillDetParams() {
+MTDCPEBase::MTDCPEBase(edm::ParameterSet const& conf, const MTDGeometry& geom) : geom_(geom) {
+  //-----------------------------------------------------------------------------
+  //  Fill all variables which are constant for an event (geometry)
+  //-----------------------------------------------------------------------------
   auto const& dus = geom_.detUnits();
   unsigned detectors = dus.size();
   m_DetParams.resize(detectors);
@@ -58,11 +56,6 @@ void MTDCPEBase::fillDetParams() {
   }
 }
 
-//-----------------------------------------------------------------------------
-//  One function to cache the variables common for one DetUnit.
-//-----------------------------------------------------------------------------
-void MTDCPEBase::setTheClu(DetParam const& dp, ClusterParam& cp) const {}
-
 //------------------------------------------------------------------------
 MTDCPEBase::DetParam const& MTDCPEBase::detParam(const GeomDetUnit& det) const { return m_DetParams.at(det.index()); }
 
diff --git a/RecoLocalFastTime/FTLClusterizer/src/MTDThresholdClusterizer.cc b/RecoLocalFastTime/FTLClusterizer/src/MTDThresholdClusterizer.cc
index f76c4a5510134..2720cdeb2b2bc 100644
--- a/RecoLocalFastTime/FTLClusterizer/src/MTDThresholdClusterizer.cc
+++ b/RecoLocalFastTime/FTLClusterizer/src/MTDThresholdClusterizer.cc
@@ -47,7 +47,7 @@ MTDThresholdClusterizer::MTDThresholdClusterizer(edm::ParameterSet const& conf)
 MTDThresholdClusterizer::~MTDThresholdClusterizer() {}
 
 // Configuration descriptions
-void MTDThresholdClusterizer::fillDescriptions(edm::ParameterSetDescription& desc) {
+void MTDThresholdClusterizer::fillPSetDescription(edm::ParameterSetDescription& desc) {
   desc.add<double>("HitThreshold", 0.);
   desc.add<double>("SeedThreshold", 0.);
   desc.add<double>("ClusterThreshold", 0.);
diff --git a/RecoLocalFastTime/FTLRecProducers/plugins/MTDTrackingRecHitProducer.cc b/RecoLocalFastTime/FTLRecProducers/plugins/MTDTrackingRecHitProducer.cc
index 794fffbe29987..6239e1dfee2cd 100644
--- a/RecoLocalFastTime/FTLRecProducers/plugins/MTDTrackingRecHitProducer.cc
+++ b/RecoLocalFastTime/FTLRecProducers/plugins/MTDTrackingRecHitProducer.cc
@@ -1,4 +1,4 @@
-#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/Framework/interface/global/EDProducer.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/Framework/interface/Event.h"
@@ -19,41 +19,28 @@
 
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 
-//#define DEBUG_ENABLED
-#ifdef DEBUG_ENABLED
-#define DEBUG(x)                 \
-  do {                           \
-    std::cout << x << std::endl; \
-  } while (0)
-#else
-#define DEBUG(x)
-#endif
-
-class MTDTrackingRecHitProducer : public edm::stream::EDProducer<> {
+class MTDTrackingRecHitProducer : public edm::global::EDProducer<> {
 public:
   explicit MTDTrackingRecHitProducer(const edm::ParameterSet& ps);
   ~MTDTrackingRecHitProducer() override = default;
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
-  void produce(edm::Event& evt, const edm::EventSetup& es) override;
-  void run(edm::Handle<edmNew::DetSetVector<FTLCluster> > inputHandle, MTDTrackingDetSetVector& output);
+  void produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const override;
 
 private:
   const edm::EDGetTokenT<FTLClusterCollection> ftlbClusters_;  // collection of barrel digis
   const edm::EDGetTokenT<FTLClusterCollection> ftleClusters_;  // collection of endcap digis
 
-  const MTDGeometry* geom_;
-  const MTDClusterParameterEstimator* cpe_;
-  edm::ESGetToken<MTDGeometry, MTDDigiGeometryRecord> mtdgeoToken_;
-  edm::ESGetToken<MTDClusterParameterEstimator, MTDCPERecord> cpeToken_;
+  const edm::ESGetToken<MTDGeometry, MTDDigiGeometryRecord> mtdgeoToken_;
+  const edm::ESGetToken<MTDClusterParameterEstimator, MTDCPERecord> cpeToken_;
 };
 
 MTDTrackingRecHitProducer::MTDTrackingRecHitProducer(const edm::ParameterSet& ps)
     : ftlbClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("barrelClusters"))),
-      ftleClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("endcapClusters"))) {
+      ftleClusters_(consumes<FTLClusterCollection>(ps.getParameter<edm::InputTag>("endcapClusters"))),
+      mtdgeoToken_(esConsumes<MTDGeometry, MTDDigiGeometryRecord>()),
+      cpeToken_(esConsumes<MTDClusterParameterEstimator, MTDCPERecord>(edm::ESInputTag("", "MTDCPEBase"))) {
   produces<MTDTrackingDetSetVector>();
-  mtdgeoToken_ = esConsumes<MTDGeometry, MTDDigiGeometryRecord>();
-  cpeToken_ = esConsumes<MTDClusterParameterEstimator, MTDCPERecord>(edm::ESInputTag("", "MTDCPEBase"));
 }
 
 // Configuration descriptions
@@ -64,12 +51,10 @@ void MTDTrackingRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions&
   descriptions.add("mtdTrackingRecHitProducer", desc);
 }
 
-void MTDTrackingRecHitProducer::produce(edm::Event& evt, const edm::EventSetup& es) {
-  auto geom = es.getTransientHandle(mtdgeoToken_);
-  geom_ = geom.product();
+void MTDTrackingRecHitProducer::produce(edm::StreamID, edm::Event& evt, const edm::EventSetup& es) const {
+  auto const& geom = es.getData(mtdgeoToken_);
 
-  auto cpe = es.getTransientHandle(cpeToken_);
-  cpe_ = cpe.product();
+  auto const& cpe = es.getData(cpeToken_);
 
   edm::Handle<FTLClusterCollection> inputBarrel;
   evt.getByToken(ftlbClusters_, inputBarrel);
@@ -77,57 +62,55 @@ void MTDTrackingRecHitProducer::produce(edm::Event& evt, const edm::EventSetup&
   edm::Handle<FTLClusterCollection> inputEndcap;
   evt.getByToken(ftleClusters_, inputEndcap);
 
+  std::array<edm::Handle<FTLClusterCollection>, 2> inputHandle{{inputBarrel, inputEndcap}};
+
   auto outputhits = std::make_unique<MTDTrackingDetSetVector>();
   auto& theoutputhits = *outputhits;
 
-  run(inputBarrel, theoutputhits);
-  run(inputEndcap, theoutputhits);
+  //---------------------------------------------------------------------------
+  //!  Iterate over DetUnits, then over Clusters and invoke the CPE on each,
+  //!  and make a RecHit to store the result.
+  //---------------------------------------------------------------------------
+
+  for (auto const& theInput : inputHandle) {
+    const edmNew::DetSetVector<FTLCluster>& input = *theInput;
+
+    LogDebug("MTDTrackingRecHitProducer") << "inputCollection " << input.size();
+    for (const auto& DSVit : input) {
+      unsigned int detid = DSVit.detId();
+      DetId detIdObject(detid);
+      const auto genericDet = geom.idToDetUnit(detIdObject);
+      if (genericDet == nullptr) {
+        throw cms::Exception("MTDTrackingRecHitProducer")
+            << "GeographicalID: " << std::hex << detid << " is invalid!" << std::dec << std::endl;
+      }
+
+      MTDTrackingDetSetVector::FastFiller recHitsOnDet(theoutputhits, detid);
+
+      for (const auto& clustIt : DSVit) {
+        LogDebug("MTDTrackingRcHitProducer") << "Cluster: size " << clustIt.size() << " " << clustIt.x() << ","
+                                             << clustIt.y() << " " << clustIt.energy() << " " << clustIt.time();
+        MTDClusterParameterEstimator::ReturnType tuple = cpe.getParameters(clustIt, *genericDet);
+        LocalPoint lp(std::get<0>(tuple));
+        LocalError le(std::get<1>(tuple));
+
+        // Create a persistent edm::Ref to the cluster
+        edm::Ref<edmNew::DetSetVector<FTLCluster>, FTLCluster> cluster = edmNew::makeRefTo(theInput, &clustIt);
+        // Make a RecHit and add it to the DetSet
+        MTDTrackingRecHit hit(lp, le, *genericDet, cluster);
+        LogDebug("MTDTrackingRcHitProducer")
+            << "MTD_TRH: " << hit.localPosition().x() << "," << hit.localPosition().y() << " : "
+            << hit.localPositionError().xx() << "," << hit.localPositionError().yy() << " : " << hit.time() << " : "
+            << hit.timeError();
+        // Now save it =================
+        recHitsOnDet.push_back(hit);
+      }  //  <-- End loop on Clusters
+    }    //    <-- End loop on DetUnits
+    LogDebug("MTDTrackingRcHitProducer") << "outputCollection " << theoutputhits.size();
+  }
 
   evt.put(std::move(outputhits));
 }
 
-//---------------------------------------------------------------------------
-//!  Iterate over DetUnits, then over Clusters and invoke the CPE on each,
-//!  and make a RecHit to store the result.
-//---------------------------------------------------------------------------
-void MTDTrackingRecHitProducer::run(edm::Handle<FTLClusterCollection> inputHandle, MTDTrackingDetSetVector& output) {
-  const edmNew::DetSetVector<FTLCluster>& input = *inputHandle;
-  edmNew::DetSetVector<FTLCluster>::const_iterator DSViter = input.begin();
-
-  DEBUG("inputCollection " << input.size());
-  for (; DSViter != input.end(); DSViter++) {
-    unsigned int detid = DSViter->detId();
-    DetId detIdObject(detid);
-    const auto genericDet = geom_->idToDetUnit(detIdObject);
-    if (genericDet == nullptr) {
-      throw cms::Exception("MTDTrackingRecHitProducer")
-          << "GeographicalID: " << std::hex << detid << " is invalid!" << std::dec << std::endl;
-    }
-
-    MTDTrackingDetSetVector::FastFiller recHitsOnDet(output, detid);
-
-    edmNew::DetSet<FTLCluster>::const_iterator clustIt = DSViter->begin(), clustEnd = DSViter->end();
-
-    for (; clustIt != clustEnd; clustIt++) {
-      DEBUG("Cluster: size " << clustIt->size() << " " << clustIt->x() << "," << clustIt->y() << " "
-                             << clustIt->energy() << " " << clustIt->time());
-      MTDClusterParameterEstimator::ReturnType tuple = cpe_->getParameters(*clustIt, *genericDet);
-      LocalPoint lp(std::get<0>(tuple));
-      LocalError le(std::get<1>(tuple));
-
-      // Create a persistent edm::Ref to the cluster
-      edm::Ref<edmNew::DetSetVector<FTLCluster>, FTLCluster> cluster = edmNew::makeRefTo(inputHandle, clustIt);
-      // Make a RecHit and add it to the DetSet
-      MTDTrackingRecHit hit(lp, le, *genericDet, cluster);
-      DEBUG("MTD_TRH: " << hit.localPosition().x() << "," << hit.localPosition().y() << " : "
-                        << hit.localPositionError().xx() << "," << hit.localPositionError().yy() << " : " << hit.time()
-                        << " : " << hit.timeError());
-      // Now save it =================
-      recHitsOnDet.push_back(hit);
-    }  //  <-- End loop on Clusters
-  }    //    <-- End loop on DetUnits
-  DEBUG("outputCollection " << output.size());
-}
-
 #include "FWCore/Framework/interface/MakerMacros.h"
 DEFINE_FWK_MODULE(MTDTrackingRecHitProducer);
diff --git a/RecoMTD/Configuration/python/RecoMTD_cff.py b/RecoMTD/Configuration/python/mtdGlobalReco_cff.py
similarity index 100%
rename from RecoMTD/Configuration/python/RecoMTD_cff.py
rename to RecoMTD/Configuration/python/mtdGlobalReco_cff.py
diff --git a/RecoMTD/MeasurementDet/interface/MTDDetLayerMeasurements.h b/RecoMTD/MeasurementDet/interface/MTDDetLayerMeasurements.h
index 6228873b41797..fb1f19afcc7f7 100644
--- a/RecoMTD/MeasurementDet/interface/MTDDetLayerMeasurements.h
+++ b/RecoMTD/MeasurementDet/interface/MTDDetLayerMeasurements.h
@@ -1,5 +1,5 @@
-#ifndef MeasurementDet_MTDDetLayerMeasurements_H
-#define MeasurementDet_MTDDetLayerMeasurements_H
+#ifndef RecoMTD_MeasurementDet_MTDDetLayerMeasurements_H
+#define RecoMTD_MeasurementDet_MTDDetLayerMeasurements_H
 
 /** \class MTDDetLayerMeasurements
  *  The class to access recHits and TrajectoryMeasurements from DetLayer.  
@@ -33,7 +33,7 @@ class MTDDetLayerMeasurements {
   typedef std::pair<const GeomDet*, TrajectoryStateOnSurface> DetWithState;
   typedef std::vector<GenericTransientTrackingRecHit::RecHitPointer> MTDRecHitContainer;
 
-  MTDDetLayerMeasurements(edm::InputTag mtdlabel, edm::ConsumesCollector& iC);
+  MTDDetLayerMeasurements(const edm::InputTag& mtdlabel, edm::ConsumesCollector& iC);
 
   virtual ~MTDDetLayerMeasurements();
 
@@ -99,7 +99,11 @@ class MTDDetLayerMeasurements {
   /// check that the event is set, and throw otherwise
   void checkEvent() const;
 
-  edm::EDGetTokenT<MTDTrackingRecHit> mtdToken_;
+  // sort functions for containers provided by measurements methods
+  template <class T>
+  T sortResult(T&);
+
+  edm::EDGetTokenT<MTDTrackingRecHit> theMTDToken;
 
   // caches that should get filled once per event
   edm::Handle<edmNew::DetSetVector<MTDTrackingRecHit>> theMTDRecHits;
diff --git a/RecoMTD/MeasurementDet/src/MTDDetLayerMeasurements.cc b/RecoMTD/MeasurementDet/src/MTDDetLayerMeasurements.cc
index 6ac222f501dd7..34e5396a00b68 100644
--- a/RecoMTD/MeasurementDet/src/MTDDetLayerMeasurements.cc
+++ b/RecoMTD/MeasurementDet/src/MTDDetLayerMeasurements.cc
@@ -19,10 +19,11 @@ typedef std::shared_ptr<GenericTransientTrackingRecHit> MTDRecHitPointer;
 typedef std::vector<GenericTransientTrackingRecHit::RecHitPointer> MTDRecHitContainer;
 typedef MTDDetLayerMeasurements::MeasurementContainer MeasurementContainer;
 
-MTDDetLayerMeasurements::MTDDetLayerMeasurements(edm::InputTag mtdlabel, edm::ConsumesCollector& iC)
-    : theMTDRecHits(), theMTDEventCacheID(0), theEvent(nullptr) {
-  mtdToken_ = iC.consumes<MTDTrackingRecHit>(mtdlabel);
-}
+MTDDetLayerMeasurements::MTDDetLayerMeasurements(const edm::InputTag& mtdlabel, edm::ConsumesCollector& iC)
+    : theMTDToken(iC.consumes<MTDTrackingRecHit>(mtdlabel)),
+      theMTDRecHits(),
+      theMTDEventCacheID(0),
+      theEvent(nullptr) {}
 
 MTDDetLayerMeasurements::~MTDDetLayerMeasurements() {}
 
@@ -35,10 +36,9 @@ MTDRecHitContainer MTDDetLayerMeasurements::recHits(const GeomDet* geomDet, cons
 
   // Create the ChamberId
   DetId detId(geoId.rawId());
-  LogDebug("Track|RecoMTD|MTDDetLayerMeasurements") << "(MTD): " << static_cast<MTDDetId>(detId) << std::endl;
+  LogDebug("MTDDetLayerMeasurements") << "(MTD): " << static_cast<MTDDetId>(detId) << std::endl;
 
   // Get the MTD-Segment which relies on this chamber
-  //auto cmp = [](const unsigned one, const unsigned two) -> bool { return one < two; };
   auto detset = (*theMTDRecHits)[detId];
 
   for (const auto& rechit : detset)
@@ -48,22 +48,30 @@ MTDRecHitContainer MTDDetLayerMeasurements::recHits(const GeomDet* geomDet, cons
 }
 
 void MTDDetLayerMeasurements::checkMTDRecHits() {
-  LogDebug("Track|RecoMTD|MTDDetLayerMeasurements") << "Checking MTD RecHits";
+  LogDebug("MTDDetLayerMeasurements") << "Checking MTD RecHits";
   checkEvent();
   auto cacheID = theEvent->cacheIdentifier();
   if (cacheID == theMTDEventCacheID)
     return;
 
   {
-    theEvent->getByToken(mtdToken_, theMTDRecHits);
+    theEvent->getByToken(theMTDToken, theMTDRecHits);
     theMTDEventCacheID = cacheID;
   }
   if (!theMTDRecHits.isValid()) {
     throw cms::Exception("MTDDetLayerMeasurements") << "Cannot get MTD RecHits";
-    LogDebug("Track|RecoMTD|MTDDetLayerMeasurements") << "Cannot get MTD RecHits";
   }
 }
 
+template <class T>
+T MTDDetLayerMeasurements::sortResult(T& result) {
+  if (!result.empty()) {
+    sort(result.begin(), result.end(), TrajMeasLessEstim());
+  }
+
+  return result;
+}
+
 ///measurements method if already got the Event
 MeasurementContainer MTDDetLayerMeasurements::measurements(const DetLayer* layer,
                                                            const TrajectoryStateOnSurface& startingState,
@@ -80,18 +88,15 @@ MeasurementContainer MTDDetLayerMeasurements::measurements(const DetLayer* layer
                                                            const edm::Event& iEvent) {
   MeasurementContainer result;
 
-  std::vector<DetWithState> dss = layer->compatibleDets(startingState, prop, est);
-  LogDebug("RecoMTD") << "compatibleDets: " << dss.size() << std::endl;
+  const auto& dss = layer->compatibleDets(startingState, prop, est);
+  LogDebug("MTDDetLayerMeasurements") << "compatibleDets: " << dss.size() << std::endl;
 
   for (const auto& dws : dss) {
     MeasurementContainer detMeasurements = measurements(layer, dws.first, dws.second, est, iEvent);
     result.insert(result.end(), detMeasurements.begin(), detMeasurements.end());
   }
 
-  if (!result.empty())
-    sort(result.begin(), result.end(), TrajMeasLessEstim());
-
-  return result;
+  return sortResult(result);
 }
 
 MeasurementContainer MTDDetLayerMeasurements::measurements(const DetLayer* layer,
@@ -105,18 +110,15 @@ MeasurementContainer MTDDetLayerMeasurements::measurements(const DetLayer* layer
   MTDRecHitContainer mtdRecHits = recHits(det, iEvent);
 
   // Create the Trajectory Measurement
-  for (auto rechit = mtdRecHits.begin(); rechit != mtdRecHits.end(); ++rechit) {
-    MeasurementEstimator::HitReturnType estimate = est.estimate(stateOnDet, **rechit);
-    LogDebug("RecoMTD") << "Dimension: " << (*rechit)->dimension() << " Chi2: " << estimate.second << std::endl;
+  for (const auto& rechit : mtdRecHits) {
+    MeasurementEstimator::HitReturnType estimate = est.estimate(stateOnDet, *rechit);
+    LogDebug("RecoMTD") << "Dimension: " << rechit->dimension() << " Chi2: " << estimate.second << std::endl;
     if (estimate.first) {
-      result.push_back(TrajectoryMeasurement(stateOnDet, *rechit, estimate.second, layer));
+      result.push_back(TrajectoryMeasurement(stateOnDet, rechit, estimate.second, layer));
     }
   }
 
-  if (!result.empty())
-    sort(result.begin(), result.end(), TrajMeasLessEstim());
-
-  return result;
+  return sortResult(result);
 }
 
 MeasurementContainer MTDDetLayerMeasurements::fastMeasurements(const DetLayer* layer,
@@ -127,18 +129,14 @@ MeasurementContainer MTDDetLayerMeasurements::fastMeasurements(const DetLayer* l
                                                                const edm::Event& iEvent) {
   MeasurementContainer result;
   MTDRecHitContainer rhs = recHits(layer, iEvent);
-  for (const MTDRecHitContainer::value_type& irh : rhs) {
+  for (const auto& irh : rhs) {
     MeasurementEstimator::HitReturnType estimate = est.estimate(theStateOnDet, (*irh));
     if (estimate.first) {
       result.push_back(TrajectoryMeasurement(theStateOnDet, irh, estimate.second, layer));
     }
   }
 
-  if (!result.empty()) {
-    sort(result.begin(), result.end(), TrajMeasLessEstim());
-  }
-
-  return result;
+  return sortResult(result);
 }
 
 ///fastMeasurements method if already got the Event
@@ -179,10 +177,7 @@ std::vector<TrajectoryMeasurementGroup> MTDDetLayerMeasurements::groupedMeasurem
       groupMeasurements.insert(groupMeasurements.end(), detMeasurements.begin(), detMeasurements.end());
     }
 
-    if (!groupMeasurements.empty())
-      std::sort(groupMeasurements.begin(), groupMeasurements.end(), TrajMeasLessEstim());
-
-    result.push_back(TrajectoryMeasurementGroup(groupMeasurements, grp));
+    result.push_back(TrajectoryMeasurementGroup(sortResult(groupMeasurements), grp));
   }
 
   return result;
diff --git a/TrackingTools/RecoGeometry/plugins/GlobalDetLayerGeometryESProducer.cc b/TrackingTools/RecoGeometry/plugins/GlobalDetLayerGeometryESProducer.cc
index c0cb84166551a..6d201bfa715bc 100644
--- a/TrackingTools/RecoGeometry/plugins/GlobalDetLayerGeometryESProducer.cc
+++ b/TrackingTools/RecoGeometry/plugins/GlobalDetLayerGeometryESProducer.cc
@@ -32,7 +32,7 @@ std::unique_ptr<DetLayerGeometry> GlobalDetLayerGeometryESProducer::produce(cons
       LogInfo("GlobalDetLayergGeometryBuilder") << "No MTD geometry is available.";
     }
   } else {
-    LogInfo("GlobalDetLayerGeometryBuilder") << "No MTDDigiGeometryRecord is available.";
+    LogInfo("GlobalDetLayerGeometryBuilder") << "No MTDRecoGeometryRecord is available.";
   }
 
   // if we've got MTD initialize it
diff --git a/TrackingTools/TrackRefitter/interface/TrackTransformer.h b/TrackingTools/TrackRefitter/interface/TrackTransformer.h
index 1d776534964e2..c73afc93c7b49 100644
--- a/TrackingTools/TrackRefitter/interface/TrackTransformer.h
+++ b/TrackingTools/TrackRefitter/interface/TrackTransformer.h
@@ -58,15 +58,15 @@ class TrackTransformer final : public TrackTransformerBase {
 
   /// fillDescriptions
   static void fillPSetDescription(edm::ParameterSetDescription& descriptions,
-                                  bool DoPredictionsOnly = false,
-                                  const std::string& Fitter = "KFFitterForRefitInsideOut",
-                                  const std::string& Smoother = "KFSmootherForRefitInsideOut",
-                                  const std::string& Propagator = "SmartPropagatorAnyRK",
-                                  const std::string& RefitDirection = "alongMomentum",
-                                  bool RefitRPCHits = true,
-                                  const std::string& TrackerRecHitBuilder = "WithTrackAngle",
-                                  const std::string& MuonRecHitBuilder = "MuonRecHitBuilder",
-                                  const std::string& MTDRecHitBuilder = "MTDRecHitBuilder");
+                                  bool doPredictionsOnly = false,
+                                  const std::string& fitter = "KFFitterForRefitInsideOut",
+                                  const std::string& smoother = "KFSmootherForRefitInsideOut",
+                                  const std::string& propagator = "SmartPropagatorAnyRK",
+                                  const std::string& refitDirection = "alongMomentum",
+                                  bool refitRPCHits = true,
+                                  const std::string& trackerRecHitBuilder = "WithTrackAngle",
+                                  const std::string& muonRecHitBuilder = "MuonRecHitBuilder",
+                                  const std::string& mtdRecHitBuilder = "MTDRecHitBuilder");
 
   // Operations
 
diff --git a/TrackingTools/TrackRefitter/src/TrackTransformer.cc b/TrackingTools/TrackRefitter/src/TrackTransformer.cc
index 93a7a9f6401fc..32b4ce343da07 100644
--- a/TrackingTools/TrackRefitter/src/TrackTransformer.cc
+++ b/TrackingTools/TrackRefitter/src/TrackTransformer.cc
@@ -56,24 +56,24 @@ TrackTransformer::TrackTransformer(const ParameterSet& parameterSet, edm::Consum
 TrackTransformer::~TrackTransformer() {}
 
 void TrackTransformer::fillPSetDescription(edm::ParameterSetDescription& desc,
-                                           bool DoPredictionsOnly,
-                                           const std::string& Fitter,
-                                           const std::string& Smoother,
-                                           const std::string& Propagator,
-                                           const std::string& RefitDirection,
-                                           bool RefitRPCHits,
-                                           const std::string& TrackerRecHitBuilder,
-                                           const std::string& MuonRecHitBuilder,
-                                           const std::string& MTDRecHitBuilder) {
-  desc.add<bool>("DoPredictionsOnly", DoPredictionsOnly);
-  desc.add<std::string>("Fitter", Fitter);
-  desc.add<std::string>("Smoother", Smoother);
-  desc.add<std::string>("Propagator", Propagator);
-  desc.add<std::string>("RefitDirection", RefitDirection);
-  desc.add<bool>("RefitRPCHits", RefitRPCHits);
-  desc.add<std::string>("TrackerRecHitBuilder", TrackerRecHitBuilder);
-  desc.add<std::string>("MuonRecHitBuilder", MuonRecHitBuilder);
-  desc.add<std::string>("MTDRecHitBuilder", MTDRecHitBuilder);
+                                           bool doPredictionsOnly,
+                                           const std::string& fitter,
+                                           const std::string& smoother,
+                                           const std::string& propagator,
+                                           const std::string& refitDirection,
+                                           bool refitRPCHits,
+                                           const std::string& trackerRecHitBuilder,
+                                           const std::string& muonRecHitBuilder,
+                                           const std::string& mtdRecHitBuilder) {
+  desc.add<bool>("DoPredictionsOnly", doPredictionsOnly);
+  desc.add<std::string>("Fitter", fitter);
+  desc.add<std::string>("Smoother", smoother);
+  desc.add<std::string>("Propagator", propagator);
+  desc.add<std::string>("RefitDirection", refitDirection);
+  desc.add<bool>("RefitRPCHits", refitRPCHits);
+  desc.add<std::string>("TrackerRecHitBuilder", trackerRecHitBuilder);
+  desc.add<std::string>("MuonRecHitBuilder", muonRecHitBuilder);
+  desc.add<std::string>("MTDRecHitBuilder", mtdRecHitBuilder);
 }
 
 void TrackTransformer::setServices(const EventSetup& setup) {