Merge remote-tracking branch 'origin' into tauTrackSequenceDevFirst

Calorimeter/CaloEvent/CaloEvent/CaloEventDict.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /***************************************************************************
@@ -63,6 +63,8 @@ namespace CaloDict{
     ElementLink<CaloShowerContainer>                     m_link4;
     std::pair<ElementLink<CaloShowerContainer>,double>   m_pair4;
 
+    std::pair<unsigned int,double>                       m_pair5;
+
     Navigable<CaloCellLinkContainer,double>              m_navCellLink;
     Navigable<CaloClusterContainer,double>               m_navCluster;
 

Calorimeter/CaloEvent/CaloEvent/selection.xml

@@ -54,7 +54,7 @@
 
   <class name="CaloClusterCellLink" />
   <class name="std::vector<std::pair<unsigned int,double> >" />
-  <class name="std::pair<unsigned int,double>" />
+  <class pattern="std::*pair*<unsigned int*double>" />
   <class name="DataVector<CaloClusterCellLink>" />
   <class name="CaloClusterCellLinkContainer"
 	 id="545AC204-2749-4AAC-9783-B1E5A7A0030F" />

Control/AthenaConfiguration/python/AthConfigFlags.py

@@ -236,6 +236,36 @@ class AthConfigFlags(object):
             f.get(self)
         return
 
+
+    def fillFromArgs(self,listOfArgs=None):
+        """
+        Expects a list of strings of key=value pairs representing configuration flags. 
+        Used to set flags from command-line parameters, like ConfigFlags.fillFromArgs(sys.argv[1:])
+        """
+        
+        if listOfArgs is None:
+            import sys
+            listOfArgs=sys.argv[1:]
+
+        for arg in listOfArgs:
+            #Safety check on arg: Contains exactly one '=' and left side is a valid flag
+            argsplit=arg.split("=")
+            if len(argsplit)!=2:
+                raise ValueError("Can't interpret argument %s, expected a key=value format" % arg)
+
+            key=argsplit[0].strip()
+            if not self.hasFlag(key):
+                raise KeyError("%s is not a known configuration flag" % key)
+            
+            #Arg looks good enough, just exec it:
+            argToExec="self."+arg
+
+            exec(argToExec)
+            pass
+        return
+
+
+
 import unittest
 class TestFlagsSetup(unittest.TestCase):    
     def setUp(self):

Control/StoreGate/StoreGate/CondHandleKey.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef STOREGATE_CONDHANDLEKEY_H
@@ -25,7 +25,8 @@ namespace SG {
 
 //    CondHandleKey& operator= (const std::string& sgkey);
 
-    StatusCode initialize();
+    StatusCode initialize(bool used = true);
+    StatusCode initialize (AllowEmptyEnum);
 
     const std::string& dbKey() const { return m_dbKey; }
     void setDbKey(const std::string& dbKey) { m_dbKey = dbKey; }

Control/StoreGate/StoreGate/CondHandleKey.icc

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "AthenaKernel/StoreID.h"
@@ -24,13 +24,14 @@ namespace SG {
   
   template <class T>
   StatusCode
-  CondHandleKey<T>::initialize() {
+  CondHandleKey<T>::initialize(bool used /*= true*/) {
     if (m_isInit) return StatusCode::SUCCESS;
     
 
-    if (VarHandleKey::initialize() != StatusCode::SUCCESS) {
+    if (VarHandleKey::initialize(used) != StatusCode::SUCCESS) {
       return StatusCode::FAILURE;
     }
+    if (empty()) return StatusCode::SUCCESS;
 
     if (!m_cs.isValid()) {
       MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
@@ -94,6 +95,14 @@ namespace SG {
 
   }
 
+  template <class T>
+  StatusCode
+  CondHandleKey<T>::initialize(AllowEmptyEnum) {
+    if (key().empty()) {
+      return StatusCode::SUCCESS;
+    }
+    return initialize (true);
+  }
 //---------------------------------------------------------------------------
 
   template <class T>

Control/StoreGate/StoreGate/ReadCondHandle.h

@@ -50,7 +50,8 @@ namespace SG {
     const_pointer_type retrieve( const EventIDBase& t);
 
     const_pointer_type  operator->()  { return  retrieve(); }
-    const_pointer_type  operator*()   { return  retrieve(); }   
+    const_pointer_type  operator*()   { return  retrieve(); }
+    const_pointer_type  cptr()        { return  retrieve(); }
 
     
     bool isValid();

Event/EventCommonTPCnv/EventCommonTPCnv/OLD_selection.xml

@@ -4,6 +4,7 @@
 
   <class name="INav4MomAssocs_p2" id="8040BEAA-BC65-43B8-B468-A7157C89ACB3" />
   <class name="INav4MomAssocs_p2::Assocs_t" />
-  <class name="INav4MomAssocs_p2::AssocElem_t" />
+  <!-- pick up INav4MomAssocs_p2::AssocElem_t and associated pair_base -->
+  <class pattern="std::*pair*<ElementLink_p2<unsigned int>,*"/>
 
 </lcgdict>

Event/EventCommonTPCnv/EventCommonTPCnv/selection.xml

@@ -18,7 +18,8 @@
 
   <class name="INav4MomAssocs_p3" id="455AEE6B-9834-4E72-8F81-2532A52E3BE7" />
   <class name="INav4MomAssocs_p3::Assocs_t" />
-  <class name="INav4MomAssocs_p3::AssocElem_t" />
+  <!-- pick up INav4MomAssocs_p3::AssocElem_t and associated pair_base -->
+  <class pattern="std::*pair*<ElementLink_p3<unsigned int>,*"/>
 
   <class name="INav4MomLinkContainer_p1" id="A7F0A4C5-F343-4724-B317-FB5A890355FA" />
   <class name="IParticleLinkContainer_p1" id="E82C71AF-AC5C-453B-9A35-FA45A849838E" />

Event/xAOD/xAODTracking/Root/Vertex_v1.cxx

@@ -99,7 +99,7 @@ namespace xAOD {
       setY( position( 1 ) );
       setZ( position( 2 ) );
       // Reset the cache
-      m_position.reset();
+      m_position.store(position);
       return;
    }
 
@@ -124,7 +124,7 @@ namespace xAOD {
 
      // Set the persistent variable:
      setCovariance( vec );
-     m_covariance.reset();
+     m_covariance.store(cov);
      return;
    }
 

HLT/Trigger/TrigControl/TrigExamples/TrigExPartialEB/share/MTCalibPeb.py

@@ -78,16 +78,17 @@ hypoTool2.RandomAcceptRate = 0.25
 hypoTool2.BurnTimePerCycleMillisec = 20
 hypoTool2.NumBurnCycles = 10
 hypoTool2.TimeBetweenROBReqMillisec = 50
+exampleROBList = [0x420024, 0x420025, 0x420026, 0x420027, 0x420034, 0x420035, 0x420036, 0x420037,
+                  0x42005c, 0x42005d, 0x42005e, 0x42005f, 0x42006c, 0x42006d, 0x42006e, 0x42006f] # ROS-LAR-EMBC-02
 hypoTool2.ROBAccessDict = {
- "01 :ADD: Preload  ": [ 0x42002a, 0x42002b ],    # robs for 1st preload
- "02 :ADD: Preload  ": [ 0x42002e, 0x42002f ],    # robs for 2nd preload
- "03 :GET: Retrieve ": [ 0x42002e, 0x420060 ],    # robs for 1st retrieval
- "04 :ADD: Preload  ": [ 0x420060 ],              # robs for 3rd preload
- "05 :ADD: Preload  ": [ 0x420064 ],              # robs for 4th preload
- "06 :ADD: Preload  ": [ 0x42002e, 0x420060 ],    # robs for 5th preload
- "07 :GET: Retrieve ": [ 0x420060 ],              # robs for 2nd retrieval
- "08 :GET: Retrieve ": [ 0x420064 ],              # robs for 3rd retrieval
- "09 :COL: Ev.Build ": [ 0x0 ]                    # event building
+ "01 :ADD:       Preload ":  [ 0x420024, 0x420025 ], # robs for 1st preload
+ "02 :ADD:       Preload ":  [ 0x420026, 0x420027 ], # robs for 2nd preload
+ "03 :GET:       Retrieve ": [ 0x420025, 0x420026 ], # robs for 1st retrieval (prefetched)
+ "04 :GET:       Retrieve ": [ 0x420034 ],           # robs for 2nd retrieval (not prefetched)
+ "05 :ADD:       Preload ":  exampleROBList,         # robs for 3rd preload (the full list)
+ "05 :GET:RND5:  Retrieve ": exampleROBList,         # robs for 3rd retrieval (5 random from the list)
+ "06 :GET:RND10: Retrieve ": exampleROBList,         # robs for 4th retrieval (10 random from the list)
+ "07 :COL:       Ev.Build ": []                      # event building
 } # This is just an example with a few ROBs (LAr in this case) for testing the ROBDataProvider
 
 # Chain 3 - medium rate, produces random data, writes PEB info for data scouting
@@ -115,7 +116,7 @@ from TrigOutputHandling.TrigOutputHandlingConfig import TriggerEDMSerialiserTool
 serialiser = TriggerEDMSerialiserToolCfg("Serialiser")
 serialiser.addCollectionListToMainResult([
   "xAOD::TrigCompositeContainer_v1#"+hypo.HypoOutputDecisions,
-  "xAOD::TrigCompositeAuxContainer_v2#"+hypo.HypoOutputDecisions+"Aux.decisions",
+  "xAOD::TrigCompositeAuxContainer_v2#"+hypo.HypoOutputDecisions+"Aux.",
 ])
 # Data scouting example
 resultList = [serialiser.fullResultID(), 1]

HLT/Trigger/TrigControl/TrigExamples/TrigExPartialEB/src/MTCalibPebHypoTool.cxx

@@ -49,7 +49,7 @@ namespace {
   }
   /// Print helper for a container with ROB/SubDet IDs
   template<typename Container>
-  std::string idsToString(const Container& ids) {
+  const std::string idsToString(const Container& ids) {
     std::ostringstream str;
     for (const uint32_t id : ids)
       str << "0x" << std::hex << id << std::dec << " ";
@@ -128,6 +128,22 @@ StatusCode MTCalibPebHypoTool::initialize() {
                  [](const auto& p){return p.first;});
   ATH_CHECK(m_randomDataWHK.initialize());
 
+  // Parse and print the ROB request dictionary
+  for (const auto& [instrString,robVec] : m_robAccessDictProp.value()) {
+    m_robAccessDict.emplace_back(ROBRequestInstruction(instrString),robVec);
+    if (m_robAccessDict.back().first.type==ROBRequestInstruction::Type::INVALID) {
+      ATH_MSG_ERROR("Invalid instruction " << instrString);
+      return StatusCode::FAILURE;
+    }
+  }
+  if (msgLvl(MSG::DEBUG) && !m_robAccessDict.empty()) {
+    ATH_MSG_DEBUG(name() << " will execute the following ROB request instructions:");
+    for (const auto& [instr,robVec] : m_robAccessDict) {
+      ATH_MSG_DEBUG("---> Instruction : " << instr.toString());
+      ATH_MSG_DEBUG("     ROB list    : " << idsToString(robVec));
+    }
+  }
+
   return StatusCode::SUCCESS;
 }
 
@@ -162,35 +178,57 @@ StatusCode MTCalibPebHypoTool::decide(const MTCalibPebHypoTool::Input& input) co
   // ---------------------------------------------------------------------------
   // Prefetch or retrieve ROBs
   // ---------------------------------------------------------------------------
-  for (const auto& p : m_robAccessDict) {
+  for (const auto& [instr,robVec] : m_robAccessDict) {
     // Check for timeout
     if (Athena::Timeout::instance(input.eventContext).reached()) {
       ATH_MSG_ERROR("Timeout reached in ROB retrieval loop");
       return Athena::Status::TIMEOUT;
     }
-    const std::string& instruction = p.first;
-    const std::vector<uint32_t>& robs = p.second;
-    if (instruction.find(":ADD:")!=std::string::npos) {
-      // Prefetch ROBs
-      ATH_MSG_DEBUG("Preloading ROBs: " << idsToString(robs));
-      m_robDataProviderSvc->addROBData(input.eventContext, robs, name()+"-ADD");
-    }
-    if (instruction.find(":GET:")!=std::string::npos) {
-      // Retrieve ROBs
-      ATH_MSG_DEBUG("Retrieving ROBs: " << idsToString(robs));
-      // VROBFRAG = std::vector<const eformat::ROBFragment<const uint32_t*>* >
-      IROBDataProviderSvc::VROBFRAG robFragments;
-      m_robDataProviderSvc->getROBData(input.eventContext, robs, robFragments, name()+"-GET");
-      ATH_MSG_DEBUG("Number of ROBs retrieved: " << robFragments.size());
-      if (!robFragments.empty())
-        ATH_MSG_DEBUG("List of ROBs found: " << std::endl << robFragments);
+
+    // Select a random sample of ROBs from the list, if needed
+    ATH_MSG_DEBUG("Processing instruction " << instr.toString());
+    std::vector<uint32_t> robs;
+    if (instr.isRandom && instr.nRandom < robVec.size()) {
+      std::sample(robVec.begin(),robVec.end(),
+                  std::back_inserter(robs),
+                  instr.nRandom,
+                  threadLocalGenerator());
     }
-    if (instruction.find(":COL:")!=std::string::npos) {
-      // Event building
-      ATH_MSG_DEBUG("Requesting full event ROBs");
-      int nrobs = m_robDataProviderSvc->collectCompleteEventData(input.eventContext, name()+"-COL");
-      ATH_MSG_DEBUG("Number of ROBs retrieved: " << nrobs);
+    else robs = robVec;
+
+    // Execute the ROB requests
+    switch (instr.type) {
+      case ROBRequestInstruction::Type::ADD: {
+        // Prefetch ROBs
+        ATH_MSG_DEBUG("Preloading ROBs: " << idsToString(robs));
+        m_robDataProviderSvc->addROBData(input.eventContext, robs, name()+"-ADD");
+        break;
+      }
+      case ROBRequestInstruction::Type::GET: {
+        // Retrieve ROBs
+        ATH_MSG_DEBUG("Retrieving ROBs: " << idsToString(robs));
+        // VROBFRAG is a typedef for std::vector<const eformat::ROBFragment<const uint32_t*>*>
+        IROBDataProviderSvc::VROBFRAG robFragments;
+        m_robDataProviderSvc->getROBData(input.eventContext, robs, robFragments, name()+"-GET");
+        ATH_MSG_DEBUG("Number of ROBs retrieved: " << robFragments.size());
+        if (!robFragments.empty())
+          ATH_MSG_DEBUG("List of ROBs found: " << std::endl << robFragments);
+        break;
+      }
+      case ROBRequestInstruction::Type::COL: {
+        // Event building
+        ATH_MSG_DEBUG("Requesting full event ROBs");
+        int nrobs = m_robDataProviderSvc->collectCompleteEventData(input.eventContext, name()+"-COL");
+        ATH_MSG_DEBUG("Number of ROBs retrieved: " << nrobs);
+        break;
+      }
+      default: {
+        ATH_MSG_ERROR("Invalid ROB request instruction " << instr.toString());
+        return StatusCode::FAILURE;
+      }
     }
+
+    // Sleep between ROB requests
     std::this_thread::sleep_for(std::chrono::milliseconds(m_timeBetweenRobReqMillisec));
   }
 
@@ -238,3 +276,32 @@ StatusCode MTCalibPebHypoTool::decide(const MTCalibPebHypoTool::Input& input) co
 
   return StatusCode::SUCCESS;
 }
+
+// =============================================================================
+MTCalibPebHypoTool::ROBRequestInstruction::ROBRequestInstruction(std::string_view str) {
+  if (str.find(":ADD:")!=std::string_view::npos) type = ROBRequestInstruction::ADD;
+  else if (str.find(":GET:")!=std::string_view::npos) type = ROBRequestInstruction::GET;
+  else if (str.find(":COL:")!=std::string_view::npos) type = ROBRequestInstruction::COL;
+  if (size_t pos=str.find(":RND"); pos!=std::string_view::npos) {
+    size_t firstDigit=pos+4;
+    size_t lastDigit=str.find_first_of(":",firstDigit);
+    size_t num = std::stoul(str.substr(firstDigit,lastDigit).data());
+    isRandom = true;
+    nRandom = num;
+  }
+}
+
+// =============================================================================
+const std::string MTCalibPebHypoTool::ROBRequestInstruction::toString() const {
+  std::string s;
+  s += "type=";
+  if (type==INVALID) s+="INVALID";
+  else if (type==ADD) s+="ADD";
+  else if (type==GET) s+="GET";
+  else if (type==COL) s+="COL";
+  s += ", isRandom=";
+  s += isRandom ? "true" : "false";
+  s += ", nRandom=";
+  s += std::to_string(nRandom);
+  return s;
+}
\ No newline at end of file

HLT/Trigger/TrigControl/TrigExamples/TrigExPartialEB/src/MTCalibPebHypoTool.h

@@ -43,6 +43,21 @@ public:
   StatusCode decide(const Input& input) const;
 
 private:
+  // ------------------------- Types -------------------------------------------
+  ///  ROB request instruction description
+  struct ROBRequestInstruction {
+    /// Constructor from string key in the ROBAccessDict property
+    ROBRequestInstruction(std::string_view str);
+    /// String form for debug print-outs
+    const std::string toString() const;
+    /// Type of instruction
+    enum Type {INVALID, ADD, GET, COL} type = INVALID;
+    /// Flag switching requests of a random sub-sample of the ROB list
+    bool isRandom = false;
+    /// Size of random request
+    size_t nRandom = 0;
+  };
+
   // ------------------------- Properties --------------------------------------
   Gaudi::Property<double> m_acceptRate {
     this, "RandomAcceptRate", -1,
@@ -60,11 +75,14 @@ private:
     this, "BurnTimeRandomly", true,
     "If true, burn time per cycle is a random value from uniform distribution between 0 and the given value"
   };
-  Gaudi::Property<std::map<std::string,std::vector<uint32_t> > > m_robAccessDict {
+  Gaudi::Property<std::map<std::string,std::vector<uint32_t> > > m_robAccessDictProp {
     this, "ROBAccessDict", {},
-    "List of prefetch/retrieve operations with given ROB IDs."
-    "The string key has to contain :ADD: (prefetch), :GET: (retrieve), or :COL: (full event building)."
-    "The value is a vector of corresponding ROB IDs."
+    "Dictionary of prefetch/retrieve operations with given ROB IDs. The value is a vector of ROB IDs. "
+    "The string key has to contain :ADD: (prefetch), :GET: (retrieve), or :COL: (full event building). :ADD: and :GET: "
+    "may be also appended with :RNDX: where X is an integer. In this case, random X ROBs will be prefetched/retrieved "
+    "from the provided list, e.g. :GET:RND10: retrieves 10 random ROBs from the list. Otherwise the full list is used. "
+    "Note std::map is sorted by std::less<std::string>, so starting the key with a number may be needed to enforce "
+    "ordering, e.g. '01 :ADD:RND10:'."
   };
   Gaudi::Property<unsigned int> m_timeBetweenRobReqMillisec {
     this, "TimeBetweenROBReqMillisec", 0,
@@ -93,6 +111,8 @@ private:
   HLT::Identifier m_decisionId;
   /// WriteHandleKey array for collections specified in the CreateRandomData property
   SG::WriteHandleKeyArray<xAOD::TrigCompositeContainer> m_randomDataWHK;
+  /// Ordered map of ROB request instructions filled from ROBAccessDict property at initialisation
+  std::vector<std::pair<ROBRequestInstruction,std::vector<uint32_t>>> m_robAccessDict;
 };
 
 #endif // TRIGEXPARTIALEB_MTCALIBPEBHYPOTOOL_H

InnerDetector/InDetConditions/InDetByteStreamErrors/InDetByteStreamErrors/selection.xml

 <lcgdict>	
-  <class name="std::pair<unsigned char, unsigned int>" />
+  <class pattern="std::*pair*<unsigned char*unsigned int>" />
   <class name="std::vector<std::pair<unsigned char, unsigned int>*>" />
   <class name="TRT_BSErrContainer"  id="9DEEFC74-1772-4A81-B83D-3D4A123603B8" />
 
-  <class name="std::pair<unsigned int, unsigned char>" />
-  <class name="std::pair<unsigned char, std::pair<unsigned int, unsigned char> >" />
+  <class pattern="std::*pair*<unsigned int*unsigned char>" />
+  <class pattern="std::*pair*<unsigned char*std::pair<unsigned int*unsigned char> >" />
   <class name="std::vector<std::pair<unsigned char, std::pair<unsigned int, unsigned char> >*>" />
 
   <class name="TRT_BSIdErrContainer"  id="60735BF7-1781-4023-AC1E-5A6456E66423" />

InnerDetector/InDetConditions/InDetCondFolders/python/InDetAlignFolders.py

@@ -14,12 +14,12 @@ topSequence = AlgSequence()
 conddb.addFolderSplitOnline("TRT","/TRT/Onl/Calib/DX","/TRT/Calib/DX")
 
 # Dead/Noisy Straw Lists
-if DetFlags.simulate.any_on() or hasattr(topSequence,"OutputConditionsAlg"): # revert to old style CondHandle in case of simulation or streaming to POOL
+if hasattr(topSequence,"OutputConditionsAlg"): # revert to old style CondHandle in case streaming to POOL
     conddb.addFolderSplitOnline("TRT","/TRT/Onl/Cond/Status","/TRT/Cond/Status")
 else:
     conddb.addFolderSplitOnline("TRT","/TRT/Onl/Cond/Status","/TRT/Cond/Status",className='TRTCond::StrawStatusMultChanContainer')
 
-if DetFlags.simulate.any_on() or hasattr(topSequence,"OutputConditionsAlg"):
+if hasattr(topSequence,"OutputConditionsAlg"):
     conddb.addFolderSplitOnline("TRT","/TRT/Onl/Cond/StatusPermanent","/TRT/Cond/StatusPermanent")
 else:
     conddb.addFolderSplitOnline("TRT","/TRT/Onl/Cond/StatusPermanent","/TRT/Cond/StatusPermanent",className='TRTCond::StrawStatusMultChanContainer')
@@ -79,8 +79,6 @@ if DetFlags.TRT_on() and ((not DetFlags.simulate.TRT_on()) or DetFlags.overlay.T
         import os
         if "AthSimulation_DIR" not in os.environ: # Protection for AthSimulation builds
             condSeq += TRTAlignCondAlg
-
-
 if DetFlags.SCT_on() and ((not DetFlags.simulate.SCT_on()) or DetFlags.overlay.SCT_on()):
 
     if not hasattr(condSeq, "SCT_AlignCondAlg"):

InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_DCSConditionsConfig.py

@@ -44,5 +44,6 @@ def SCT_DCSConditionsCfg(flags, name="InDetSCT_DCSConditions", **kwargs):
         acc.addCondAlgo(hvAlg)
         tempAlg = SCT_DCSConditionsTempCondAlg(name=name + "TempCondAlg", ReadKey=tempFolder)
         acc.addCondAlgo(tempAlg)
-    return acc, tool
+    acc.setPrivateTools(tool)
+    return acc
 

InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_ReadCalibChipDataConfig.py

@@ -13,7 +13,7 @@ def SCT_ReadCalibChipDataToolCfg(flags, name="InDetSCT_ReadCalibChipDataTool", *
     return SCT_ReadCalibChipDataTool(name, **kwargs)
 
 def SCT_ReadCalibChipDataCfg(flags, name="SCT_ReadCalibChip", **kwargs):
-    """Return configured ComponentAccumulator and tool for SCT_ReadCalibChipDataCfg
+    """Return configured ComponentAccumulator with SCT_ReadCalibChipDataCfg tool
 
     Accepts optional noiseFolder and gainFolder keyword arguments
     """
@@ -29,5 +29,6 @@ def SCT_ReadCalibChipDataCfg(flags, name="SCT_ReadCalibChip", **kwargs):
     gainAlg = SCT_ReadCalibChipGainCondAlg(name=name + "GainCondAlg", ReadKey=gainFolder)
     acc.addCondAlgo(gainAlg)
     tool = kwargs.get("ReadCalibChipDataTool", SCT_ReadCalibChipDataToolCfg(flags))
-    return acc, tool
+    acc.setPrivateTools(tool)
+    return acc
 

InnerDetector/InDetConditions/SCT_ConditionsTools/python/SCT_SiliconConditionsConfig.py

@@ -30,5 +30,6 @@ def SCT_SiliconConditionsCfg(flags, name="SCT_Silicon", **kwargs):
         tempAlg = SCT_SiliconTempCondAlg(name=name + "TempCondAlg", **CondArgs)
         acc.addCondAlgo(hvAlg)
         acc.addCondAlgo(tempAlg)
-    return acc, tool
+    acc.setPrivateTools(tool)
+    return acc
 

InnerDetector/InDetConditions/SCT_ConditionsTools/test/SCT_ConditionsConfig_test.py

@@ -16,14 +16,10 @@ from SCT_ConditionsTools.SCT_ReadCalibChipDataConfig import SCT_ReadCalibChipDat
 log.setLevel(DEBUG)
 Configurable.configurableRun3Behavior = True
 ConfigFlags.Input.Files = defaultTestFiles.HITS
-# DCS
-DCSAcc, DCSTool = SCT_DCSConditionsCfg(ConfigFlags, name="DCSTest")
-# Silicon
-SiliconAcc, SiliconTool = SCT_SiliconConditionsCfg(ConfigFlags, name="SiliconTest")
-# ReadCalibChipData
-ReadAcc, ReadTool = SCT_ReadCalibChipDataCfg(ConfigFlags, name="ReadTest")
-# prevent raise on __del__
-DCSAcc.wasMerged()
-SiliconAcc.wasMerged()
-ReadAcc.wasMerged()
+# call tests
+tacc = SCT_DCSConditionsCfg(ConfigFlags, name="DCSTest")
+tacc.merge(SCT_SiliconConditionsCfg(ConfigFlags, name="SiliconTest"))
+tacc.merge(SCT_ReadCalibChipDataCfg(ConfigFlags, name="ReadTest"))
+# reset to prevent errors on deletion
+tacc.__init__()
 

InnerDetector/InDetConditions/SiLorentzAngleTool/python/PixelLorentzAngleConfig.py

@@ -23,12 +23,15 @@ def PixelLorentzAngleCfg(flags, name="PixelSiLorentzAngleCondAlg", **kwargs):
     """
     acc, svc = MagneticFieldSvcCfg(flags)
     tool = kwargs.get("SiLorentzAngleTool", PixelLorentzAngleToolCfg(flags))
-    acc.merge(PixelDCSConditionsCfg(flags))
-    SiPropAcc, SiPropTool = PixelSiPropertiesCfg(flags)
+    DCSCondAcc = PixelDCSConditionsCfg(flags)
+    DCSCondAcc.popPrivateTools()
+    acc.merge(DCSCondAcc)
+    SiPropAcc = PixelSiPropertiesCfg(flags)
     acc.merge(SiPropAcc)
-    kwargs.setdefault("SiPropertiesTool", SiPropTool)
+    kwargs.setdefault("SiPropertiesTool", SiPropAcc.popPrivateTools())
     kwargs.setdefault("UseMagFieldSvc", tool.UseMagFieldSvc)
     kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline)
     acc.addCondAlgo(PixelSiLorentzAngleCondAlg(name, **kwargs))
-    return acc, tool
+    acc.setPrivateTools(tool)
+    return acc
 

InnerDetector/InDetConditions/SiLorentzAngleTool/python/SCT_LorentzAngleConfig.py

@@ -39,19 +39,20 @@ def SCT_LorentzAngleCfg(flags, name="SCT_SiLorentzAngleCondAlg",
             DCSkwargs["hvFolder"] = dcs_folder + "/HV"
             DCSkwargs["tempFolder"] = dcs_folder + "/MODTEMP"
             DCSkwargs["stateFolder"] = dcs_folder + "/CHANSTAT"
-        DCSAcc, DCSTool = SCT_DCSConditionsCfg(flags, **DCSkwargs)
+        DCSAcc = SCT_DCSConditionsCfg(flags, **DCSkwargs)
         acc.merge(DCSAcc)
-        SCAcc, SCTool = SCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSTool)
+        SCAcc = SCT_SiliconConditionsCfg(flags, DCSConditionsTool=DCSAcc.popPrivateTools())
     else:
         SCTool = SCT_SiliconConditionsToolCfg(flags, UseDB=False, ForceUseGeoModel=True)
-        SCAcc, SCTool = SCT_SiliconConditionsCfg(flags, SiliconConditionsTool=SCTool)
+        SCAcc = SCT_SiliconConditionsCfg(flags, SiliconConditionsTool=SCTool)
+    SCAcc.popPrivateTools()
     acc.merge(SCAcc)
     # set up SCTSiLorentzAngleCondAlg
     kwargs.setdefault("UseMagFieldSvc", tool.UseMagFieldSvc)
     kwargs.setdefault("UseMagFieldDcs", not flags.Common.isOnline)
     kwargs.setdefault("UseGeoModel", forceUseGeoModel)
     kwargs.setdefault("useSctDefaults", False)
-    alg = SCTSiLorentzAngleCondAlg(name, **kwargs)
-    acc.addCondAlgo(alg)
-    return acc, tool
+    acc.addCondAlgo(SCTSiLorentzAngleCondAlg(name, **kwargs))
+    acc.setPrivateTools(tool)
+    return acc