Calorimeter/CaloRec/ispellwords

@@ -654,7 +654,6 @@ TileCalibrationCellHitCnt
 TileCalibHitActiveCell
 TileCalibHitInactiveCell
 TileCalibHitDeadMaterial
-CellDetailsNoiseTool
 DetStore
 AuditInitialize
 doLArHitToCellDirect
@@ -908,12 +907,10 @@ const
 CPUTimeRef
 LArClusterCopier
 larClusterCopier
-CaloNoiseTool
 TopoClusterMapperGetter
 SRT
 sizep
 stl
-useNoiseTool
 AuditBeginRun
 theCaloCellContainerCheckerTool
 EMCellContainerName
@@ -952,7 +949,6 @@ AuditFinalize
 CopyCell
 leakRSS
 gapscin
-UseCaloNoiseTool
 MeVTool
 PreSampE
 TWOPI
@@ -1018,7 +1014,6 @@ jetrec
 makeinfo
 jobProperty
 CaloTopoSplitterClusterCell
-theCaloNoiseTool
 laplace
 ThresholdGeVCells
 thresholdGeVCells
@@ -1036,7 +1031,6 @@ EvtMax
 CaloTopoSplitterHashCluster
 CaloClusterStoreHelper
 DMCalib
-LArNoiseTool
 MinBias
 AuditRestart
 maxima
@@ -1048,7 +1042,6 @@ CellContainers
 maxEt
 LArCmbTwrBldr
 CaloTowerCmbGetter
-ICalorimeterNoiseTool
 LArCmbTwrBldrChronobuild
 ClusterContainer
 memexe
@@ -1087,7 +1080,6 @@ AthenaKernel
 CaloCellsName
 MyPackage
 TileCells
-CaloNoiseToolDefault
 lastEvForLeak
 LArRawChannels
 efcal
@@ -1232,7 +1224,6 @@ ntileb
 enums
 CellCorrections
 MonitorService
-ICaloNoiseTool
 iCalo
 EMTopo
 ntileg
@@ -1259,7 +1250,6 @@ eng
 Unal
 enum
 endif
-noiseTool
 MinLLongitudinal
 endcap
 EndCap

Calorimeter/CaloRec/python/CaloTopoTowerGetter.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
 
 # specifies Tower/TopoCluster -> TopoTower
 from AthenaCommon.JobProperties import jobproperties as jp
@@ -111,8 +111,6 @@ class CaloTopoTowerGetter ( Configured )  :
                 theCaloTopoTowerAlgorithm.MinimumClusterEnergy   = -1000000000.0
                 theCaloTopoTowerAlgorithm.CellEnergySignificance = -1.
 
-                # noise tool
-                theCaloTopoTowerAlgorithm.UseCaloNoiseTool       = False
 
                 ########################
 

Calorimeter/CaloRec/python/MakeTowersFromClusters.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 AthenaCommon.AppMgr import ServiceMgr as svcMgr
 
@@ -132,11 +132,6 @@ def MakeTowersFromClusters(towerMakerName      = 'CaloTowerBuilderAlg',        #
     
     ''' External tools for moment calculation
     '''
-    ##from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
-    #from AthenaCommon.AppMgr import ToolSvc
-    #caloNoiseTool  = CaloNoiseToolDefault()
-    #ToolSvc       += caloNoiseTool
-        
     from CaloTools.CaloNoiseCondAlg import CaloNoiseCondAlg
     CaloNoiseCondAlg ()
     CaloNoiseCondAlg(noisetype="totalNoise") # "electronicNoise","pileupNoise","totalNoise"
@@ -148,8 +143,6 @@ def MakeTowersFromClusters(towerMakerName      = 'CaloTowerBuilderAlg',        #
     from CaloRec.CaloRecConf          import CaloClusterMomentsMaker
     clusterMoments                  = CaloClusterMomentsMaker (towerMakerName+'MomentMaker')
     clusterMoments.MaxAxisAngle     = 20*deg
-    #clusterMoments.CaloNoiseTool    = caloNoiseTool
-    #clusterMoments.UsePileUpNoise   = True
     clusterMoments.TwoGaussianNoise = jobproperties.CaloTopoClusterFlags.doTwoGaussianNoise()
     clusterMoments.MinBadLArQuality = 4000
     clusterMoments.MomentsNames     = [

Calorimeter/CaloRec/share/CaloRec_jobOptions.py

@@ -90,13 +90,9 @@ if rec.readESD and not rec.doESD:
 ## if rec.readESD() and DetFlags.detdescr.Calo_on():
 ##     from CaloRec.CaloRecConf import CaloCellMaker
 ##     theCaloCellMaker=CaloCellMaker(CaloCellsOutputName="AllCalo",CaloCellHack=True)    
-##     # calo modifying tool to be inserted there
-##     from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
-##     theCaloNoiseTool = CaloNoiseToolDefault()
-##     ToolSvc+=theCaloNoiseTool
     
 ##     from CaloCellCorrection.CaloCellCorrectionConf import CaloCellRandomizer     
-##     theCaloCellRandomizer=CaloCellRandomizer(noiseTool=theCaloNoiseTool,DoGaussRandomization=True)
+##     theCaloCellRandomizer=CaloCellRandomizer(DoGaussRandomization=True)
 ##     ToolSvc += theCaloCellRandomizer
 
 ##     from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool

Calorimeter/CaloRec/src/CaloTopoTowerAlgorithm.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "GaudiKernel/MsgStream.h"
@@ -18,7 +18,6 @@
 #include "CaloEvent/CaloCellContainer.h"
 #include "CaloEvent/CaloClusterContainer.h"
 #include "CaloEvent/CaloTopoTowerContainer.h"
-#include "CaloInterface/ICalorimeterNoiseTool.h"
 #include "CaloTopoTowerAlgorithm.h"
 
 #include <string>
@@ -59,8 +58,6 @@ CaloTopoTowerAlgorithm::CaloTopoTowerAlgorithm(const std::string& name,
 
   // Noise Tool stuff
   declareProperty("DefaultNoiseSigma",      m_noiseSigma           = 10.0);
-  declareProperty("UseCaloNoiseTool",       m_useNoiseTool         = false);
-  declareProperty("UsePileUpNoise",         m_usePileUpNoise       = true);
   declareProperty("CellEnergySignificance", m_cellESignificanceThreshold = -1);
 
   // Calo from which to use cells
@@ -97,13 +94,6 @@ StatusCode CaloTopoTowerAlgorithm::initialize()
   ATH_CHECK(m_towerContainerKey.initialize());
   ATH_CHECK(m_newTowerContainerKey.initialize());
 
-  // Report some information regarding the noise tool
-  if ( m_useNoiseTool && m_usePileUpNoise) {
-    ATH_MSG_DEBUG( "Pile-Up Noise from Noise Tool "
-         << " is selected! The noise sigma will be the"
-                   << " quadratic sum of the electronics noise and the pile up!"  );
-  }
-
   m_caloIndices.clear();
   for ( unsigned int iCalos=0; iCalos< m_includedCalos.size(); iCalos++ )
     {
@@ -268,8 +258,6 @@ StatusCode CaloTopoTowerAlgorithm::execute (const EventContext& ctx) const
   theTowers->SetUseCellWeights(m_useCellWeights);
 
   // Noise tool stuff
-  theTowers->SetUseNoiseTool(m_useNoiseTool);
-  theTowers->SetUsePileUpNoise(m_usePileUpNoise);
   theTowers->SetNoiseSigma(m_noiseSigma);
   theTowers->SetCellESignificanceThreshold(m_cellESignificanceThreshold);
 

Calorimeter/CaloRec/src/CaloTopoTowerAlgorithm.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef CALOREC_CALOTOPOTOWERALGORITHM_H
@@ -87,8 +87,6 @@ class CaloTopoTowerAlgorithm : public AthReentrantAlgorithm
   bool   m_useCellWeights;
 
   // Noise tool stuff
-  bool m_useNoiseTool;
-  bool m_usePileUpNoise;
   float m_noiseSigma;
   float m_cellESignificanceThreshold;
 

Control/AthenaBaseComps/AthenaBaseComps/DynamicDataHelper.h

@@ -66,7 +66,7 @@ namespace Ath {
       DataObjIDPtrColl m_inputHandles;
       DataObjIDPtrColl m_outputHandles;
 
-      std::vector< std::pair<IDynamicDataConsumer *,Gaudi::Algorithm *> > m_dynDataConsumer;
+      std::unordered_map< IDynamicDataConsumer *,std::vector<Gaudi::Algorithm *> > m_dynDataConsumer;
 
    };
 }

Control/AthenaBaseComps/src/DynamicDataHelper.cxx

@@ -68,7 +68,10 @@ namespace Ath {
             [this](Gaudi::Algorithm *an_alg) {
                IDynamicDataConsumer *a_dyn_data_consumer=dynamic_cast<IDynamicDataConsumer *>(an_alg);
                if (a_dyn_data_consumer) {
-                  m_dynDataConsumer.push_back(std::make_pair(a_dyn_data_consumer, an_alg));
+                  std::vector<Gaudi::Algorithm *> &alg_list = m_dynDataConsumer[a_dyn_data_consumer];
+                  if (std::find(alg_list.begin(),alg_list.end(),an_alg)==alg_list.end()) {
+                     alg_list.push_back(an_alg);
+                  }
                }
                // have to collect input and output handles because the sequence will only collect them  after initialize
                insertHandles(m_inputHandles, an_alg->inputHandles());
@@ -79,7 +82,10 @@ namespace Ath {
                auto tool_visitor = [this, an_alg](IAlgTool *alg_tool) {
                   IDynamicDataConsumer *a_dyn_data_consumer=dynamic_cast<IDynamicDataConsumer *>(alg_tool);
                   if (a_dyn_data_consumer) {
-                     m_dynDataConsumer.push_back(std::make_pair(a_dyn_data_consumer, an_alg));
+                     std::vector<Gaudi::Algorithm *> &alg_list = m_dynDataConsumer[a_dyn_data_consumer];
+                     if (std::find(alg_list.begin(),alg_list.end(),an_alg)==alg_list.end()) {
+                        alg_list.push_back(an_alg);
+                     }
                   }
                   if (auto* tool_impl = dynamic_cast<AlgTool*>( alg_tool ); tool_impl) {
                      insertHandles(m_inputHandles, tool_impl->inputHandles());
@@ -130,29 +136,32 @@ namespace Ath {
          }
          out << endmsg;
       }
-      for (std::pair<IDynamicDataConsumer *,Gaudi::Algorithm *> &dyn_data_consumer :  m_dynDataConsumer ) {
+      for (std::pair<IDynamicDataConsumer * const,std::vector<Gaudi::Algorithm *> > &dyn_data_consumer :  m_dynDataConsumer ) {
          std::vector<Gaudi::DataHandle *> tmp_new_input_handles;
          std::vector<Gaudi::DataHandle *> tmp_new_output_handles;
          bool ret = dyn_data_consumer.first->updateDataNeeds(input_data_in, output_data_in, tmp_new_input_handles, tmp_new_output_handles);
          if (msgLvl(out,MSG::VERBOSE)) {
-            out << MSG::VERBOSE << " new data from " << dyn_data_consumer.second->name()
-                << " i:" << tmp_new_input_handles.size()
+            out << MSG::VERBOSE << " new data for";
+            for (const Gaudi::Algorithm *parent_alg : dyn_data_consumer.second) {
+               out << " " << parent_alg->name();
+            }
+            out << " i:" << tmp_new_input_handles.size()
                 << " o:" << tmp_new_output_handles.size()
                 << endmsg;
          }
          updated |=  ret;
          if (ret) {
             if (msgLvl(out,MSG::DEBUG)) {
-               if (Gaudi::Algorithm *an_alg = dynamic_cast<Gaudi::Algorithm *>(dyn_data_consumer.first); an_alg) {
+               if (Gaudi::Algorithm * const an_alg = dynamic_cast<Gaudi::Algorithm * const>(dyn_data_consumer.first); an_alg) {
                   out << MSG::DEBUG << an_alg->name() << " updated its data needs." << endmsg;
                   // DEBUG:
                   out << MSG::DEBUG << an_alg->name() << " inputs:";
-                  for (const Gaudi::DataHandle *handle : an_alg->inputHandles()) {
-                     out << " " << handle->fullKey();
-                  }
-                  out << endmsg;
+                     for (const Gaudi::DataHandle *handle : an_alg->inputHandles()) {
+                        out << " " << handle->fullKey();
+                     }
+                     out << endmsg;
                }
-               else if (AlgTool *alg_tool = dynamic_cast<AlgTool *>(dyn_data_consumer.first); alg_tool) {
+               else if (AlgTool *alg_tool = dynamic_cast<AlgTool * const>(dyn_data_consumer.first); alg_tool) {
                   out << MSG::DEBUG << alg_tool->name() << " updated its data needs." << endmsg;
                   // DEBUG:
                   out << MSG::DEBUG << alg_tool->name() << " inputs:";
@@ -166,20 +175,21 @@ namespace Ath {
                }
             }
          }
-         Gaudi::Algorithm *parent_alg = dyn_data_consumer.second;
-         input_data_out.reserve(input_data_out.size()+tmp_new_input_handles.size());
-         for (Gaudi::DataHandle *a_handle : tmp_new_input_handles) {
-            parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Reader);
-            input_data_out.push_back(&(a_handle->fullKey()));
-            if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new input for " << parent_alg->name() << " "
-                                            << a_handle->fullKey().className() << " / " <<  a_handle->objKey() << endmsg;
-         }
-         output_data_out.reserve(output_data_out.size()+tmp_new_output_handles.size());
-         for (Gaudi::DataHandle *a_handle : tmp_new_output_handles) {
-            parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Writer);
-            output_data_out.push_back(&(a_handle->fullKey()));
-            if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new output for " << parent_alg->name() << " "
-                                            << a_handle->fullKey().className() << " / "  << a_handle->objKey() << endmsg;
+         for (Gaudi::Algorithm *parent_alg : dyn_data_consumer.second) {
+            input_data_out.reserve(input_data_out.size()+tmp_new_input_handles.size());
+            for (Gaudi::DataHandle *a_handle : tmp_new_input_handles) {
+               parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Reader);
+               input_data_out.push_back(&(a_handle->fullKey()));
+               if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new input for " << parent_alg->name() << " "
+                                               << a_handle->fullKey().className() << " / " <<  a_handle->objKey() << endmsg;
+            }
+            output_data_out.reserve(output_data_out.size()+tmp_new_output_handles.size());
+            for (Gaudi::DataHandle *a_handle : tmp_new_output_handles) {
+               parent_alg->addDependency(a_handle->fullKey(), Gaudi::DataHandle::Writer);
+               output_data_out.push_back(&(a_handle->fullKey()));
+               if (msgLvl(out,MSG::DEBUG)) out << MSG::DEBUG << " addDependency new output for " << parent_alg->name() << " "
+                                               << a_handle->fullKey().className() << " / "  << a_handle->objKey() << endmsg;
+            }
          }
       }
       return updated;

Control/AthenaCommon/share/GenerateBootstrapTest.ref

 Willing to acquire file bootstrap.pkl from
 /afs/cern.ch/user/s/ssnyder/atlas-work3/build-x86_64-centos7-gcc8-dbg/x86_64-centos7-gcc8-dbg/share/bootstrap.pkl
 copy bootstrap.pkl
-... Read 2 items from python pickle file:  bootstrap.pkl
-... Read 2 items from python pickle file:  bootstrap_test.pkl
+... Read defaultdict from bootstrap.pkl
+... Read 27 items from python pickle file:  bootstrap.pkl
+... Read defaultdict from bootstrap_test.pkl
+... Read 27 items from python pickle file:  bootstrap_test.pkl
 Step 1: reference file #components: 27
 Step 2: file to check  #components: 27
 Willing to acquire file bootstrap_threaded.pkl from
 /afs/cern.ch/user/s/ssnyder/atlas-work3/build-x86_64-centos7-gcc8-dbg/x86_64-centos7-gcc8-dbg/share/bootstrap_threaded.pkl
 copy bootstrap_threaded.pkl
-... Read 2 items from python pickle file:  bootstrap_threaded.pkl
-... Read 2 items from python pickle file:  bootstrap_threaded_test.pkl
+... Read defaultdict from bootstrap_threaded.pkl
+... Read 34 items from python pickle file:  bootstrap_threaded.pkl
+... Read defaultdict from bootstrap_threaded_test.pkl
+... Read 34 items from python pickle file:  bootstrap_threaded_test.pkl
 Step 1: reference file #components: 34
 Step 2: file to check  #components: 34

Control/AthenaConfiguration/python/iconfTool/models/loaders.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
 
 import pickle
 import logging
@@ -85,6 +85,8 @@ def loadConfigFile(fname, args) -> Dict:
                 cfg, (collections.defaultdict, dict)
             ):  # old configuration
                 conf.update(cfg)
+                conf.update(pickle.load(input_file)) # special services
+                # FIXME: there's a third pickle object with python components
             elif isinstance(cfg, (collections.Sequence)):
                 for c in cfg:
                     conf.update(c)

Control/GaudiSequencer/src/AthEventCounter.cxx

@@ -10,26 +10,7 @@
 ///////////////////////////////////////////////////////////////////
 
 #include "AthEventCounter.h"
-
-/**
- ** Constructor(s)
- **/
-AthEventCounter::AthEventCounter(const std::string& name, ISvcLocator* pSvcLocator) :
-  AthAlgorithm( name, pSvcLocator ),
-  m_skip ( 0 ),
-  m_total( 0 )
-{
-  declareProperty( "Frequency", m_frequency=1,
-                   "The frequency with which the number of events should be "
-                   "reported. The default is 1, corresponding to every event" );
-  m_frequency.verifier().setBounds( 0, 1000 );
-}
-
-/**
- ** Destructor
- **/
-AthEventCounter::~AthEventCounter( )
-{}
+#include <cstdlib>
 
 StatusCode
 AthEventCounter::initialize()
@@ -39,16 +20,17 @@ AthEventCounter::initialize()
 }
 
 StatusCode
-AthEventCounter::execute()
+AthEventCounter::execute(const EventContext& ) const 
 {
-  m_total++;
-  int freq = m_frequency;
-  if ( freq > 0 ) {
-    m_skip++;
-    if ( m_skip >= freq ) {
-      ATH_MSG_INFO ("execute ==> seen events: " << m_total);
-      m_skip = 0;
-    }
+  int currTotal=(m_total++); 
+  if (m_frequency==0) {
+    return StatusCode::SUCCESS;
+  }
+
+  int rem=std::div(currTotal,m_frequency).rem;
+
+  if (rem==0) {
+      ATH_MSG_INFO ("execute ==> seen events: " << currTotal);
   }
   return StatusCode::SUCCESS;
 }

Control/GaudiSequencer/src/AthEventCounter.h

 ///////////////////////// -*- C++ -*- /////////////////////////////
 
 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 // AthEventCounter.h
@@ -11,29 +11,23 @@
 #ifndef GAUDISEQUENCER_ATHEVENTCOUNTER_H
 #define GAUDISEQUENCER_ATHEVENTCOUNTER_H
 
-#include "AthenaBaseComps/AthAlgorithm.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
 #include "Gaudi/Property.h"
+#include <atomic>
 
-class AthEventCounter : public AthAlgorithm 
+class AthEventCounter : public AthReentrantAlgorithm 
 {
 public:
 
-  /**
-   ** Constructor(s)
-   **/
-  AthEventCounter( const std::string& name, ISvcLocator* pSvcLocator );
-
-  /**
-   ** Destructor
-   **/
-  ~AthEventCounter( );
+  using AthReentrantAlgorithm::AthReentrantAlgorithm;
+  ~AthEventCounter( ) = default;
 
   /*****************************
    ** Public Function Members **
    *****************************/
 
   StatusCode initialize();
-  StatusCode execute();
+  StatusCode execute(const EventContext& ctx) const ;
   StatusCode finalize();
 
 private:
@@ -47,18 +41,14 @@ private:
    ** should be reported. The default is 1, corresponding
    ** to every event.
    **/
-  Gaudi::CheckedProperty<int> m_frequency;
-
-  /**
-   ** The number of events skipped since the last time
-   ** the count was reported.
-   **/
-  int m_skip;
+  Gaudi::Property<int> m_frequency{this, "Frequency", 1,
+      "The frequency with which the number of events should be "
+      "reported. The default is 1, corresponding to every event" };
 
   /**
    ** The total events seen.
    **/
-  int m_total;
+  mutable std::atomic<int> m_total{0};
 };
 
 #endif // GAUDISEQUENCER_ATHEVENTCOUNTER_H

Database/AthenaPOOL/OutputStreamAthenaPool/python/MultipleStreamManager.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
 
 ########################################################
 ##  AugmentedStreams & MultipleStreamManager classes  ##
@@ -284,12 +284,14 @@ class AugmentedByteStream( AugmentedStreamBase ):
         self.bsCopyTool.ByteStreamOutputSvc=self.bsOutputSvc
         self.bsCopyTool.ByteStreamInputSvc=svcMgr.ByteStreamInputSvc
 
-        # create AthenaOutputStream for BS Copy and add it to topSequence
+        # create AthenaOutputStream for BS Copy
         from AthenaServices.AthenaServicesConf import AthenaOutputStream
         self.Stream = AthenaOutputStream( StreamName, WritingTool=self.bsCopyTool )
 
-        #topSequence += self.Stream #<-- coherent with asAlg=False in OutputStreamAthenaPool.py
-        theApp.addOutputStream( self.Stream )
+        # add the stream to the output sequence
+        from AthenaCommon.AlgSequence import AthSequencer
+        outSequence = AthSequencer("AthOutSeq")
+        outSequence += self.Stream
         return
 
     def SetOutputFileName(self, name):

Database/CoolConvUtilities/python/AtlCoolTool.py

@@ -368,7 +368,7 @@ class AtlCoolTool:
             i+= " ["+spec[idx].name() + " (" + typename + ") : "
             if (typename.startswith("Blob")):
                 blob=payload[idx]
-                i+= "size=%i,chk=%i" % (blob.size(),crc32(blob.read().encode()))
+                i+= "size=%i,chk=%i" % (blob.size(),crc32(blob.read()))
             else:
                 i+= str(payload[idx])
             i+="]"

DetectorDescription/RegionSelector/python/RegSelToolConfig.py

@@ -7,11 +7,12 @@
 #
 #   @date    Sun  8 Mar 2020 03:27:57 GMT
 #                 
-#   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 # CompFactory creates old or new configs depending on the enva
-
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+    
 def _condAlgName(detector):
     return "RegSelCondAlg_"+detector
 
@@ -29,7 +30,9 @@ def _createRegSelCondAlg( detector,  CondAlgConstructor ):
                                       PrintTable  = False,
                                       RegSelLUT = ("RegSelLUTCondData_"+detector) )
 
-    if detector == "Pixel":
+    if detector == "MDT" and athenaCommonFlags.isOnline:
+         condAlg.Conditions = "" 
+    elif detector == "Pixel":
         condAlg.DetEleCollKey = "PixelDetectorElementCollection"
         condAlg.PixelCablingCondData = "PixelCablingCondData"
     elif detector == "SCT":
@@ -103,6 +106,11 @@ def makeRegSelTool_MDT() :
     from AthenaCommon.DetFlags import DetFlags
     enabled = DetFlags.detdescr.MDT_on()
     from MuonRegionSelector.MuonRegionSelectorConf import MDT_RegSelCondAlg
+    if enabled and not athenaCommonFlags.isOnline:
+        from AthenaCommon.AlgSequence import AthSequencer
+        from MuonCondAlg.MuonTopCondAlgConfigRUN2 import MdtCondDbAlg
+        condseq = AthSequencer('AthCondSeq')
+        if not hasattr(condseq, "MdtCondDbAlg"): condseq+= MdtCondDbAlg()
     return _makeRegSelTool( "MDT", enabled, MDT_RegSelCondAlg )
 
 def makeRegSelTool_RPC() :
@@ -183,13 +191,18 @@ def makeRegSelTool_TILE() :
 
 ##### new JO counterparts
 
-def regSelToolCfg(flags, detector, CondAlg, CablingConfigCfg=None):
+def regSelToolCfg(flags, detector, CondAlg, CablingConfigCfg=None, DetConditionsCfg=None):
     from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
     ca = ComponentAccumulator()
     if CablingConfigCfg:
         ca.merge(CablingConfigCfg(flags))
+    if DetConditionsCfg:
+        ca.merge(DetConditionsCfg(flags))
     ca.setPrivateTools(_createRegSelTool(detector, True))
-    ca.addCondAlgo(_createRegSelCondAlg(detector, CondAlg))
+    the_alg = _createRegSelCondAlg(detector, CondAlg)
+    if detector == "MDT" and flags.Common.isOnline:
+        the_alg.Conditions = ""
+    ca.addCondAlgo(the_alg)
     return ca
 
 # inner detector
@@ -212,7 +225,9 @@ def regSelTool_TRT_Cfg(flags):
 
 def regSelTool_MDT_Cfg(flags):
     from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
-    return regSelToolCfg(flags, "MDT", CompFactory.MDT_RegSelCondAlg, MDTCablingConfigCfg)
+    from MuonConfig.MuonCondAlgConfig import MdtCondDbAlgCfg
+    return regSelToolCfg(flags, "MDT", CompFactory.MDT_RegSelCondAlg, MDTCablingConfigCfg, 
+                        MdtCondDbAlgCfg if not flags.Common.isOnline else None)
 
 def regSelTool_RPC_Cfg(flags):
     from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg

Event/xAOD/xAODCore/CMakeLists.txt

@@ -6,7 +6,7 @@ atlas_subdir( xAODCore )
 # Extra dependencies based on what environment we are in.
 set( extra_libs )
 if( NOT XAOD_STANDALONE )
-   set( extra_libs AthenaKernel )
+   set( extra_libs AthenaKernel GaudiKernel)
 endif()
 
 # External dependencies.

Event/xAOD/xAODCore/xAODCore/ShallowCopy.h

 // Dear emacs, this is -*- c++ -*-
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 // $Id: ShallowCopy.h 766390 2016-08-04 11:18:59Z wlampl $
@@ -20,25 +20,110 @@
 #include "xAODCore/ShallowAuxContainer.h"
 #include "xAODCore/ShallowAuxInfo.h"
 
+#ifndef XAOD_STANDALONE
+#include <GaudiKernel/ThreadLocalContext.h>
+#else
+class EventContext;
+#endif
+
+
 namespace xAOD {
 
   /// Function to prepare an object to be stored in a shallow-copy container
   ///
-  /// To be used by shallowCopyContainer. The default implementation 
-  /// here is dummy, just calling the default constructor. Can be 
-  /// overloaded for types that require special treatment 
+  /// To be used by shallowCopyContainer. The default implementation
+  /// here is dummy, just calling the default constructor. Can be
+  /// overloaded for types that require special treatment
   /// (like xAOD::CaloCluster)
   /// @param elem: Input object, ignored in this implementation
-  /// @returns A uniqe_ptr to the object to be push_back'ed into the 
-  ///          shallow-copy container. 
+  /// @returns A uniqe_ptr to the object to be push_back'ed into the
+  ///          shallow-copy container.
 
   template< class T >
   std::unique_ptr<T> prepareElementForShallowCopy(const T* /*elem*/) {
     return std::make_unique<T>();
   }
 
+  namespace detail{
+  /// Impl function for shallow copy container
+  /// @param cont The container to make a shallow copy of
+  /// @param ctx The currentEventContext
+  /// @returns A pair of unique_ptr to the created objects.
+  template<class T>
+  std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxContainer>>
+  shallowCopyContainerImpl(const T& cont,
+                           DataLink<SG::IConstAuxStore>& link){
+
+    if (!link.cptr()) {
+      // This can happen when we read the input file in standalone
+      // mode in branch access mode. That's unfortunately not
+      // compatible with using a shallow copy auxiliary store.
+      std::cout << "xAOD::shallowCopyContainer ERROR Couldn't set up "
+                << "DataLink to the original container's auxiliary store"
+                << std::endl;
+      std::cout << "xAOD::shallowCopyContainer ERROR Are you using the "
+                << "xAOD::TEvent::kBranchAccess access mode?" << std::endl;
+      return {};
+    }
+
+    // Create the new DV container:
+    auto newCont = std::make_unique<T>();
+
+    // Add the required number of elements to it:
+    newCont->reserve(cont.size());
+    for (size_t i = 0; i < cont.size(); ++i) {
+      newCont->push_back(prepareElementForShallowCopy(cont[i]));
+    }
+
+    // Create a new shallow auxiliary container:
+    auto aux = std::make_unique<ShallowAuxContainer>(link);
+
+    // Connect it to the interface container:
+    newCont->setStore(aux.get());
+
+    // Return the new objects:
+    return std::make_pair(std::move(newCont), std::move(aux));
+  }
+  }//end namespace detail
+
+  /// Function making a shallow copy of a constant container
+  ///
+  /// This function can be used to make a shallow copy of an existing
+  /// (constant) container. It is most useful when reading an input file,
+  /// and/or applying systematic variations on a container.
+  ///
+  /// @param cont The container to make a shallow copy of
+  /// @param ctx The currentEventContext
+  /// @returns A pair of unique_ptr to the created objects.
+  ///
+  /// In Analysis Base it can be still called by using
+  /// Gaudi::Hive::currentContext() as 2nd argument,
+  /// although in practice is ignored as we do not really have
+  /// an actual EventContext type.
+  ///
+  /// Be aware: If CONT has decorations, then the scheduler won't automatically
+  /// known that they are available on the copy.  To make that happen, see
+  /// StoreGate/ShallowCopyDecorDeps.h.
+
+  template<class T>
+  std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxContainer>>
+  shallowCopyContainer(const T& cont,
+                       [[maybe_unused]] const EventContext& ctx
+  ){
+#ifndef XAOD_STANDALONE
+    DataLink<SG::IConstAuxStore> link (cont.getConstStore(), ctx);
+#else
+    //Note that in AnalysisBase
+    //- EventContext, is not a complete type, we have no class.
+    //- We do not have a DataLink ctor with EventContext
+    //- The return value of currentContext() can not be used.
+    DataLink<SG::IConstAuxStore> link(cont.getConstStore());
+#endif
+    return detail::shallowCopyContainerImpl(cont,link);
+  }
 
    /// Function making a shallow copy of a constant container
+   //
    ///
    /// This function can be used to make a shallow copy of an existing
    /// (constant) container. It is most useful when reading an input file,
@@ -54,40 +139,9 @@ namespace xAOD {
    ///
    template< class T >
    std::pair< T*, ShallowAuxContainer* > shallowCopyContainer( const T& cont ) {
-
-      // Create a DataLink, to check if we'll be successful:
-      DataLink< SG::IConstAuxStore > link( cont.getConstStore() );
-      if( ! link.cptr() ) {
-         // This can happen when we read the input file in standalone
-         // mode in branch access mode. That's unfortunately not
-         // compatible with using a shallow copy auxiliary store.
-         std::cout << "xAOD::shallowCopyContainer ERROR Couldn't set up "
-                   << "DataLink to the original container's auxiliary store"
-                   << std::endl;
-         std::cout << "xAOD::shallowCopyContainer ERROR Are you using the "
-                   << "xAOD::TEvent::kBranchAccess access mode?"
-                   << std::endl;
-         std::pair< T*, ShallowAuxContainer* > dummy;
-         return dummy;
-      }
-
-      // Create the new DV container:
-      T* newCont = new T();
-
-      // Add the required number of elements to it:
-      newCont->reserve( cont.size() );
-      for( size_t i = 0; i < cont.size(); ++i ) {
-	newCont->push_back(prepareElementForShallowCopy(cont[i]));
-      }
-
-      // Create a new shallow auxiliary container:
-      ShallowAuxContainer* aux = new ShallowAuxContainer( link );
-
-      // Connect it to the interface container:
-      newCont->setStore( aux );
-
-      // Return the new objects:
-      return std::make_pair( newCont, aux );
+     DataLink<SG::IConstAuxStore> link (cont.getConstStore());
+     auto tmp = detail::shallowCopyContainerImpl(cont, link);
+     return std::make_pair(tmp.first.release(), tmp.second.release());
    }
 
    /// Function making a shallow copy of a constant standalone object

Event/xAOD/xAODTrigger/CMakeLists.txt

@@ -28,8 +28,9 @@ atlas_add_xaod_smart_pointer_dicts(
               "xAOD::EmTauRoIContainer_v2" "xAOD::TriggerMenuContainer_v1"
               "xAOD::TrigCompositeContainer_v1" "xAOD::BunchConfContainer_v1"
               "xAOD::TrigPassBitsContainer_v1" "xAOD::TriggerMenuJsonContainer_v1"
-              "xAOD::eFexTauRoIContainer_v1"
-   OBJECTS "xAOD::EnergySumRoI_v1" "xAOD::EnergySumRoI_v2"
+              "xAOD::eFexTauRoIContainer_v1" "xAOD::jFexSRJetRoIContainer_v1" 
+
+  OBJECTS "xAOD::EnergySumRoI_v1" "xAOD::EnergySumRoI_v2"
            "xAOD::TrigDecision_v1" "xAOD::TrigNavigation_v1"
            "xAOD::RoiDescriptorStore_v1" )
 

Event/xAOD/xAODTrigger/Root/dict/ContainerProxies.cxx

@@ -17,7 +17,10 @@
 #include "xAODTrigger/versions/JetRoIContainer_v2.h"
 #include "xAODTrigger/versions/MuonRoIContainer_v1.h"
 #include "xAODTrigger/versions/eFexEMRoIContainer_v1.h"
+
 #include "xAODTrigger/versions/eFexTauRoIContainer_v1.h"
+#include "xAODTrigger/versions/jFexSRJetRoIContainer_v1.h"
+
 #include "xAODTrigger/versions/gFexJetRoIContainer_v1.h"
 #include "xAODTrigger/versions/gFexGlobalRoIContainer_v1.h"
 
@@ -35,7 +38,9 @@ ADD_NS_DV_PROXY( xAOD, JetRoIContainer_v1 );
 ADD_NS_DV_PROXY( xAOD, JetRoIContainer_v2 );
 ADD_NS_DV_PROXY( xAOD, MuonRoIContainer_v1 );
 ADD_NS_DV_PROXY( xAOD, eFexEMRoIContainer_v1 );
+
 ADD_NS_DV_PROXY( xAOD, eFexTauRoIContainer_v1 );
+ADD_NS_DV_PROXY( xAOD, jFexSRJetRoIContainer_v1);
 ADD_NS_DV_PROXY( xAOD, gFexJetRoIContainer_v1 );
 ADD_NS_DV_PROXY( xAOD, gFexGlobalRoIContainer_v1 );
 

Event/xAOD/xAODTrigger/Root/jFexSRJetRoIAuxContainer_v1.cxx

+/*
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+// Local includes(s):
+#include "xAODTrigger/versions/jFexSRJetRoIAuxContainer_v1.h"
+
+namespace xAOD{
+
+  jFexSRJetRoIAuxContainer_v1::jFexSRJetRoIAuxContainer_v1()
+      : AuxContainerBase() {
+  
+      AUX_VARIABLE(word0);
+      AUX_VARIABLE(jFexNumber);
+      AUX_VARIABLE(tobEt);
+      AUX_VARIABLE(iEta);
+      AUX_VARIABLE(iPhi);     
+      AUX_VARIABLE(satFlag);
+  }
+
+}//end of namespace xAOD