diff --git a/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.cxx b/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.cxx
index 5b86b901316aec30d4165d1f13a2595654ac8943..dc1bc79b266a1b507351a98722a4db4cda237752 100644
--- a/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.cxx
+++ b/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.cxx
@@ -106,7 +106,7 @@ EMBremCollectionBuilder::execute(const EventContext& ctx) const
   std::vector<const xAOD::TrackParticle*> siliconTrkTracks;
   siliconTrkTracks.reserve(16);
   std::vector<TrackWithIndex> trtAloneTrkTracks;
-  trtAloneTrkTracks.reserve(16);
+  trtAloneTrkTracks.reserve(8);
   for(const xAOD::TrackParticle* track : *selectedTracks){
     const Trk::Track* trktrack{nullptr};
     if (  track->trackLink().isValid() ){
@@ -209,21 +209,25 @@ EMBremCollectionBuilder::createCollections(
   }
 
   for (auto& Info : refitted){
-    ATH_CHECK(createNew(Info,finalTracks,finalTrkPartContainer,AllTracks));
+    ATH_CHECK(
+      createNew(ctx, Info, finalTracks, finalTrkPartContainer, AllTracks));
   }
 
   for (auto& Info  :  failedfit){
-    ATH_CHECK(createNew(Info,finalTracks,finalTrkPartContainer,AllTracks));
+    ATH_CHECK(
+      createNew(ctx, Info, finalTracks, finalTrkPartContainer, AllTracks));
   }
 
   for (auto& Info : trtAlone){
-    ATH_CHECK(createNew(Info,finalTracks,finalTrkPartContainer,AllTracks));
+    ATH_CHECK(
+      createNew(ctx, Info, finalTracks, finalTrkPartContainer, AllTracks));
   }
   return StatusCode::SUCCESS;
 }
 
 StatusCode
 EMBremCollectionBuilder::createNew(
+  const EventContext& ctx,
   TrackWithIndex& Info,
   TrackCollection* finalTracks,
   xAOD::TrackParticleContainer* finalTrkPartContainer,
@@ -236,7 +240,7 @@ EMBremCollectionBuilder::createNew(
    * Create TrackParticle it should be now owned by finalTrkPartContainer
    */
   xAOD::TrackParticle* aParticle = m_particleCreatorTool->createParticle(
-    *(Info.track), finalTrkPartContainer, nullptr, xAOD::electron);
+    ctx, *(Info.track), finalTrkPartContainer, nullptr, xAOD::electron);
 
   if (!aParticle) {
     ATH_MSG_WARNING(
diff --git a/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.h b/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.h
index a36e62ce0dc766a41b05e592b73f4bc32946aaa1..1edaff28162b45de015050c0fa21b0bc515487cb 100644
--- a/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.h
+++ b/Reconstruction/egamma/egammaAlgs/src/EMBremCollectionBuilder.h
@@ -75,7 +75,8 @@ private:
     xAOD::TrackParticleContainer* finalTrkPartContainer,
     const xAOD::TrackParticleContainer* AllTracks) const;
 
-  StatusCode createNew(TrackWithIndex& Info,
+  StatusCode createNew(const EventContext& ctx,
+                       TrackWithIndex& Info,
                        TrackCollection* finalTracks,
                        xAOD::TrackParticleContainer* finalTrkPartContainer,
                        const xAOD::TrackParticleContainer* AllTracks) const;
diff --git a/Tracking/TrkTools/TrkParticleCreator/TrkParticleCreator/TrackParticleCreatorTool.h b/Tracking/TrkTools/TrkParticleCreator/TrkParticleCreator/TrackParticleCreatorTool.h
index 378b9b2b2c264247562c7a6c6017c5b9a2af97cf..f2c64b2fa3ff41b5cdd2642a201f875793968db6 100644
--- a/Tracking/TrkTools/TrkParticleCreator/TrkParticleCreator/TrackParticleCreatorTool.h
+++ b/Tracking/TrkTools/TrkParticleCreator/TrkParticleCreator/TrackParticleCreatorTool.h
@@ -15,7 +15,6 @@ changes : 11.02.04 added docu
 #define TRKPARTICLECREATOR_PARTICLECREATORTOOL_H
 
 #include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/EventContext.h"
 #include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
 
 #include "AthContainers/AuxElement.h"
@@ -77,17 +76,21 @@ public:
   ownership of the Trk::Track or Vx::Candidate, so they should be passed by
   reference.
   */
-  virtual Rec::TrackParticle* createParticle(const Trk::Track* track,
-                                             const Trk::VxCandidate* vxCandidate,
-                                             Trk::TrackParticleOrigin prtOrigin) const override;
+  virtual Rec::TrackParticle* createParticle(
+    const EventContext& ctx,
+    const Trk::Track* track,
+    const Trk::VxCandidate* vxCandidate,
+    Trk::TrackParticleOrigin prtOrigin) const override final;
 
   /** Method to construct a xAOD::TrackParticle from a Rec::TrackParticle.
   @param track particle
   @param TrackParticleContainer needed to have an AuxStore, if provided particle
   will be added to store which takes ownership
   */
-  virtual xAOD::TrackParticle* createParticle(const Rec::TrackParticle& trackParticle,
-                                              xAOD::TrackParticleContainer* container) const override;
+  virtual xAOD::TrackParticle* createParticle(
+    const EventContext& ctx,
+    const Rec::TrackParticle& trackParticle,
+    xAOD::TrackParticleContainer* container) const override final;
 
   /** Method to construct a xAOD::TrackParticle from a passed Track. Currently,
   it will ONLY fill the MeasuredPerigee i.e. the TrackParticle will not be
@@ -101,11 +104,13 @@ public:
   @param prtOrigin Particle type
   @param prd_to_track_map an optional PRD-to-track map to compute shared hits.
   */
-  virtual xAOD::TrackParticle* createParticle(const Trk::Track& track,
-                                              xAOD::TrackParticleContainer* container,
-                                              const xAOD::Vertex* vxCandidate,
-                                              xAOD::ParticleHypothesis prtOrigin,
-                                              const Trk::PRDtoTrackMap* prd_to_track_map) const override;
+  virtual xAOD::TrackParticle* createParticle(
+    const EventContext& ctx,
+    const Trk::Track& track,
+    xAOD::TrackParticleContainer* container,
+    const xAOD::Vertex* vxCandidate,
+    xAOD::ParticleHypothesis prtOrigin,
+    const Trk::PRDtoTrackMap* prd_to_track_map) const override final;
 
   /** Method to construct a TrackParticle from a passed Track. Currently, it
   will ONLY fill the MeasuredPerigee i.e. the TrackParticle will not be complete
@@ -117,21 +122,28 @@ public:
   @param prtOrigin
   @param prd_to_track_map an optional PRD-to-track map to compute shared hits.
   */
-  virtual xAOD::TrackParticle* createParticle(const ElementLink<TrackCollection>& trackLink,
-                                              xAOD::TrackParticleContainer* container,
-                                              const xAOD::Vertex* vxCandidate,
-                                              xAOD::ParticleHypothesis prtOrigin,
-                                              const Trk::PRDtoTrackMap* prd_to_track_map) const override;
+  virtual xAOD::TrackParticle* createParticle(
+    const EventContext& ctx,
+    const ElementLink<TrackCollection>& trackLink,
+    xAOD::TrackParticleContainer* container,
+    const xAOD::Vertex* vxCandidate,
+    xAOD::ParticleHypothesis prtOrigin,
+    const Trk::PRDtoTrackMap* prd_to_track_map) const override final;
 
   /** create a xAOD::TrackParticle out of constituents */
-  virtual xAOD::TrackParticle* createParticle(const Perigee* perigee,
-                                              const FitQuality* fq,
-                                              const TrackInfo* trackInfo,
-                                              const TrackSummary* summary,
-                                              const std::vector<const Trk::TrackParameters*>& parameters,
-                                              const std::vector<xAOD::ParameterPosition>& positions,
-                                              xAOD::ParticleHypothesis prtOrigin,
-                                              xAOD::TrackParticleContainer* container) const override;
+  virtual xAOD::TrackParticle* createParticle(
+    const EventContext& ctx,
+    const Perigee* perigee,
+    const FitQuality* fq,
+    const TrackInfo* trackInfo,
+    const TrackSummary* summary,
+    const std::vector<const Trk::TrackParameters*>& parameters,
+    const std::vector<xAOD::ParameterPosition>& positions,
+    xAOD::ParticleHypothesis prtOrigin,
+    xAOD::TrackParticleContainer* container) const override final;
+
+  virtual const InDet::BeamSpotData* CacheBeamSpotData(
+    const EventContext& ctx) const override final;
 
   /** Method to set FitQuality of a xAOD::TrackParticle */
   void setFitQuality(xAOD::TrackParticle& tp, const FitQuality& fq) const;
@@ -142,15 +154,19 @@ public:
                     xAOD::ParticleHypothesis prtOrigin) const;
 
   /** Method to set TrackSummary of a xAOD::TrackParticle */
-  void setTrackSummary(xAOD::TrackParticle& tp, const TrackSummary& summary) const;
+  void setTrackSummary(xAOD::TrackParticle& tp,
+                       const TrackSummary& summary) const;
 
   /** Method to set Defining parameters of a xAOD::TrackParticle */
-  void setDefiningParameters(xAOD::TrackParticle& tp, const Perigee& perigee) const;
+  void setDefiningParameters(xAOD::TrackParticle& tp,
+                             const Perigee& perigee) const;
 
   /** Method to set parameters of a xAOD::TrackParticle */
-  void setParameters(xAOD::TrackParticle& tp,
-                     const std::vector<const Trk::TrackParameters*>& parameters,
-                     const std::vector<xAOD::ParameterPosition>& positions) const;
+  void setParameters(
+    const EventContext& ctx,
+    xAOD::TrackParticle& tp,
+    const std::vector<const Trk::TrackParameters*>& parameters,
+    const std::vector<xAOD::ParameterPosition>& positions) const;
 
   void setTilt(xAOD::TrackParticle& tp, float tiltx, float tilty) const;
 
@@ -163,8 +179,6 @@ public:
   /** Get the name used for the decoration of the track particle with the number
    * of used hits for TRT dE/dx computation.*/
   static const std::string& trtdEdxUsedHitsAuxName() { return s_trtdEdxUsedHitsDecorationName; }
-  virtual const InDet::BeamSpotData* CacheBeamSpotData(const ::EventContext& ctx) const override;
-
 private:
   void compare(const Rec::TrackParticle& tp, const xAOD::TrackParticle& tpx) const;
   void compare(const TrackParameters& tp1, const TrackParameters& tp2) const;
@@ -208,12 +222,12 @@ private:
 
   /** The pairs if enums  of an eProbability which is added as a decoration to
    * the track particle and the name of the decoration.*/
-  std::vector<std::pair<SG::AuxElement::Decorator<float>, Trk::eProbabilityType>> m_decorateEProbabilities;
-  std::vector<std::pair<SG::AuxElement::Decorator<uint8_t>, Trk::SummaryType>> m_decorateSummaryTypes;
+  std::vector<std::pair<SG::AuxElement::Accessor<float>, Trk::eProbabilityType>> m_decorateEProbabilities;
+  std::vector<std::pair<SG::AuxElement::Accessor<uint8_t>, Trk::SummaryType>> m_decorateSummaryTypes;
 
   /** Name used for the decoration of the track particle with TRT dE/dx .*/
   static const std::string s_trtdEdxUsedHitsDecorationName;
-  static const SG::AuxElement::Decorator<uint8_t> s_trtdEdxUsedHitsDecoration;
+  static const SG::AuxElement::Accessor<uint8_t> s_trtdEdxUsedHitsDecoration;
 
   bool m_doIBL;
   bool m_useTrackSummaryTool;
diff --git a/Tracking/TrkTools/TrkParticleCreator/src/TrackParticleCreatorTool.cxx b/Tracking/TrkTools/TrkParticleCreator/src/TrackParticleCreatorTool.cxx
index 8c844009a059d5d86a94fc9525e01b262c1cc1a2..8b42badeca206635d50c1e0375e54153a84d66d4 100644
--- a/Tracking/TrkTools/TrkParticleCreator/src/TrackParticleCreatorTool.cxx
+++ b/Tracking/TrkTools/TrkParticleCreator/src/TrackParticleCreatorTool.cxx
@@ -98,15 +98,20 @@ createExtraSummaryTypeMap(std::map<std::string, Trk::SummaryType>& extra_summary
 }
 }
 
-const SG::AuxElement::Decorator<uint8_t> TrackParticleCreatorTool::s_trtdEdxUsedHitsDecoration(
-  TrackParticleCreatorTool::trtdEdxUsedHitsAuxName());
+const SG::AuxElement::Accessor<uint8_t>
+  TrackParticleCreatorTool::s_trtdEdxUsedHitsDecoration(
+    TrackParticleCreatorTool::trtdEdxUsedHitsAuxName());
 
-TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const std::string& n, const IInterface* p)
+TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t,
+                                                   const std::string& n,
+                                                   const IInterface* p)
   : base_class(t, n, p)
   , m_detID(nullptr)
   , m_pixelID(nullptr)
   , m_IBLParameterSvc("IBLParameterSvc", n)
-  , m_copyExtraSummaryName{ "eProbabilityComb", "eProbabilityHT", "eProbabilityNN", "TRTTrackOccupancy", "TRTdEdx", "TRTdEdxUsedHits" }
+  , m_copyExtraSummaryName{ "eProbabilityComb", "eProbabilityHT",
+                            "eProbabilityNN",   "TRTTrackOccupancy",
+                            "TRTdEdx",          "TRTdEdxUsedHits" }
   , m_copyEProbabilities{}
   , m_decorateEProbabilities{}
   , m_decorateSummaryTypes{}
@@ -148,7 +153,8 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
 
     if (!m_expressPerigeeToBeamSpot){
-      ATH_MSG_WARNING("Using old configuration option! please use one of " << m_perigeeOptions << ". Assuming Origin." );
+      ATH_MSG_WARNING("Using old configuration option! please use one of "
+                      << m_perigeeOptions << ". Assuming Origin.");
       m_perigeeExpression = "Origin";
     }
 
@@ -158,9 +164,9 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
         if ( m_trackSummaryTool.retrieve().isFailure() ) {
           ATH_MSG_FATAL("Failed to retrieve tool " << m_trackSummaryTool );
           return StatusCode::FAILURE;
-        } 
+        }
           ATH_MSG_DEBUG( "Retrieved tool " << m_trackSummaryTool );
-        
+
       }
     else {
       m_trackSummaryTool.disable();
@@ -170,9 +176,9 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     if ( m_extrapolator.retrieve().isFailure() ) {
       ATH_MSG_FATAL( "Failed to retrieve tool " << m_extrapolator );
       return StatusCode::FAILURE;
-    } 
+    }
       ATH_MSG_DEBUG( "Retrieved tool " << m_extrapolator );
-    
+
 
     if (detStore()->retrieve(m_detID, "AtlasID" ).isFailure()) {
       ATH_MSG_FATAL ("Could not get AtlasDetectorID ");
@@ -187,9 +193,9 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     if (m_IBLParameterSvc.retrieve().isFailure()) {
       ATH_MSG_FATAL( "Could not retrieve IBLParameterSvc" );
       return StatusCode::FAILURE;
-    } 
+    }
       ATH_MSG_INFO( "Retrieved tool " << m_IBLParameterSvc );
-    
+
 
     m_doIBL = m_IBLParameterSvc->containsIBL();
     ATH_MSG_INFO( "doIBL set to "<<m_doIBL );
@@ -202,18 +208,18 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     if ( m_trackToVertex.retrieve().isFailure() ) {
       ATH_MSG_FATAL( "Failed to retrieve tool " << m_trackToVertex );
       return StatusCode::FAILURE;
-    } 
+    }
       ATH_MSG_DEBUG( "Retrieved tool " << m_trackToVertex );
-    
+
 
     if (m_useMuonSummaryTool){
       /* Retrieve hit summary tool from ToolService */
       if ( m_hitSummaryTool.retrieve().isFailure() ) {
         ATH_MSG_FATAL("Failed to retrieve tool " << m_hitSummaryTool );
         return StatusCode::FAILURE;
-      } 
+      }
         ATH_MSG_DEBUG( "Retrieved tool " << m_hitSummaryTool);
-      
+
     }
     else{
       m_hitSummaryTool.disable();
@@ -244,7 +250,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
             errors.push_back(eprob_to_copy);
           }
           else {
-            m_decorateSummaryTypes.emplace_back(SG::AuxElement::Decorator<uint8_t>(extra_summary_type_iter->first),
+            m_decorateSummaryTypes.emplace_back(SG::AuxElement::Accessor<uint8_t>(extra_summary_type_iter->first),
                                                 extra_summary_type_iter->second);
           }
         }
@@ -253,7 +259,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
             m_copyEProbabilities.push_back(eprob_iter->second.first);
           }
           else{
-            m_decorateEProbabilities.emplace_back(SG::AuxElement::Decorator<float>(eprob_iter->first),
+            m_decorateEProbabilities.emplace_back(SG::AuxElement::Accessor<float>(eprob_iter->first),
                                                   eprob_iter->second.first);
           }
         }
@@ -277,9 +283,12 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     return StatusCode::SUCCESS;
   }
 
-  Rec::TrackParticle* TrackParticleCreatorTool::createParticle(const Trk::Track* track,
-                                                               const Trk::VxCandidate* vxCandidate,
-                                                               Trk::TrackParticleOrigin prtOrigin) const
+  Rec::TrackParticle*
+  TrackParticleCreatorTool::createParticle(
+    const EventContext& ctx,
+    const Trk::Track* track,
+    const Trk::VxCandidate* vxCandidate,
+    Trk::TrackParticleOrigin prtOrigin) const
   {
     if (track == nullptr) return nullptr;
     const Trk::Perigee* aPer = nullptr;
@@ -310,7 +319,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
 
     else if  (m_perigeeExpression == "BeamSpot"){ //Express parameters at beamspot
         const Trk::Perigee* result =
-          m_trackToVertex->perigeeAtBeamspot(*track, CacheBeamSpotData(Gaudi::Hive::currentContext()));
+          m_trackToVertex->perigeeAtBeamspot(*track, CacheBeamSpotData(ctx));
         if (!result) {
 
           ATH_MSG_WARNING("Failed to extrapolate to first Beamspot");
@@ -345,7 +354,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
     else if (m_perigeeExpression == "BeamLine"){
       const Trk::Perigee* result =
-        m_trackToVertex->perigeeAtBeamline(*track, CacheBeamSpotData(Gaudi::Hive::currentContext()));
+        m_trackToVertex->perigeeAtBeamline(*track, CacheBeamSpotData(ctx));
       if (!result){
 
         ATH_MSG_WARNING("Failed to extrapolate to Beamline");
@@ -360,7 +369,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
 
     std::unique_ptr<const Trk::TrackSummary> summary;
     if (m_trackSummaryTool.get()!=nullptr) {
-      summary = m_trackSummaryTool->summary(*track, nullptr);
+      summary = m_trackSummaryTool->summary(ctx,*track, nullptr);
       if (summary == nullptr) {
         ATH_MSG_DEBUG ("No proper TrackSummary was returned. Creating TrackParticle with a dummy TrackSummary");
         summary = std::make_unique<Trk::TrackSummary>();
@@ -474,11 +483,15 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     return tp;
   }
 
-  xAOD::TrackParticle* TrackParticleCreatorTool::createParticle( const Trk::Track& track,
-                                                                 xAOD::TrackParticleContainer* container,
-                                                                 const xAOD::Vertex* vxCandidate,
-                                                                 xAOD::ParticleHypothesis prtOrigin,
-                                                                 const Trk::PRDtoTrackMap *prd_to_track_map) const {
+  xAOD::TrackParticle*
+  TrackParticleCreatorTool::createParticle(
+    const EventContext& ctx,
+    const Trk::Track& track,
+    xAOD::TrackParticleContainer* container,
+    const xAOD::Vertex* vxCandidate,
+    xAOD::ParticleHypothesis prtOrigin,
+    const Trk::PRDtoTrackMap* prd_to_track_map) const
+  {
     const Trk::Perigee* aPer = nullptr;
     const Trk::TrackParameters* parsToBeDeleted = nullptr;
     // the default way; I left it as it was because it is working fine!!
@@ -502,14 +515,14 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
         }
       }
     }else if (m_perigeeExpression == "BeamSpot"){ //Express parameters at beamspot
-      const Trk::Perigee* result = m_trackToVertex->perigeeAtBeamspot(track, CacheBeamSpotData(Gaudi::Hive::currentContext()));
+      const Trk::Perigee* result = m_trackToVertex->perigeeAtBeamspot(track,CacheBeamSpotData(ctx));
       if (!result){
         ATH_MSG_WARNING("Failed to extrapolate to first Beamspot - No TrackParticle created.");
         return nullptr;
       }
         parsToBeDeleted = result;
         aPer = result;
-      
+
     } else if (m_perigeeExpression == "Vertex"){  // the non default way, express the perigee wrt. the vertex position
       if (vxCandidate != nullptr) {
         const Trk::Perigee* result =  m_trackToVertex->perigeeAtVertex(track, vxCandidate->position());
@@ -527,15 +540,15 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
     else if (m_perigeeExpression == "BeamLine"){
       const Trk::Perigee* result =
-        m_trackToVertex->perigeeAtBeamline(track, CacheBeamSpotData(Gaudi::Hive::currentContext()));
+        m_trackToVertex->perigeeAtBeamline(track, CacheBeamSpotData(ctx));
       if (!result){
         ATH_MSG_WARNING("Failed to extrapolate to Beamline - No TrackParticle created.");
         return nullptr;
       }
-      
+
         parsToBeDeleted = result;
         aPer = result;
-      
+
     }
     /*
      * We start from the existing summary
@@ -545,7 +558,8 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     const Trk::TrackSummary* summary = track.trackSummary();
     if (m_trackSummaryTool.get() != nullptr) {
       if (!track.trackSummary()) {
-        updated_summary = m_trackSummaryTool->summary(track, prd_to_track_map);
+        updated_summary =
+          m_trackSummaryTool->summary(ctx, track, prd_to_track_map);
         summary = updated_summary.get();
       } else if (m_computeAdditionalInfo) {
         updated_summary = std::make_unique<Trk::TrackSummary>(*track.trackSummary());
@@ -680,7 +694,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
                     nbc_meas_A1++;
                   }
                   // Need to replace these magic numbers with constexpr with meaning full names
-                  if (charge<13750./cos(theta)-22500.){ 
+                  if (charge<13750./cos(theta)-22500.){
                     isBC_B3=true;
                     nbc_meas_B3++;
                   }
@@ -784,7 +798,8 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
       }
     }
 
-    xAOD::TrackParticle* trackparticle = createParticle(aPer,
+    xAOD::TrackParticle* trackparticle = createParticle(ctx,
+                                                        aPer,
                                                         track.fitQuality(),
                                                         &track.info(),
                                                         summary,
@@ -793,32 +808,35 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
                                                         prtOrigin,
                                                         container);
     switch (m_badclusterID) {
-    case 1: {
-      trackparticle->auxdecor<int>("nBC_meas")=nbc_meas_A1;
-      break;
-    }
-    case 2: {
-      trackparticle->auxdecor<int>("nBC_meas")=nbc_meas_B3;
-      break;
-    }
-    case 3: {
-      trackparticle->auxdecor<int>("nBC_meas")=nbc_meas_A1_or_B3;
-      break;
-    }
-    case 4: {
-      trackparticle->auxdecor<int>("nBC_meas")=nbc_meas_A1_or_B3_or_C;
-      break;
-    }
-    default: {
-    }
+      case 1: {
+        trackparticle->auxdecor<int>("nBC_meas") = nbc_meas_A1;
+        break;
+      }
+      case 2: {
+        trackparticle->auxdecor<int>("nBC_meas") = nbc_meas_B3;
+        break;
+      }
+      case 3: {
+        trackparticle->auxdecor<int>("nBC_meas") = nbc_meas_A1_or_B3;
+        break;
+      }
+      case 4: {
+        trackparticle->auxdecor<int>("nBC_meas") = nbc_meas_A1_or_B3_or_C;
+        break;
+      }
+      default: {
+      }
     }
 
     delete parsToBeDeleted;
     return trackparticle;
   }
 
-  xAOD::TrackParticle* TrackParticleCreatorTool::createParticle(const Rec::TrackParticle& trackParticle,
-                                                                xAOD::TrackParticleContainer* container) const
+  xAOD::TrackParticle*
+  TrackParticleCreatorTool::createParticle(
+    const EventContext& ctx,
+    const Rec::TrackParticle& trackParticle,
+    xAOD::TrackParticleContainer* container) const
   {
 
     // Attempt to fill the position enums - will necessarily be a bit of a hack, since we don't have all the information.
@@ -838,7 +856,8 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
 
     xAOD::TrackParticle* trackparticle =
-      createParticle(trackParticle.measuredPerigee(),
+      createParticle(ctx,
+                     trackParticle.measuredPerigee(),
                      trackParticle.fitQuality(),
                      &trackParticle.info(),
                      trackParticle.trackSummary(),
@@ -861,15 +880,17 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
   }
 
   xAOD::TrackParticle*
-  TrackParticleCreatorTool::createParticle(const ElementLink<TrackCollection>& trackLink,
-                                           xAOD::TrackParticleContainer* container,
-                                           const xAOD::Vertex* vxCandidate,
-                                           xAOD::ParticleHypothesis prtOrigin,
-                                           const Trk::PRDtoTrackMap* prd_to_track_map) const
+  TrackParticleCreatorTool::createParticle(
+    const EventContext& ctx,
+    const ElementLink<TrackCollection>& trackLink,
+    xAOD::TrackParticleContainer* container,
+    const xAOD::Vertex* vxCandidate,
+    xAOD::ParticleHypothesis prtOrigin,
+    const Trk::PRDtoTrackMap* prd_to_track_map) const
   {
 
     xAOD::TrackParticle* trackparticle = createParticle(
-      **trackLink, container, vxCandidate, prtOrigin, prd_to_track_map);
+      ctx, **trackLink, container, vxCandidate, prtOrigin, prd_to_track_map);
 
     if (!trackparticle){
       ATH_MSG_WARNING( "WARNING: Problem creating TrackParticle - Returning 0");
@@ -882,14 +903,16 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
   }
 
   xAOD::TrackParticle*
-  TrackParticleCreatorTool::createParticle(const Perigee* perigee,
-                                           const FitQuality* fq,
-                                           const TrackInfo* trackInfo,
-                                           const TrackSummary* summary,
-                                           const std::vector<const Trk::TrackParameters*>& parameters,
-                                           const std::vector<xAOD::ParameterPosition>& positions,
-                                           xAOD::ParticleHypothesis prtOrigin,
-                                           xAOD::TrackParticleContainer* container) const
+  TrackParticleCreatorTool::createParticle(
+    const EventContext& ctx,
+    const Perigee* perigee,
+    const FitQuality* fq,
+    const TrackInfo* trackInfo,
+    const TrackSummary* summary,
+    const std::vector<const Trk::TrackParameters*>& parameters,
+    const std::vector<xAOD::ParameterPosition>& positions,
+    xAOD::ParticleHypothesis prtOrigin,
+    xAOD::TrackParticleContainer* container) const
   {
 
     xAOD::TrackParticle* trackparticle = new xAOD::TrackParticle;
@@ -926,7 +949,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
       setNumberOfUsedHits(*trackparticle,summary->numberOfUsedHitsdEdx());
       setNumberOfOverflowHits(*trackparticle,summary->numberOfOverflowHitsdEdx());
     }
-    const auto *beamspot = CacheBeamSpotData(Gaudi::Hive::currentContext());
+    const auto *beamspot = CacheBeamSpotData(ctx);
     if (beamspot) {
       setTilt(*trackparticle,beamspot->beamTilt(0),beamspot->beamTilt(1));
     }
@@ -937,7 +960,7 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     else {
       ATH_MSG_WARNING( "Track without perigee parameters? Not setting any defining parameters!");
     }
-    setParameters(*trackparticle,parameters, positions);
+    setParameters(ctx, *trackparticle, parameters, positions);
 
     return trackparticle;
   }
@@ -961,29 +984,33 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
   }
 
   void TrackParticleCreatorTool::compare( const Rec::TrackParticle& tp, const xAOD::TrackParticle& tpx ) const {
-    if ( tp.measuredPerigee() ) compare(*tp.measuredPerigee(),tpx.perigeeParameters());
-
-    // do to add other components
-    if ( tp.fitQuality() ){
-
+    if (tp.measuredPerigee()){
+      compare(*tp.measuredPerigee(), tpx.perigeeParameters());
     }
+
     //trackParticle.info(),trackParticle.trackSummary(),
     if ( tp.trackParameters().size() != tpx.numberOfParameters()){
-      ATH_MSG_WARNING("Number of parameters not the same " << tp.trackParameters().size() << " --- " << tpx.numberOfParameters());
+      ATH_MSG_WARNING("Number of parameters not the same "
+                      << tp.trackParameters().size() << " --- "
+                      << tpx.numberOfParameters());
     }
   }
 
   void
-  TrackParticleCreatorTool::setParameters(xAOD::TrackParticle& tp,
-                                          const std::vector<const Trk::TrackParameters*>& parameters,
-                                          const std::vector<xAOD::ParameterPosition>& positions) const
+  TrackParticleCreatorTool::setParameters(
+    const EventContext& ctx,
+    xAOD::TrackParticle& tp,
+    const std::vector<const Trk::TrackParameters*>& parameters,
+    const std::vector<xAOD::ParameterPosition>& positions) const
   {
     std::vector< std::vector < float > > parametersVec;
     parametersVec.resize(parameters.size());
     unsigned int numParam=0;
 
-    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, Gaudi::Hive::currentContext()};
-    const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
+    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{
+      m_fieldCacheCondObjInputKey, ctx
+    };
+    const AtlasFieldCacheCondObj* fieldCondObj{ *readHandle };
     MagField::AtlasFieldCache fieldCache;
     fieldCondObj->getInitializedCache (fieldCache);
 
@@ -1031,7 +1058,10 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
         float x_position = tp.parameterX(i);
         float y_position = tp.parameterY(i);
         tp.setRadiusOfFirstHit(std::sqrt(x_position*x_position + y_position*y_position));
-        tp.setIdentifierOfFirstHit(parameters[i]->associatedSurface().associatedDetectorElementIdentifier().get_compact());
+        tp.setIdentifierOfFirstHit(parameters[i]
+                                     ->associatedSurface()
+                                     .associatedDetectorElementIdentifier()
+                                     .get_compact());
       }
     }
   }
@@ -1061,19 +1091,34 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
 
     for (unsigned int i =0 ; i<Trk::numberOfTrackSummaryTypes ; i++){
       // Only add values which are +ve (i.e., which were created)
-      if ( i >= Trk::numberOfMdtHits && i <= Trk::numberOfRpcEtaHits ) continue;
-      if ( i == Trk::numberOfCscUnspoiltEtaHits ) continue;
-      if ( i >= Trk::numberOfCscEtaHoles && i <= Trk::numberOfTgcPhiHoles ) continue;
+      if (i >= Trk::numberOfMdtHits && i <= Trk::numberOfRpcEtaHits) {
+        continue;
+      }
+      if (i == Trk::numberOfCscUnspoiltEtaHits) {
+        continue;
+      }
+      if (i >= Trk::numberOfCscEtaHoles && i <= Trk::numberOfTgcPhiHoles) {
+        continue;
+      }
       // skip values which are floats
-      if ( std::find(floatSummaryTypes.begin(), floatSummaryTypes.end(), i) != floatSummaryTypes.end() ) continue;
-      if ( i >= Trk::numberOfStgcEtaHits && i <= Trk::numberOfMmHoles) continue;
+      if (std::find(floatSummaryTypes.begin(), floatSummaryTypes.end(), i) !=
+          floatSummaryTypes.end()) {
+        continue;
+      }
+      if (i >= Trk::numberOfStgcEtaHits && i <= Trk::numberOfMmHoles) {
+        continue;
+      }
       // coverity[mixed_enums]
-      if (i == Trk::numberOfTRTHitsUsedFordEdx ) continue;
+      if (i == Trk::numberOfTRTHitsUsedFordEdx) {
+        continue;
+      }
 
       int value = summary.get(static_cast<Trk::SummaryType>(i));
       uint8_t uvalue = static_cast<uint8_t>(value);
       // coverity[first_enum_type]
-      if (value>0) tp.setSummaryValue(uvalue, static_cast<xAOD::SummaryType>(i));
+      if (value>0) {
+        tp.setSummaryValue(uvalue, static_cast<xAOD::SummaryType>(i));
+      }
     }
 
     // first eProbabilities which are set in the xAOD track summary
@@ -1083,14 +1128,16 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
 
     // now the eProbabilities which are set as a decoration.
-    for (const std::pair<SG::AuxElement::Decorator<float>, Trk::eProbabilityType>& decoration :
+    for (const std::pair<SG::AuxElement::Accessor<float>,
+                         Trk::eProbabilityType>& decoration :
          m_decorateEProbabilities) {
       float fvalue = summary.getPID(decoration.second);
       decoration.first(tp) = fvalue;
     }
 
     // now the extra summary types
-    for (const std::pair<SG::AuxElement::Decorator<uint8_t>, Trk::SummaryType>& decoration : m_decorateSummaryTypes) {
+    for (const std::pair<SG::AuxElement::Accessor<uint8_t>, Trk::SummaryType>&
+           decoration : m_decorateSummaryTypes) {
       uint8_t summary_value = summary.get(decoration.second);
       decoration.first(tp) = summary_value;
     }
@@ -1119,11 +1166,10 @@ TrackParticleCreatorTool::TrackParticleCreatorTool(const std::string& t, const s
     }
   }
 
-  const InDet::BeamSpotData* TrackParticleCreatorTool::CacheBeamSpotData(const ::EventContext &ctx) const {
-    // if (ctx.evt() == m_lastEvent) return m_lastBeamSpot;
+  const InDet::BeamSpotData*
+  TrackParticleCreatorTool::CacheBeamSpotData(const EventContext& ctx) const
+  {
     return m_trackToVertex->GetBeamSpotData(ctx);
-    // m_lastEvent = ctx.evt();
-    // return m_lastBeamSpot;
   }
 
   } // end of namespace Trk
diff --git a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ITrackParticleCreatorTool.h b/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ITrackParticleCreatorTool.h
index 85625d849ff1c146cf25652ca8a7f651af1b4674..cc83db1d46926e93568fa9026f3f5c5e6c990879 100755
--- a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ITrackParticleCreatorTool.h
+++ b/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ITrackParticleCreatorTool.h
@@ -10,6 +10,7 @@
 
 #include "GaudiKernel/IAlgTool.h"
 #include "GaudiKernel/EventContext.h"
+#include "GaudiKernel/ThreadLocalContext.h"
 #include "TrkParticleBase/TrackParticleBase.h" // to know TrackParticleOrigin enum
 #include "TrkTrack/TrackCollection.h"
 #include "AthLinks/ElementLink.h"
@@ -49,58 +50,137 @@ namespace Trk
         @param track Pointer to a valid track (i.e. do not pass a zero!). Ownership is not taken (i.e. it will not be deleted) 
         @param vxCandidate Pointer to a valid vxCandidate (i.e. do not pass a zero!). Ownership is not taken (i.e. it will not be deleted) 
         @param prtOrigin  
-        @warning In my opinion, the interface is not optimal - we're not taking ownership of the Trk::Track or Vx::Candidate,  
-        so they should be passed by reference. 
-    */ 
-    virtual Rec::TrackParticle* createParticle( const Trk::Track* track,
-                                                const Trk::VxCandidate* vxCandidate = nullptr,
-                                                Trk::TrackParticleOrigin prtOrigin = Trk::NoVtx) const =0;  // @TODO can this be removed ?
+    */
+    virtual Rec::TrackParticle* createParticle(
+      const EventContext& ctx,
+      const Trk::Track* track,
+      const Trk::VxCandidate* vxCandidate = nullptr,
+      Trk::TrackParticleOrigin prtOrigin = Trk::NoVtx) const = 0;
+
+    Rec::TrackParticle* createParticle(
+      const Trk::Track* track,
+      const Trk::VxCandidate* vxCandidate = nullptr,
+      Trk::TrackParticleOrigin prtOrigin = Trk::NoVtx) const
+    {
+      return createParticle(
+        Gaudi::Hive::currentContext(), track, vxCandidate, prtOrigin);
+    }
 
     /** Method to construct a xAOD::TrackParticle from a Rec::TrackParticle.
-        @param track particle 
-        @param TrackParticleContainer needed to have an AuxStore, if provided particle will be added to store which takes ownership
+        @param track particle
+        @param TrackParticleContainer needed to have an AuxStore, if provided
+       particle will be added to store which takes ownership
     */
-    virtual xAOD::TrackParticle* createParticle( const Rec::TrackParticle& trackParticle,  xAOD::TrackParticleContainer* container=nullptr ) const = 0;
-
-    /** Method to construct a TrackParticle from a passed Track. Currently, it will ONLY fill the MeasuredPerigee
-        i.e. the TrackParticle will not be complete
+    virtual xAOD::TrackParticle* createParticle(
+      const EventContext& ctx,
+      const Rec::TrackParticle& trackParticle,
+      xAOD::TrackParticleContainer* container = nullptr) const = 0;
+
+    xAOD::TrackParticle* createParticle(
+      const Rec::TrackParticle& trackParticle,
+      xAOD::TrackParticleContainer* container = nullptr) const
+    {
+      return createParticle(
+        Gaudi::Hive::currentContext(), trackParticle, container);
+    }
+
+    /** Method to construct a TrackParticle from a passed Track.
         @param track element link to the track is not set, use the method with the element link if you want the link as well
         @param TrackParticleContainer needed to have an AuxStore, if provided particle will be added to store which takes ownership
-        @param xAOD::Vertex Pointer to a valid vxCandidate (i.e. do not pass a zero!). Ownership is not taken (i.e. it will not be deleted)
+        @param xAOD::Vertex Pointer to a  vxCandidate . Ownership is not taken 
         @param prtOrigin
         @param prd_to_track_map an optional PRD-to-track map to compute shared hits.
     */
-    virtual xAOD::TrackParticle* createParticle( const Trk::Track& track,
-                                                 xAOD::TrackParticleContainer* container=nullptr,
-                                                 const xAOD::Vertex* vxCandidate = nullptr,
-                                                 xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
-                                                 const Trk::PRDtoTrackMap *prd_to_track_map = nullptr) const =0;
-
-    /** Method to construct a TrackParticle from a passed Track. Currently, it will ONLY fill the MeasuredPerigee
-        i.e. the TrackParticle will not be complete
+    virtual xAOD::TrackParticle* createParticle(
+      const EventContext& ctx,
+      const Trk::Track& track,
+      xAOD::TrackParticleContainer* container = nullptr,
+      const xAOD::Vertex* vxCandidate = nullptr,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      const Trk::PRDtoTrackMap* prd_to_track_map = nullptr) const = 0;
+
+    xAOD::TrackParticle* createParticle(
+      const Trk::Track& track,
+      xAOD::TrackParticleContainer* container = nullptr,
+      const xAOD::Vertex* vxCandidate = nullptr,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      const Trk::PRDtoTrackMap* prd_to_track_map = nullptr) const
+    {
+      return createParticle(Gaudi::Hive::currentContext(),
+                            track,
+                            container,
+                            vxCandidate,
+                            prtOrigin,
+                            prd_to_track_map);
+    }
+
+    /** Method to construct a TrackParticle from a passed Track. 
         @param track element link to a valid track (i.e. do not pass a zero!).
         @param TrackParticleContainer needed to have an AuxStore, if provided particle will be added to store which takes ownership
-        @param xAOD::Vertex Pointer to a valid vxCandidate (i.e. do not pass a zero!). Ownership is not taken (i.e. it will not be deleted)
+        @param xAOD::Vertex Pointer to a  vxCandidate.
         @param prtOrigin
         @param prd_to_track_map an optional PRD-to-track map to compute shared hits.
     */
-    virtual xAOD::TrackParticle* createParticle( const ElementLink<TrackCollection>& trackLink,
-                                                 xAOD::TrackParticleContainer* container=nullptr,
-                                                 const xAOD::Vertex* vxCandidate = nullptr,
-                                                 xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
-                                                 const Trk::PRDtoTrackMap *prd_to_track_map = nullptr) const =0;
-
-    /** create a xAOD::TrackParticle out of constituents (please don't use this - it will eventually be removed) */
-    virtual xAOD::TrackParticle* createParticle( const Perigee* perigee, const FitQuality* fq, 
-                                                 const TrackInfo* trackInfo, const TrackSummary* summary,
-                                                 const std::vector<const Trk::TrackParameters*>& parameters,
-                                                 const std::vector< xAOD::ParameterPosition>& positions,  
-                                                 xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
-                                                 xAOD::TrackParticleContainer* container = nullptr ) const = 0;
-
-    /** Convenience method to retrieve Beamspot Data object -- cache this once per event for optimal performance */
-    virtual const InDet::BeamSpotData* CacheBeamSpotData(const ::EventContext &ctx) const =0;
-
+    virtual xAOD::TrackParticle* createParticle(
+      const EventContext& ctx,
+      const ElementLink<TrackCollection>& trackLink,
+      xAOD::TrackParticleContainer* container = nullptr,
+      const xAOD::Vertex* vxCandidate = nullptr,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      const Trk::PRDtoTrackMap* prd_to_track_map = nullptr) const = 0;
+
+    xAOD::TrackParticle* createParticle(
+      const ElementLink<TrackCollection>& trackLink,
+      xAOD::TrackParticleContainer* container = nullptr,
+      const xAOD::Vertex* vxCandidate = nullptr,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      const Trk::PRDtoTrackMap* prd_to_track_map = nullptr) const
+    {
+      return createParticle(Gaudi::Hive::currentContext(),
+                            trackLink,
+                            container,
+                            vxCandidate,
+                            prtOrigin,
+                            prd_to_track_map);
+    }
+
+    /** create a xAOD::TrackParticle out of constituents (please don't use this
+     * - it will eventually be removed) */
+    virtual xAOD::TrackParticle* createParticle(
+      const EventContext& ctx,
+      const Perigee* perigee,
+      const FitQuality* fq,
+      const TrackInfo* trackInfo,
+      const TrackSummary* summary,
+      const std::vector<const Trk::TrackParameters*>& parameters,
+      const std::vector<xAOD::ParameterPosition>& positions,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      xAOD::TrackParticleContainer* container = nullptr) const = 0;
+
+    xAOD::TrackParticle* createParticle(
+      const Perigee* perigee,
+      const FitQuality* fq,
+      const TrackInfo* trackInfo,
+      const TrackSummary* summary,
+      const std::vector<const Trk::TrackParameters*>& parameters,
+      const std::vector<xAOD::ParameterPosition>& positions,
+      xAOD::ParticleHypothesis prtOrigin = xAOD::noHypothesis,
+      xAOD::TrackParticleContainer* container = nullptr) const
+    {
+      return createParticle(Gaudi::Hive::currentContext(),
+                            perigee,
+                            fq,
+                            trackInfo,
+                            summary,
+                            parameters,
+                            positions,
+                            prtOrigin,
+                            container);
+    }
+
+    /** Convenience method to retrieve Beamspot Data object */
+    virtual const InDet::BeamSpotData* CacheBeamSpotData(
+      const EventContext& ctx) const = 0;
   };
 
 } // end of namespace