InnerDetector/InDetRecTools/SiClusterizationTool/CMakeLists.txt

@@ -15,13 +15,13 @@ find_package( Boost )
 atlas_add_library( SiClusterizationToolLib
    SiClusterizationTool/*.h src/*.cxx
    PUBLIC_HEADERS SiClusterizationTool
-   INCLUDE_DIRS PixelGeoModelLib ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS}
+   INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS}
    DEFINITIONS ${CLHEP_DEFINITIONS}
    PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${COOL_INCLUDE_DIRS} ${LWTNN_INCLUDE_DIRS}
    LINK_LIBRARIES ${CLHEP_LIBRARIES} ${EIGEN_LIBRARIES} ${ROOT_LIBRARIES} AthenaBaseComps AthenaKernel AthAllocators
    BeamSpotConditionsData EventPrimitives GaudiKernel GeoPrimitives Identifier InDetCondTools InDetConditionsSummaryService 
    InDetIdentifier InDetPrepRawData InDetRawData InDetReadoutGeometry SCT_ReadoutGeometry InDetRecToolInterfaces
-   InDetSimData PixelConditionsData PixelReadoutGeometryLib PoolSvcLib StoreGateLib TrkNeuralNetworkUtilsLib TrkParameters LwtnnUtils xAODInDetMeasurement
+   InDetSimData PixelConditionsData PixelGeoModelLib PixelReadoutGeometryLib PoolSvcLib StoreGateLib TrkNeuralNetworkUtilsLib TrkParameters LwtnnUtils xAODInDetMeasurement
    PRIVATE_LINK_LIBRARIES ${Boost_LIBRARIES} ${COOL_LIBRARIES} ${LWTNN_LIBRARIES} AthenaPoolUtilities AtlasDetDescr AtlasHepMCLib FileCatalog ReadoutGeometryBase TrkEventPrimitives TrkSurfaces VxVertex CxxUtils xAODCore )
 
 atlas_add_component( SiClusterizationTool

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h

@@ -118,6 +118,15 @@ class MdtReadoutElement : public MuonReadoutElement {
     double innerTubeRadius() const;
     /// Adds the thickness of the tube wall onto the radius
     double tubeRadius() const;
+    /// Returns the length of the bottom edge of the chamber (short width)
+    double moduleWidthS() const;
+    /// Returns the length of the top edge of the chamber (top width)
+    double moduleWidthL() const;
+    /// Returns the height of the chamber (Distance bottom - topWidth)
+    double moduleHeight() const;
+    /// Returns the thickness of the chamber
+    double moduleThickness() const;
+
     
     /// Returns the global position of the tube center. 
     Amg::Vector3D globalTubePos(const ActsGeometryContext& ctx, 
@@ -153,7 +162,7 @@ class MdtReadoutElement : public MuonReadoutElement {
     double wireLength(const IdentifierHash& hash) const;
 
 
-
+        friend ActsTrk::TransformCacheDetEle<MdtReadoutElement>;
    private:
         /// Returns the tube position in the chamber coordinate frame
         Amg::Vector3D localTubePos(const IdentifierHash& hash) const;
@@ -168,6 +177,7 @@ class MdtReadoutElement : public MuonReadoutElement {
         /// z-axis: Pointing along the wire
         Amg::Transform3D toTubeFrame(const IdentifierHash& hash) const;
 
+
         parameterBook m_pars{};
         const MdtIdHelper& m_idHelper{idHelperSvc()->mdtIdHelper()};
         /// Identifier index of the multilayer (1-2)
@@ -179,5 +189,10 @@ class MdtReadoutElement : public MuonReadoutElement {
 std::ostream& operator<<(std::ostream& ostr, const MdtReadoutElement::parameterBook& pars);
 }  // namespace MuonGMR4
 
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MdtReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
+
 #include <MuonReadoutGeometryR4/MdtReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.icc

@@ -4,6 +4,20 @@
 #ifndef MUONREADOUTGEOMETRYR4_MDTREADOUTELEMENT_ICC
 #define MUONREADOUTGEOMETRYR4_MDTREADOUTELEMENT_ICC
 
+#include <GaudiKernel/SystemOfUnits.h>
+namespace ActsTrk{
+    template <> inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MdtReadoutElement>::fetchTransform(const DetectorAlignStore* store) const {
+            const unsigned int tubeNum = m_parent->tubeNumber(hash()) + 1;
+            if (tubeNum == 0) {
+                const Amg::Translation3D toCenter{0.5*m_parent->moduleHeight() * Amg::Vector3D::UnitY()};
+                return m_parent->toStation(store) * m_parent->toChamberLayer(hash()) *
+                        toCenter * Amg::getRotateY3D(90*Gaudi::Units::deg); 
+            }
+            return m_parent->toStation(store) * m_parent->toTubeFrame(hash());
+        }
+}
+
 namespace MuonGMR4 {
 inline unsigned int MdtReadoutElement::multilayer() const { return m_stML; }
 inline unsigned int MdtReadoutElement::numLayers() const { return m_pars.tubeLayers.size(); }
@@ -12,7 +26,11 @@ inline double MdtReadoutElement::innerTubeRadius() const {return m_pars.tubeInne
 inline double MdtReadoutElement::tubeRadius() const {return innerTubeRadius() + m_pars.tubeWall;}
 inline double MdtReadoutElement::tubePitch() const { return m_pars.tubePitch;}
 inline double MdtReadoutElement::thickness() const {return 2.* m_pars.halfHeight;}
-    
+inline double MdtReadoutElement::moduleWidthS() const{ return 2.*m_pars.shortHalfX; }
+inline double MdtReadoutElement::moduleWidthL() const{ return 2.*m_pars.longHalfX; }
+inline double MdtReadoutElement::moduleHeight() const{ return 2.*m_pars.halfY; }
+inline double MdtReadoutElement::moduleThickness() const{ return 2.*m_pars.halfHeight; }
+  
 inline bool MdtReadoutElement::isValid(const IdentifierHash& measHash) const {
     return  layerNumber(measHash) < numLayers() && 
             tubeNumber(measHash) < numTubesInLay() && 

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MmReadoutElement.h

@@ -114,6 +114,9 @@ class MmReadoutElement : public MuonReadoutElement {
 
     const StripLayer& stripLayer(const Identifier& measId) const;    
     const StripLayer& stripLayer(const IdentifierHash& measHash) const;    
+ 
+    friend ActsTrk::TransformCacheDetEle<MmReadoutElement>;
+
    private:
        
     
@@ -133,6 +136,11 @@ class MmReadoutElement : public MuonReadoutElement {
 std::ostream& operator<<(std::ostream& ostr, const MmReadoutElement::parameterBook& pars);
 }  // namespace MuonGMR4
 
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MmReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
+
 
 #include <MuonReadoutGeometryR4/MmReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MmReadoutElement.icc

@@ -4,7 +4,13 @@
 #ifndef MUONREADOUTGEOMETRYR4_MMREADOUTELEMENT_ICC
 #define MUONREADOUTGEOMETRYR4_MMREADOUTELEMENT_ICC
 
+namespace ActsTrk{
+    template <>  inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MmReadoutElement>::fetchTransform(const DetectorAlignStore* store) const {
+            return m_parent->toStation(store) * m_parent->fromGapToChamOrigin(hash());
+        }
 
+}
 namespace MuonGMR4 {
 
 inline double MmReadoutElement::thickness() const { return 2.* m_pars.halfThickness; }

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonChamber.h

@@ -21,6 +21,20 @@
 
 #include <set>
 
+namespace MuonGMR4{
+    class MuonChamber;
+}
+namespace ActsTrk {
+    template<> TransformCacheDetEle<MuonGMR4::MuonChamber>::TransformCacheDetEle(const IdentifierHash& hash, 
+                                                                                 const MuonGMR4::MuonChamber* chamber);
+    
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MuonChamber>::fetchTransform(const DetectorAlignStore* store) const;
+    template <> const IDetectorElement*
+        TransformCacheDetEle<MuonGMR4::MuonChamber>::parent() const;
+
+}
+
 namespace MuonGMR4 {
     class MuonChamber {
         public:
@@ -75,12 +89,7 @@ namespace MuonGMR4 {
         private:
            defineArgs m_args{};
            using AlignmentStore = ActsGeometryContext::AlignmentStore;
-           Amg::Transform3D fromLayerToGlobal(const AlignmentStore* store) const;
-
-           ActsTrk::TransformCache m_localToGlobal{IdentifierHash{0},
-                    [this](const AlignmentStore* store, const IdentifierHash&){
-                        return fromLayerToGlobal(store);
-                    },readOutElements()[0]};
+           ActsTrk::TransformCacheDetEle<MuonChamber> m_localToGlobal{IdentifierHash{0}, this};
     };
     
     std::ostream& operator<<(std::ostream& ostr,
@@ -90,5 +99,7 @@ namespace MuonGMR4 {
                              const MuonChamber& chamber);
 
 }
+
+
 #endif
 #endif
\ No newline at end of file

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.h

@@ -164,19 +164,15 @@ class MuonReadoutElement : public GeoVDetectorElement, public AthMessaging, publ
     void releaseUnAlignedTrfs() const;
 
     unsigned int storeAlignedTransforms(const ActsTrk::DetectorAlignStore& store) const override final;
+
+     /// Returns the transformation into the center of the readout volume
+     Amg::Transform3D toStation(const ActsTrk::DetectorAlignStore* alignStore) const;
    protected:
-     using TransformMaker = ActsTrk::TransformCache::TransformMaker;
       
      /// Inserts a transfomration for caching
-     StatusCode insertTransform(const IdentifierHash& hash,
-                                 TransformMaker make);
-
-     StatusCode insertTransform(const IdentifierHash& hash,
-                                std::shared_ptr<const TransformMaker> make);
+     template <class MuonDetImpl> StatusCode insertTransform(const IdentifierHash& hash);
 
      StatusCode createGeoTransform();
-     /// Returns the transformation into the center of the readout volume
-     Amg::Transform3D toStation(const ActsTrk::DetectorAlignStore* alignStore) const;
 #ifndef SIMULATIONBASE
      //Creates a MuonSurfaceCache for straw surfaces using the given Bounds and Identifier Hash
      StatusCode strawSurfaceFactory(const IdentifierHash& hash, std::shared_ptr<Acts::LineBounds> lBounds);
@@ -214,5 +210,11 @@ class MuonReadoutElement : public GeoVDetectorElement, public AthMessaging, publ
 #endif
 };
 }  // namespace MuonGMR4
+
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MuonReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
+
 #include <MuonReadoutGeometryR4/MuonReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.icc

@@ -4,6 +4,14 @@
 #ifndef MUONGEOMODELR4_MUONREADOUTELEMENT_ICC
 #define MUONGEOMODELR4_MUONREADOUTELEMENT_ICC
 
+
+namespace ActsTrk{
+    template <> inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::MuonReadoutElement>::fetchTransform(const DetectorAlignStore* store) const {
+        return m_parent->toStation(store);
+   }
+}
+
 namespace MuonGMR4 {
 
 inline const GeoAlignableTransform* MuonReadoutElement::alignableTransform() const { return m_args.alignTransform; }
@@ -42,5 +50,18 @@ inline const Amg::Transform3D& MuonReadoutElement::localToGlobalTrans(const Acts
     return localToGlobalTrans(ctx, layerHash(id));
 }
 
+template<class MuonImpl>
+StatusCode MuonReadoutElement::insertTransform(const IdentifierHash& hash) {    
+    TransformCacheMap::const_iterator cache = m_localToGlobalCaches.find(hash);
+    if (cache != m_localToGlobalCaches.end()) {
+        ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" - "<<idHelperSvc()->toStringDetEl(identify())
+                   <<" has already a transformation cached for hash "<<hash);
+        return StatusCode::FAILURE;
+    }
+    auto newCache = std::make_unique<ActsTrk::TransformCacheDetEle<MuonImpl>>(hash, static_cast<MuonImpl*>(this));
+    m_localToGlobalCaches.insert(std::make_pair(hash, std::move(newCache)));
+    return StatusCode::SUCCESS;
+}
+
 }  // namespace MuonGMR4
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.h

@@ -118,7 +118,8 @@ class RpcReadoutElement : public MuonReadoutElement {
                                      const unsigned int gasGap, 
                                      const unsigned int doubPhi, 
                                      const bool measPhi);
-
+    
+    friend class ActsTrk::TransformCacheDetEle<RpcReadoutElement>;
    private:
         /// Access to the StripLayer associated to a given measurement Hash
         const StripLayer& sensorLayout(const IdentifierHash& measHash) const;
@@ -153,6 +154,11 @@ class RpcReadoutElement : public MuonReadoutElement {
 std::ostream& operator<<(std::ostream& ostr, const RpcReadoutElement::parameterBook& pars);
 }  // namespace MuonGMR4
 
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::RpcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
+
 
 #include <MuonReadoutGeometryR4/RpcReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.icc

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 #ifndef MUONREADOUTGEOMETRYR4_RPCREADOUTELEMENT_ICC
 #define MUONREADOUTGEOMETRYR4_RPCREADOUTELEMENT_ICC
 
 
+namespace ActsTrk{
+    template <> inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::RpcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const{
+            return m_parent->toStation(store) * m_parent->fromGapToChamOrigin(hash());
+        }
+}
+
 namespace MuonGMR4 {
     namespace RpcIdMeasHashFields{
         constexpr unsigned int minOne = -1;

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/TgcReadoutElement.h

@@ -91,6 +91,9 @@ class TgcReadoutElement : public MuonReadoutElement {
     /// Returns access to the strip design of the given gasGap [1-3]
     /// If the gap does not have strips an exception is thrown
     const RadialStripDesign& stripLayout(unsigned int gasGap)  const;
+
+    friend class ActsTrk::TransformCacheDetEle<TgcReadoutElement>;
+
    private:
         parameterBook m_pars{};
         const TgcIdHelper& m_idHelper{idHelperSvc()->tgcIdHelper()};
@@ -117,6 +120,10 @@ class TgcReadoutElement : public MuonReadoutElement {
 std::ostream& operator<<(std::ostream& ostr, const TgcReadoutElement::parameterBook& pars);
 }  // namespace MuonGMR4
 
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::TgcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
 
 #include <MuonReadoutGeometryR4/TgcReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/TgcReadoutElement.icc

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 #ifndef MUONREADOUTGEOMETRYR4_TGCREADOUTELEMENT_ICC
 #define MUONREADOUTGEOMETRYR4_TGCREADOUTELEMENT_ICC
 
 
+namespace ActsTrk{
+    template <>  inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::TgcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const{
+            return m_parent->toStation(store) * m_parent->fromGapToChamOrigin(hash());
+        }
+}
+
 namespace MuonGMR4 {
 inline double TgcReadoutElement::moduleWidthS() const { return 2.*m_pars.halfWidthShort; }
 inline double TgcReadoutElement::moduleWidthL() const { return 2.*m_pars.halfWidthLong; }

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/sTgcReadoutElement.h

@@ -266,7 +266,7 @@ class sTgcReadoutElement : public MuonReadoutElement {
                                      const unsigned int channelType, 
                                      const unsigned int channel,
                                      const unsigned int wireInGrp = 0);
-
+    friend class ActsTrk::TransformCacheDetEle<sTgcReadoutElement>;
    private:
         /// Returns channel position for a given identifierHash
         static unsigned int channelNumber(const IdentifierHash& measHash);
@@ -286,9 +286,13 @@ class sTgcReadoutElement : public MuonReadoutElement {
         const unsigned int m_hashShiftChType{2*CxxUtils::count_ones(static_cast<unsigned int>(numLayers()))};
 };
 
-std::ostream& operator<<(
-    std::ostream& ostr, const MuonGMR4::sTgcReadoutElement::parameterBook& pars);
+std::ostream& operator<<(std::ostream& ostr, const MuonGMR4::sTgcReadoutElement::parameterBook& pars);
 }  // namespace MuonGMR4
 
+namespace ActsTrk{
+    template <> Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::sTgcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const;
+}
+
 #include <MuonReadoutGeometryR4/sTgcReadoutElement.icc>
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/sTgcReadoutElement.icc

@@ -5,6 +5,14 @@
 #define MUONREADOUTGEOMETRYR4_STGCREADOUTELEMENT_ICC
 
 
+namespace ActsTrk{
+    template <> inline Amg::Transform3D 
+        TransformCacheDetEle<MuonGMR4::sTgcReadoutElement>::fetchTransform(const DetectorAlignStore* store) const{
+            return  m_parent->toStation(store) * m_parent->fromGapToChamOrigin(hash());
+        }
+}
+
+
 namespace MuonGMR4 {
     namespace sTgcIdMeasHashFields {
         constexpr unsigned int minusOne = -1;

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MdtReadoutElement.cxx

@@ -58,21 +58,11 @@ StatusCode MdtReadoutElement::initElement() {
   /// w.r.t. to the chamber edge. Move first tube into the proper position
 
   std::optional<Amg::Vector3D> prevLayPos{std::nullopt};
-  std::shared_ptr<TransformMaker> tubeMaker = std::make_shared<TransformMaker>(
-                     [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                           return toStation(store) * toTubeFrame(hash); 
-                     });
-
-  std::shared_ptr<TransformMaker> layerMaker = std::make_shared<TransformMaker>(
-                    [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                    const Amg::Translation3D toCenter{m_pars.halfY * Amg::Vector3D::UnitY()};
-                    return toStation(store) * toChamberLayer(hash)*toCenter*Amg::getRotateY3D(90*Gaudi::Units::deg); 
-                  });
 
   for (unsigned int lay =1 ; lay <= numLayers() ; ++lay) {
      /// Cache the transformations to the chamber layers
      const IdentifierHash layHash = measurementHash(lay,0);
-     ATH_CHECK(insertTransform(layHash, layerMaker));
+     ATH_CHECK(insertTransform<MdtReadoutElement>(layHash));
 #ifndef SIMULATIONBASE
      ATH_CHECK(planeSurfaceFactory(layHash, m_pars.layerBounds->make_bounds(m_pars.shortHalfX, 
                                                                             m_pars.longHalfX, 
@@ -86,7 +76,7 @@ StatusCode MdtReadoutElement::initElement() {
          prevTubePos = std::nullopt;
          continue;
       }
-      ATH_CHECK(insertTransform(idHash, tubeMaker));
+      ATH_CHECK(insertTransform<MdtReadoutElement>(idHash));
 #ifndef SIMULATIONBASE
       ATH_CHECK(strawSurfaceFactory(idHash, m_pars.tubeBounds->make_bounds(innerTubeRadius(), 0.5*tubeLength(idHash))));
 #endif

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MmReadoutElement.cxx

@@ -48,10 +48,7 @@ StatusCode MmReadoutElement::initElement() {
          ATH_MSG_FATAL("Layer "<<m_pars.layers[layer]<<" has a very strange hash. Expect "<<layer);
          return StatusCode::FAILURE;
       }
-      ATH_CHECK(insertTransform(layHash, 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+      ATH_CHECK(insertTransform<MmReadoutElement>(layHash));
 #ifndef SIMULATIONBASE
       const StripDesign& design{m_pars.layers[layer].design()};
       ATH_CHECK(planeSurfaceFactory(layHash, m_pars.layerBounds->make_bounds(design.shortHalfHeight(),

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonChamber.cxx

@@ -7,6 +7,33 @@
 #include <ActsGeoUtils/NoDeletePtr.h>
 
 
+namespace ActsTrk {
+template<> 
+    TransformCacheDetEle<MuonGMR4::MuonChamber>::TransformCacheDetEle(const IdentifierHash& hash, 
+                                                                     const MuonGMR4::MuonChamber* chamber):
+        TransformCache{hash, chamber->detectorType()},
+        m_parent{chamber} {}
+template<> const IDetectorElement*
+        TransformCacheDetEle<MuonGMR4::MuonChamber>::parent() const { return nullptr; }
+template <> Amg::Transform3D 
+    TransformCacheDetEle<MuonGMR4::MuonChamber>::fetchTransform(const DetectorAlignStore* store) const{
+        ActsGeometryContext gctx{};
+        /// If the store is given, assume that the tracking alignment already caches the transformations
+        /// of the needed detector surfaces --> We can build a geo context on the fly.
+        if (store) {
+            auto copyStore = std::make_unique<DetectorAlignStore>(detectorType());
+            copyStore->geoModelAlignment = store->geoModelAlignment;
+            copyStore->trackingAlignment = store->trackingAlignment;
+            copyStore->internalAlignment = store->internalAlignment;
+            gctx.setStore(std::move(copyStore)); 
+        }        
+        const auto& pars{m_parent->parameters()};
+        return pars.readoutEles[0]->localToGlobalTrans(gctx) * pars.centerTrans;
+
+    }
+
+}
+
 
 namespace MuonGMR4 {
 
@@ -44,19 +71,6 @@ const Amg::Transform3D& MuonChamber::localToGlobalTrans(const ActsGeometryContex
 Amg::Transform3D MuonChamber::globalToLocalTrans(const ActsGeometryContext& gctx) const {
     return localToGlobalTrans(gctx).inverse(); 
 }
-Amg::Transform3D MuonChamber::fromLayerToGlobal(const AlignmentStore* store) const {
-    ActsGeometryContext gctx{};
-    /// If the store is given, assume that the tracking alignment already caches the transformations
-    /// of the needed detector surfaces --> We can build a geo context on the fly.
-    if (store) {
-        auto copyStore = std::make_unique<AlignmentStore>(detectorType());
-        copyStore->geoModelAlignment = store->geoModelAlignment;
-        copyStore->trackingAlignment = store->trackingAlignment;
-        copyStore->internalAlignment = store->internalAlignment;
-        gctx.setStore(std::move(copyStore)); 
-    }        
-    return m_args.readoutEles[0]->localToGlobalTrans(gctx) * m_args.centerTrans;
-}
 double MuonChamber::halfXLong() const { return m_args.halfXLong; }
 double MuonChamber::halfXShort() const { return m_args.halfXShort; }
 double MuonChamber::halfY() const { return m_args.halfY; }

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonReadoutElement.cxx

@@ -34,9 +34,7 @@ StatusCode MuonReadoutElement::createGeoTransform() {
        ATH_MSG_FATAL("The readout element "<<idHelperSvc()->toStringDetEl(identify())<<" has no assigned alignable node");
        return StatusCode::FAILURE;
     }
-    return insertTransform(geoTransformHash(), [this](const DetectorAlignStore* store, const IdentifierHash&){
-            return toStation(store);
-    });
+    return insertTransform<MuonReadoutElement>(geoTransformHash());
 }
 IdentifierHash MuonReadoutElement::geoTransformHash() {     
     static const IdentifierHash hash{static_cast<unsigned>(~0)-1};
@@ -72,22 +70,6 @@ unsigned int MuonReadoutElement::storeAlignedTransforms(const ActsTrk::DetectorA
     return aligned;
 }
 
-StatusCode MuonReadoutElement::insertTransform(const IdentifierHash& hash,
-                                               TransformMaker make) {
-    return insertTransform(hash, std::make_shared<const TransformMaker>(make));
-}
-StatusCode MuonReadoutElement::insertTransform(const IdentifierHash& hash,
-                                               std::shared_ptr<const TransformMaker> make) {
-    
-    TransformCacheMap::const_iterator cache = m_localToGlobalCaches.find(hash);
-    if (cache != m_localToGlobalCaches.end()) {
-        ATH_MSG_FATAL(__FILE__<<":"<<__LINE__<<" - "<<idHelperSvc()->toStringDetEl(identify())
-                   <<" has already a transformation cached for hash "<<hash);
-        return StatusCode::FAILURE;
-    }
-    m_localToGlobalCaches.insert(std::make_pair(hash, std::make_unique<ActsTrk::TransformCache>(hash, make, this)));
-    return StatusCode::SUCCESS;
-}
 Amg::Transform3D MuonReadoutElement::globalToLocalTrans(const ActsGeometryContext& ctx) const {
     return globalToLocalTrans(ctx, geoTransformHash());
 }

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/RpcReadoutElement.cxx

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 #include <EventPrimitives/EventPrimitivesToStringConverter.h>
 #include <GeoPrimitives/GeoPrimitivesHelpers.h>
@@ -48,10 +48,7 @@ StatusCode RpcReadoutElement::initElement() {
          ATH_MSG_VERBOSE("Layer "<<layer <<" has not sensor layout associated.");
          continue;
       }
-      ATH_CHECK(insertTransform(layHash, 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+      ATH_CHECK(insertTransform<RpcReadoutElement>(layHash));
 #ifndef SIMULATIONBASE
       const StripDesign& design{sensorLayout(layHash).design()};
       ATH_CHECK(planeSurfaceFactory(layHash, m_pars.layerBounds->make_bounds(design.halfWidth(),

MuonSpectrometer/MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/TgcReadoutElement.cxx

@@ -57,10 +57,7 @@ StatusCode TgcReadoutElement::initElement() {
     for (unsigned int gap = 1; gap <= nGasGaps(); ++gap) {
          if (numWireGangs(gap)) {
             const IdentifierHash layHash{constructHash(0, gap, false)}; 
-            ATH_CHECK(insertTransform(layHash, 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+            ATH_CHECK(insertTransform<TgcReadoutElement>(layHash));
 #ifndef SIMULATIONBASE
             const StripDesign& layout{wireGangLayout(gap)};
             ATH_CHECK(planeSurfaceFactory(layHash, m_pars.layerBounds->make_bounds(layout.shortHalfHeight(),
@@ -70,10 +67,7 @@ StatusCode TgcReadoutElement::initElement() {
          }
          if (numStrips(gap)) {
             const IdentifierHash layHash{constructHash(0, gap, true)}; 
-            ATH_CHECK(insertTransform(layHash, 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+            ATH_CHECK(insertTransform<TgcReadoutElement>(layHash));
 #ifndef SIMULATIONBASE
             const StripDesign& layout{stripLayout(gap)};
             /// We probably need a rotated version of these bounds. However, that's not part