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

@@ -39,10 +39,7 @@ StatusCode sTgcReadoutElement::initElement() {
          ATH_MSG_FATAL("Layer "<<m_pars.stripLayers[layer]<<" has a very strange hash. Expect "<<layer);
        return StatusCode::FAILURE;
       }
-      ATH_CHECK(insertTransform(m_pars.stripLayers[layer].hash(), 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+      ATH_CHECK(insertTransform<sTgcReadoutElement>(m_pars.stripLayers[layer].hash()));
    }
    for (unsigned int layer = 0; layer < m_pars.wireGroupLayers.size(); ++layer) {
       IdentifierHash layHash{layer};
@@ -50,10 +47,7 @@ StatusCode sTgcReadoutElement::initElement() {
          ATH_MSG_FATAL("Layer "<<m_pars.wireGroupLayers[layer]<<" has a very strange hash. Expect "<<layer);
        return StatusCode::FAILURE;
       }
-      ATH_CHECK(insertTransform(m_pars.wireGroupLayers[layer].hash(), 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));
+      ATH_CHECK(insertTransform<sTgcReadoutElement>(m_pars.wireGroupLayers[layer].hash()));
    }
    for (unsigned int layer = 0; layer < m_pars.padLayers.size(); ++layer) {
       IdentifierHash layHash{layer};
@@ -61,10 +55,7 @@ StatusCode sTgcReadoutElement::initElement() {
          ATH_MSG_FATAL("Layer "<<m_pars.padLayers[layer]<<" has a very strange hash. Expect "<<layer);
        return StatusCode::FAILURE;
       }
-      ATH_CHECK(insertTransform(m_pars.padLayers[layer].hash(), 
-                                 [this](const DetectorAlignStore* store, const IdentifierHash& hash){
-                                    return toStation(store) * fromGapToChamOrigin(hash); 
-                                 }));     
+      ATH_CHECK(insertTransform<sTgcReadoutElement>(m_pars.padLayers[layer].hash()));
    }
    ActsGeometryContext gctx{};
    m_gasGapPitch = (center(gctx, createHash(1, sTgcIdHelper::sTgcChannelTypes::Strip, 0)) -

Tools/PyUtils/CMakeLists.txt

@@ -36,8 +36,8 @@ else()
     atlas_install_python_modules( python/*.py python/scripts python/AthFile POST_BUILD_CMD ${ATLAS_FLAKE8} )
     atlas_install_scripts( bin/acmd.py bin/checkFile.py bin/checkPlugins.py
        bin/checkSG.py bin/checkMetaSG.py bin/checkTP.py bin/checkxAOD.py
-       bin/diff-athfile bin/diff-jobo-cfg.py bin/diffConfigs.py
-       bin/diffPoolFiles.py bin/dlldep.py bin/dso-stats.py bin/dump-athfile.py
+       bin/diff-jobo-cfg.py bin/diffConfigs.py
+       bin/diffPoolFiles.py bin/dlldep.py bin/dso-stats.py
        bin/dumpAthfilelite.py bin/filter-and-merge-d3pd.py bin/getMetadata.py
        bin/gprof2dot bin/issues bin/magnifyPoolFile.py
        bin/apydep.py bin/pool_extractFileIdentifier.py
@@ -54,7 +54,6 @@ else()
     atlas_add_alias( filter-and-merge-d3pd "filter-and-merge-d3pd.py" )
     atlas_add_alias( diffPoolFiles "diffPoolFiles.py" )
     atlas_add_alias( print_auditor_callgraph "print_auditor_callgraph.py" )
-    atlas_add_alias( dump-athfile "dump-athfile.py" )
     atlas_add_alias( pyroot "pyroot.py" )
     atlas_add_alias( checkxAOD "checkxAOD.py" )
     atlas_add_alias( checkSG "checkSG.py" )

Tools/PyUtils/bin/diff-athfile

-#!/usr/bin/env python
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# @file:    diff-athfile.py
-# @purpose: simple command-line utility to diff metadata in two files.
-#           Uses PyUtils.AthFile.fopen. Based on dump-athfile.py.
-# @author:  Graeme Stewart <graeme.andrew.stewart@cern.ch>
-# @date:    Jan 2012
-#
-# @example:
-# @code
-# diff-athfile.py aod.1.pool.root aod.2.pool.root 
-# @endcode
-#
-
-import sys
-import os
-
-from optparse import OptionParser
-
-if __name__ == "__main__":
-
-    parser = OptionParser(usage="usage: %prog [options] my.1.file my.2.file")
-    parser.add_option( "-o",
-                       "--output",
-                       dest = "oname",
-                       default = 'athfile-infos.ascii',
-                       help = "Name of the output file which will contain the informations gathered during AthFile processing. These informations will be stored into a python-shelve file." )
-    parser.add_option( '--evtmax',
-                       dest = 'evtmax',
-                       default = 1,
-                       type = int,
-                       help = 'Maximum number of events to process in the file(s)')
-    parser.add_option( "-q",
-                       "--quiet",
-                       dest = "quiet",
-                       default = False,
-                       action = "store_true",
-                       help = 'Quiet output - only print differences')
-    
-    (options, args) = parser.parse_args()
-
-    fnames = []
-    
-    if len(args) > 0:
-        fnames = [ arg for arg in args if arg[0] != "-" ]
-        pass
-
-    if len(fnames) != 2:
-        str(parser.print_help() or "")
-        sys.exit(1)
-
-    sc = 0
-    import PyUtils.AthFile as af
-    msg = af.msg
-    if options.quiet:
-        from logging import WARNING
-        msg.setLevel(WARNING)
-    
-    fhandles = {}
-    try:
-        for fname in fnames:
-            fhandles[fname] = af.fopen(fname, evtmax=options.evtmax)
-            msg.info(':'*80)
-            msg.info('Opened file %s.', fname)
-            
-
-        # Ignore the following keys, which are bound to be different:
-        # 'file_md5sum', 'file_name', 'file_type', 'file_guid',
-        simpleCompKeys = ('nentries','run_number', 'run_type', 'evt_number', 'evt_type', 'lumi_block',
-                        'beam_energy', 'beam_type',
-                        'stream_tags', 'stream_names', 'geometry', 'conditions_tag',)
-        bitByBitKeys = ('metadata',)
-    
-        for k in simpleCompKeys:
-            if fhandles[fnames[0]].infos[k] == fhandles[fnames[1]].infos[k]:
-                msg.info('%s equal in %s and %s: %s', k, fnames[0], fnames[1], fhandles[fnames[0]].infos[k])
-            else:
-                msg.warning('%s not equal in %s and %s: %s != %s',
-                            k, fnames[0], fnames[1], fhandles[fnames[0]].infos[k], fhandles[fnames[1]].infos[k])
-                sc = 1
-
-        for k in bitByBitKeys:
-            # First check dictionary keys are the same
-            skeys = list(fhandles[fnames[0]].infos[k].keys())
-            skeys1 = list(fhandles[fnames[1]].infos[k].keys())
-            skeys.sort()
-            skeys1.sort()
-            if skeys != skeys1:
-                msg.warning('%s keys not equal for %s and %s: %s != %s',
-                            k, fnames[0], fnames[1], skeys, skeys1)
-                sc = 1
-            else:
-                msg.info('%s keys are equal for %s and %s: %s',
-                         k, fnames[0], fnames[1], skeys)
-                for subk in skeys:
-                    if fhandles[fnames[0]].infos[k][subk] == fhandles[fnames[1]].infos[k][subk]:
-                        # Here suppress the very long value output
-                        msg.info('%s element %s values are equal for %s and %s: (value suppressed)',
-                                 k, subk, fnames[0], fnames[1])
-                    else:
-                        msg.warning('%s element %s values are not equal for %s and %s: %s != %s',
-                                    k, subk, fnames[0], fnames[1], fhandles[fnames[0]].infos[k][subk],
-                                    fhandles[fnames[1]].infos[k][subk])
-                        sc = 1
-                        
-                
-        msg.info(':'*80)
-    except Exception as e:
-        msg.error("Caught exception [%s] !!", str(e.__class__))
-        msg.error("What:\n%s\n%s\n%s",e,
-                  sys.exc_info()[0],
-                  sys.exc_info()[1])
-        import traceback
-        msg.error(traceback.print_exc())
-        sc = 2
-        pass
-
-    except Exception:
-        msg.error("Caught something !! (don't know what)")
-        msg.error("\n%s\n%s",sys.exc_info()[0], sys.exc_info()[1])
-        sc = 2
-        pass
-
-    
-    if options.oname:
-        oname = options.oname
-        msg.info("saving report into [%s]...", oname)
-        if os.path.exists(oname):
-            os.rename(oname, oname+'.bak')
-        af.server.save_cache(oname)
-
-    msg.info("Bye.")
-    sys.exit(sc)

Tools/PyUtils/bin/dump-athfile.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# @file:    dump-athfile.py
-# @purpose: simple command-line utility wrapping PyUtils.AthFile.fopen
-# @author:  Sebastien Binet <binet@cern.ch>
-# @date:    May 2009
-#
-# @example:
-# @code
-# dump-athfile aod.pool.root
-# dump-athfile daq.data
-# dump-athfile /castor/cern.ch/user/j/johndoe/aod.pool.root
-# dump-athfile somedir/*/*.pool
-# @endcode
-#
-
-from __future__ import print_function
-
-__author__  = "Sebastien Binet <binet@cern.ch>"
-
-import sys
-import os
-
-from optparse import OptionParser
-
-if __name__ == "__main__":
-
-    parser = OptionParser(usage="usage: %prog [options] [-f] my.file")
-    parser.add_option( "-f",
-                       "--file",
-                       dest = "fname",
-                       help = "The path to the POOL/BS file to analyze" )
-    parser.add_option( "-o",
-                       "--output",
-                       dest = "oname",
-                       default = 'athfile-infos.ascii',
-                       help = "Name of the output file which will contain the informations gathered during AthFile processing. These informations will be stored into a python-shelve file." )
-    parser.add_option( '--evtmax',
-                       dest = 'evtmax',
-                       default = 1,
-                       type = int,
-                       help = 'Maximum number of events to process in the file(s)')
-    parser.add_option( '--debug',
-                       dest = 'debug',
-                       default = False,
-                       action='store_true',
-                       help = 'enable debugging informations')
-    
-    (options, args) = parser.parse_args()
-
-    if options.debug:
-        os.environ['ATHFILE_DEBUG'] = '1'
-        os.environ['PYUTILS_SHUTUP_DEBUG'] = '1'
-        pass
-        
-    fnames = []
-    
-    if len(args) > 0:
-        fnames = [ arg for arg in args if arg[0] != "-" ]
-        pass
-
-    if options.fname is None and len(fnames) == 0:
-        str(parser.print_help() or "")
-        sys.exit(1)
-
-    if options.fname is not None:
-        fname = os.path.expandvars(os.path.expanduser(options.fname))
-        fnames.append(fname)
-
-    fnames = list(set(fnames))
-    sc = 0
-    import PyUtils.AthFile as af
-    msg = af.msg
-    infos = []
-    try:
-        infos = af.pfopen(fnames, evtmax=options.evtmax)
-    except Exception as e:
-        msg.error("Caught exception [%s] !!", str(e.__class__))
-        msg.error("What:\n%s\n%s\n%s",e,
-                  sys.exc_info()[0],
-                  sys.exc_info()[1])
-        sc = 1
-        pass
-
-    except Exception:
-        msg.error("Caught something !! (don't know what)")
-        msg.error("\n%s\n%s",sys.exc_info()[0], sys.exc_info()[1])
-        sc = 10
-        pass
-
-    if sc != 0:
-        msg.info("Bye.")
-        sys.exit(sc)
-        pass
-    
-    for f in infos:
-        file_size = f.infos['file_size']/1024./1024.
-        if file_size < 0: file_size = None
-        else:             file_size = str(file_size)+' MB'
-
-        msg.info(':'*80)
-        msg.info('::::: summary :::::')
-        fmt = ' - %-15s: %s'
-        print (fmt % ('file md5',       f.infos['file_md5sum']))
-        print (fmt % ('file name',      f.infos['file_name']))
-        print (fmt % ('file type',      f.infos['file_type']))
-        print (fmt % ('file size',      file_size))
-        print (fmt % ('file guid',      f.infos['file_guid']))
-        print (fmt % ('nentries',       f.infos['nentries']))
-        print (fmt % ('run number',     f.infos['run_number']))
-        print (fmt % ('run type',       f.infos['run_type']))
-        print (fmt % ('evt number',     f.infos['evt_number']))
-        print (fmt % ('evt type',       f.infos['evt_type']))
-        print (fmt % ('mc channel #',   f.infos['mc_channel_number']))
-        print (fmt % ('lumi block',     f.infos['lumi_block']))
-        print (fmt % ('beam energy',    f.infos['beam_energy']))
-        print (fmt % ('beam type',      f.infos['beam_type']))
-        print (fmt % ('stream tags',    f.infos['stream_tags']))
-        print (fmt % ('stream names',   f.infos['stream_names']))
-        print (fmt % ('geometry',       f.infos['geometry']))
-        print (fmt % ('conditions tag', f.infos['conditions_tag']))
-        _metadata = f.infos['metadata']
-
-        if _metadata is not None:
-            # ATEAM-162: determine if this is 25ns or 50ns sub-campaign
-            DigitizationParameters = _metadata['/Digitization/Parameters'] if '/Digitization/Parameters' in _metadata.keys() else {}
-            if DigitizationParameters is not None and 'bunchSpacing' in DigitizationParameters.keys() and 'BeamIntensityPattern' in DigitizationParameters.keys() :
-                bunchSlotLength = DigitizationParameters['bunchSpacing']
-                pattern = DigitizationParameters['BeamIntensityPattern']
-                if pattern is not None:
-                    firstBunch = pattern.index(1.0)
-                    bunchCountInTwoFirstSlots = pattern[firstBunch:firstBunch+2].count(1.0)
-                    if bunchCountInTwoFirstSlots == 1:
-                        campaign = '50 ns'
-                    elif bunchCountInTwoFirstSlots == 2:
-                        campaign = '25 ns'
-                    else:
-                        campaign = None
-                    print (fmt % ('bunch spacing',   campaign + ' i.e. ..., ' + str(pattern[firstBunch:firstBunch+4])[1:-1] + ', ...'))
-
-            _metadata = _metadata.keys() if isinstance(_metadata,dict) else None
-        print (fmt % ('meta data',      _metadata))
-
-        msg.info(':'*80)
-        if len(infos) > 1:
-            print ("")
-        pass # loop over infos
-    
-    if options.oname:
-        oname = options.oname
-        msg.info("saving report into [%s]...", oname)
-        if os.path.exists(oname):
-            os.rename(oname, oname+'.bak')
-        af.server.save_cache(oname)
-
-    msg.info("Bye.")
-    sys.exit(sc)

Tools/PyUtils/bin/meta-diff.py

@@ -77,9 +77,10 @@ def main():
         choices=["tiny", "lite", "full", "peeker"],
         help="""\
              This flag provides the user capability to select the amount of
-             metadata retrieved. There three options:
+             metadata retrieved. There are four options:
                          tiny (only those values used in PyJobTransforms),
-                         lite (same output as dump-athfile)
+                         lite
+                         peeker
                          and full ( all  available data found)
              """,
     )

Tools/PyUtils/bin/meta-reader.py

@@ -121,9 +121,10 @@ def _main():
 						metavar='MODE',
 						type=str,
 						choices=['tiny', 'lite', 'full', 'peeker', 'iov'],
-						help="This flag provides the user capability to select the amount of metadata retrieved. There three options: "
+						help="This flag provides the user capability to select the amount of metadata retrieved. There are five options: "
 							"tiny (only those values used in PyJobTransforms), "
-							"lite (same output as dump-athfile), "
+							"lite, "
+							"peeker, "
 							"full (all available data found), "
 							"and iov (full+iov details)" )
 

Tools/PyUtils/python/scripts/__init__.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 # hook for PyUtils.scripts package
 
@@ -9,7 +9,6 @@ acmdlib.register('chk-rflx', 'PyUtils.scripts.check_reflex')
 acmdlib.register('diff-pool', 'PyUtils.scripts.diff_pool_files')
 acmdlib.register('diff-root', 'PyUtils.scripts.diff_root_files')
 acmdlib.register('dump-root', 'PyUtils.scripts.dump_root_file')
-acmdlib.register('ath-dump', 'PyUtils.scripts.ath_dump')
 acmdlib.register('gen-klass', 'PyUtils.scripts.gen_klass')
 
 acmdlib.register('merge-files', 'PyUtils.scripts.merge_files')

Tools/PyUtils/python/scripts/ath_dump.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# @file PyUtils.scripts.ath_dump
-# @purpose entry point for ath-dump command, the dump-athfile cousin
-# @author Sebastien Binet
-# @date January 2010
-
-from __future__ import print_function
-
-__author__ = "Sebastien Binet"
-__doc__ = "entry point for ath-dump command, the dump-athfile cousin"
-
-### imports -------------------------------------------------------------------
-import PyUtils.acmdlib as acmdlib
-
-@acmdlib.command(name='ath-dump')
-@acmdlib.argument('files', nargs='+',
-                  help='path to POOL or BS file(s) to analyse')
-@acmdlib.argument('-o', '--output',
-                  default='athfile-infos.ascii',
-                  help="""Name of the output file which will contain the
-                  informations gathered during AthFile processing.
-                  These informations will be stored into a python-shelve file.
-                  """)
-@acmdlib.argument('--evtmax',
-                  default=1,
-                  type=int,
-                  help="""Maximum number of events to process in each file""")
-def main(args):
-    """simple command-line utility wrapping PyUtils.AthFile.fopen
-    """
-    exitcode = 0
-    fnames = args.files
-    if isinstance(fnames, str):
-        fnames = [fnames]
-
-    import sys
-    import os
-    import os.path as osp
-    for i,f in enumerate(fnames):
-        fnames[i] = osp.expandvars(osp.expanduser(f))
-
-    import PyUtils.AthFile as af
-    msg = af.msg
-    for fname in fnames:
-        try:
-            f = af.fopen(fname, evtmax=args.evtmax)
-            msg.info(':'*80)
-            msg.info('::::: summary :::::')
-            fmt = ' - %-15s: %s'
-            print (fmt % ('file md5',       f.infos['file_md5sum']))
-            print (fmt % ('file name',      f.infos['file_name']))
-            print (fmt % ('file type',      f.infos['file_type']))
-            print (fmt % ('file guid',      f.infos['file_guid']))
-            print (fmt % ('nentries',       f.infos['nentries']))
-            print (fmt % ('run number',     f.infos['run_number']))
-            print (fmt % ('run type',       f.infos['run_type']))
-            print (fmt % ('evt number',     f.infos['evt_number']))
-            print (fmt % ('evt type',       f.infos['evt_type']))
-            print (fmt % ('lumi block',     f.infos['lumi_block']))
-            print (fmt % ('beam energy',    f.infos['beam_energy']))
-            print (fmt % ('beam type',      f.infos['beam_type']))
-            print (fmt % ('stream tags',    f.infos['stream_tags']))
-            print (fmt % ('stream names',   f.infos['stream_names']))
-            print (fmt % ('geometry',       f.infos['geometry']))
-            print (fmt % ('conditions tag', f.infos['conditions_tag']))
-            _metadata = f.infos['metadata']
-            _metadata = _metadata.keys() if isinstance(_metadata,dict) else None
-            print (fmt % ('meta data',      _metadata))
-
-            msg.info(':'*80)
-        except Exception as e:
-            msg.error("Caught exception [%s] !!", str(e.__class__))
-            msg.error("What:\n%s\n%s\n%s",e,
-                      sys.exc_info()[0],
-                      sys.exc_info()[1])
-            import traceback
-            traceback.print_exc()
-            exitcode = 1
-            pass
-
-        except Exception:
-            msg.error("Caught something !! (don't know what)")
-            msg.error("\n%s\n%s",sys.exc_info()[0], sys.exc_info()[1])
-            exitcode = 10
-            pass
-        if len(fnames) > 1:
-            print ("")
-        pass # loop over fileNames
-    
-    if args.output:
-        oname = args.output
-        msg.info("saving report into [%s]...", oname)
-        if osp.exists(oname):
-            os.rename(oname, oname+'.bak')
-        af.server.save_cache(oname)
-
-    msg.info("Bye.")
-    return exitcode
-
-

Tracking/Acts/ActsGeoUtils/ActsGeoUtils/TransformCache.h

@@ -5,82 +5,77 @@
 #define ActsGeoUtils_TransformCache_H
 
 #include <shared_mutex>
+#include <type_traits>
 #include <ActsGeoUtils/Defs.h>
 #include <ActsGeometryInterfaces/IDetectorElement.h>
 #include <Identifier/IdentifierHash.h>
 #include <CxxUtils/CachedUniquePtr.h>
 
 namespace ActsTrk {
-
+  /*** @brief: The TransformCache holds the local -> global transformations associated with a tracking surface 
+   *           from the Readout geometry. The cache establishes the connection with the ActsGeometryContext or more
+   *           precisely with its DetectorAlignStore to provide the transformations of an aligned surface. 
+   *           As soon as the alignment store is accessed, the nominal surface is released from memory.
+   *           In order to be used for each detector technology, the virtual <fetchTransform> needs to
+   *           be defined further downstream. The method is called everytime when a new cache is invoked. */
   class TransformCache {
-    public:
-      /** @brief: Functional to initialize the cache for a given alignment. Ideally, this functional is defined
-       *          by each of the MuonReadoutElement and calls the protected
-       * 
-       *              Amg::Transform3D toStation(ActsTrk::RawGeomAlignStore* alignStore) const
-       *
-       *          method which is applying the alignment transformations via the GeoModel kernel. The IdentifierHash
-       *          encodes the active sensor number within the MuonReadoutElement. Hence, it  can be used 
-       *          to find the transformation to go from the origin of  the GeoModel detector coordinate system 
-       *          to the origin of the sensor coordinate system.
-      */
-      using TransformMaker = std::function<Amg::Transform3D(const ActsTrk::DetectorAlignStore* store, const IdentifierHash& hash)>;
+      public:
+          TransformCache(const IdentifierHash& cacheHash,
+                         const DetectorType type);
+          
+          TransformCache(const TransformCache& other) = delete;
+          TransformCache& operator=(const TransformCache& other) = delete;
+
+          virtual ~TransformCache();
+
+          /** @brief Returns the sensor hash of this transformation cache */
+          IdentifierHash hash() const;
+          /** @brief Returns the parent IDetectorElement owning the cache*/
+          virtual const IDetectorElement* parent() const = 0;
+          
+          /** @brief Returns the matching transformation from the alignment store. 
+            *        If a nullptr is given, then it's equivalent to the case that the transformation
+            *        is pointing to a perfectly aligned surface. In this case, the internal nominal
+            *        transformation cache is invoked.
+            * */
+          const Amg::Transform3D& getTransform(const DetectorAlignStore* store) const;
+
+#ifndef SIMULATIONBASE
+          /** @brief returns the cached transform from the Acts Geometry context */
+          const Amg::Transform3D& transform(const Acts::GeometryContext& gctx) const;
+#endif
+          /** @brief resets the nominal cache associated with the detector element*/
+          void releaseNominalCache() const;
+          /** @brief returns the detector type of the cache*/
+          DetectorType detectorType() const;
+      protected:
+          virtual Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const = 0;
+      private:
+          const IdentifierHash m_hash{0};
+          const DetectorType m_type{DetectorType::UnDefined};
+          using TicketCounter = DetectorAlignStore::TrackingAlignStore;
+          const unsigned int m_clientNo{TicketCounter::drawTicket(m_type)};
+          mutable std::shared_mutex m_mutex ATLAS_THREAD_SAFE{};
+          mutable CxxUtils::CachedUniquePtrT<Amg::Transform3D> m_nomCache ATLAS_THREAD_SAFE{};
+  };
+
 
+
+  template<typename CachingDetectorEle> 
+  class TransformCacheDetEle: public TransformCache {
+    public:
       /** @brief: Standard constructor taking the hash of the sensor element and 
        *          and the TransformMaker expressed usually as a lambda function
       **/
-      TransformCache(const IdentifierHash& hash, 
-                     TransformMaker maker,
-                     const IDetectorElement* parentEle);
-      
-      TransformCache(const IdentifierHash& hash, 
-                     std::shared_ptr<const TransformMaker> maker,
-                     const IDetectorElement* parentEle);
-      /** @brief: Delete copy constructor & assignment operator*/
-      TransformCache(const TransformCache& other) = delete;
-      TransformCache& operator=(const TransformCache& other) = delete;
-      /** @brief Destructor releasing the ticket for later reuse*/
-      ~TransformCache();
+      TransformCacheDetEle(const IdentifierHash& hash, 
+                           const CachingDetectorEle* parentEle);
       
-      /** @brief Returns the matching transformation from the alignment store. 
-       *         If a nullptr is given, then it's equivalent to the case that the transformation
-       *         is pointing to a perfectly aligned surface. In this case, the internal nominal
-       *         transformation cache is invoked.
-       * */
-      const Amg::Transform3D& getTransform(const DetectorAlignStore* store) const;
-      /** @brief Returns the sensor hash of this transformation cache */
-      IdentifierHash hash() const;
-      /** @brief Returns the transform maker function of this transformation cache*/
-      const TransformMaker& transformMaker() const;
-      /** @brief Returns the parent IDetectorElement owning the cache*/
-      const IDetectorElement* parent() const;
-      /** @brief resets the nominal cache associated with the detector element*/
-      void releaseNominalCache() const;
-    
+      const IDetectorElement* parent() const override final;
     private:
-       const IDetectorElement* m_parent{nullptr};
-       const DetectorType m_type{m_parent->detectorType()};
-       using TicketCounter = DetectorAlignStore::TrackingAlignStore;
-       const unsigned int m_clientNo{TicketCounter::drawTicket(m_type)};
-       IdentifierHash m_hash{0};
-       std::shared_ptr<const TransformMaker> m_transform{};
-       mutable std::shared_mutex m_mutex ATLAS_THREAD_SAFE{};
-       mutable CxxUtils::CachedUniquePtrT<Amg::Transform3D> m_nomCache ATLAS_THREAD_SAFE{};
+       Amg::Transform3D fetchTransform(const DetectorAlignStore* store) const override final;
+       const CachingDetectorEle* m_parent{nullptr};
   };
 
-inline bool operator<(const std::unique_ptr<TransformCache>& a,
-                      const std::unique_ptr<TransformCache>& b) {
-    return a->hash() < b->hash();
-}
-inline bool operator<(const IdentifierHash& a,
-                      const std::unique_ptr<TransformCache>& b) {
-    return a < b->hash();
-}
-inline bool operator<(const std::unique_ptr<TransformCache>& a,
-                      const IdentifierHash& b) {
-    return a->hash() < b;
-}
-using TransformCacheSet = std::set<std::unique_ptr<TransformCache>, std::less<>>;
 }
 #include <ActsGeoUtils/TransformCache.icc>
 #endif
\ No newline at end of file

Tracking/Acts/ActsGeoUtils/ActsGeoUtils/TransformCache.icc

@@ -13,7 +13,7 @@ namespace ActsTrk {
         if (alignStore) {
             const Amg::Transform3D* cache = alignStore->trackingAlignment->getTransform(m_clientNo);
             if (cache) return *cache;
-            const Amg::Transform3D& trf{alignStore->trackingAlignment->setTransform(m_clientNo, (*m_transform)(alignStore, m_hash))};
+            const Amg::Transform3D& trf{alignStore->trackingAlignment->setTransform(m_clientNo, fetchTransform(alignStore))};
             /// If an external alignment store is presented release the nominal transformation
             releaseNominalCache();
             return trf;
@@ -21,12 +21,32 @@ namespace ActsTrk {
         /// Fall back solution to go onto the nominal cache    
         if (!m_nomCache) {
             std::unique_lock guard{m_mutex};
-            m_nomCache.set(std::make_unique<Amg::Transform3D>((*m_transform)(nullptr, m_hash)));
+            m_nomCache.set(std::make_unique<Amg::Transform3D>(fetchTransform(alignStore)));
             return (*m_nomCache);
         }
         std::shared_lock guard{m_mutex};
         return (*m_nomCache);
     }
+    inline IdentifierHash TransformCache::hash() const { return m_hash; }
+#ifndef SIMULATIONBASE
+    ATH_FLATTEN
+    inline const Amg::Transform3D& TransformCache::transform(const Acts::GeometryContext& anygctx) const {
+        const ActsGeometryContext* gctx = anygctx.get<const ActsGeometryContext*>();    
+        // unpack the alignment store from the context
+        return getTransform(gctx->getStore(m_type).get());
+
+    }
+#endif
 
- }
+
+template<typename CachingDetectorEle>
+   TransformCacheDetEle<CachingDetectorEle>::TransformCacheDetEle(const IdentifierHash& hash,
+                                                      const CachingDetectorEle* parentEle):
+        TransformCache(hash, parentEle->detectorType()),
+        m_parent{parentEle} {}
+template<typename CachingDetectorEle>
+    const IDetectorElement* TransformCacheDetEle<CachingDetectorEle>::parent()  const {
+        return m_parent;
+    }
+}
 #endif
\ No newline at end of file

Tracking/Acts/ActsGeoUtils/src/SurfaceCache.cxx

@@ -13,9 +13,7 @@ namespace ActsTrk{
 
   const TransformCache* SurfaceCache::transformCache() const { return m_transformCache; }
   const Acts::Transform3& SurfaceCache::transform(const Acts::GeometryContext& anygctx) const  {
-    const ActsGeometryContext* gctx = anygctx.get<const ActsGeometryContext*>();    
-    // unpack the alignment store from the context
-    return m_transformCache->getTransform(gctx->getStore(m_transformCache->parent()->detectorType()).get());
+    return m_transformCache->transform(anygctx);
   }
   const Acts::Surface& SurfaceCache::surface() const  { 
     if (!m_surface) THROW_EXCEPTION("Surface has not been set before");

Tracking/Acts/ActsGeoUtils/src/TransformCache.cxx

@@ -10,25 +10,15 @@ namespace ActsTrk {
         TicketCounter::giveBackTicket(m_type, m_clientNo);
     }
     TransformCache::TransformCache(const IdentifierHash& hash,
-                                   TransformMaker maker,
-                                   const IDetectorElement* parentEle): 
-        TransformCache(hash,std::make_unique<TransformMaker>(maker), parentEle) {}
-    TransformCache::TransformCache(const IdentifierHash& hash,
-                                   std::shared_ptr<const TransformMaker> maker,
-                                   const IDetectorElement* parentEle): 
-          m_parent{parentEle},
+                                   const DetectorType type): 
           m_hash{hash},
-          m_transform{maker}{}
+          m_type{type} {}
 
-    const IDetectorElement* TransformCache::parent() const {
-        return m_parent;
-    }
     void TransformCache::releaseNominalCache() const {
         std::unique_lock guard{m_mutex};
         m_nomCache.release();
-        const GeoVDetectorElement* vParent =dynamic_cast<const GeoVDetectorElement*>(m_parent);
+        const GeoVDetectorElement* vParent = dynamic_cast<const GeoVDetectorElement*>(parent());
         if (vParent) vParent->getMaterialGeom()->clearPositionInfo();
     } 
-    IdentifierHash TransformCache::hash() const { return m_hash; }
-    const TransformCache::TransformMaker& TransformCache::transformMaker() const { return *m_transform; }
+    DetectorType TransformCache::detectorType() const { return m_type; }
 }

Tracking/Acts/ActsGeometry/ActsGeometry/ActsDetectorElement.h

@@ -34,11 +34,11 @@ class SurfaceBounds;
 }
 
 class ActsTrackingGeometrySvc;
-
 class IdentityHelper;
 
 /// @class ActsDetectorElement
 ///
+
 class ActsDetectorElement : public ActsTrk::IDetectorElement, public GeoVDetectorElement {
 public:
   using DetectorType = ActsTrk::DetectorType;
@@ -98,10 +98,11 @@ public:
   /// is based on.
   const GeoVDetectorElement *upstreamDetectorElement() const;
 
+  Amg::Transform3D transform(const ActsTrk::DetectorAlignStore* store) const;
 private:
   DetectorType m_type{DetectorType::UnDefined};
 
-  ActsTrk::TransformCache m_trfCache;
+  ActsTrk::TransformCacheDetEle<ActsDetectorElement> m_trfCache{0, this};
   /// Detector element as variant
   const GeoVDetectorElement *m_detElement{nullptr};
   /// Boundaries of the detector element
@@ -112,9 +113,16 @@ private:
   std::shared_ptr<Acts::Surface> m_surface{};
   std::vector<std::shared_ptr<const Acts::Surface>> m_surfaces{};
 
-
+  std::unique_ptr<const Amg::Transform3D> m_trtTrf{};
 
   Identifier m_explicitIdentifier{};
 };
 
+namespace ActsTrk{
+    template <> inline Amg::Transform3D 
+        TransformCacheDetEle<ActsDetectorElement>::fetchTransform(const DetectorAlignStore* store) const{
+        return m_parent->transform(store);
+   }
+}
+
 #endif

Tracking/Acts/ActsGeometry/src/ActsDetectorElement.cxx

@@ -51,35 +51,6 @@ constexpr double length_unit = 1_mm;
 ActsDetectorElement::ActsDetectorElement(const InDetDD::SiDetectorElement &detElem) :
   GeoVDetectorElement{detElem.getMaterialGeom()},
   m_type{detElem.isPixel() ? DetectorType::Pixel : DetectorType::Sct},
-  m_trfCache{0,[this,&detElem](const DetectorAlignStore* store, const IdentifierHash&) {
-
-      const InDetDD::SiDetectorDesign &design = detElem.design();
-      const Trk::SurfaceBounds::BoundsType boundsType = detElem.bounds().type();
-
-      // extra shift for split row modules
-      Amg::Transform3D extraTransform{Amg::CLHEPTransformToEigen(detElem.recoToHitTransform())};    
-      if (boundsType == Trk::SurfaceBounds::Rectangle &&
-          typeid(design) == typeid(InDetDD::StripBoxDesign) ) {
-
-          extraTransform = design.moduleShift() * extraTransform;
-
-      } else if (boundsType == Trk::SurfaceBounds::Annulus) {
-        // need to rotate pi/2 to reproduce ABXY orientation, phiS so that phi=0
-        // is center and symmetric
-        const double phiShift = M_PI_2 - static_cast<const InDetDD::StripStereoAnnulusDesign&>(design).stereo();
-
-        const Amg::Vector2D origin2D = static_cast<const Acts::AnnulusBounds&>(m_surface->bounds()).moduleOrigin();
-        const Amg::Translation3D transl{origin2D.x(), origin2D.y(), 0};
-        const Amg::Transform3D originTrf{transl * Amg::getRotateZ3D(-phiShift)};
-        extraTransform = extraTransform * originTrf.inverse();
-      }
-      GeoAlignmentStore* alignStore = store ? store->geoModelAlignment.get() : nullptr;
-      Amg::Transform3D l2g = m_detElement->getMaterialGeom()->getAbsoluteTransform(alignStore) * extraTransform;
-      // need to make sure translation has correct units
-      l2g.translation() *= 1.0 / CLHEP::mm * length_unit;
-
-      return l2g;
-  },this},
   m_detElement{&detElem} {
 
 
@@ -118,8 +89,7 @@ ActsDetectorElement::ActsDetectorElement(const InDetDD::SiDetectorElement &detEl
   } else if (boundsType == Trk::SurfaceBounds::Annulus) {
 
     const InDetDD::SiDetectorDesign &design = detElem.design();
-    const auto *annulus =
-        dynamic_cast<const InDetDD::StripStereoAnnulusDesign *>(&design);
+    const auto *annulus = dynamic_cast<const InDetDD::StripStereoAnnulusDesign *>(&design);
     if (annulus == nullptr) {
       throw std::domain_error("ActsDetectorElement got inconsistent surface");
     }
@@ -157,8 +127,8 @@ ActsDetectorElement::ActsDetectorElement(const Acts::Transform3 &trf,
                                          const Identifier &id) :
     GeoVDetectorElement{detElem.getMaterialGeom()},
     m_type{DetectorType::Trt}, 
-    m_trfCache{0,[trf](const DetectorAlignStore* , const IdentifierHash&) { return trf; },this},
     m_detElement{&detElem}, 
+    m_trtTrf{std::make_unique<Amg::Transform3D>(trf)},
     m_explicitIdentifier(id) {
 
   // we know this is a straw
@@ -189,14 +159,6 @@ ActsDetectorElement::ActsDetectorElement(const Acts::Transform3 &trf,
 ActsDetectorElement::ActsDetectorElement(const InDetDD::HGTD_DetectorElement &detElem, const Identifier &id) :
     GeoVDetectorElement{detElem.getMaterialGeom()},
     m_type{DetectorType::Hgtd}, 
-    m_trfCache{0, [this](const DetectorAlignStore* store, const IdentifierHash&) {
-
-        GeoAlignmentStore* geoModelStore = store ? store->geoModelAlignment.get() : nullptr;
-        Amg::Transform3D l2g = m_detElement->getMaterialGeom()->getAbsoluteTransform(geoModelStore);
-        // need to make sure translation has correct units
-        l2g.translation() *= 1.0 / CLHEP::mm * length_unit;
-        return l2g;
-    }, this},
     m_detElement{&detElem}, 
     m_thickness{detElem.thickness()}, 
     m_explicitIdentifier{id} {
@@ -222,6 +184,48 @@ ActsDetectorElement::ActsDetectorElement(const InDetDD::HGTD_DetectorElement &de
   }
 }
 
+Amg::Transform3D ActsDetectorElement::transform(const ActsTrk::DetectorAlignStore* store) const {
+   
+    GeoAlignmentStore* geoModelStore = store ? store->geoModelAlignment.get() : nullptr;
+    Amg::Transform3D l2g{Amg::Transform3D::Identity()};
+   switch (m_type) {
+      case DetectorType::Hgtd:{
+         l2g= m_detElement->getMaterialGeom()->getAbsoluteTransform(geoModelStore);
+         break;
+      } case DetectorType::Trt: {
+         l2g = (*m_trtTrf);
+         break;
+      }
+      /// Pixel or Sct
+      default: {
+          const auto& detElem = static_cast<const InDetDD::SiDetectorElement&>(*m_detElement);
+          const InDetDD::SiDetectorDesign&design = detElem.design();
+          const Trk::SurfaceBounds::BoundsType boundsType = detElem.bounds().type();
+
+          // extra shift for split row modules
+          Amg::Transform3D extraTransform{Amg::CLHEPTransformToEigen(detElem.recoToHitTransform())};    
+          if (boundsType == Trk::SurfaceBounds::Rectangle &&
+              typeid(design) == typeid(InDetDD::StripBoxDesign) ) {            
+              extraTransform = design.moduleShift() * extraTransform;
+          } else if (boundsType == Trk::SurfaceBounds::Annulus) {
+              // need to rotate pi/2 to reproduce ABXY orientation, phiS so that phi=0
+              // is center and symmetric
+              const double phiShift = M_PI_2 - static_cast<const InDetDD::StripStereoAnnulusDesign&>(design).stereo();
+
+              const Amg::Vector2D origin2D = static_cast<const Acts::AnnulusBounds&>(m_surface->bounds()).moduleOrigin();
+              const Amg::Translation3D transl{origin2D.x(), origin2D.y(), 0};
+              const Amg::Transform3D originTrf{transl * Amg::getRotateZ3D(-phiShift)};
+              extraTransform = extraTransform * originTrf.inverse();
+          }
+          l2g = m_detElement->getMaterialGeom()->getAbsoluteTransform(geoModelStore) * extraTransform;
+      }
+   };
+   // need to make sure translation has correct units
+   l2g.translation() *= 1.0 / CLHEP::mm * length_unit;
+
+   return l2g;
+
+}
 IdentityHelper ActsDetectorElement::identityHelper() const {
   if (detectorType() == DetectorType::Pixel || detectorType() == DetectorType::Sct) {
         return IdentityHelper(static_cast<const InDetDD::SiDetectorElement *>(m_detElement));
@@ -231,11 +235,7 @@ IdentityHelper ActsDetectorElement::identityHelper() const {
 }
 
 const Acts::Transform3 &ActsDetectorElement::transform(const Acts::GeometryContext &anygctx) const {
-    // any cast to known context type
-    const ActsGeometryContext *gctx = anygctx.get<const ActsGeometryContext *>();
-    // unpack the alignment store from the context
-    return m_trfCache.getTransform(gctx->getStore(detectorType()).get());
-
+    return m_trfCache.transform(anygctx);
 }
 
 unsigned int ActsDetectorElement::storeAlignedTransforms(const ActsTrk::DetectorAlignStore& store) const {