From 292d13bd2e64c2287a9e694a810981b49ecbcdb5 Mon Sep 17 00:00:00 2001
From: Matti Kortelainen <matti.kortelainen@cern.ch>
Date: Fri, 3 Sep 2021 21:54:11 +0200
Subject: [PATCH 1/2] Add MultipleScatteringParametrisationMaker ESProduct that
 makes MultipleScatteringParametrisation objects

In order to store MSLayerKeeper* objects in EventSetup instead of thread local objects.
---
 .../TrackerMultipleScatteringRecord.h         | 16 ++++++
 .../src/TrackerMultipleScatteringRecord.cc    |  4 ++
 .../MultipleScatteringParametrisation.h       | 13 +----
 .../MultipleScatteringParametrisationMaker.h  | 26 ++++++++++
 .../TkMSParametrization/plugins/BuildFile.xml | 10 ++++
 ...catteringParametrisationMakerESProducer.cc | 44 ++++++++++++++++
 ..._MultipleScatteringParametrisationMaker.cc |  4 ++
 .../TkMSParametrization/src/MSLayersKeeper.h  |  1 -
 .../src/MSLayersKeeperX0AtEta.cc              | 16 +++---
 .../src/MSLayersKeeperX0AtEta.h               | 13 ++---
 .../src/MSLayersKeeperX0Averaged.cc           | 14 ++---
 .../src/MSLayersKeeperX0Averaged.h            | 12 ++---
 .../src/MSLayersKeeperX0DetLayer.cc           |  5 +-
 .../src/MSLayersKeeperX0DetLayer.h            |  6 +--
 .../src/MultipleScatteringGeometry.cc         | 28 ++++------
 .../src/MultipleScatteringGeometry.h          | 13 ++---
 .../src/MultipleScatteringParametrisation.cc  | 51 +++----------------
 .../MultipleScatteringParametrisationMaker.cc | 28 ++++++++++
 .../TkMSParametrization/test/TestMS.cc        | 25 +++++----
 19 files changed, 199 insertions(+), 130 deletions(-)
 create mode 100644 RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h
 create mode 100644 RecoTracker/Record/src/TrackerMultipleScatteringRecord.cc
 create mode 100644 RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h
 create mode 100644 RecoTracker/TkMSParametrization/plugins/BuildFile.xml
 create mode 100644 RecoTracker/TkMSParametrization/plugins/MultipleScatteringParametrisationMakerESProducer.cc
 create mode 100644 RecoTracker/TkMSParametrization/src/ES_MultipleScatteringParametrisationMaker.cc
 create mode 100644 RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisationMaker.cc

diff --git a/RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h b/RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h
new file mode 100644
index 0000000000000..acdca47bb7978
--- /dev/null
+++ b/RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h
@@ -0,0 +1,16 @@
+#ifndef RecoTracker_Record_TrackerMultipleScatteringRecord_h
+#define RecoTracker_Record_TrackerMultipleScatteringRecord_h
+
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+#include "FWCore/Framework/interface/DependentRecordImplementation.h"
+
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
+
+#include "FWCore/Utilities/interface/mplVector.h"
+
+class TrackerMultipleScatteringRecord : public edm::eventsetup::DependentRecordImplementation<
+                                            TrackerMultipleScatteringRecord,
+                                            edm::mpl::Vector<IdealMagneticFieldRecord, TrackerRecoGeometryRecord> > {};
+
+#endif
diff --git a/RecoTracker/Record/src/TrackerMultipleScatteringRecord.cc b/RecoTracker/Record/src/TrackerMultipleScatteringRecord.cc
new file mode 100644
index 0000000000000..9fb7ca3934463
--- /dev/null
+++ b/RecoTracker/Record/src/TrackerMultipleScatteringRecord.cc
@@ -0,0 +1,4 @@
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+
+EVENTSETUP_RECORD_REG(TrackerMultipleScatteringRecord);
diff --git a/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h b/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h
index 87ad0260bfc50..b483d61c2fe70 100644
--- a/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h
+++ b/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h
@@ -15,20 +15,9 @@ class DetLayer;
 
 class MultipleScatteringParametrisation {
 public:
-  static void initKeepers(const edm::EventSetup &iSetup);
-
-  enum X0Source { useDetLayer = 0, useX0AtEta = 1, useX0DataAveraged = 2 };
   enum Consecutive { notAssumeConsecutive, useConsecutive };
 
-  MultipleScatteringParametrisation() {}
-
-  MultipleScatteringParametrisation(const DetLayer *layer,
-                                    const edm::EventSetup &iSetup,
-                                    X0Source x0source = useX0AtEta) {
-    init(layer, iSetup, x0source);
-  }
-
-  void init(const DetLayer *layer, const edm::EventSetup &iSetup, X0Source x0source = useX0AtEta);
+  MultipleScatteringParametrisation(const DetLayer *layer, const MSLayersKeeper *layerKeeper);
 
   /// MS sigma  at the layer for which parametrisation is initialised;
   /// particle assumed to come from nominal vertex, "fast" methods called
diff --git a/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h b/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h
new file mode 100644
index 0000000000000..52da6570540f6
--- /dev/null
+++ b/RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h
@@ -0,0 +1,26 @@
+#ifndef RecoTracker_TkMSParametrization_MSLayersKeepers_h
+#define RecoTracker_TkMSParametrization_MSLayersKeepers_h
+
+#include "FWCore/Utilities/interface/propagate_const.h"
+#include "MagneticField/Engine/interface/MagneticField.h"
+#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
+
+class DetLayer;
+
+class MultipleScatteringParametrisationMaker {
+public:
+  enum class X0Source { useDetLayer = 0, useX0AtEta = 1, useX0DataAveraged = 2 };
+
+  MultipleScatteringParametrisationMaker(GeometricSearchTracker const& tracker, MagneticField const& bfield);
+  ~MultipleScatteringParametrisationMaker();
+
+  MultipleScatteringParametrisation parametrisation(const DetLayer* layer,
+                                                    X0Source x0Source = X0Source::useX0AtEta) const;
+
+private:
+  struct Keepers;
+  edm::propagate_const<std::unique_ptr<Keepers>> impl_;
+};
+
+#endif
diff --git a/RecoTracker/TkMSParametrization/plugins/BuildFile.xml b/RecoTracker/TkMSParametrization/plugins/BuildFile.xml
new file mode 100644
index 0000000000000..b8ad7f2535fa7
--- /dev/null
+++ b/RecoTracker/TkMSParametrization/plugins/BuildFile.xml
@@ -0,0 +1,10 @@
+<use name="FWCore/Framework"/>
+<use name="FWCore/ParameterSet"/>
+<use name="MagneticField/Engine"/>
+<use name="MagneticField/Records"/>
+<use name="RecoTracker/Record"/>
+<use name="RecoTracker/TkDetLayers"/>
+<use name="RecoTracker/TkMSParametrization"/>
+<library file="*.cc" name="RecoTrackerTkMSParametrizationPlugins">
+  <flags EDM_PLUGIN="1"/>
+</library>
diff --git a/RecoTracker/TkMSParametrization/plugins/MultipleScatteringParametrisationMakerESProducer.cc b/RecoTracker/TkMSParametrization/plugins/MultipleScatteringParametrisationMakerESProducer.cc
new file mode 100644
index 0000000000000..40b7e8d3c868e
--- /dev/null
+++ b/RecoTracker/TkMSParametrization/plugins/MultipleScatteringParametrisationMakerESProducer.cc
@@ -0,0 +1,44 @@
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterDescription.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+
+#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
+#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
+#include "MagneticField/Engine/interface/MagneticField.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+
+class MultipleScatteringParametrisationMakerESProducer : public edm::ESProducer {
+public:
+  MultipleScatteringParametrisationMakerESProducer(edm::ParameterSet const& iConfig);
+
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
+
+  std::unique_ptr<MultipleScatteringParametrisationMaker> produce(const TrackerMultipleScatteringRecord& iRecord);
+
+private:
+  edm::ESGetToken<GeometricSearchTracker, TrackerRecoGeometryRecord> trackerToken_;
+  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> bfieldToken_;
+};
+
+MultipleScatteringParametrisationMakerESProducer::MultipleScatteringParametrisationMakerESProducer(
+    edm::ParameterSet const& iConfig) {
+  auto cc = setWhatProduced(this);
+  trackerToken_ = cc.consumes();
+  bfieldToken_ = cc.consumes();
+}
+
+void MultipleScatteringParametrisationMakerESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+  edm::ParameterSetDescription desc;
+  descriptions.addWithDefaultLabel(desc);
+}
+
+std::unique_ptr<MultipleScatteringParametrisationMaker> MultipleScatteringParametrisationMakerESProducer::produce(
+    const TrackerMultipleScatteringRecord& iRecord) {
+  return std::make_unique<MultipleScatteringParametrisationMaker>(iRecord.get(trackerToken_),
+                                                                  iRecord.get(bfieldToken_));
+}
+
+DEFINE_FWK_EVENTSETUP_MODULE(MultipleScatteringParametrisationMakerESProducer);
diff --git a/RecoTracker/TkMSParametrization/src/ES_MultipleScatteringParametrisationMaker.cc b/RecoTracker/TkMSParametrization/src/ES_MultipleScatteringParametrisationMaker.cc
new file mode 100644
index 0000000000000..467fbf1bc75c7
--- /dev/null
+++ b/RecoTracker/TkMSParametrization/src/ES_MultipleScatteringParametrisationMaker.cc
@@ -0,0 +1,4 @@
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+TYPELOOKUP_DATA_REG(MultipleScatteringParametrisationMaker);
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeper.h b/RecoTracker/TkMSParametrization/src/MSLayersKeeper.h
index d1a66deb839ee..fcacdf0929ee0 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeper.h
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeper.h
@@ -13,7 +13,6 @@ class dso_hidden MSLayersKeeper {
   virtual ~MSLayersKeeper() {}
   virtual MSLayer layer(const DetLayer* dl) const { return MSLayer(dl, DataX0(this)); }
   virtual const MSLayersAtAngle& layers(float cotTheta) const = 0;
-  virtual void init(const edm::EventSetup& iSetup) {}
 
 protected:
   typedef MSLayer::DataX0 DataX0;
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.cc b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.cc
index 8156e6f2af9c5..d4caf1afa1ea2 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.cc
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.cc
@@ -34,10 +34,7 @@ int MSLayersKeeperX0AtEta::idxBin(float eta) const {
 }
 
 //------------------------------------------------------------------------------
-void MSLayersKeeperX0AtEta::init(const edm::EventSetup& iSetup) {
-  if (isInitialised)
-    return;
-  isInitialised = true;
+MSLayersKeeperX0AtEta::MSLayersKeeperX0AtEta(const GeometricSearchTracker& tracker, const MagneticField& bfield) {
   const float BIG = 99999.;
 
   // set size from data file
@@ -47,13 +44,13 @@ void MSLayersKeeperX0AtEta::init(const edm::EventSetup& iSetup) {
   theDeltaEta = (theHalfNBins != 0) ? etaMax / theHalfNBins : BIG;
 
   theLayersData = vector<MSLayersAtAngle>(max(2 * theHalfNBins, 1));
-  MultipleScatteringGeometry layout(iSetup);
+  MultipleScatteringGeometry layout(tracker);
   for (int idxbin = 0; idxbin < 2 * theHalfNBins; idxbin++) {
     float etaValue = eta(idxbin);
     float cotTheta = sinh(etaValue);
 
-    vector<MSLayer> layers = layout.detLayers(etaValue, 0, iSetup);
-    vector<MSLayer> tmplay = layout.otherLayers(etaValue, iSetup);
+    vector<MSLayer> layers = layout.detLayers(etaValue, 0, bfield);
+    vector<MSLayer> tmplay = layout.otherLayers(etaValue);
     layers.insert(layers.end(), tmplay.begin(), tmplay.end());
     sort(layers.begin(), layers.end());
     setX0(layers, etaValue, msX0data);
@@ -76,7 +73,7 @@ void MSLayersKeeperX0AtEta::init(const edm::EventSetup& iSetup) {
     for (int isign = -1; isign <= 1; isign += 2) {
       float z = isign * 15.9;  //3 sigma from zero
       const MSLayersAtAngle& layersAtAngle = theLayersData[idxbin];
-      vector<MSLayer> candidates = layout.detLayers(etaValue, z, iSetup);
+      vector<MSLayer> candidates = layout.detLayers(etaValue, z, bfield);
       vector<MSLayer>::iterator it;
       for (it = candidates.begin(); it != candidates.end(); it++) {
         if (layersAtAngle.findLayer(*it))
@@ -144,3 +141,6 @@ void MSLayersKeeperX0AtEta::setX0(vector<MSLayer>& layers, float eta, const SumX
     sumX0atAngleLast = sumX0atAngle;
   }
 }
+
+//------------------------------------------------------------------------------
+MSLayersKeeperX0AtEta::~MSLayersKeeperX0AtEta() = default;
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.h b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.h
index 69452b3fe9120..dbd855f4abdd6 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.h
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0AtEta.h
@@ -1,17 +1,19 @@
 #ifndef MSLayersKeeperX0AtEta_H
 #define MSLayersKeeperX0AtEta_H
 
-#include "MSLayersKeeper.h"
-#include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Utilities/interface/Visibility.h"
+#include "MagneticField/Engine/interface/MagneticField.h"
+#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
+
+#include "MSLayersKeeper.h"
+
 class SumX0AtEtaDataProvider;
 class MSLayersKeeperX0Averaged;
 
 class dso_hidden MSLayersKeeperX0AtEta final : public MSLayersKeeper {
 public:
-  MSLayersKeeperX0AtEta() : isInitialised(false) {}
-  ~MSLayersKeeperX0AtEta() override {}
-  void init(const edm::EventSetup &iSetup) override;
+  MSLayersKeeperX0AtEta(const GeometricSearchTracker &tracker, const MagneticField &bfield);
+  ~MSLayersKeeperX0AtEta() override;
   const MSLayersAtAngle &layers(float cotTheta) const override;
 
 private:
@@ -20,7 +22,6 @@ class dso_hidden MSLayersKeeperX0AtEta final : public MSLayersKeeper {
   static void setX0(std::vector<MSLayer> &, float eta, const SumX0AtEtaDataProvider &);
 
 private:
-  bool isInitialised;
   int theHalfNBins;
   float theDeltaEta;
   std::vector<MSLayersAtAngle> theLayersData;
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.cc b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.cc
index 701ef9299cfe4..88fb251761438 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.cc
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.cc
@@ -4,19 +4,15 @@
 
 using namespace std;
 
-void MSLayersKeeperX0Averaged::init(const edm::EventSetup &iSetup) {
-  if (isInitialised)
-    return;
-  isInitialised = true;
+MSLayersKeeperX0Averaged::MSLayersKeeperX0Averaged(const GeometricSearchTracker &tracker, const MagneticField &bfield) {
   //  cout << "HERE INITIALISATION! MSLayersKeeperX0Averaged"<<endl;
-  MSLayersKeeperX0AtEta layersX0Eta;
-  layersX0Eta.init(iSetup);
-  MultipleScatteringGeometry geom(iSetup);
-  vector<MSLayer> allLayers = geom.detLayers(iSetup);
+  MSLayersKeeperX0AtEta layersX0Eta(tracker, bfield);
+  MultipleScatteringGeometry geom(tracker);
+  vector<MSLayer> allLayers = geom.detLayers();
   vector<MSLayer>::iterator it;
   for (int i = -1; i <= 1; i++) {
     float eta = i * (-1.8);
-    vector<MSLayer> tmpLayers = geom.otherLayers(eta, iSetup);
+    vector<MSLayer> tmpLayers = geom.otherLayers(eta);
     vector<MSLayer>::const_iterator ic;
     for (ic = tmpLayers.begin(); ic != tmpLayers.end(); ic++) {
       it = find(allLayers.begin(), allLayers.end(), *ic);
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.h b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.h
index 206165064916a..92bdf5886da84 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.h
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0Averaged.h
@@ -1,20 +1,20 @@
 #ifndef MSLayersKeeperX0Averaged_H
 #define MSLayersKeeperX0Averaged_H
 
-#include "MSLayersKeeper.h"
-#include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Utilities/interface/Visibility.h"
+#include "MagneticField/Engine/interface/MagneticField.h"
+#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
+
+#include "MSLayersKeeper.h"
 
 class dso_hidden MSLayersKeeperX0Averaged final : public MSLayersKeeper {
 public:
-  MSLayersKeeperX0Averaged() : isInitialised(false) {}
-  ~MSLayersKeeperX0Averaged() override {}
-  void init(const edm::EventSetup& iSetup) override;
+  MSLayersKeeperX0Averaged(const GeometricSearchTracker& tracker, const MagneticField& bfield);
+  ~MSLayersKeeperX0Averaged() override = default;
   MSLayer layer(const DetLayer* layer) const override { return *theLayersData.findLayer(MSLayer(layer)); }
   const MSLayersAtAngle& layers(float cotTheta) const override { return theLayersData; }
 
 private:
-  bool isInitialised;
   MSLayersAtAngle theLayersData;
 };
 #endif
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.cc b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.cc
index 1c42609af26dd..58dce6983f47c 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.cc
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.cc
@@ -10,10 +10,7 @@
 
 using namespace std;
 
-void MSLayersKeeperX0DetLayer::init(const edm::EventSetup &iSetup) {
-  if (isInitialised)
-    return;
-  isInitialised = true;
+MSLayersKeeperX0DetLayer::MSLayersKeeperX0DetLayer() {
   //  vector<MSLayer> allLayers = MSLayersKeeperX0DetLayerGeom().detLayers();
   //MP
   vector<MSLayer> allLayers;
diff --git a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.h b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.h
index 7ffc864ceaf2b..89b3d7723a2fc 100644
--- a/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.h
+++ b/RecoTracker/TkMSParametrization/src/MSLayersKeeperX0DetLayer.h
@@ -8,14 +8,12 @@
 
 class dso_hidden MSLayersKeeperX0DetLayer final : public MSLayersKeeper {
 public:
-  MSLayersKeeperX0DetLayer() : isInitialised(false) {}
-  ~MSLayersKeeperX0DetLayer() override {}
-  void init(const edm::EventSetup& iSetup) override;
+  MSLayersKeeperX0DetLayer();
+  ~MSLayersKeeperX0DetLayer() override = default;
   MSLayer layer(const DetLayer* layer) const override { return *theLayersData.findLayer(MSLayer(layer)); }
   const MSLayersAtAngle& layers(float cotTheta) const override { return theLayersData; }
 
 private:
-  bool isInitialised;
   MSLayersAtAngle theLayersData;
 };
 #endif
diff --git a/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.cc b/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.cc
index 5914f47d4c9a0..0091cc24a3b56 100644
--- a/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.cc
+++ b/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.cc
@@ -4,11 +4,6 @@
 
 #include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
 #include "TrackingTools/GeomPropagators/interface/StraightLinePropagator.h"
-#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
-#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
-#include "MagneticField/Engine/interface/MagneticField.h"
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 
 using namespace GeomDetEnumerators;
 using namespace std;
@@ -19,14 +14,11 @@ const float MultipleScatteringGeometry::endflangesZ = 30;
 const float MultipleScatteringGeometry::supportR = 19.;
 
 //------------------------------------------------------------------------------
-MultipleScatteringGeometry::MultipleScatteringGeometry(const edm::EventSetup &iSetup) {
-  edm::ESHandle<GeometricSearchTracker> track;
-  iSetup.get<TrackerRecoGeometryRecord>().get(track);
-
-  vector<BarrelDetLayer const *> barrelLayers = track->barrelLayers();
+MultipleScatteringGeometry::MultipleScatteringGeometry(const GeometricSearchTracker &tracker) {
+  vector<BarrelDetLayer const *> barrelLayers = tracker.barrelLayers();
   vector<BarrelDetLayer const *>::const_iterator ib;
-  vector<ForwardDetLayer const *> forwardPosLayers = track->posForwardLayers();
-  vector<ForwardDetLayer const *> forwardNegLayers = track->negForwardLayers();
+  vector<ForwardDetLayer const *> forwardPosLayers = tracker.posForwardLayers();
+  vector<ForwardDetLayer const *> forwardNegLayers = tracker.negForwardLayers();
   vector<ForwardDetLayer const *>::const_iterator ie;
   // barrelLayers = accessor.barrelLayers();
   for (ib = barrelLayers.begin(); ib != barrelLayers.end(); ib++)
@@ -40,7 +32,7 @@ MultipleScatteringGeometry::MultipleScatteringGeometry(const edm::EventSetup &iS
 }
 
 //------------------------------------------------------------------------------
-vector<MSLayer> MultipleScatteringGeometry::detLayers(const edm::EventSetup &iSetup) const {
+vector<MSLayer> MultipleScatteringGeometry::detLayers() const {
   vector<MSLayer> result;
   vector<const DetLayer *>::const_iterator il;
   for (il = theLayers.begin(); il != theLayers.end(); il++)
@@ -49,16 +41,14 @@ vector<MSLayer> MultipleScatteringGeometry::detLayers(const edm::EventSetup &iSe
 }
 
 //------------------------------------------------------------------------------
-vector<MSLayer> MultipleScatteringGeometry::detLayers(float eta, float z, const edm::EventSetup &iSetup) const {
+vector<MSLayer> MultipleScatteringGeometry::detLayers(float eta, float z, const MagneticField &bfield) const {
   vector<MSLayer> result;
   GlobalPoint zero(0, 0, z);
   float r = 1;
   float dirZ = r * sinh(eta);
   GlobalVector dir(r, 0., dirZ);
-  edm::ESHandle<MagneticField> pSetup;
-  iSetup.get<IdealMagneticFieldRecord>().get(pSetup);
-  FreeTrajectoryState fts(GlobalTrajectoryParameters(zero, dir, 1, &(*pSetup)));
-  StraightLinePropagator propagator(&(*pSetup), alongMomentum);
+  FreeTrajectoryState fts(GlobalTrajectoryParameters(zero, dir, 1, &bfield));
+  StraightLinePropagator propagator(&bfield, alongMomentum);
   vector<const DetLayer *>::const_iterator il;
   TrajectoryStateOnSurface tsos;
   for (il = theLayers.begin(); il != theLayers.end(); il++) {
@@ -103,7 +93,7 @@ vector<MSLayer> MultipleScatteringGeometry::detLayers(float eta, float z, const
   return result;
 }
 //------------------------------------------------------------------------------
-vector<MSLayer> MultipleScatteringGeometry::otherLayers(float eta, const edm::EventSetup &iSetup) const {
+vector<MSLayer> MultipleScatteringGeometry::otherLayers(float eta) const {
   vector<MSLayer> result;
   // zero
   //  MSLayer zero(barrel, 0., MSLayer::Range(-15,15));
diff --git a/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.h b/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.h
index 0b2d871fd6063..97fa2cb83a381 100644
--- a/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.h
+++ b/RecoTracker/TkMSParametrization/src/MultipleScatteringGeometry.h
@@ -2,18 +2,19 @@
 #define MultipleScatteringGeometry_H
 
 #include <vector>
-#include "RecoTracker/TkMSParametrization/interface/MSLayer.h"
-#include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Utilities/interface/Visibility.h"
+#include "MagneticField/Engine/interface/MagneticField.h"
+#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"
+#include "RecoTracker/TkMSParametrization/interface/MSLayer.h"
 
 class DetLayer;
 
 class dso_hidden MultipleScatteringGeometry {
 public:
-  MultipleScatteringGeometry(const edm::EventSetup &iSetup);
-  std::vector<MSLayer> detLayers(float eta, float z, const edm::EventSetup &iSetup) const;
-  std::vector<MSLayer> detLayers(const edm::EventSetup &iSetup) const;
-  std::vector<MSLayer> otherLayers(float eta, const edm::EventSetup &iSetup) const;
+  MultipleScatteringGeometry(const GeometricSearchTracker &tracker);
+  std::vector<MSLayer> detLayers(float eta, float z, const MagneticField &bfield) const;
+  std::vector<MSLayer> detLayers() const;
+  std::vector<MSLayer> otherLayers(float eta) const;
 
 protected:
   std::vector<const DetLayer *> theLayers;
diff --git a/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisation.cc b/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisation.cc
index 277bef5e8c973..b43d4640fd175 100644
--- a/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisation.cc
+++ b/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisation.cc
@@ -11,58 +11,19 @@ inline T sqr(T t) {
 }
 
 #include "MSLayersKeeper.h"
-#include "MSLayersKeeperX0AtEta.h"
-#include "MSLayersKeeperX0Averaged.h"
-#include "MSLayersKeeperX0DetLayer.h"
 #include "MSLayersAtAngle.h"
 
-//#include "RecoTracker/TkMSParametrization/interface/PixelRecoUtilities.h"
-
-#include <iostream>
-
 using namespace std;
 
 const float MultipleScatteringParametrisation::x0ToSigma = 0.0136f;
 
-namespace {
-  struct Keepers {
-    MSLayersKeeperX0DetLayer x0DetLayer;
-    MSLayersKeeperX0AtEta x0AtEta;
-    MSLayersKeeperX0Averaged x0Averaged;
-    MSLayersKeeper *keepers[3];  // {&x0DetLayer,&x0AtEta,&x0Averaged};
-    bool isInitialised;          // =false;
-    MSLayersKeeper const *operator()(int i) const { return keepers[i]; }
-    void init(const edm::EventSetup &iSetup) {
-      if (isInitialised)
-        return;
-      for (auto x : keepers)
-        x->init(iSetup);
-      isInitialised = true;
-    }
-    Keepers() : keepers{&x0DetLayer, &x0AtEta, &x0Averaged}, isInitialised(false) {}
-  };
-
-  thread_local Keepers keepers;
-  //NOTE: This is being used to globally cache information from the EventSetup
-  // this should not be done so we need this code changed.
-  //NOTE; the thread_local only works in this case because MultipleScateringParametrisation
-  // instances are only ever created on the stack and not the heap.
-
-}  // namespace
-
-void MultipleScatteringParametrisation::initKeepers(const edm::EventSetup &iSetup) { keepers.init(iSetup); }
-
-//using namespace PixelRecoUtilities;
 //----------------------------------------------------------------------
-void MultipleScatteringParametrisation::init(const DetLayer *layer, const edm::EventSetup &iSetup, X0Source x0Source) {
-  theLayerKeeper = keepers(x0Source);
-
-  // FIXME not thread safe: move elsewhere...
-  initKeepers(iSetup);
-
-  if (!layer)
-    return;
-  theLayer = theLayerKeeper->layer(layer);
+MultipleScatteringParametrisation::MultipleScatteringParametrisation(const DetLayer *layer,
+                                                                     const MSLayersKeeper *layerKeeper)
+    : theLayerKeeper(layerKeeper) {
+  if (layer) {
+    theLayer = theLayerKeeper->layer(layer);
+  }
 }
 
 //----------------------------------------------------------------------
diff --git a/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisationMaker.cc b/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisationMaker.cc
new file mode 100644
index 0000000000000..befbfc83d389b
--- /dev/null
+++ b/RecoTracker/TkMSParametrization/src/MultipleScatteringParametrisationMaker.cc
@@ -0,0 +1,28 @@
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
+
+#include "MSLayersKeeper.h"
+#include "MSLayersKeeperX0AtEta.h"
+#include "MSLayersKeeperX0Averaged.h"
+#include "MSLayersKeeperX0DetLayer.h"
+#include "MSLayersAtAngle.h"
+
+struct MultipleScatteringParametrisationMaker::Keepers {
+  Keepers(GeometricSearchTracker const& tracker, MagneticField const& bfield)
+      : x0AtEta(tracker, bfield), x0Averaged(tracker, bfield), keepers{&x0DetLayer, &x0AtEta, &x0Averaged} {}
+
+  MSLayersKeeperX0DetLayer x0DetLayer;
+  MSLayersKeeperX0AtEta x0AtEta;
+  MSLayersKeeperX0Averaged x0Averaged;
+  MSLayersKeeper* keepers[3];  // {&x0DetLayer,&x0AtEta,&x0Averaged};
+};
+
+MultipleScatteringParametrisationMaker::MultipleScatteringParametrisationMaker(GeometricSearchTracker const& tracker,
+                                                                               MagneticField const& bfield)
+    : impl_(std::make_unique<Keepers>(tracker, bfield)) {}
+
+MultipleScatteringParametrisationMaker::~MultipleScatteringParametrisationMaker() = default;
+
+MultipleScatteringParametrisation MultipleScatteringParametrisationMaker::parametrisation(const DetLayer* layer,
+                                                                                          X0Source x0Source) const {
+  return MultipleScatteringParametrisation(layer, impl_->keepers[static_cast<int>(x0Source)]);
+}
diff --git a/RecoTracker/TkMSParametrization/test/TestMS.cc b/RecoTracker/TkMSParametrization/test/TestMS.cc
index 2425cfaa9f878..d001a5759d719 100644
--- a/RecoTracker/TkMSParametrization/test/TestMS.cc
+++ b/RecoTracker/TkMSParametrization/test/TestMS.cc
@@ -10,6 +10,7 @@
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 
 #include "TrackingTools/DetLayers/interface/BarrelDetLayer.h"
 #include "TrackingTools/DetLayers/interface/ForwardDetLayer.h"
@@ -43,11 +44,13 @@ class TestMS : public edm::EDAnalyzer {
   virtual void analyze(const edm::Event& ev, const edm::EventSetup& es) override;
 
 private:
+  edm::ESGetToken<GeometricSearchTracker, TrackerRecoGeometryRecord> trackerToken_;
+  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> bfieldToken_;
   TFile* rootFile;
   TH1F *hB1, *hB2, *hB3, *hF1, *hF2;
 };
 
-TestMS::TestMS(const edm::ParameterSet& conf) {
+TestMS::TestMS(const edm::ParameterSet& conf) : trackerToken_(esConsumes()), bfieldToken_(esConsumes()) {
   rootFile = new TFile("histos.root", "RECREATE");
   const int nch = 250;
   const float rmin = 0;
@@ -73,19 +76,21 @@ TestMS::~TestMS() {
 void TestMS::analyze(const edm::Event& ev, const edm::EventSetup& es) {}
 
 void TestMS::beginRun(edm::Run const& run, const edm::EventSetup& es) {
-  edm::ESHandle<GeometricSearchTracker> tracker;
-  es.get<TrackerRecoGeometryRecord>().get(tracker);
+  auto const& tracker = es.getData(trackerToken_);
+  auto const& bfield = es.getData(bfieldToken_);
 
-  vector<BarrelDetLayer const*> barrel = tracker->barrelLayers();
+  vector<BarrelDetLayer const*> barrel = tracker.barrelLayers();
   //  vector<ForwardDetLayer*> endcap=tracker->posForwardLayers();
-  vector<ForwardDetLayer const*> endcap = tracker->negForwardLayers();
+  vector<ForwardDetLayer const*> endcap = tracker.negForwardLayers();
 
-  MultipleScatteringParametrisation sb1(barrel[0], es);
-  MultipleScatteringParametrisation sb2(barrel[1], es);
-  MultipleScatteringParametrisation sb3(barrel[2], es);
+  MultipleScatteringParametrisationMaker maker(tracker, bfield);
 
-  MultipleScatteringParametrisation sf1(endcap[0], es);
-  MultipleScatteringParametrisation sf2(endcap[1], es);
+  MultipleScatteringParametrisation sb1 = maker.parametrisation(barrel[0]);
+  MultipleScatteringParametrisation sb2 = maker.parametrisation(barrel[1]);
+  MultipleScatteringParametrisation sb3 = maker.parametrisation(barrel[2]);
+
+  MultipleScatteringParametrisation sf1 = maker.parametrisation(endcap[0]);
+  MultipleScatteringParametrisation sf2 = maker.parametrisation(endcap[1]);
 
   const int nch = 250;
   const float rmin = 0;

From 7cf94fc330d93ca2616e782c8dc85ba79dc5fe0c Mon Sep 17 00:00:00 2001
From: Matti Kortelainen <matti.kortelainen@cern.ch>
Date: Mon, 6 Sep 2021 15:13:06 +0200
Subject: [PATCH 2/2] Migrate code to use
 MultipleScatteringParametrisationMaker

---
 ...pendentRecords_forGlobalTag_nofakes_cff.py |  3 ++
 .../python/customizeHLTforCMSSW.py            |  6 ++++
 .../interface/PixelTripletLowPtGenerator.h    | 11 +++++--
 .../interface/ThirdHitPrediction.h            | 10 +++---
 .../src/PixelTripletLowPtGenerator.cc         | 17 +++++++---
 .../src/ThirdHitPrediction.cc                 | 21 +++++-------
 .../plugins/PixelTripletHLTGenerator.cc       | 25 ++++++++-------
 .../plugins/PixelTripletHLTGenerator.h        |  5 +++
 .../plugins/PixelTripletLargeTipGenerator.cc  | 26 +++++++++------
 .../plugins/PixelTripletLargeTipGenerator.h   |  5 +++
 .../plugins/PixelTripletNoTipGenerator.cc     | 16 +++++-----
 .../plugins/PixelTripletNoTipGenerator.h      | 12 ++++---
 .../plugins/ThirdHitCorrection.cc             | 28 ++++++++--------
 .../plugins/ThirdHitCorrection.h              | 32 +++++++++++--------
 .../src/HitPairGeneratorFromLayerPair.cc      |  8 ++++-
 RecoTracker/TkHitPairs/src/InnerDeltaPhi.cc   | 11 +++----
 RecoTracker/TkHitPairs/src/InnerDeltaPhi.h    |  6 ++--
 .../src/GlobalTrackingRegion.cc               |  6 +++-
 .../src/RectangularEtaPhiTrackingRegion.cc    | 18 ++++++++---
 19 files changed, 165 insertions(+), 101 deletions(-)

diff --git a/CalibTracker/Configuration/python/Tracker_DependentRecords_forGlobalTag_nofakes_cff.py b/CalibTracker/Configuration/python/Tracker_DependentRecords_forGlobalTag_nofakes_cff.py
index 90cef7dd880b8..51f4de06462d5 100644
--- a/CalibTracker/Configuration/python/Tracker_DependentRecords_forGlobalTag_nofakes_cff.py
+++ b/CalibTracker/Configuration/python/Tracker_DependentRecords_forGlobalTag_nofakes_cff.py
@@ -45,3 +45,6 @@
                   tag    = cms.string("")
                   )
         )
+
+# Multiple scattering parametrisation
+from RecoTracker.TkMSParametrization.multipleScatteringParametrisationMakerESProducer_cfi import *
diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
index 01b08a9b7a69c..110bc676a9232 100644
--- a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
+++ b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py
@@ -137,6 +137,11 @@ def customiseFor35315(process):
 
     return process
 
+# MultipleScatteringParametrisationMakerESProducer
+def customiseFor35269(process):
+    process.load("RecoTracker.TkMSParametrization.multipleScatteringParametrisationMakerESProducer_cfi")
+    return process
+
 # CMSSW version specific customizations
 def customizeHLTforCMSSW(process, menuType="GRun"):
     
@@ -144,5 +149,6 @@ def customizeHLTforCMSSW(process, menuType="GRun"):
     # process = customiseFor12718(process)
 
     process = customiseFor35315(process)
+    process = customiseFor35269(process)
 
     return process
diff --git a/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h b/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h
index 1793db0b5129f..8da3d41d2deb9 100644
--- a/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h
+++ b/RecoPixelVertexing/PixelLowPtUtilities/interface/PixelTripletLowPtGenerator.h
@@ -19,9 +19,14 @@
 
 #include "RecoPixelVertexing/PixelLowPtUtilities/interface/TripletFilter.h"
 
+class IdealMagneticFieldRecord;
+class MultipleScatteringParametrisationMaker;
+class TrackerMultipleScatteringRecord;
+class SiPixelClusterShapeCache;
 class TrackerGeometry;
+class TransientTrackingRecHitBuilder;
+class TransientRecHitRecord;
 class TripletFilter;
-class SiPixelClusterShapeCache;
 
 #include <vector>
 
@@ -48,6 +53,9 @@ class PixelTripletLowPtGenerator : public HitTripletGeneratorFromPairAndLayers {
 private:
   edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> m_geomToken;
   edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> m_topoToken;
+  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> m_magfieldToken;
+  edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> m_ttrhBuilderToken;
+  edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> m_msmakerToken;
 
   void getTracker(const edm::EventSetup& es);
   GlobalPoint getGlobalPosition(const TrackingRecHit* recHit);
@@ -60,7 +68,6 @@ class PixelTripletLowPtGenerator : public HitTripletGeneratorFromPairAndLayers {
   double rzTolerance;
   double maxAngleRatio;
 
-  std::string builderName;
   bool checkMultipleScattering;
   bool checkClusterShape;
 };
diff --git a/RecoPixelVertexing/PixelLowPtUtilities/interface/ThirdHitPrediction.h b/RecoPixelVertexing/PixelLowPtUtilities/interface/ThirdHitPrediction.h
index 44a3349939cb8..3c27ed671ed40 100644
--- a/RecoPixelVertexing/PixelLowPtUtilities/interface/ThirdHitPrediction.h
+++ b/RecoPixelVertexing/PixelLowPtUtilities/interface/ThirdHitPrediction.h
@@ -22,7 +22,9 @@ class DetLayer;
 class OrderedHitPair;
 class TrackingRecHit;
 
+class MagneticField;
 class TransientTrackingRecHitBuilder;
+class MultipleScatteringParametrisationMaker;
 
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/Framework/interface/ESHandle.h"
@@ -38,10 +40,10 @@ class ThirdHitPrediction {
   ThirdHitPrediction(const TrackingRegion& region,
                      GlobalPoint inner,
                      GlobalPoint outer,
-                     const edm::EventSetup& es,
+                     const MagneticField& magfield,
+                     const TransientTrackingRecHitBuilder& ttrhBuilder,
                      double nSigMultipleScattering,
-                     double maxAngleRatio,
-                     std::string builderName);
+                     double maxAngleRatio);
   ~ThirdHitPrediction();
 
   void getRanges(const DetLayer* layer, float phi[], float rz[]);
@@ -50,7 +52,7 @@ class ThirdHitPrediction {
   bool isCompatibleWithMultipleScattering(GlobalPoint g3,
                                           const std::vector<const TrackingRecHit*>& h,
                                           std::vector<GlobalVector>& localDirs,
-                                          const edm::EventSetup& es);
+                                          const MultipleScatteringParametrisationMaker& msmaker);
 
 private:
   void initLayer(const DetLayer* layer);
diff --git a/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc b/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc
index f5bf4ed86d4d9..8b2b2b3470c90 100644
--- a/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc
+++ b/RecoPixelVertexing/PixelLowPtUtilities/src/PixelTripletLowPtGenerator.cc
@@ -6,12 +6,16 @@
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoPointRZ.h"
 #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h"
 
-#include "FWCore/Framework/interface/ESHandle.h"
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "FWCore/Framework/interface/Event.h"
 #include "DataFormats/SiPixelCluster/interface/SiPixelClusterShapeCache.h"
 
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
+#include "TrackingTools/Records/interface/TransientRecHitRecord.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+
 #undef Debug
 
 using namespace std;
@@ -21,6 +25,9 @@ PixelTripletLowPtGenerator::PixelTripletLowPtGenerator(const edm::ParameterSet&
     : HitTripletGeneratorFromPairAndLayers(),  // no theMaxElement used in this class
       m_geomToken(iC.esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()),
       m_topoToken(iC.esConsumes<TrackerTopology, TrackerTopologyRcd>()),
+      m_magfieldToken(iC.esConsumes()),
+      m_ttrhBuilderToken(iC.esConsumes(edm::ESInputTag("", cfg.getParameter<string>("TTRHBuilder")))),
+      m_msmakerToken(iC.esConsumes()),
       theTracker(nullptr),
       theClusterShapeCacheToken(
           iC.consumes<SiPixelClusterShapeCache>(cfg.getParameter<edm::InputTag>("clusterShapeCacheSrc"))) {
@@ -29,7 +36,6 @@ PixelTripletLowPtGenerator::PixelTripletLowPtGenerator(const edm::ParameterSet&
   checkClusterShape = cfg.getParameter<bool>("checkClusterShape");
   rzTolerance = cfg.getParameter<double>("rzTolerance");
   maxAngleRatio = cfg.getParameter<double>("maxAngleRatio");
-  builderName = cfg.getParameter<string>("TTRHBuilder");
 }
 
 /*****************************************************************************/
@@ -65,6 +71,9 @@ void PixelTripletLowPtGenerator::hitTriplets(const TrackingRegion& region,
                                              const std::vector<SeedingLayerSetsHits::SeedingLayer>& thirdLayers) {
   //Retrieve tracker topology from geometry
   const TrackerTopology* tTopo = &es.getData(m_topoToken);
+  const auto& magfield = es.getData(m_magfieldToken);
+  const auto& ttrhBuilder = es.getData(m_ttrhBuilderToken);
+  const auto& msmaker = es.getData(m_msmakerToken);
 
   edm::Handle<SiPixelClusterShapeCache> clusterShapeCache;
   ev.getByToken(theClusterShapeCacheToken, clusterShapeCache);
@@ -105,7 +114,7 @@ void PixelTripletLowPtGenerator::hitTriplets(const TrackingRegion& region,
 
     // Initialize helix prediction
     ThirdHitPrediction thePrediction(
-        region, points[0], points[1], es, nSigMultipleScattering, maxAngleRatio, builderName);
+        region, points[0], points[1], magfield, ttrhBuilder, nSigMultipleScattering, maxAngleRatio);
 
     // Look at all layers
     for (int il = 0; il < size; il++) {
@@ -138,7 +147,7 @@ void PixelTripletLowPtGenerator::hitTriplets(const TrackingRegion& region,
 
         // Check if third hit is compatible with multiple scattering
         vector<GlobalVector> globalDirs;
-        if (thePrediction.isCompatibleWithMultipleScattering(points[2], recHits, globalDirs, es) == false) {
+        if (thePrediction.isCompatibleWithMultipleScattering(points[2], recHits, globalDirs, msmaker) == false) {
 #ifdef Debug
           cerr << "  not compatible: multiple scattering" << endl;
 #endif
diff --git a/RecoPixelVertexing/PixelLowPtUtilities/src/ThirdHitPrediction.cc b/RecoPixelVertexing/PixelLowPtUtilities/src/ThirdHitPrediction.cc
index 0c6edb2d42e32..abedbe9373ef0 100644
--- a/RecoPixelVertexing/PixelLowPtUtilities/src/ThirdHitPrediction.cc
+++ b/RecoPixelVertexing/PixelLowPtUtilities/src/ThirdHitPrediction.cc
@@ -1,8 +1,8 @@
 #include "DataFormats/GeometryVector/interface/GlobalPoint.h"
 #include "MagneticField/Engine/interface/MagneticField.h"
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 #include "RecoPixelVertexing/PixelLowPtUtilities/interface/ThirdHitPrediction.h"
 #include "RecoPixelVertexing/PixelTrackFitting/interface/CircleFromThreePoints.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
 #include "TrackingTools/DetLayers/interface/BarrelDetLayer.h"
 #include "TrackingTools/DetLayers/interface/DetLayer.h"
@@ -18,19 +18,14 @@ using namespace std;
 ThirdHitPrediction::ThirdHitPrediction(const TrackingRegion& region,
                                        GlobalPoint inner,
                                        GlobalPoint outer,
-                                       const edm::EventSetup& es,
+                                       const MagneticField& magfield,
+                                       const TransientTrackingRecHitBuilder& ttrhBuilder,
                                        double nSigMultipleScattering,
-                                       double maxAngleRatio,
-                                       string builderName) {
+                                       double maxAngleRatio) {
   using namespace edm;
-  ESHandle<MagneticField> magfield;
-  es.get<IdealMagneticFieldRecord>().get(magfield);
+  theTTRecHitBuilder = &ttrhBuilder;
 
-  edm::ESHandle<TransientTrackingRecHitBuilder> ttrhbESH;
-  es.get<TransientRecHitRecord>().get(builderName, ttrhbESH);
-  theTTRecHitBuilder = ttrhbESH.product();
-
-  Bz = fabs(magfield->inInverseGeV(GlobalPoint(0, 0, 0)).z());
+  Bz = fabs(magfield.inInverseGeV(GlobalPoint(0, 0, 0)).z());
 
   c0 = Global2DVector(region.origin().x(), region.origin().y());
 
@@ -345,7 +340,7 @@ void ThirdHitPrediction::getRanges(float rz3, float phi[], float rz[]) { calcula
 bool ThirdHitPrediction::isCompatibleWithMultipleScattering(GlobalPoint g3,
                                                             const vector<const TrackingRecHit*>& h,
                                                             vector<GlobalVector>& globalDirs,
-                                                            const edm::EventSetup& es) {
+                                                            const MultipleScatteringParametrisationMaker& msmaker) {
   Global2DVector p1(g1.x(), g1.y());
   Global2DVector p2(g2.x(), g2.y());
   Global2DVector p3(g3.x(), g3.y());
@@ -383,7 +378,7 @@ bool ThirdHitPrediction::isCompatibleWithMultipleScattering(GlobalPoint g3,
     float m_pi = 0.13957018;
     float beta = p / sqrt(sqr(p) + sqr(m_pi));
 
-    MultipleScatteringParametrisation msp(theLayer, es);
+    MultipleScatteringParametrisation msp = msmaker.parametrisation(theLayer);
     PixelRecoPointRZ rz2(g2.perp(), g2.z());
 
     float sigma_z = msp(pt, cotTheta, rz2) / beta;
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc
index 73f8a806c5182..490372d06a107 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.cc
@@ -1,14 +1,12 @@
 #include "RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h"
 #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
 
 #include "ThirdHitPredictionFromInvParabola.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitRZPrediction.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoUtilities.h"
-#include "FWCore/Framework/interface/ESHandle.h"
 
-#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
-#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
 #include "ThirdHitCorrection.h"
 #include "RecoTracker/TkHitPairs/interface/RecHitsSortedInPhi.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
@@ -23,8 +21,6 @@
 
 #include "DataFormats/Math/interface/normalizedPhi.h"
 
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
 #include <cstdio>
 #include <iostream>
 
@@ -35,6 +31,7 @@ using namespace std;
 
 PixelTripletHLTGenerator::PixelTripletHLTGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC)
     : HitTripletGeneratorFromPairAndLayers(cfg),
+      fieldToken_(iC.esConsumes()),
       useFixedPreFiltering(cfg.getParameter<bool>("useFixedPreFiltering")),
       extraHitRZtolerance(cfg.getParameter<double>("extraHitRZtolerance")),
       extraHitRPhitolerance(cfg.getParameter<double>("extraHitRPhitolerance")),
@@ -46,6 +43,9 @@ PixelTripletHLTGenerator::PixelTripletHLTGenerator(const edm::ParameterSet& cfg,
   if (comparitorName != "none") {
     theComparitor = SeedComparitorFactory::get()->create(comparitorName, comparitorPSet, iC);
   }
+  if (useMScat) {
+    msmakerToken_ = iC.esConsumes();
+  }
 }
 
 PixelTripletHLTGenerator::~PixelTripletHLTGenerator() {}
@@ -139,9 +139,11 @@ void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region,
   const float maxphi = M_PI + maxDelphi, minphi = -maxphi;  // increase to cater for any range
   const float safePhi = M_PI - maxDelphi;                   // sideband
 
-  edm::ESHandle<MagneticField> hfield;
-  es.get<IdealMagneticFieldRecord>().get(hfield);
-  const auto& field = *hfield;
+  const auto& field = es.getData(fieldToken_);
+  const MultipleScatteringParametrisationMaker* msmaker = nullptr;
+  if (useMScat) {
+    msmaker = &es.getData(msmakerToken_);
+  }
 
   // fill the prediction vector
   for (int il = 0; il < nThirdLayers; ++il) {
@@ -150,13 +152,14 @@ void PixelTripletHLTGenerator::hitTriplets(const TrackingRegion& region,
     pred.initLayer(thirdLayerDetLayer[il]);
     pred.initTolerance(extraHitRZtolerance);
 
-    corrections[il].init(es,
-                         region.ptMin(),
+    corrections[il].init(region.ptMin(),
                          *doublets.detLayer(HitDoublets::inner),
                          *doublets.detLayer(HitDoublets::outer),
                          *thirdLayerDetLayer[il],
                          useMScat,
-                         useBend);
+                         msmaker,
+                         useBend,
+                         &field);
 
     layerTree.clear();
     float minv = 999999.0f, maxv = -minv;  // Initialise to extreme values in case no hits
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h
index 667d9bc3c3a81..c92239727cd4e 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletHLTGenerator.h
@@ -10,7 +10,10 @@
 #include "CombinedHitTripletGenerator.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 
 #include <utility>
 #include <vector>
@@ -64,6 +67,8 @@ class PixelTripletHLTGenerator : public HitTripletGeneratorFromPairAndLayers {
                    std::vector<int>* tripletLastLayerIndex);
 
 private:
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> fieldToken_;
+  edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> msmakerToken_;
   const bool useFixedPreFiltering;
   const float extraHitRZtolerance;
   const float extraHitRPhitolerance;
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc
index 9fb793274e56e..3de960c80e0bc 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.cc
@@ -1,5 +1,6 @@
 #include "RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h"
 #include "RecoTracker/TkHitPairs/interface/HitPairGeneratorFromLayerPair.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitPredictionFromCircle.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/ThirdHitRZPrediction.h"
@@ -15,8 +16,6 @@
 #include "MatchedHitRZCorrectionFromBending.h"
 #include "CommonTools/RecoAlgos/interface/KDTreeLinkerAlgo.h"
 
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
 #include <algorithm>
 #include <iostream>
 #include <vector>
@@ -53,7 +52,12 @@ PixelTripletLargeTipGenerator::PixelTripletLargeTipGenerator(const edm::Paramete
       useMScat(cfg.getParameter<bool>("useMultScattering")),
       useBend(cfg.getParameter<bool>("useBending")),
       dphi(useFixedPreFiltering ? cfg.getParameter<double>("phiPreFiltering") : 0),
-      trackerTopologyESToken_(iC.esConsumes()) {}
+      trackerTopologyESToken_(iC.esConsumes()),
+      fieldESToken_(iC.esConsumes()) {
+  if (useMScat) {
+    msmakerESToken_ = iC.esConsumes();
+  }
+}
 
 PixelTripletLargeTipGenerator::~PixelTripletLargeTipGenerator() {}
 
@@ -133,10 +137,11 @@ void PixelTripletLargeTipGenerator::hitTriplets(const TrackingRegion& region,
                                                 const int nThirdLayers,
                                                 std::vector<int>* tripletLastLayerIndex) {
   const TrackerTopology* tTopo = &es.getData(trackerTopologyESToken_);
-
-  edm::ESHandle<MagneticField> hfield;
-  es.get<IdealMagneticFieldRecord>().get(hfield);
-  const auto& field = *hfield;
+  const auto& field = es.getData(fieldESToken_);
+  const MultipleScatteringParametrisationMaker* msmaker = nullptr;
+  if (useMScat) {
+    msmaker = &es.getData(msmakerESToken_);
+  }
 
   auto outSeq = doublets.detLayer(HitDoublets::outer)->seqNum();
 
@@ -166,13 +171,14 @@ void PixelTripletLargeTipGenerator::hitTriplets(const TrackingRegion& region,
     predRZ.helix1.initTolerance(extraHitRZtolerance);
     predRZ.helix2.initTolerance(extraHitRZtolerance);
     predRZ.rzPositionFixup = MatchedHitRZCorrectionFromBending(layer, tTopo);
-    predRZ.correction.init(es,
-                           region.ptMin(),
+    predRZ.correction.init(region.ptMin(),
                            *doublets.detLayer(HitDoublets::inner),
                            *doublets.detLayer(HitDoublets::outer),
                            *thirdLayerDetLayer[il],
                            useMScat,
-                           false);
+                           msmaker,
+                           false,
+                           nullptr);
 
     layerTree.clear();
     float minv = 999999.0;
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h
index 5a790a43514f3..45da0f5fa2eb7 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletLargeTipGenerator.h
@@ -12,7 +12,10 @@
 #include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
 #include "FWCore/Utilities/interface/ESGetToken.h"
 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 
 #include <utility>
 #include <vector>
@@ -72,5 +75,7 @@ class PixelTripletLargeTipGenerator : public HitTripletGeneratorFromPairAndLayer
   const float dphi;
 
   const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> trackerTopologyESToken_;
+  const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> fieldESToken_;
+  edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> msmakerESToken_;
 };
 #endif
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc
index 269f92c42dced..48980e80c9a76 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.cc
@@ -1,4 +1,5 @@
 #include "PixelTripletNoTipGenerator.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
 #include "FWCore/Framework/interface/EventSetup.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 
@@ -16,8 +17,6 @@
 #include "TrackingTools/DetLayers/interface/DetLayer.h"
 #include "DataFormats/GeometrySurface/interface/SimpleDiskBounds.h"
 
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
-
 typedef PixelRecoRange<float> Range;
 template <class T>
 T sqr(T t) {
@@ -28,6 +27,8 @@ using namespace std;
 
 PixelTripletNoTipGenerator::PixelTripletNoTipGenerator(const edm::ParameterSet& cfg, edm::ConsumesCollector& iC)
     : HitTripletGeneratorFromPairAndLayers(cfg),
+      fieldToken_(iC.esConsumes()),
+      msmakerToken_(iC.esConsumes()),
       extraHitRZtolerance(cfg.getParameter<double>("extraHitRZtolerance")),
       extraHitRPhitolerance(cfg.getParameter<double>("extraHitRPhitolerance")),
       extraHitPhiToleranceForPreFiltering(cfg.getParameter<double>("extraHitPhiToleranceForPreFiltering")),
@@ -74,12 +75,11 @@ void PixelTripletNoTipGenerator::hitTriplets(const TrackingRegion& region,
     thirdHitMap[il] = &(*theLayerCache)(thirdLayers[il], region, es);
   }
 
-  edm::ESHandle<MagneticField> hfield;
-  es.get<IdealMagneticFieldRecord>().get(hfield);
-  const auto& field = *hfield;
+  const auto& field = es.getData(fieldToken_);
+  const auto& msmaker = es.getData(msmakerToken_);
 
-  MultipleScatteringParametrisation sigma1RPhi(firstLayer, es);
-  MultipleScatteringParametrisation sigma2RPhi(secondLayer, es);
+  MultipleScatteringParametrisation sigma1RPhi = msmaker.parametrisation(firstLayer);
+  MultipleScatteringParametrisation sigma2RPhi = msmaker.parametrisation(secondLayer);
 
   typedef RecHitsSortedInPhi::Hit Hit;
   for (ip = pairs.begin(); ip != pairs.end(); ip++) {
@@ -106,7 +106,7 @@ void PixelTripletNoTipGenerator::hitTriplets(const TrackingRegion& region,
     for (int il = 0; il <= size - 1; il++) {
       const DetLayer* layer = thirdLayers[il].detLayer();
       bool barrelLayer = (layer->location() == GeomDetEnumerators::barrel);
-      MultipleScatteringParametrisation sigma3RPhi(layer, es);
+      MultipleScatteringParametrisation sigma3RPhi = msmaker.parametrisation(layer);
       double msRPhi3 = sigma3RPhi(pt_p1p2, line.cotLine(), point2);
 
       Range rRange;
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.h b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.h
index 3f01abf8b2bff..160fabcbb1d19 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.h
+++ b/RecoPixelVertexing/PixelTriplets/plugins/PixelTripletNoTipGenerator.h
@@ -1,13 +1,13 @@
 #ifndef PixelTripletNoTipGenerator_H
 #define PixelTripletNoTipGenerator_H
 
+#include "FWCore/Framework/interface/FrameworkfwdMostUsed.h"
+#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 #include "RecoPixelVertexing/PixelTriplets/interface/HitTripletGeneratorFromPairAndLayers.h"
-#include "CombinedHitTripletGenerator.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 
-namespace edm {
-  class Event;
-  class EventSetup;
-}  // namespace edm
+#include "CombinedHitTripletGenerator.h"
 
 #include <utility>
 #include <vector>
@@ -35,6 +35,8 @@ class PixelTripletNoTipGenerator : public HitTripletGeneratorFromPairAndLayers {
                    const int nThirdLayers) override;
 
 private:
+  edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> fieldToken_;
+  edm::ESGetToken<MultipleScatteringParametrisationMaker, TrackerMultipleScatteringRecord> msmakerToken_;
   float extraHitRZtolerance;
   float extraHitRPhitolerance;
   float extraHitPhiToleranceForPreFiltering;
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.cc b/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.cc
index d217a3f13ec46..b98017b540e84 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.cc
+++ b/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.cc
@@ -2,7 +2,7 @@
 
 #include "TrackingTools/DetLayers/interface/BarrelDetLayer.h"
 #include "TrackingTools/DetLayers/interface/ForwardDetLayer.h"
-#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 
 using namespace pixelrecoutilities;
 
@@ -15,17 +15,16 @@ namespace {
 
 using pixelrecoutilities::LongitudinalBendingCorrection;
 
-void ThirdHitCorrection::init(const edm::EventSetup &es,
-                              float pt,
+void ThirdHitCorrection::init(float pt,
                               const DetLayer &layer3,
                               bool useMultipleScattering,
-                              bool useBendingCorrection) {
+                              const MultipleScatteringParametrisationMaker *msmaker,
+                              bool useBendingCorrection,
+                              const MagneticField *bfield) {
   theUseMultipleScattering = useMultipleScattering;
   theUseBendingCorrection = useBendingCorrection;
   if (useBendingCorrection) {
-    edm::ESHandle<MagneticField> hfield;
-    es.get<IdealMagneticFieldRecord>().get(hfield);
-    theBendingCorrection.init(pt, *hfield);
+    theBendingCorrection.init(pt, *bfield);
   }
 
   theMultScattCorrRPhi = 0;
@@ -35,17 +34,18 @@ void ThirdHitCorrection::init(const edm::EventSetup &es,
   thePt = pt;
 
   if (theUseMultipleScattering)
-    sigmaRPhi.init(&layer3, es);
+    sigmaRPhi = msmaker->parametrisation(&layer3);
 }
 
-void ThirdHitCorrection::init(const edm::EventSetup &es,
-                              float pt,
+void ThirdHitCorrection::init(float pt,
                               const DetLayer &layer1,
                               const DetLayer &layer2,
                               const DetLayer &layer3,
                               bool useMultipleScattering,
-                              bool useBendingCorrection) {
-  init(es, pt, layer3, useMultipleScattering, useBendingCorrection);
+                              const MultipleScatteringParametrisationMaker *msmaker,
+                              bool useBendingCorrection,
+                              const MagneticField *bfield) {
+  init(pt, layer3, useMultipleScattering, msmaker, useBendingCorrection, bfield);
 
   if (!theUseMultipleScattering)
     return;
@@ -78,7 +78,7 @@ void ThirdHitCorrection::init(const edm::EventSetup &es,
     }
   };
 
-  theMultScattCorrRPhi = 3.f * sigmaRPhi(pt, line.cotLine(), point2(), layer2.seqNum());
+  theMultScattCorrRPhi = 3.f * (*sigmaRPhi)(pt, line.cotLine(), point2(), layer2.seqNum());
 }
 
 void ThirdHitCorrection::init(const PixelRecoLineRZ &line, const PixelRecoPointRZ &constraint, int il) {
@@ -87,7 +87,7 @@ void ThirdHitCorrection::init(const PixelRecoLineRZ &line, const PixelRecoPointR
     return;
 
   // auto newCorr = theMultScattCorrRPhi;
-  theMultScattCorrRPhi = 3.f * sigmaRPhi(thePt, line.cotLine(), constraint, il);
+  theMultScattCorrRPhi = 3.f * (*sigmaRPhi)(thePt, line.cotLine(), constraint, il);
   // std::cout << "ThirdHitCorr " << (theBarrel ? "B " : "F " )<< theMultScattCorrRPhi << ' ' << newCorr << ' ' << newCorr/theMultScattCorrRPhi << std::endl;
   float overSinTheta = std::sqrt(1.f + sqr(line.cotLine()));
   if (theBarrel) {
diff --git a/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.h b/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.h
index 7e1111bfe54a4..21ec8d1c82ed5 100644
--- a/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.h
+++ b/RecoPixelVertexing/PixelTriplets/plugins/ThirdHitCorrection.h
@@ -1,47 +1,51 @@
 #ifndef RecoPixelVertexing_PixelTriplets_ThirdHitCorrection_H
 #define RecoPixelVertexing_PixelTriplets_ThirdHitCorrection_H
 
-namespace edm {
-  class EventSetup;
-}
 #include "RecoTracker/TkMSParametrization/interface/LongitudinalBendingCorrection.h"
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
 
 class DetLayer;
+class MagneticField;
+class MultipleScatteringParametrisationMaker;
 
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoRange.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoPointRZ.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoLineRZ.h"
 
+#include <optional>
+
 class ThirdHitCorrection {
 public:
   typedef PixelRecoRange<float> Range;
 
   ThirdHitCorrection() {}
 
-  void init(const edm::EventSetup &es,
-            float pt,
+  void init(float pt,
             const DetLayer &layer1,
             const DetLayer &layer2,
             const DetLayer &layer3,
             bool useMultipleScattering,
-            bool useBendingCorrection);
+            const MultipleScatteringParametrisationMaker *msmaker,
+            bool useBendingCorrection,
+            const MagneticField *bfield);
 
-  void init(const edm::EventSetup &es,
-            float pt,
+  void init(float pt,
             const DetLayer &layer3,
             bool useMultipleScattering,
-            bool useBendingCorrection);
+            const MultipleScatteringParametrisationMaker *msmaker,
+            bool useBendingCorrection,
+            const MagneticField *bfield);
 
-  ThirdHitCorrection(const edm::EventSetup &es,
-                     float pt,
+  ThirdHitCorrection(float pt,
                      const DetLayer *layer,
                      const PixelRecoLineRZ &line,
                      const PixelRecoPointRZ &constraint,
                      int ol,
                      bool useMultipleScattering,
-                     bool useBendingCorrection) {
-    init(es, pt, *layer, useMultipleScattering, useBendingCorrection);
+                     const MultipleScatteringParametrisationMaker *msmaker,
+                     bool useBendingCorrection,
+                     const MagneticField *bfield) {
+    init(pt, *layer, useMultipleScattering, msmaker, useBendingCorrection, bfield);
     init(line, constraint, ol);
   }
 
@@ -66,7 +70,7 @@ class ThirdHitCorrection {
   float thePt;
 
   pixelrecoutilities::LongitudinalBendingCorrection theBendingCorrection;
-  MultipleScatteringParametrisation sigmaRPhi;
+  std::optional<MultipleScatteringParametrisation> sigmaRPhi;
 };
 
 #endif
diff --git a/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc b/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc
index dbaaf3544eec1..e2757c4b6bafa 100644
--- a/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc
+++ b/RecoTracker/TkHitPairs/src/HitPairGeneratorFromLayerPair.cc
@@ -29,6 +29,8 @@ namespace {
 #include "TrackingTools/Records/interface/TransientRecHitRecord.h"
 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
 #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
 #include "FWCore/Framework/interface/ESHandle.h"
 
 HitPairGeneratorFromLayerPair::HitPairGeneratorFromLayerPair(unsigned int inner,
@@ -115,7 +117,11 @@ void HitPairGeneratorFromLayerPair::doublets(const TrackingRegion& region,
                                              HitDoublets& result) {
   //  HitDoublets result(innerHitsMap,outerHitsMap); result.reserve(std::max(innerHitsMap.size(),outerHitsMap.size()));
   typedef RecHitsSortedInPhi::Hit Hit;
-  InnerDeltaPhi deltaPhi(outerHitDetLayer, innerHitDetLayer, region, iSetup);
+  edm::ESHandle<MagneticField> hfield;
+  iSetup.get<IdealMagneticFieldRecord>().get(hfield);
+  edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+  iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+  InnerDeltaPhi deltaPhi(outerHitDetLayer, innerHitDetLayer, region, *hfield, *hmaker);
 
   // std::cout << "layers " << theInnerLayer.detLayer()->seqNum()  << " " << outerLayer.detLayer()->seqNum() << std::endl;
 
diff --git a/RecoTracker/TkHitPairs/src/InnerDeltaPhi.cc b/RecoTracker/TkHitPairs/src/InnerDeltaPhi.cc
index 265bfb1047736..07384a11ebfcd 100644
--- a/RecoTracker/TkHitPairs/src/InnerDeltaPhi.cc
+++ b/RecoTracker/TkHitPairs/src/InnerDeltaPhi.cc
@@ -84,7 +84,8 @@ namespace {
 InnerDeltaPhi::InnerDeltaPhi(const DetLayer& outlayer,
                              const DetLayer& layer,
                              const TrackingRegion& region,
-                             const edm::EventSetup& iSetup,
+                             const MagneticField& field,
+                             const MultipleScatteringParametrisationMaker& msmaker,
                              bool precise,
                              float extraTolerance)
     : innerIsBarrel(layer.isBarrel()),
@@ -100,14 +101,10 @@ InnerDeltaPhi::InnerDeltaPhi(const DetLayer& outlayer,
       theVtxZ(region.origin().z()),
       thePtMin(region.ptMin()),
       theVtx(region.origin().x(), region.origin().y()),
-      sigma(&layer, iSetup)
-
-{
+      sigma(msmaker.parametrisation(&layer)) {
   float zMinOrigin = theVtxZ - region.originZBound();
   float zMaxOrigin = theVtxZ + region.originZBound();
-  edm::ESHandle<MagneticField> hfield;
-  iSetup.get<IdealMagneticFieldRecord>().get(hfield);
-  theRCurvature = PixelRecoUtilities::bendingRadius(thePtMin, *hfield);
+  theRCurvature = PixelRecoUtilities::bendingRadius(thePtMin, field);
 
   if (innerIsBarrel)
     initBarrelLayer(layer);
diff --git a/RecoTracker/TkHitPairs/src/InnerDeltaPhi.h b/RecoTracker/TkHitPairs/src/InnerDeltaPhi.h
index 87a777231228b..401aed193ae25 100644
--- a/RecoTracker/TkHitPairs/src/InnerDeltaPhi.h
+++ b/RecoTracker/TkHitPairs/src/InnerDeltaPhi.h
@@ -2,9 +2,8 @@
 #define InnerDeltaPhi_H
 
 /** predict phi bending in layer for the tracks constratind by outer hit r-z */
-#include "FWCore/Framework/interface/EventSetup.h"
-
 #include "RecoTracker/TkTrackingRegions/interface/TrackingRegion.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
 
 #include "FWCore/Utilities/interface/Visibility.h"
@@ -23,7 +22,8 @@ class dso_hidden InnerDeltaPhi {
   InnerDeltaPhi(const DetLayer& outlayer,
                 const DetLayer& layer,
                 const TrackingRegion& region,
-                const edm::EventSetup& iSetup,
+                const MagneticField& field,
+                const MultipleScatteringParametrisationMaker& msmaker,
                 bool precise = true,
                 float extraTolerance = 0.f);
 
diff --git a/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc b/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc
index 63dfc4785d939..ec1ed855382f5 100644
--- a/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc
+++ b/RecoTracker/TkTrackingRegions/src/GlobalTrackingRegion.cc
@@ -6,7 +6,9 @@
 #include "RecoTracker/TkTrackingRegions/interface/HitRCheck.h"
 #include "RecoTracker/TkTrackingRegions/interface/HitZCheck.h"
 
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoUtilities.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoPointRZ.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoLineRZ.h"
@@ -89,7 +91,9 @@ std::unique_ptr<HitRZCompatibility> GlobalTrackingRegion::checkRZ(const DetLayer
   HitRZConstraint rzConstraint(leftLine, rightLine);
 
   if UNLIKELY (theUseMS) {
-    MultipleScatteringParametrisation iSigma(layer, iSetup);
+    edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+    iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+    MultipleScatteringParametrisation iSigma = hmaker->parametrisation(layer);
     PixelRecoPointRZ vtxMean(0., origin().z());
 
     float innerScatt = 3.f * (outerlayer ? iSigma(ptMin(), vtxMean, outerred, outerlayer->seqNum())
diff --git a/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc b/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc
index bdc4257cbfd6f..da72a58eeebd2 100644
--- a/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc
+++ b/RecoTracker/TkTrackingRegions/src/RectangularEtaPhiTrackingRegion.cc
@@ -17,6 +17,7 @@
 #include "RecoTracker/TkTrackingRegions/interface/HitEtaCheck.h"
 #include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
 #include "RecoTracker/TkMSParametrization/interface/PixelRecoUtilities.h"
+#include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisationMaker.h"
 #include "RecoTracker/TkMSParametrization/interface/MultipleScatteringParametrisation.h"
 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
@@ -25,6 +26,7 @@
 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
 
 #include "RecoTracker/Record/interface/CkfComponentsRecord.h"
+#include "RecoTracker/Record/interface/TrackerMultipleScatteringRecord.h"
 #include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h"
 #include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h"
 #include "TrackingTools/MeasurementDet/interface/LayerMeasurements.h"
@@ -126,7 +128,9 @@ std::unique_ptr<HitRZCompatibility> RectangularEtaPhiTrackingRegion::checkRZOld(
   float innerScatt = 0;
   //CHECK
   if (theUseMS) {
-    MultipleScatteringParametrisation oSigma(layer, iSetup);
+    edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+    iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+    MultipleScatteringParametrisation oSigma = hmaker->parametrisation(layer);
     float cotThetaOuter = theMeanLambda;
     float sinThetaOuterInv = std::sqrt(1.f + sqr(cotThetaOuter));
     outerZscatt = 3.f * oSigma(ptMin(), cotThetaOuter) * sinThetaOuterInv;
@@ -142,7 +146,9 @@ std::unique_ptr<HitRZCompatibility> RectangularEtaPhiTrackingRegion::checkRZOld(
   //CHECK
 
   if (theUseMS) {
-    MultipleScatteringParametrisation iSigma(layer, iSetup);
+    edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+    iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+    MultipleScatteringParametrisation iSigma = hmaker->parametrisation(layer);
 
     innerScatt =
         3.f * (outerlayer ? iSigma(ptMin(), vtxMean, outer, outerlayer->seqNum()) : iSigma(ptMin(), vtxMean, outer));
@@ -203,7 +209,9 @@ std::unique_ptr<MeasurementEstimator> RectangularEtaPhiTrackingRegion::estimator
     auto invR = 1.f / radius;
     auto cotTheta = (hitZWindow.mean() - origin().z()) * invR;
     auto sinThetaInv = std::sqrt(1.f + sqr(cotTheta));
-    MultipleScatteringParametrisation msSigma(layer, iSetup);
+    edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+    iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+    MultipleScatteringParametrisation msSigma = hmaker->parametrisation(layer);
     auto scatt = 3.f * msSigma(ptMin(), cotTheta);
     auto bendR = longitudinalBendingCorrection(radius, ptMin(), field);
 
@@ -261,7 +269,9 @@ std::unique_ptr<MeasurementEstimator> RectangularEtaPhiTrackingRegion::estimator
   if (thePrecise) {
     float cotTheta = (detZWindow.mean() - origin().z()) / hitRWindow.mean();
     float cosThetaInv = std::sqrt(1 + sqr(cotTheta)) / cotTheta;
-    MultipleScatteringParametrisation msSigma(layer, iSetup);
+    edm::ESHandle<MultipleScatteringParametrisationMaker> hmaker;
+    iSetup.get<TrackerMultipleScatteringRecord>().get(hmaker);
+    MultipleScatteringParametrisation msSigma = hmaker->parametrisation(layer);
     float scatt = 3.f * msSigma(ptMin(), cotTheta);
     float bendR = longitudinalBendingCorrection(hitRWindow.max(), ptMin(), field);
     float hitErrRPhi = 0.;