AtlasTest/CITest/Athena.cmake

@@ -149,35 +149,35 @@ atlas_add_citest( RecoRun4MC_DAODPHYS
 #################################################################################
 
 atlas_add_citest( CPAlgorithmsRun2MC_PHYS
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type mc --no-physlite-broken --force-input ../DerivationRun2MC_PHYS/run_mc_PHYS_Run2/DAOD_PHYS.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type mc --input-file ../DerivationRun2MC_PHYS/run_mc_PHYS_Run2/DAOD_PHYS.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun2MC_PHYS )
 
 atlas_add_citest( CPAlgorithmsRun2MC_PHYSLITE
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type mc --physlite --no-physlite-broken --force-input ../DerivationRun2MC_PHYSLITE/run_mc_PHYSLITE_Run2/DAOD_PHYSLITE.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type mc --physlite --input-file ../DerivationRun2MC_PHYSLITE/run_mc_PHYSLITE_Run2/DAOD_PHYSLITE.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun2MC_PHYSLITE )
 
 atlas_add_citest( CPAlgorithmsRun2Data_PHYS
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type data --no-physlite-broken --force-input ../DerivationRun2Data_PHYS/run_data_PHYS_Run2/DAOD_PHYS.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type data --input-file ../DerivationRun2Data_PHYS/run_data_PHYS_Run2/DAOD_PHYS.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun2Data_PHYS )
 
 atlas_add_citest( CPAlgorithmsRun2Data_PHYSLITE
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type data --physlite --no-physlite-broken --force-input ../DerivationRun2Data_PHYSLITE/run_data_PHYSLITE_Run2/DAOD_PHYSLITE.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type data --physlite --input-file ../DerivationRun2Data_PHYSLITE/run_data_PHYSLITE_Run2/DAOD_PHYSLITE.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun2Data_PHYSLITE )
 
 atlas_add_citest( CPAlgorithmsRun3MC_PHYS
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type mc --no-physlite-broken --force-input ../DerivationRun3MC_PHYS/run_mc_PHYS_Run3/DAOD_PHYS.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type mc --input-file ../DerivationRun3MC_PHYS/run_mc_PHYS_Run3/DAOD_PHYS.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun3MC_PHYS )
 
 atlas_add_citest( CPAlgorithmsRun3MC_PHYSLITE
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type mc --physlite --no-physlite-broken --force-input ../DerivationRun3MC_PHYSLITE/run_mc_PHYSLITE_Run3/DAOD_PHYSLITE.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type mc --physlite --input-file ../DerivationRun3MC_PHYSLITE/run_mc_PHYSLITE_Run3/DAOD_PHYSLITE.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun3MC_PHYSLITE )
 
 atlas_add_citest( CPAlgorithmsRun3Data_PHYS
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type data --no-physlite-broken --force-input ../DerivationRun3Data_PHYS/run_data_PHYS_Run3/DAOD_PHYS.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type data --input-file ../DerivationRun3Data_PHYS/run_data_PHYS_Run3/DAOD_PHYS.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun3Data_PHYS )
 
 atlas_add_citest( CPAlgorithmsRun3Data_PHYSLITE
-   SCRIPT athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py - --block-config --data-type data --physlite --no-physlite-broken --force-input ../DerivationRun3Data_PHYSLITE/run_data_PHYSLITE_Run3/DAOD_PHYSLITE.myOutput.pool.root
+   SCRIPT FullCPAlgorithmsTest_CA.py --block-config --data-type data --physlite --input-file ../DerivationRun3Data_PHYSLITE/run_data_PHYSLITE_Run3/DAOD_PHYSLITE.myOutput.pool.root
    DEPENDS_SUCCESS DerivationRun3Data_PHYSLITE )
 
 

Calorimeter/CaloCondPhysAlgs/python/CaloScaleNoiseConfig.py

@@ -105,6 +105,8 @@ if __name__=="__main__":
     flags.Input.TimeStamps=[TimeStamp]
     flags.Input.Files=[]
     flags.IOVDb.DatabaseInstance="CONDBR2"
+    from AthenaConfiguration.TestDefaults import defaultGeometryTags
+    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN3
   
     if args.globaltag:
         flags.IOVDb.GlobalTag=args.globaltag

Calorimeter/CaloCondPhysAlgs/share/CaloNoise2Ntuple_MC.py

@@ -110,6 +110,10 @@ if not hasattr(ServiceMgr, 'THistSvc'):
 
 ServiceMgr.THistSvc.Output  = ["file1 DATAFILE='"+outputNtuple+"' OPT='RECREATE'"]
 
+from AthenaCommon.AlgSequence import AthSequencer
+condSequence = AthSequencer("AthCondSeq")
+if hasattr(condSequence, 'TileSamplingFractionCondAlg'):
+     condSequence.TileSamplingFractionCondAlg.G4Version = -1
 
 #--------------------------------------------------------------
 # Set output level threshold (1=VERBOSE, 2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )

Control/AthOnnx/AthOnnxComps/src/OnnxRuntimeInferenceTool.h

@@ -48,7 +48,7 @@ namespace AthOnnx {
         ServiceHandle<IOnnxRuntimeSvc> m_onnxRuntimeSvc{"AthOnnx::OnnxRuntimeSvc", "AthOnnx::OnnxRuntimeSvc"};
         ToolHandle<IOnnxRuntimeSessionTool> m_onnxSessionTool{
             this, "ORTSessionTool", 
-            "AthOnnx::OnnxRuntimeInferenceToolCPU"
+            "AthOnnx::OnnxRuntimeSessionToolCPU"
         };        
         std::vector<std::string> m_inputNodeNames;
         std::vector<std::string> m_outputNodeNames;

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/WriteHandle.icc

@@ -278,6 +278,10 @@ StatusCode
 WriteHandle<T>::WriteHandle::record (std::unique_ptr<T> data,
                                      std::unique_ptr<AUXSTORE> auxstore)
 {
+  // If there's no store association, do it now.
+  if (data->getStore() == nullptr)
+    data->setStore (auxstore.get());
+
   m_ptr = data.get();
   if (xAOD::TActiveStore::store()->record (std::move (auxstore), key() + "Aux.").isFailure())
     return StatusCode::FAILURE;

Control/AthToolSupport/AsgTesting/utils/compareFlatTrees.cxx

@@ -389,8 +389,10 @@ int main ATLAS_NOT_THREAD_SAFE(int argc, char *argv[])
     rp->GetLowerRefGraph()->SetMaximum(1.5);
     rp->GetLowYaxis()->SetNdivisions(505);
 
-    c1->SetTicks(0, 1);
-    c1->Update();
+    if (valid) {
+      c1->SetTicks(0, 1);
+      c1->Update();
+    }
 
     if (!fileOpen)
     {

Control/AthenaCommon/python/CFElements.py

@@ -223,26 +223,19 @@ def flatAlgorithmSequences( start ):
     __inner(start, c)
     return OrderedDict(c)
 
-def flatSequencers( start, algsCollection=None ):
-    """ Returns dict of sequences keyed by name and containing list of it's members """
 
-    def __inner( seq, collector ):
-        if compName(seq) not in collector:
-            collector[compName(seq)] = []
+def iterSequences( start ):
+    """Iterator of sequences and their algorithms from (and including) the `start`
+    sequence object. Do start from a sequence name use findSubSequence."""
+    def __inner( seq ):
         for c in getSequenceChildren(seq):
-            isSeq = isSequence(c)
-            if not isSeq and algsCollection is not None and compName(c) in algsCollection:
-                collector[compName(seq)].append( algsCollection[compName(c)] )
-                continue
-            collector[compName(seq)].append( c )
-            if isSeq and compName(c) not in collector:
-                __inner( c, collector )
+            yield c
+            if isSequence(c):
+                yield from __inner(c)
 
+    yield start
+    yield from __inner(start)
 
-    from collections import defaultdict
-    c = defaultdict(list)
-    __inner(start, c)
-    return c
 
 # self test
 import unittest
@@ -288,15 +281,27 @@ class TestCF(object):
         owner = findOwningSequence( self.top, "SomeAlg0")
         self.assertEqual( compName(owner) , "top", "Wrong owner %s" % compName(owner) )
 
-    def test_flatCollectors( self ):
-        flat = flatAlgorithmSequences( self.top )
-        #print "here", flat.keys()
-        expected = [ "top", "nest2" ]
-        self.assertEqual( set( flat.keys() ), set( expected ), "To many or to few sequences in flat structure, present: %s expected: %s "% ( " ".join( flat.keys() ), " ".join( expected ) ) )
+    def test_iterSequences( self ):
+        # Traverse from top
+        result = [seq.getName() for seq in iterSequences( self.top )]
+        self.assertEqual( result, ['top', 'nest1', 'nest2', 'deep_nest1', 'deep_nest2',
+                                   'SomeAlg1', 'SomeAlg2', 'SomeAlg3', 'SomeAlg0'] )
 
-        expected = [ "top", "nest1", "nest2", "deep_nest1", "deep_nest2" ]
-        flat = flatSequencers( self.top )
-        self.assertEqual( set( flat.keys() ), set( expected ), "To many or to few sequences in flat structure, present: %s expected: %s "% ( " ".join( flat.keys() ), " ".join( expected ) ) )
+        # Traverse from nested sequence
+        nest2 = findSubSequence( self.top, "nest2" )
+        result = [seq.getName() for seq in iterSequences( nest2 )]
+        self.assertEqual( result, ['nest2', 'deep_nest1', 'deep_nest2',
+                                   'SomeAlg1', 'SomeAlg2', 'SomeAlg3'] )
+
+        # Traverse empty sequence
+        deep_nest2 = findSubSequence( self.top, "deep_nest2" )
+        result = [seq.getName() for seq in iterSequences( deep_nest2 )]
+        self.assertEqual( result, ['deep_nest2'] )
+
+        # Traverse from algorithm
+        alg1 = findAlgorithm( self.top, "SomeAlg1" )
+        result = [seq.getName() for seq in iterSequences( alg1 )]
+        self.assertEqual( result, ['SomeAlg1'] )
 
     def test_findAlgorithms( self ):
         a1 = findAlgorithm( self.top, "SomeAlg0" )

Control/AthenaConfiguration/python/AllConfigFlags.py

@@ -282,9 +282,9 @@ def initConfigFlags():
 
 #Digitization Flags:
     def __digitization():
-        from Digitization.DigitizationConfigFlags import createDigitizationCfgFlags
+        from DigitizationConfig.DigitizationConfigFlags import createDigitizationCfgFlags
         return createDigitizationCfgFlags()
-    _addFlagsCategory(acf, "Digitization", __digitization, 'Digitization' )
+    _addFlagsCategory(acf, "Digitization", __digitization, 'DigitizationConfig' )
 
 #Overlay Flags:
     def __overlay():

Control/AthenaConfiguration/python/ComponentAccumulator.py

@@ -2,11 +2,12 @@
 # Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
 import GaudiConfig2
+from GaudiKernel.DataHandle import DataHandle
 import GaudiKernel.GaudiHandles as GaudiHandles
 
 from AthenaCommon.Logging import logging
 from AthenaCommon.Debugging import DbgStage
-from AthenaCommon.CFElements import (isSequence, findSubSequence, findAlgorithm, flatSequencers,
+from AthenaCommon.CFElements import (isSequence, findSubSequence, findAlgorithm, iterSequences,
                                      checkSequenceConsistency, findAllAlgorithmsByName, compName)
 
 from AthenaConfiguration.AccumulatorCache import AccumulatorCachable
@@ -16,7 +17,6 @@ from AthenaConfiguration.DebuggingContext import (Context, raiseWithCurrentConte
                                                   createContextForDeduplication)
 
 import atexit
-from collections import OrderedDict
 from collections.abc import Sequence
 import sys
 
@@ -117,7 +117,7 @@ class ComponentAccumulator(AccumulatorCachable):
 
         self._sequence = sequence
         self._allSequences = [self._sequence]
-        self._algorithms = {}            #Flat algorithms list, useful for merging
+        self._algorithms = {}            #Dictionary of algorithm instances keyed by name
         self._conditionsAlgs = []        #Unordered list of conditions algorithms + their private tools
         self._services = []              #List of service, not yet sure if the order matters here in the MT age
         self._servicesToCreate = []
@@ -305,7 +305,7 @@ class ComponentAccumulator(AccumulatorCachable):
                             "comp": comp.getFullJobOptName(),
                             "mode":  "W",
                             "prop": "ExtraOutputs"})
-            from GaudiKernel.DataHandle import DataHandle
+
             for prop, descr in comp._descriptors.items():
                 if isinstance(descr.default, DataHandle):
                     io.append( {"type": descr.default.type(),
@@ -528,11 +528,8 @@ class ComponentAccumulator(AccumulatorCachable):
 
     def getEventAlgos(self, seqName=None):
         """Get all algorithms within sequence"""
-        if seqName is None:
-            seq=self._sequence
-        else:
-            seq = findSubSequence(self._sequence, seqName )
-        return list( OrderedDict.fromkeys( sum( flatSequencers( seq, algsCollection=self._algorithms ).values(), []) ).keys() )
+        seq = self._sequence if seqName is None else findSubSequence(self._sequence, seqName )
+        return [s for s in iterSequences(seq) if not isSequence(s)]
 
     def addCondAlgo(self,algo,primary=False,domain=None):
         """Add Conditions algorithm"""
@@ -1050,18 +1047,17 @@ class ComponentAccumulator(AccumulatorCachable):
                     # Recursively add properties of tools to JobOptionsSvc
                     for v1 in v:
                         getCompsToBeAdded(v1, namePrefix=name + ".")
-                elif (
-                    not isSequence(comp) and k != "Members"
-                ):  # This property is handled separately
+                else:
                     # For a list of DataHandle, we need to stringify
                     # each element individually.  Otherwise, we get the repr
                     # version of the elements, which Gaudi JO will choke on.
-                    from GaudiKernel.DataHandle import DataHandle
                     if isinstance(v, list) and v and isinstance(v[0], DataHandle):
                         v = [str(x) for x in v]
+                    # For sequences, need to convert the list of algs to names
+                    elif isSequence(comp) and k == "Members":
+                        v = [alg.getFullJobOptName() for alg in comp.Members]
                     vstr = "" if v is None else str(v)
                     bshPropsToSet.append((name, k, vstr))
-
        
         try:
             from AthenaPython import PyAthenaComps
@@ -1071,7 +1067,7 @@ class ComponentAccumulator(AccumulatorCachable):
             PyAlg = type(None)
             PySvc = type(None)
 
-        # Services:
+        # Services
         for svc in self._services:
             if svc.getName() != "MessageSvc":  # MessageSvc will exist already! Needs special treatment
                 getCompsToBeAdded(svc)
@@ -1080,22 +1076,13 @@ class ComponentAccumulator(AccumulatorCachable):
             else:
                 mspPropsToSet.update((k,str(v)) for k,v in svc._properties.items())
 
-        #Algorithms
-        for seqName, algoList in flatSequencers(self._sequence, algsCollection=self._algorithms).items():
-            seq = self.getSequence(seqName)
-            for k, v in seq._properties.items():
-                if k != "Members":  # This property is handled separately
-                    vstr = "" if v is None else str(v)
-                    bshPropsToSet.append((seqName, k, vstr))
-            bshPropsToSet.append(
-                (seqName, "Members", str([alg.getFullJobOptName() for alg in algoList]),)
-            )
-            for alg in algoList:
-                getCompsToBeAdded(alg)
-                if isinstance(alg, PyAlg):
-                    alg.setup()
+        # Algorithms and Sequences
+        for alg in iterSequences(self._sequence):
+            getCompsToBeAdded(alg)
+            if isinstance(alg, PyAlg):
+                alg.setup()
 
-        #Cond-Algs
+        # Cond Algs
         condalgseq = []
         for alg in self._conditionsAlgs:
             getCompsToBeAdded(alg)
@@ -1104,11 +1091,11 @@ class ComponentAccumulator(AccumulatorCachable):
                 alg.setup()
         bshPropsToSet.append(("AthCondSeq", "Members", str(condalgseq)))
 
-        #Public Tools:
+        # Public Tools
         for pt in self._publicTools:
             getCompsToBeAdded(pt, namePrefix="ToolSvc.")
 
-        #Auditors:
+        # Auditors
         for aud in self._auditors:
             getCompsToBeAdded(aud)
 

Control/AthenaConfiguration/python/iconfTool/models/loaders.py

@@ -139,7 +139,8 @@ def types_in_properties(comp_name, value, dict_to_update):
             else:
                 logger.debug("What is typeless comp? %s", value)
     if isinstance(value, dict):
-        [ types_in_properties(comp_name, v, dict_to_update) for v in value.values() ]
+        for v in value.values():
+            types_in_properties(comp_name, v, dict_to_update)
 
 
 def collect_types(conf):
@@ -464,8 +465,6 @@ def loadConfigFile(fname, args) -> Dict:
     if conf is None:
         sys.exit("Unable to load %s file" % fname)
 
-    known_types = collect_types(conf)
-
     if args.includeComps or args.excludeComps or args.includeClasses or args.excludeClasses:
         logger.info(f"include/exclude comps like {args.includeComps}/{args.excludeComps}")
         conf = excludeIncludeComps(conf, args, args.follow)
@@ -477,6 +476,7 @@ def loadConfigFile(fname, args) -> Dict:
         conf = renameComps(conf, args)
 
     if args.ignoreDefaults:
+        known_types = collect_types(conf)
         conf = ignoreDefaults(conf, args, known_types)
 
     if args.shortenDefaultComponents:
@@ -531,7 +531,7 @@ class ComponentsDiffFileLoader:
         return (
             first.get_name() == second.get_name()
             and first.x_pos == second.x_pos
-            and type(first) == type(second)
+            and type(first) is type(second)
         )
 
     def mark_differences(

Control/AthenaConfiguration/share/confTool.py

@@ -55,6 +55,13 @@ def parse_args():
         help="Don't report components existing in only one of the two configurations",
         action="store_true",
     )
+    parser.add_argument(
+        "--ignoreOrder",
+        metavar="PROP",
+        action="append",
+        default=[],
+        help="Ignore order for sequence properties matching regex",
+    )
     parser.add_argument(
         "--allComponentPrint",
         help="Print all component if there are differences in any of its properties",
@@ -127,11 +134,12 @@ def parse_args():
         print("Run with arguments:")
         print( "confTool.py", " ".join(sys.argv[1:]))
 
-    main(args)
+    return main(args)
 
 knownDifferences={}
 
 def main(args):
+    exit_code = 0
     if not args.quiet and args.ignoreIrrelevant:
         print(f"Properties to ignore: {args.ignore}")
     color = fullColor()
@@ -191,10 +199,9 @@ def main(args):
         global knownDifferences
         if args.knownDifferencesFile:
             knownDifferences = loadDifferencesFile(args.knownDifferencesFile)
-        _compareConfig(configRef, configChk, args, color)
-
-
+        exit_code = _compareConfig(configRef, configChk, args, color) != 0
 
+    return exit_code
 
 
 def _print(conf, color):
@@ -340,6 +347,7 @@ def _compareConfig(configRef, configChk, args, color):
     def _componentDescription(comp_name):
         return (comp_name+ " renamed from " + componentReverseRenamig[comp_name]) if comp_name in componentReverseRenamig else comp_name
 
+    countDifferent = 0
     for component in allComps:
         if component not in configRef:
             if not args.ignoreMissing:
@@ -368,7 +376,7 @@ def _compareConfig(configRef, configChk, args, color):
         else:
             print(f"{color.difference}Component", _componentDescription(component), f"may differ{color.reset}")
             if not args.allComponentPrint:
-                countDifferent = _compareComponent(refValue, chkValue, "\t", args, component, color)
+                countDifferent = _compareComponent(refValue, chkValue, "\t", args, component, "", color)
                 if countDifferent == 0:
                     print("   but all are suppressed by renaming/known differences/...") 
                 else:
@@ -382,6 +390,7 @@ def _compareConfig(configRef, configChk, args, color):
                     f"\t{color.second}Chk{color.reset}\t",
                     sorted(configChk[component].items(), key=lambda kv: kv[0]),
                 )
+    return countDifferent
 
 
 def _parseNumericalValues(values):
@@ -425,7 +434,7 @@ def _handleComponentsReanaming( refVal ):
             updatedRef.append(v)
     return updatedRef if isinstance(refVal, list) else updatedRef[0]
 
-def _compareComponent(compRef, compChk, prefix, args, component, color):
+def _compareComponent(compRef, compChk, prefix, args, component, propname, color):
     countDifferent=0
     if isinstance(compRef, dict):
         allProps = list(set(compRef.keys()) | set(compChk.keys()))
@@ -481,7 +490,7 @@ def _compareComponent(compRef, compChk, prefix, args, component, color):
                     countDifferent += _compareIOVDbFolders(refVal, chkVal, "\t", args, color)
                 else:
                     countDifferent += _compareComponent(
-                        refVal, chkVal, "\t" + prefix + ">> ", args, component, color
+                        refVal, chkVal, "\t" + prefix + ">> ", args, component, prop, color
                     )
 
     elif isinstance(compRef, (list, tuple, set)) and len(compRef) > 1:
@@ -508,16 +517,17 @@ def _compareComponent(compRef, compChk, prefix, args, component, color):
 
         if len(compRef) == len(compChk):
             if sorted(compRef) == sorted(compChk):
-                print(
-                    f"{prefix} : {color.difference} ^^ Different order ^^ {color.reset}"
-                )
-                countDifferent += 1
+                if any(re.match(f"^{regex}$",f"{component}.{propname}") for regex in args.ignoreOrder):
+                    print(f"{prefix} : {color.knowndifference} ^^ Different order ignored ^^ {color.reset}")
+                else:
+                    print(f"{prefix} : {color.difference} ^^ Different order ^^ {color.reset}")
+                    countDifferent += 1
             else:
                 for i, (refVal, chkVal) in enumerate(zip(compRef, compChk)):
                     if refVal != chkVal:
                         print(f"{prefix} : {color.first} {refVal} {color.reset} vs {color.second} {chkVal} {color.reset} {color.difference}<< at index {i} {color.reset}")
                         countDifferent += _compareComponent(
-                            refVal, chkVal, "\t" + prefix + ">> ", args, "", color
+                            refVal, chkVal, "\t" + prefix + ">> ", args, "", "", color
                         )
     return countDifferent
 
@@ -560,8 +570,8 @@ def _compareIOVDbFolders(compRef, compChk, prefix, args, color):
         refParsed.append(_parseIOVDbFolder(item))
     for item in compChk:
         chkParsed.append(_parseIOVDbFolder(item))
-    return _compareComponent(refParsed, chkParsed, prefix, args, "", color)
+    return _compareComponent(refParsed, chkParsed, prefix, args, "", "", color)
 
 
 if __name__ == "__main__":
-    parse_args()
+    sys.exit(parse_args())

Control/AthenaKernel/AthenaKernel/ExtendedEventContext.h

@@ -78,7 +78,7 @@ namespace Atlas {
     EventIDBase::number_type m_conditionsRun {EventIDBase::UNDEFNUM};
     const TrigRoiDescriptor* m_roi {nullptr};
     const SG::ThinningCache* m_thinningCache {nullptr};
-    std::pmr::memory_resource* m_memResource;
+    std::pmr::memory_resource* m_memResource{nullptr};
   };
 
 

Control/AthenaMonitoring/share/DataQualitySteering_jobOptions.py

@@ -215,22 +215,7 @@ if DQMonFlags.doMonitoring():
       # LAr monitoring   #
       #------------------#
       if DQMonFlags.doLArMon():
-         from LArMonTools.LArMonFlags import LArMonFlags
-         if LArMonFlags.doLArCollisionTimeMon():
-            #Schedule algorithms producing collision timing
-            include("LArClusterRec/LArClusterCollisionTime_jobOptions.py")
-            include("LArCellRec/LArCollisionTime_jobOptions.py")
-         try:
-            LArMon = AthenaMonManager(name="LArMonManager",
-                           FileKey             = DQMonFlags.monManFileKey(),
-                           Environment         = DQMonFlags.monManEnvironment(),
-                           ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(),
-                           DataType            = DQMonFlags.monManDataType())
-            topSequence += LArMon
-            include("LArMonTools/LArAllMonitoring_jobOptions.py")
-            include("LArMonitoring/LArMonitoring_jobOption.py")
-         except Exception:
-            treatException("DataQualitySteering_jobOptions.py: exception when setting up LAr monitoring")
+         local_logger.warning("Legacy LAr monitoring not existing anymore")
 
       #-------------------------------------------------------------------------#
       # Calo monitoring - cells and clusters independent of LAr or Tile origin  #

Control/AthenaMonitoringKernel/AthenaMonitoringKernel/MonitoredGroup.h

 /*
-  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 AthenaMonitoringKernel_MonitoredGroup_h
@@ -163,7 +163,7 @@ namespace Monitored {
   template<typename V,typename std::enable_if_t<std::is_integral_v<V>>* =nullptr>
   std::map<std::string,int> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, const std::vector<std::string>& labels) {
     std::map<std::string,int> indexMap;
-    for ( auto label : labels ) {
+    for ( const std::string& label : labels ) {
       std::string groupName = baseName + "_" + label;
       indexMap[label] = detail::findToolIndex(tools,groupName);
     }
@@ -174,7 +174,7 @@ namespace Monitored {
   template<typename V,typename std::enable_if_t<!std::is_integral_v<V>>* =nullptr,typename...T>
   std::map<std::string,V> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, const std::vector<std::string>& labels, T... dimensions) {
     std::map<std::string,V> indexMap;
-    for ( auto label : labels ) {
+    for ( const std::string& label : labels ) {
       std::string groupName = baseName + "_" + label;
       indexMap[label] = buildToolMap<typename V::mapped_type>(tools,groupName,dimensions...);
     }

Control/AthenaMonitoringKernel/AthenaMonitoringKernel/MonitoredScalar.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef AthenaMonitoringKernel_MonitoredScalar_h
@@ -88,6 +88,7 @@ namespace Monitored {
     Scalar(Scalar const&) = delete;
 
     Scalar& operator=(Scalar const&) = delete;
+    // cppcheck-suppress passedByValue
     T operator=(T value)
     {
       m_value = value;

Control/AthenaMonitoringKernel/src/HistogramFiller/HistogramFactory.cxx

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 #include "CxxUtils/checker_macros.h"
 
@@ -16,7 +16,7 @@
 using namespace Monitored;
 
 HistogramFactory::HistogramFactory(const ServiceHandle<ITHistSvc>& histSvc,
-                                   std::string histoPath)
+                                   const std::string& histoPath)
 : m_histSvc(histSvc)
 {
   size_t whereToStart = 0;

Control/AthenaMonitoringKernel/src/HistogramFiller/HistogramFactory.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef AthenaMonitoringKernel_HistogramFiller_HistogramFactory_h
@@ -26,12 +26,12 @@ namespace Monitored {
   class HistogramFactory {
   public:
     /**
-     * @brief Defualt constructor
+     * @brief Default constructor
      * 
      * @param histSvc ROOT framework histogramming service
      * @param groupName Name of the group to which produced histograms will belong
      */
-    HistogramFactory(const ServiceHandle<ITHistSvc>& histSvc, std::string groupName);
+    HistogramFactory(const ServiceHandle<ITHistSvc>& histSvc, const std::string& groupName);
     /**
      * @brief Virtual destructor
      */

Control/AthenaMonitoringKernel/test/HistogramFillerFactoryTestSuite.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #undef NDEBUG
@@ -207,7 +207,7 @@ class HistogramFillerFactoryTestSuite {
   private:
     typedef void (HistogramFillerFactoryTestSuite::*TestCase)(void);
 
-    function<void(void)> registerTestCase(TestCase testCase, string testCaseName) {
+    function<void(void)> registerTestCase(TestCase testCase, const string& testCaseName) {
       return [this, testCase, testCaseName]() {
         m_log << MSG::INFO << "Current test case: " << testCaseName << endmsg;
         beforeEach();

Control/AthenaMonitoringKernel/test/HistogramProviderTestSuite.cxx

 /*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #undef NDEBUG
@@ -273,7 +273,7 @@ class LumiblockHistogramProviderTestSuite {
   private:
     typedef void (LumiblockHistogramProviderTestSuite::*TestCase)(void);
 
-    function<void(void)> registerTestCase(TestCase testCase, string testCaseName) {
+    function<void(void)> registerTestCase(TestCase testCase, const string& testCaseName) {
       return [this, testCase, testCaseName]() {
         m_log << MSG::INFO << "Current test case: " << testCaseName << endmsg;
         beforeEach();

Control/SGTools/src/DataStore.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 "SGTools/DataStore.h"
@@ -118,22 +118,18 @@ void DataStore::clearStore(bool force, bool hard, MsgStream* /*pmlog*/)
 void DataStore::keys(const CLID& id, std::vector<std::string>& vkeys,
 		     bool includeAlias, bool onlyValid)
 {
-  vector<string> tkeys;
-  ProxyMap& pmap = m_storeMap[id];
-  ConstProxyIterator p_iter = pmap.begin();
-  for (; p_iter != pmap.end(); p_iter++) {
+  vkeys.clear();
+  for (const ProxyMap::value_type& p : m_storeMap[id]) {
     bool includeProxy(true);
-    if (onlyValid) includeProxy=p_iter->second->isValid();
+    if (onlyValid) includeProxy=p.second->isValid();
     if (includeAlias) {
-      if (includeProxy) tkeys.push_back(p_iter->first);
+      if (includeProxy) vkeys.push_back(p.first);
     }
     else {
-      if (p_iter->first == p_iter->second->name() && includeProxy) 
-	tkeys.push_back(p_iter->first);
+      if (p.first == p.second->name() && includeProxy) 
+	vkeys.push_back(p.first);
     }
   }
-  vkeys.swap(tkeys);
-  return;
 }
 
 //////////////////////////////////////////////////////////////