Calorimeter/CaloDetDescr/CaloDetDescr/CaloDepthTool.h

@@ -228,21 +228,24 @@ public:
 private:
    const CaloDetDescrManager* caloMgr() const;
 
-  std::string m_depth_choice;
+   Gaudi::Property<std::string> m_depth_choice{ this,
+                                                "DepthChoice",
+                                                "",
+                                                "depth choice" };
 
-  /** ID Helper
-   */
-  const CaloCell_ID* m_calo_id;
+   /** ID Helper
+    */
+   const CaloCell_ID* m_calo_id;
 
-  /** DD manager
-   */
-  CxxUtils::CachedPointer<CaloDetDescrManager> m_calo_dd;
+   /** DD manager
+    */
+   CxxUtils::CachedPointer<CaloDetDescrManager> m_calo_dd;
 
-  /** Phi range helper object
-   */
-  CaloPhiRange m_range;
+   /** Phi range helper object
+    */
+   CaloPhiRange m_range;
 
-  double m_default;
+   double m_default;
 };
 
  

Calorimeter/CaloDetDescr/src/CaloDepthTool.cxx

@@ -38,12 +38,10 @@ CaloDepthTool::CaloDepthTool(const std::string& type,
 			     const std::string& name, 
 			     const IInterface* parent) :
   AthAlgTool(type, name, parent),
-  m_depth_choice(""),
   m_calo_id(nullptr),
   m_default(0)
 {
   declareInterface<CaloDepthTool>( this );
-  declareProperty("DepthChoice", m_depth_choice,"choice of depth paramaterisation" );
 }
 
 CaloDepthTool::~CaloDepthTool()

Calorimeter/CaloRec/python/CaloBCIDAvgAlgSCConfig.py

+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+
+# File: CaloRec/python/CaloBCIDAvgAlgSCConfig.py
+# Purpose: Configure CaloBCIDAvgAlgSC.
+
+from __future__ import print_function
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+
+def CaloBCIDAvgAlgSCCfg (flags, sequence=None):
+    result = ComponentAccumulator()
+
+    from CaloRec.CaloBCIDLumiCondAlgSCConfig import CaloBCIDLumiCondAlgSCCfg
+    result.merge (CaloBCIDLumiCondAlgSCCfg (flags))
+    result.addEventAlgo(CompFactory.CaloBCIDAvgAlg(
+        name="CaloBCIDAvgAlgSC",
+        IsSuperCell=True,
+        BCIDLumiKey="CaloBCIDLumiSC",
+        WriteKey="CaloBCIDAverageSC"), sequenceName=sequence)
+    return result

Calorimeter/CaloRec/python/CaloBCIDCoeffsCondAlgSCConfig.py

+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+
+# File: CaloRec/python/CaloBCIDCoeffsCondAlgSCConfig.py
+# Purpose: Configure CaloBCIDCoeffsCondAlgSC.
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+def CaloBCIDCoeffsCondAlgSCCfg (flags,  name = 'CaloBCIDCoeffsCondAlgSC', **kwargs):
+    acc = ComponentAccumulator()
+
+    if not flags.Input.isMC:
+        #Data case
+        pass
+    else:
+        #MC case
+        kwargs.setdefault("MCSymKey", '')
+
+        from LArRecUtils.LArRecUtilsConfig import LArOFCSCCondAlgCfg
+        acc.merge(LArOFCSCCondAlgCfg(flags))
+        kwargs.setdefault("OFCKey", 'LArOFCSC')
+
+        requiredConditions=["PileupAverageSC","ShapeSC"]
+        from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBMCSCCfg
+        acc.merge(LArElecCalibDBMCSCCfg(flags,requiredConditions))
+        #conddb.addFolder("LAR_OFL","/LAR/ElecCalibMCSC/LArPileupAverage<tag>LARElecCalibMCSCLArPileupAverage-IOVDEP-00</tag>",className="CondAttrListCollection"
+        kwargs.setdefault("MinBiasAvgKey", "LArPileupAverageSC")
+        kwargs.setdefault("ShapeKey", "LArShapeSC")
+
+        kwargs.setdefault("OutputCoeffsKey", 'CaloBCIDCoeffsSC')
+
+        kwargs.setdefault("IsSuperCell", True)
+
+        acc.addCondAlgo (CompFactory.CaloBCIDCoeffsCondAlg(name, **kwargs))
+
+    return acc

Calorimeter/CaloRec/python/CaloBCIDLumiCondAlgSCConfig.py

+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+
+# File: CaloRec/python/CaloBCIDLumiCondAlgSCConfig.py
+# Purpose: Configure CaloBCIDLumiCondAlgSC.
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+
+
+def CaloBCIDLumiCondAlgSCCfg (flags):
+    result = ComponentAccumulator()
+
+    from CaloRec.CaloBCIDCoeffsCondAlgSCConfig import CaloBCIDCoeffsCondAlgSCCfg
+    result.merge (CaloBCIDCoeffsCondAlgSCCfg (flags))
+
+    if not flags.Input.isMC:
+        from LumiBlockComps.LuminosityCondAlgConfig import LuminosityCondAlgCfg
+        result.merge (LuminosityCondAlgCfg (flags))
+
+    else:
+        from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg
+        result.merge (BunchCrossingCondAlgCfg(flags))
+
+
+    CaloBCIDLumiCondAlg = CompFactory.CaloBCIDLumiCondAlg # CaloRec
+    alg = CaloBCIDLumiCondAlg ('CaloBCIDLumiCondAlgSC',
+                               CoeffsKey = 'CaloBCIDCoeffsSC',
+                               BunchCrossingCondDataKey = 'BunchCrossingData',
+                               LuminosityCondDataKey = 'LuminosityCondData',
+                               isMC = flags.Input.isMC,
+                               OutputLumiKey = 'CaloBCIDLumiSC')
+    result.addCondAlgo (alg)
+
+    return result

Calorimeter/CaloRec/python/CaloRecoConfig.py

@@ -39,6 +39,13 @@ def CaloRecoCfg(configFlags, clustersname=None,doLCCalib=None):
     from CaloRec.CaloFwdTopoTowerConfig import CaloFwdTopoTowerCfg
     result.merge(CaloFwdTopoTowerCfg(configFlags,CaloTopoClusterContainerKey="CaloTopoClusters"))
 
+    #Configure NoisyROSummary
+    from LArCellRec.LArNoisyROSummaryConfig import LArNoisyROSummaryCfg
+    result.merge(LArNoisyROSummaryCfg(configFlags))
+
+    from LArROD.LArFebErrorSummaryMakerConfig import LArFebErrorSummaryMakerCfg
+    result.merge(LArFebErrorSummaryMakerCfg(configFlags))
+
 
     return result
 

Calorimeter/CaloTrackingGeometry/CaloTrackingGeometry/CaloSurfaceBuilder.h

@@ -26,6 +26,7 @@
 #include "CaloIdentifier/CaloCell_ID.h"
 #include "CaloGeoHelpers/CaloPhiRange.h"
 #include "CaloDetDescr/CaloSubdetNames.h"
+#include "CaloDetDescr/CaloDepthTool.h"
 
 #include <mutex>
 #include <vector>
@@ -33,7 +34,6 @@
 class CaloDetDescrManager;
 class ICaloCoordinateTool;
 class IMessageSvc;
-class CaloDepthTool;
 class ICaloRecoMaterialTool;
 class ICaloRecoSimpleGeomTool;
 class ICaloSurfaceHelper;
@@ -162,9 +162,11 @@ private:
   ToolHandle<ICaloRecoMaterialTool>             m_lar_mat;
   ToolHandle<ICaloRecoSimpleGeomTool>           m_lar_simplegeom;
 
-  // Defines the depths for DD and User surfaces : 
-  ToolHandle<CaloDepthTool>                     m_calodepth;
- 
+  // Defines the depths for DD and User surfaces :
+  ToolHandle<CaloDepthTool> m_calodepth{ this,
+                                         "CaloDepthTool",
+                                         "CaloDepthTool/CaloDepthTool",
+                                         "CaloDepthTool to be used" };
 };
 
 inline std::vector<std::pair<const Trk::Surface*,const Trk::Surface*> > CaloSurfaceBuilder::entrySurfaces() const

Calorimeter/CaloTrackingGeometry/src/CaloSurfaceBuilder.cxx

@@ -38,7 +38,6 @@
 #include "CaloDetDescr/CaloDetDescriptor.h"
 #include "CaloDetDescr/CaloDetDescrElement.h"
 #include "CaloDetDescr/ICaloCoordinateTool.h"
-#include "CaloDetDescr/CaloDepthTool.h"
 #include "CaloDetDescr/ICaloRecoMaterialTool.h"
 #include "CaloDetDescr/ICaloRecoSimpleGeomTool.h"
 
@@ -65,14 +64,11 @@ CaloSurfaceBuilder::CaloSurfaceBuilder(const std::string& type,
   m_calo_dd(nullptr),
   m_tile_dd(nullptr),
   m_lar_mat("LArRecoMaterialTool"),
-  m_lar_simplegeom("LArRecoSimpleGeomTool"),
-  m_calodepth("CaloDepthTool")
+  m_lar_simplegeom("LArRecoSimpleGeomTool")
 {
   declareInterface<ICaloSurfaceBuilder>( this );
   declareProperty ("LArRecoMaterialTool",       m_lar_mat);
   declareProperty ("LarRecoSimpleGeometryTool", m_lar_simplegeom);
-  declareProperty ("CaloDepthTool",             m_calodepth);
-
 }
 
 CaloSurfaceBuilder::~CaloSurfaceBuilder()

Control/AthCUDA/AthCUDAKernel/CMakeLists.txt

@@ -12,6 +12,10 @@ atlas_add_library( AthCUDAKernelLib
 set_target_properties( AthCUDAKernelLib PROPERTIES
    POSITION_INDEPENDENT_CODE ON )
 
+# Disable faulty "declared but never used" warnings for the template code.
+target_compile_options( AthCUDAKernelLib PUBLIC
+   $<$<COMPILE_LANGUAGE:CUDA>:-Xcudafe --diag_suppress=177> )
+
 # Test(s) in the package.
 atlas_add_test( ArrayKernelTask
    SOURCES test/test_ArrayKernelTask.cu

Control/AthenaConfiguration/python/AccumulatorCache.py

@@ -6,9 +6,11 @@ from AthenaCommon.Logging import logging
 _msg = logging.getLogger('AccumulatorCache')
 
 import functools
+import time
 from copy import deepcopy
-
 from collections.abc import Hashable
+from collections import defaultdict
+from dataclasses import dataclass
 
 class AccumulatorDecorator:
     """Class for use in function decorators, implements memoization.
@@ -24,6 +26,15 @@ class AccumulatorDecorator:
     VERIFY_NOTHING = 0
     VERIFY_HASH = 1
 
+    @dataclass
+    class CacheStats:
+        hits  : int = 0
+        misses: int = 0
+        t_hits: float = 0
+        t_misses: float = 0
+
+    _stats = defaultdict(CacheStats)
+
     def __init__(self , func , size , verify , deepCopy): 
         """The constructor is typically called in a function returning a decorator.
 
@@ -44,17 +55,35 @@ class AccumulatorDecorator:
         self._func = func
         self._cache = {}
         self._resultCache = {}
-        self._hits = 0
-        self._misses = 0
         self._verify = verify
         self._deepcopy = deepCopy
 
-    def __str__(self):
-        return "|cache size : " + str(len(self._cache)) + " , misses : " + str(self._misses) + " , hits : " + str(self._hits) + " , function : " + str(self._func.__name__) + "|"
+        if self._verify not in [self.VERIFY_NOTHING, self.VERIFY_HASH]:
+            raise RuntimeError(f"Invalid value for verify ({verify}) in AccumulatorCache for {func}")
 
     def getInfo(self):
-        """Rerurn a dictionary with information about the cache size and cache usage"""
-        return {"cache_size" : len(self._cache) , "misses" : self._misses , "hits" : self._hits , "function" : self._func , "result_cache_size" : len(self._resultCache)}
+        """Return a dictionary with information about the cache size and cache usage"""
+        return {"cache_size" : len(self._cache),
+                "misses" : self._stats[self._func].misses,
+                "hits" : self._stats[self._func].hits,
+                "function" : self._func,
+                "result_cache_size" : len(self._resultCache)}
+
+    @classmethod
+    def printStats(cls):
+        """Print cache statistics"""
+        header = "%-70s |    Hits (time) |  Misses (time) |" % "AccumulatorCache"
+        print("-"*len(header))
+        print(header)
+        print("-"*len(header))
+        # Print sorted by hit+miss time:
+        for func, stats in sorted(cls._stats.items(), key=lambda s:s[1].t_hits+s[1].t_misses, reverse=True):
+            name = f"{func.__module__}.{func.__name__}"
+            if len(name) > 70:
+                name = '...' + name[-67:]
+            print(f"{name:70} | {stats.hits:6} ({stats.t_hits:4.1f}s) | "
+                  f"{stats.misses:6} ({stats.t_misses:4.1f}s) |")
+        print("-"*len(header))
 
     @classmethod
     def suspendCaching(cls):
@@ -81,6 +110,24 @@ class AccumulatorDecorator:
         return None
 
     def __call__(self , *args , **kwargs):
+        try:
+            t0 = time.perf_counter()
+            res, cacheHit = self._callImpl(*args, **kwargs)
+            return res
+        finally:
+            t1 = time.perf_counter()
+            if cacheHit is True:
+                self._stats[self._func].hits += 1
+                self._stats[self._func].t_hits += (t1-t0)
+            elif cacheHit is False:
+                self._stats[self._func].misses += 1
+                self._stats[self._func].t_misses += (t1-t0)
+
+    def _callImpl(self , *args , **kwargs):
+        """Implementation of __call__.
+
+        Returns: (result, cacheHit)
+        """
         if(AccumulatorDecorator._memoize):
             hashable_args = True
             for a in args:
@@ -99,7 +146,7 @@ class AccumulatorDecorator:
 
                 if(hsh in self._cache):
                     res = self._cache[hsh]
-
+                    cacheHit = None
                     if(AccumulatorDecorator.VERIFY_HASH == self._verify):
                         resHsh = self._resultCache[hsh]
                         chkHsh = None
@@ -113,28 +160,22 @@ class AccumulatorDecorator:
                                 _msg.debug("Hash of function result, cached using AccumulatorDecorator, not available for verification.")
                         if((chkHsh is None) or (resHsh is None) or resHsh != chkHsh): 
                             # at least one hash is not available (None) so no verification can be performed 
-                            # or
-                            # hashes are different
-                            self._misses += 1
+                            # or hashes are different
+                            cacheHit = False
                             res = self._func(*args , **kwargs)
                             self._cache[hsh] = res
                             self._resultCache[hsh] = None
                             if(AccumulatorDecorator._hasHash(res)):
                                 self._resultCache[hsh] = AccumulatorDecorator._getHash(res)
                         else:
-                            self._hits += 1
-                    elif(AccumulatorDecorator.VERIFY_NOTHING == self._verify):
-                        self._hits += 1
+                            cacheHit = True
                     else:
-                        _msg.debug("Incorrect value of verify in AccumulatorDecorator, assuming AccumulatorDecorator.VERIFY_NOTHING.")
-                        self._hits += 1
+                        cacheHit = True
+
+                    return (deepcopy(res) if self._deepcopy else res, cacheHit)
 
-                    if(self._deepcopy):
-                        return deepcopy(res)
-                    else:
-                        return res
                 else:
-                    self._misses += 1
+                    _msg.debug('Hash not found in AccumulatorCache for function %s' , self._func)
                     if(len(self._cache) >= self._maxSize):
                         del self._cache[next(iter(self._cache))]
 
@@ -147,23 +188,19 @@ class AccumulatorDecorator:
                         if(AccumulatorDecorator._hasHash(res)):
                             self._resultCache[hsh] = AccumulatorDecorator._getHash(res)
                         self._cache[hsh] = res
-                    elif(AccumulatorDecorator.VERIFY_NOTHING == self._verify):
-                        self._cache[hsh] = res
                     else:
-                        _msg.debug("Incorrect value of verify in AccumulatorDecorator, assuming AccumulatorDecorator.VERIFY_NOTHING.")
                         self._cache[hsh] = res
 
-                    if(self._deepcopy):
-                        return deepcopy(res)
-                    else:
-                        return res
+                    return (deepcopy(res) if self._deepcopy else res, False)
             else:
-                self._misses += 1 
-                return self._func(*args , **kwargs)
+                _msg.debug('Could not calculate hash of arguments for function %s in AccumulatorCache.' , self._func)
+                return (self._func(*args , **kwargs), False)
         else:
-            return self._func(*args , **kwargs)
+            return (self._func(*args , **kwargs), None)
+
 
-def AccumulatorCache(func = None , maxSize = 128 , verifyResult = AccumulatorDecorator.VERIFY_NOTHING , deepCopy = True): 
+def AccumulatorCache(func = None, maxSize = 128,
+                     verifyResult = AccumulatorDecorator.VERIFY_NOTHING, deepCopy = True):
     """Function decorator, implements memoization.
 
     Keyword arguments:
@@ -180,10 +217,7 @@ def AccumulatorCache(func = None , maxSize = 128 , verifyResult = AccumulatorDec
         An instance of AccumulatorDecorator.
     """
 
-    def newWrapper(funct):
-        return AccumulatorDecorator(funct , maxSize , verifyResult , deepCopy)
+    def wrapper_accumulator(func):
+        return AccumulatorDecorator(func, maxSize, verifyResult, deepCopy)
 
-    if(func):
-        return newWrapper(func)
-    else:
-        return newWrapper
+    return wrapper_accumulator(func) if func else wrapper_accumulator

Control/AthenaConfiguration/python/testAccumulatorCache.py

@@ -40,6 +40,8 @@ class TestCache(unittest.TestCase):
         self.assertEqual(returnSame.__name__ , "returnSame")
         self.assertEqual(returnSame.__doc__ , "returns the same number")
 
+        AccumulatorDecorator.printStats()
+
         @AccumulatorCache(verifyResult = AccumulatorDecorator.VERIFY_NOTHING , deepCopy = False)
         def fac(x):
             return hashwrapper(1 if x.x == 0 else x.x * fac(hashwrapper(x.x - 1)).x)
@@ -291,24 +293,6 @@ class TestCache(unittest.TestCase):
         self.assertEqual(info["misses"] , 3)
         self.assertEqual(info["cache_size"] , 0)
 
-    def runTest(self):
-        print("... basic tests, simple caching and introspection ...")
-        self.test_basic()
-        print("... testing cache limit ...")
-        self.test_cache_limit()
-        print("... testing if cached results were modified ...")
-        self.test_validation()
-        print("... testing suspend ...")
-        self.test_suspend()
-        print("... testing verify copy ...")
-        self.test_verify_copy()
-        print("... testing verify default ...")
-        self.test_verify_default()
-
-
-
-if(__name__ == '__main__'):
-    suite = unittest.TestSuite()
-    suite.addTest(TestCache())
-    runner = unittest.TextTestRunner(failfast = False)
-    runner.run(suite)
+
+if __name__ == '__main__':
+    unittest.main()

Control/AthenaExamples/AthAsgExUnittest/test/gt_MockxAODJet.cxx

@@ -68,7 +68,7 @@ namespace Athena_test {
 
   TEST_F( MockxAODJetTest, jetgetAttribute ) {
     EXPECT_CALL( mockjet, getAttributeFloat( "test", _ ) )
-      .WillOnce( DoAll( SetArgReferee<1>( 42 ), Return(true) ) );
+      .WillOnce( testing::DoAll( SetArgReferee<1>( 42 ), Return(true) ) );
     float value;
     EXPECT_TRUE( jet->getAttribute<float>( "test", value ) );
     EXPECT_EQ( 42, value );

Control/AthenaMonitoring/python/BadLBFilterTool.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
-from PyUtils.Decorators import memoize
-from functools import reduce
+from functools import reduce, cache
 
 def _resolve_db_tag(origDbTag):
     from AthenaCommon.GlobalFlags  import globalflags
@@ -32,7 +31,7 @@ def _InstanceFromProjectName():
 
 # Set up the bad lb filter conditions algorithm
 # Cache instance once already created
-@memoize
+@cache
 def GetBadLBFilterAlg(name, defects, writekey, ignoreRecoverable=False, origDbTag=None):
     """
     Configure an instance of the bad LB filter conditions algorithm. Not intended to be called directly by users.
@@ -119,7 +118,7 @@ def GetBadLBFilterTool(name, defects, alwaysReturnTrue=False, ignoreRecoverable=
 
     return monFilterTool
 
-@memoize
+@cache
 def LArBadDefectList(origDbTag=None):
     """
     Get the defects to configure for LAr - cache results to avoid lots of DB lookups

Control/AthenaMonitoring/python/BadLBFilterToolConfig.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 from AthenaConfiguration.ComponentFactory import CompFactory
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
 from AthenaConfiguration.AccumulatorCache import AccumulatorCache
@@ -74,7 +74,6 @@ def BadLBFilterToolCfg(inputFlags,name, defects, alwaysReturnTrue=False, ignoreR
     return result
 
 
-#@memoize - hash function on flags is deprecated, use AccumulatorCache instead
 @AccumulatorCache
 def LArDefectList(inputFlags,origDbTag=None):
     """

Control/AthenaMonitoring/python/EventFlagFilterTool.py

-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
-from PyUtils.Decorators import memoize
+from functools import cache
 
 # Set up the event cleaning filter tool
 # Cache instances that are already created
-@memoize
+@cache
 def GetEventFlagFilterTool(name, doLAr=True, doTile=True, doSCT=True, doCore=True, alwaysReturnTrue=False):
     """
     Configure an instance of the bad LB filter tool.  If called twice with the same options, will return the same instance.

Control/AthenaPython/python/Bindings.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 # @file: AthenaPython/python/Bindings.py
 # @author: Sebastien Binet <binet@cern.ch>
 
-from __future__ import print_function
-
 ### data
 __author__  = """
 Sebastien Binet (binet@cern.ch)
 """
 
 ### imports
-from PyUtils.Decorators import memoize
+from functools import cache
 from AthenaCommon.Logging import logging
 
-@memoize
+@cache
 def _load_dict(lib):
     """Helper function to remember which libraries have been already loaded
     """
@@ -23,7 +21,7 @@ def _load_dict(lib):
         lib="lib"+lib
     return cppyy.load_library(lib)
 
-@memoize
+@cache
 def _import_ROOT():
     import ROOT
     ROOT.gROOT.SetBatch(True)
@@ -79,7 +77,7 @@ class _PyAthenaBindingsCatalog(object):
         return
 
     @staticmethod
-    @memoize
+    @cache
     def init(name):
         """Initialize the python binding with the callback previously registered
         If no callback was registered, swallow the warning...
@@ -100,7 +98,7 @@ class _PyAthenaBindingsCatalog(object):
         return klass
 
 ### helper method to easily retrieve services by name -------------------------
-@memoize
+@cache
 def py_svc(svcName, createIf=True, iface=None):
     """
     Helper function to retrieve a service by name, using Gaudi python bindings.
@@ -141,7 +139,7 @@ def py_svc(svcName, createIf=True, iface=None):
     return svc
 
 ### helper method to easily retrieve tools from ToolSvc by name ---------------
-@memoize
+@cache
 def py_tool(toolName, createIf=True, iface=None):
     """
     Helper function to retrieve a tool (owned by the ToolSvc) by name, using
@@ -193,7 +191,6 @@ def py_tool(toolName, createIf=True, iface=None):
     return tool
 
 ### helper method to easily retrieve algorithms by name -----------------------
-# @c memoize # don't memoize ?
 def py_alg(algName, iface='IAlgorithm'):
     """
     Helper function to retrieve an IAlgorithm (managed by the IAlgManager_) by
@@ -238,7 +235,7 @@ def py_alg(algName, iface='IAlgorithm'):
     return alg
 
 ### pythonizations for StoreGateSvc
-@memoize
+@cache
 def _py_init_StoreGateSvc():
     ## most probably, user will want to interact with PyRoot objects
     ## => install the fixes for our user
@@ -251,7 +248,7 @@ def _py_init_StoreGateSvc():
     return StoreGateSvc
 
 ### pythonizations for IIncidentSvc
-@memoize
+@cache
 def _py_init_IIncidentSvc():
     import cppyy
     # IIncidentSvc bindings from dictionary
@@ -283,7 +280,7 @@ def _py_init_IIncidentSvc():
     return IIncidentSvc
         
 ### pythonizations for ClassIDSvc
-@memoize
+@cache
 def _py_init_ClassIDSvc():
     import cppyy
     # IClassIDSvc bindings from dictionary
@@ -304,7 +301,7 @@ def _py_init_ClassIDSvc():
     IClassIDSvc._clidgen = clidGenerator(db=None)
 
     # add pythonized methods
-    @memoize
+    @cache
     def _clid (self, name):
         # handle special cases where CLID has been registered with a typedef
         try:   name = _clid_typename_aliases[name]
@@ -316,7 +313,7 @@ def _py_init_ClassIDSvc():
     IClassIDSvc.clid = _clid
     del _clid
     
-    @memoize
+    @cache
     def _typename (self, clid):
         # handle special cases of missing clids
         try:
@@ -330,7 +327,7 @@ def _py_init_ClassIDSvc():
     return IClassIDSvc
 
 ### pythonizations for ITHistSvc
-@memoize
+@cache
 def _py_init_THistSvc():
     import cppyy
     # ITHistSvc bindings from dictionary
@@ -588,7 +585,7 @@ del %s""" % (n,n,n,n,n)
     return ITHistSvc
 
 ### pythonizations for EventStreamInfo
-@memoize
+@cache
 def _py_init_EventStreamInfo():
     import cppyy
     # EventStreamInfo bindings from dictionary
@@ -620,7 +617,7 @@ def _py_init_EventStreamInfo():
     return ESI
 
 ### pythonizations for EventType
-@memoize
+@cache
 def _py_init_EventType():
     import cppyy
     # EventStreamInfo bindings from dictionary
@@ -652,27 +649,27 @@ def _py_init_EventType():
     return cls
 
 ### pythonizations for DataLink
-@memoize
+@cache
 def _py_init_DataLink():
     return _gen_data_link
 
 ### pythonizations for ElementLink
-@memoize
+@cache
 def _py_init_ElementLink():
     return _gen_element_link
 
 ### pythonizations for ElementLinkVector
-@memoize
+@cache
 def _py_init_ElementLinkVector():
     return _gen_elv
 
 ### pythonizations for NavigationToken
-@memoize
+@cache
 def _py_init_NavigationToken():
     return _gen_navtok
 
 ### helper method to easily instantiate DataLink ------------------------------
-@memoize
+@cache
 def _gen_data_link(klass, storage_policy=None):
     """helper method to easily instantiate a DataLink class.
     Sensible default for the storage policy is chosen if none given (it usually
@@ -691,7 +688,7 @@ def _gen_data_link(klass, storage_policy=None):
     return ROOT.DataLink(klass, storage_policy)
 
 ### helper method to easily instantiate ElementLink ---------------------------
-@memoize
+@cache
 def _gen_element_link(klass, storage_policy=None, indexing_policy=None):
     """helper method to easily instantiate an ElementLink class.
     Sensible defaults for the storage and indexing policies are chosen if none
@@ -714,7 +711,7 @@ def _gen_element_link(klass, storage_policy=None, indexing_policy=None):
     return ROOT.ElementLink(klass)
 
 ### helper method to easily instantiate ElementLinkVector ---------------------
-@memoize
+@cache
 def _gen_elv(klass, storage_policy=None, indexing_policy=None):
     """helper method to easily instantiate an ElementLinkVector class.
     Sensible defaults for the storage and indexing policies are chosen if none
@@ -734,7 +731,7 @@ def _gen_elv(klass, storage_policy=None, indexing_policy=None):
     return ROOT.ElementLinkVector(klass, storage_policy, indexing_policy)
 
 ### helper method to easily instantiate NavigationToken -----------------------
-@memoize
+@cache
 def _gen_navtok(klass, weight_cls=None, hash_cls=None):
     """helper method to easily instantiate a NavigationToken class.
     Sensible default for the weight and hash parameters are chosen if none are

Control/IOVSvc/CMakeLists.txt

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 # Declare the package name:
 atlas_subdir( IOVSvc )
@@ -14,7 +14,7 @@ atlas_add_library( IOVSvcLib
                    INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
                    PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
                    LINK_LIBRARIES AthenaBaseComps AthenaKernel GaudiKernel SGTools
-                   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} PersistentDataModel StoreGateLib xAODEventInfo )
+                   PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} PersistentDataModel StoreGateLib xAODEventInfo RootUtils )
 
 atlas_add_component( IOVSvc
                      src/components/*.cxx

Control/IOVSvc/src/CondInputLoader.cxx

@@ -21,12 +21,15 @@
 #include "AthenaKernel/IIOVSvc.h"
 #include "StoreGate/CondHandleKey.h"
 #include "AthenaKernel/CondContMaker.h"
+#include "AthenaKernel/ITPCnvBase.h"
+#include "RootUtils/WithRootErrorHandler.h"
 
 #include "xAODEventInfo/EventInfo.h"
 #include "AthenaKernel/BaseInfo.h"
 #include "ICondSvcSetupDone.h"
 
 #include "TClass.h"
+#include "boost/algorithm/string/predicate.hpp"
 
 
 namespace
@@ -89,6 +92,7 @@ CondInputLoader::initialize()
   ATH_CHECK( m_clidSvc.retrieve() );
   ATH_CHECK( m_rcuSvc.retrieve() );
   ATH_CHECK( m_dictLoader.retrieve() );
+  ATH_CHECK( m_tpCnvSvc.retrieve() );
 
   // Trigger read of IOV database
   ServiceHandle<IIOVSvc> ivs("IOVSvc",name());
@@ -127,7 +131,22 @@ CondInputLoader::initialize()
         // Loading root dictionaries in a multithreaded environment
         // is unreliable.
         // So try to be sure all dictionaries are loaded now.
-        m_dictLoader->load_type (id.clid());
+        RootType rt = loadDict (id.clid());
+
+        // Special case for LArConditionsSubset classes.
+        if (rt.Class()) {
+          size_t nbases = rt.BaseSize();
+          std::string pat = "LArConditionsContainer<";
+          for (size_t ibase = 0;  ibase < nbases; ++ibase) {
+            std::string basename = rt.BaseAt(ibase).Name();
+            if (boost::starts_with (basename, pat)) {
+              std::string subset = "LArConditionsSubset<" + basename.substr (pat.size(), std::string::npos);
+              loadDict (subset);
+              loadDict ("LArConditionsSubset_p1");
+            }
+          }
+        }
+
 	break; //quit loop over m_load
       } // end if CondInputLoader deals with this folder
     }//end loop over m_load
@@ -162,7 +181,7 @@ CondInputLoader::initialize()
                                StoreID::storeName(StoreID::CONDITION_STORE));
           m_load.value().emplace(vhk.fullKey());
           // Again, make sure all needed dictionaries are loaded.
-          m_dictLoader->load_type (clid2);
+          m_dictLoader->load_type (clid2, true);
         }
       }
     }
@@ -372,3 +391,30 @@ CondInputLoader::extraDeps_update_handler( Gaudi::Details::PropertyBase& /*Extra
 {  
   // do nothing
 }
+
+//-----------------------------------------------------------------------------
+
+RootType CondInputLoader::loadDict (const std::string& name)
+{
+  // First try to load the persistent class dictionary.
+  std::unique_ptr<ITPCnvBase> tpcnv = m_tpCnvSvc->t2p_cnv_unique (name);
+  if (tpcnv) {
+    RootType rtp = m_dictLoader->load_type (tpcnv->persistentTInfo());
+    if (rtp.Class()) {
+      return rtp;
+    }
+  }
+
+  // Otherwise try to load the dictionary for the class itself.
+  return m_dictLoader->load_type (name);
+}
+
+
+RootType CondInputLoader::loadDict (CLID clid)
+{
+  std::string name;
+  if (m_clidSvc->getTypeNameOfID (clid, name).isSuccess()) {
+    return loadDict (name);
+  }
+  return RootType();
+}

Control/IOVSvc/src/CondInputLoader.h

@@ -17,6 +17,7 @@
 #include "AthenaKernel/IIOVSvc.h"
 #include "AthenaKernel/IIOVDbSvc.h"
 #include "AthenaKernel/IDictLoaderSvc.h"
+#include "AthenaKernel/ITPCnvSvc.h"
 #include "StoreGate/StoreGateSvc.h"
 #include "AthenaBaseComps/AthAlgorithm.h"
 #include "PersistentDataModel/AthenaAttributeList.h"
@@ -47,6 +48,9 @@ class CondInputLoader
   // from AthAlgorithm
   void extraDeps_update_handler(Gaudi::Details::PropertyBase&);
 
+  RootType loadDict (CLID clid);
+  RootType loadDict (const std::string& name);
+
   /// Containers
   Gaudi::Property<DataObjIDColl> m_load{this,"Load",{},
                                         "List of objects to be loaded","OrderedSet<std::vector<std::string> >"};
@@ -69,6 +73,8 @@ class CondInputLoader
   ServiceHandle<Athena::IRCUSvc> m_rcuSvc;
   ServiceHandle<IDictLoaderSvc> m_dictLoader
     { this, "DictLoaderSvc", "AthDictLoaderSvc", "" };
+   ServiceHandle<ITPCnvSvc>      m_tpCnvSvc
+    { this, "TPCnvSvc", "AthTPCnvSvc", "" };
   
   std::map<std::string,std::string> m_keyFolderMap;
 }; 

Control/PerformanceMonitoring/PerfMonComps/python/PyPerfMon.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
 # @file: PyPerfMon.py
 # @author: Sebastien Binet <binet@cern.ch>
@@ -9,18 +9,15 @@ __doc__     = """python module holding a python service to monitor athena perfor
 """
 
 import os,sys
+from functools import cache
 
 import AthenaCommon.Logging as L
-
-_perfMonStates = ('ini','evt','fin')
-
 from PerfMonComps.PyMonUtils import Units, pymon
+from PyUtils.Decorators import forking
 
-from PyUtils.Decorators import memoize, forking
-
-import six
+_perfMonStates = ('ini','evt','fin')
 
-@memoize
+@cache
 def _import_ROOT():
     # FIXME: work-around ROOT's silly behaviour wrt graphics libraries
     # see: https://savannah.cern.ch/bugs/?35461
@@ -430,7 +427,7 @@ class Svc(object):
         ## write out meta-data
         import PyUtils.dbsqlite as dbs
         meta = dbs.open(headerFile, 'n')
-        for k,v in six.iteritems (self.meta):
+        for k,v in self.meta.items():
             meta[k] = v
         meta['version_id'] = '0.4.0' # stream-format + header file
         meta['pmon_tuple_files'] = map( os.path.basename, outFiles[1:] )