diff --git a/Control/AthenaCommon/python/CFElements.py b/Control/AthenaCommon/python/CFElements.py
index 0d24c59db7525b841eac5ab6399f68ab9c735078..bf65e34ba9c380bb28f37770bf589a683eddc2bd 100755
--- a/Control/AthenaCommon/python/CFElements.py
+++ b/Control/AthenaCommon/python/CFElements.py
@@ -1,5 +1,5 @@
 from AthenaCommon.AlgSequence import AthSequencer
-
+import collections
 
 def parOR(name, subs=[]):
     """ parallel OR sequencer """
@@ -22,6 +22,39 @@ def seqAND(name, subs=[]):
         seq += s
     return seq
 
+def getAllSequenceNames(seq, depth=0):
+    """ Generate a list of sequence names and depths in the graph, e.g.
+    [('AthAlgSeq', 0), ('seq1', 1), ('seq2', 1), ('seq1', 2)]
+    represents
+    \\__ AthAlgSeq (seq: PAR AND)
+        \\__ seq1 (seq: SEQ AND)
+           \\__ seq2 (seq: SEQ AND)
+    """
+
+    seqNameList = [(seq.name(), depth)]
+    for c in seq.getChildren():
+      if isSequence(c):
+        seqNameList +=  getAllSequenceNames(c, depth+1)
+
+    return seqNameList
+
+def checkSequenceConsistency( seq ):
+    """ Enforce rules for sequence graph - identical items can only appear at same depth """
+    seqNameList = getAllSequenceNames(seq)
+    names = [sNL[0] for sNL in seqNameList]
+
+    for item, count in collections.Counter(names).items():
+        if count > 1:
+            depths = set()
+            for (name, depth) in seqNameList:
+                if name == item:
+                  depths.add(depth)
+            if len(depths) > 1:
+                if names[0] == name:
+                    raise RuntimeError("Sequence %s contains sub-sequence %s" %(name, name) )
+                else:
+                    raise RuntimeError("Sequence %s contains sub-sequence %s at different depths" %(names[0], item,) )
+
 def seqOR(name, subs=[]):
     """ sequential OR sequencer, used when a barrier needs to be set but all subs reached irrespective of the decision """
     seq = AthSequencer( name )
diff --git a/Control/AthenaConfiguration/python/ComponentAccumulator.py b/Control/AthenaConfiguration/python/ComponentAccumulator.py
index a85a9ffc3d2a1fbb4a153ceaefa517b3b1af8924..8aeb13c5ff584292c11268eaad4aa31207f62dcd 100644
--- a/Control/AthenaConfiguration/python/ComponentAccumulator.py
+++ b/Control/AthenaConfiguration/python/ComponentAccumulator.py
@@ -2,7 +2,7 @@
 
 from AthenaCommon.Logging import logging
 from AthenaCommon.Configurable import Configurable,ConfigurableService,ConfigurableAlgorithm,ConfigurableAlgTool
-from AthenaCommon.CFElements import isSequence,findSubSequence,findAlgorithm,flatSequencers,findOwningSequence
+from AthenaCommon.CFElements import isSequence,findSubSequence,findAlgorithm,flatSequencers,findOwningSequence,checkSequenceConsistency
 from AthenaCommon.AlgSequence import AthSequencer
 
 from AthenaConfiguration.AthConfigFlags import AthConfigFlags
@@ -126,9 +126,8 @@ class ComponentAccumulator(object):
             if parent is None:
                 raise ConfigurationError("Missing sequence %s to add new sequence to" % parentName )
 
-        if findSubSequence( parent, newseq.name() ):
-            raise ConfigurationError("Sequence %s already present" % newseq.name() )
         parent += newseq
+        checkSequenceConsistency(self._sequence)
         return newseq 
 
 
@@ -148,6 +147,7 @@ class ComponentAccumulator(object):
 
         owner.remove( seq )
         dest += seq
+        checkSequenceConsistency(self._sequence)
         return seq
 
 
@@ -442,6 +442,7 @@ class ComponentAccumulator(object):
                     else: # absent, adding
                         self._msg.debug("  Merging algorithm %s to a sequence %s", c.name(), dest.name() )
                         dest += c
+            checkSequenceConsistency(self._sequence)
                         
 
         #Merge sequences:
@@ -877,7 +878,7 @@ class TestHLTCF( unittest.TestCase ):
         self.assertNotEqual( s['hltSteps']['Members'], '[]', "Empty set of members in hltSteps, Sequences recording order metters" )
 
 
-class MultipleParrentsInSequences( unittest.TestCase ):
+class MultipleParentsInSequences( unittest.TestCase ):
     def runTest( self ):
        # test if an algorithm (or sequence) can be controlled by more than one sequence
         Configurable.configurableRun3Behavior=1
@@ -900,7 +901,7 @@ class MultipleParrentsInSequences( unittest.TestCase ):
         accTop.merge( acc1 )
         accTop.merge( acc2 )
                 
-        accTop.printConfig()
+        #accTop.printConfig()
 
         self.assertIsNotNone( findAlgorithm( accTop.getSequence( "seq1" ), "recoAlg" ), "Algorithm missing in the first sequence" )
         self.assertIsNotNone( findAlgorithm( accTop.getSequence( "seq2" ), "recoAlg" ), "Algorithm missing in the second sequence" )
@@ -918,6 +919,81 @@ class MultipleParrentsInSequences( unittest.TestCase ):
             self.assertEquals( s['seq2']["Members"], "['AthSequencer/seqReco']", "After pickling recoSeq missing in seq2 " + s['seq2']["Members"])
             self.assertEquals( s['seqReco']["Members"], "['ConfigurablePyAlgorithm/recoAlg']", "After pickling seqReco is corrupt " + s['seqReco']["Members"] )
 
+class ForbidRecursiveSequences( unittest.TestCase ):
+    def runTest( self ):
+        #Can't add a sequence with the same name below itself, e.g.
+        # \__ AthAlgSeq (seq: PAR AND)
+        #    \__ seq1 (seq: SEQ AND)
+        #       \__ seq1 (seq: SEQ AND)
+        def selfSequence():
+            Configurable.configurableRun3Behavior=1
+            from AthenaCommon.CFElements import seqAND
+            accTop = ComponentAccumulator()
+            accTop.store( open("test.pkl", "w") )#silence RuntimeError
+            seq1 = seqAND("seq1")
+            seq1_again = seqAND("seq1")
+            accTop.addSequence(seq1)
+            accTop.addSequence(seq1_again, parentName = "seq1")
+
+        #Allowed to add a sequence with the same name at same depth, e.g.
+        # \__ AthAlgSeq (seq: PAR AND)
+        #    \__ seq1 (seq: SEQ AND)
+        #       \__ seq2 (seq: SEQ AND)
+        #       \__ seq2 (seq: SEQ AND)
+        # should not raise any exceptions
+        def selfTwinSequence():
+            Configurable.configurableRun3Behavior=1
+            from AthenaCommon.CFElements import seqAND
+            accTop = ComponentAccumulator()
+            accTop.store( open("test.pkl", "w") )#silence RuntimeError
+            seq1 = seqAND("seq1")
+            seq2 = seqAND("seq2")
+            seq2_again = seqAND("seq1")
+            accTop.addSequence(seq1)
+            accTop.addSequence(seq2, parentName = "seq1")
+            accTop.addSequence(seq2_again, parentName = "seq1")
+            accTop.store( open("test.pkl", "w") )
+            
+
+        #Can't add a sequence with the same name two steps below itself, e.g.
+        # \__ AthAlgSeq (seq: PAR AND)
+        #    \__ seq1 (seq: SEQ AND)
+        #       \__ seq2 (seq: SEQ AND)
+        #          \__ seq1 (seq: SEQ AND)
+        def selfGrandParentSequence():
+            Configurable.configurableRun3Behavior=1
+            from AthenaCommon.CFElements import seqAND
+            accTop = ComponentAccumulator()
+            accTop.store( open("test.pkl", "w") )#silence RuntimeError
+            seq1 = seqAND("seq1")
+            seq2 = seqAND("seq2")
+            seq1_again = seqAND("seq1")
+            accTop.addSequence(seq1)
+            accTop.addSequence(seq2, parentName = "seq1")
+            accTop.addSequence(seq1_again, parentName = "seq2")
+            accTop.store(open("test.pkl", "w"))
+
+        #Can't merge sequences with the same name two steps below itself, e.g.
+        # \__ AthAlgSeq (seq: PAR AND)
+        #    \__ seq1 (seq: SEQ AND)
+        #       \__ seq2 (seq: SEQ AND)
+        #          \__ seq1 (seq: SEQ AND)
+        def selfMergedGrandParentSequence():
+            Configurable.configurableRun3Behavior=1
+            from AthenaCommon.CFElements import seqAND
+            acc1=ComponentAccumulator()
+            acc1.store( open("test.pkl", "w") )#silence RuntimeError
+            acc1.addSequence(seqAND("seq1"))
+            acc2=ComponentAccumulator()
+            acc2.store( open("test.pkl", "w") )#silence RuntimeError
+            acc2.addSequence(seqAND("seq2"))
+            acc2.addSequence(seqAND("seq1"), "seq2")
+            acc1.merge(acc2)
+
+        self.assertRaises(RuntimeError, selfSequence )
+        self.assertRaises(RuntimeError, selfGrandParentSequence )
+        self.assertRaises(RuntimeError, selfMergedGrandParentSequence )
+
 class FailedMerging( unittest.TestCase ):
     def runTest( self ):
         topCA = ComponentAccumulator()
@@ -944,8 +1020,12 @@ class MergeMovingAlgorithms( unittest.TestCase ):
 
         destinationCA.merge( sourceCA, sequenceName="dest"  )
         #destinationCA.merge( sourceCA ) 
+        destinationCA.store(open("test.pkl", "w"))#silence RuntimeError
+        sourceCA.store(open("test.pkl", "w"))#silence RuntimeError
         self.assertIsNotNone( findAlgorithm( destinationCA.getSequence("dest"), "alg1" ), "Algorithm not placed in sub-sequence" )
         self.assertIsNotNone( findSubSequence( destinationCA.getSequence(), "innerSeq" ), "The sequence is not added" )
         self.assertIsNotNone( findAlgorithm( destinationCA.getSequence("dest"), "alg3" ), "Algorithm deep in thesource CA not placed in sub-sequence of destiantion CA" )
 
         
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Control/RngComps/src/AthRNGSvc.cxx b/Control/RngComps/src/AthRNGSvc.cxx
index d49fe7979cc0a177a71cb625faca580b8adb7e41..4992afc5296f30ef7a065efca6ef9e651e57655f 100644
--- a/Control/RngComps/src/AthRNGSvc.cxx
+++ b/Control/RngComps/src/AthRNGSvc.cxx
@@ -43,8 +43,6 @@ StatusCode AthRNGSvc::initialize()
     return StatusCode::FAILURE;
   }
   
-  ATH_MSG_INFO("Selected random engine: \"" << m_rngType << "\"");
-
   return StatusCode::SUCCESS;
 }
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConditionsParameterTestAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConditionsParameterTestAlg.cxx
index 7e4d95c422c52c5d758991e1ddd81264adb0ca9f..5857013c413c5fe1b08dc84fd226dc10a8f66209 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConditionsParameterTestAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConditionsParameterTestAlg.cxx
@@ -71,19 +71,19 @@ StatusCode SCT_ConditionsParameterTestAlg::execute(const EventContext& ctx) cons
   ATH_MSG_INFO(m_conditionsParameterTool);
   
   try {
-    paramFilled =(m_conditionsParameterTool->filled());
+    paramFilled =(m_conditionsParameterTool->filled(ctx));
   } catch (...) {
     ATH_MSG_FATAL("Exception caught while trying to determine whether the data object was filled");
     return StatusCode::FAILURE;
   }
 
   try {
-    float maxval{m_conditionsParameterTool->max(SCT_CondParameterData::AVG_THRESHOLD)};
-    float minval{m_conditionsParameterTool->min(SCT_CondParameterData::AVG_THRESHOLD)};
-    float avg{m_conditionsParameterTool->avg(SCT_CondParameterData::AVG_THRESHOLD)};
-    float sd{m_conditionsParameterTool->sd(SCT_CondParameterData::AVG_THRESHOLD)};
-    unsigned int n{m_conditionsParameterTool->n(SCT_CondParameterData::AVG_THRESHOLD)};
-    float thresh{m_conditionsParameterTool->value(IdentifierHash{1760}, SCT_CondParameterData::AVG_THRESHOLD)};
+    float maxval{m_conditionsParameterTool->max(SCT_CondParameterData::AVG_THRESHOLD, ctx)};
+    float minval{m_conditionsParameterTool->min(SCT_CondParameterData::AVG_THRESHOLD, ctx)};
+    float avg{m_conditionsParameterTool->avg(SCT_CondParameterData::AVG_THRESHOLD, ctx)};
+    float sd{m_conditionsParameterTool->sd(SCT_CondParameterData::AVG_THRESHOLD, ctx)};
+    unsigned int n{m_conditionsParameterTool->n(SCT_CondParameterData::AVG_THRESHOLD, ctx)};
+    float thresh{m_conditionsParameterTool->value(IdentifierHash{1760}, SCT_CondParameterData::AVG_THRESHOLD, ctx)};
     ATH_MSG_INFO("   value element 1760: " << thresh);
     ATH_MSG_INFO("        max threshold: " << maxval);
     ATH_MSG_INFO("        min threshold: " << minval);
@@ -98,7 +98,7 @@ StatusCode SCT_ConditionsParameterTestAlg::execute(const EventContext& ctx) cons
   SCT_ConditionsAlgorithms::S_t histo;
   init(histo, 0.0, 8.0, 100);
   std::vector<float> values;
-  m_conditionsParameterTool->getValues(values, SCT_CondParameterData::AVG_THRESHOLD);
+  m_conditionsParameterTool->getValues(values, SCT_CondParameterData::AVG_THRESHOLD, ctx);
   for (float i: values) {
     fill(histo, i);
   }
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
index b5f5886a5264a939409c4701f85df0e811ea42d8..93bb496955e0f3c933cd18f898a943de51a05551 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
@@ -29,15 +29,15 @@ StatusCode SCT_ConfigurationConditionsTestAlg::initialize() {
   return StatusCode::SUCCESS;
 } 
 
-StatusCode SCT_ConfigurationConditionsTestAlg::execute(const EventContext& /*ctx*/) const {
+StatusCode SCT_ConfigurationConditionsTestAlg::execute(const EventContext& ctx) const {
   ATH_MSG_INFO("in execute()");
 
   // Bad modules
-  unsigned int nBadMods{static_cast<unsigned int>(m_configConditions->badModules()->size())};
+  unsigned int nBadMods{static_cast<unsigned int>(m_configConditions->badModules(ctx)->size())};
 
   // Bad links
   unsigned int nBadLink0{0}, nBadLink1{0}, nBadLinkBoth{0};
-  const std::map<IdentifierHash, std::pair<bool, bool>>* badLinks{m_configConditions->badLinks()};
+  const std::map<IdentifierHash, std::pair<bool, bool>>* badLinks{m_configConditions->badLinks(ctx)};
   std::map<IdentifierHash, std::pair<bool, bool>>::const_iterator linkItr{badLinks->begin()};
   std::map<IdentifierHash, std::pair<bool, bool>>::const_iterator linkEnd{badLinks->end()};
   while (linkItr != linkEnd) {
@@ -50,7 +50,7 @@ StatusCode SCT_ConfigurationConditionsTestAlg::execute(const EventContext& /*ctx
 
   // Bad chips
   unsigned int nBadChips{0};
-  const std::map<Identifier, unsigned int>* badChips{m_configConditions->badChips()};
+  const std::map<Identifier, unsigned int>* badChips{m_configConditions->badChips(ctx)};
   std::map<Identifier, unsigned int>::const_iterator chipItr{badChips->begin()};
   std::map<Identifier, unsigned int>::const_iterator chipEnd{badChips->end()};
   while (chipItr != chipEnd) {
@@ -61,12 +61,12 @@ StatusCode SCT_ConfigurationConditionsTestAlg::execute(const EventContext& /*ctx
 
   // Bad strips 
   std::set<Identifier> badStripsAll;
-  m_configConditions->badStrips(badStripsAll);
+  m_configConditions->badStrips(badStripsAll, ctx);
   unsigned int nBadStrips{static_cast<unsigned int>(badStripsAll.size())};
 
   // Bad strips (w/o bad modules and chips)
   std::set<Identifier> badStripsExclusive;
-  m_configConditions->badStrips(badStripsExclusive, true, true);
+  m_configConditions->badStrips(badStripsExclusive, ctx, true, true);
   unsigned int nBadStripsExclusive{static_cast<unsigned int>(badStripsExclusive.size())};
   unsigned int nBadStripsExclusiveBEC[]{0,0,0};
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_DCSConditionsTestAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_DCSConditionsTestAlg.cxx
index a45ecf9beba4bf67f15e3b1a0f0a1525096e4a37..154e8adfb8e4d7386e7800eeaed265cc1513a221 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_DCSConditionsTestAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_DCSConditionsTestAlg.cxx
@@ -41,7 +41,7 @@ StatusCode SCT_DCSConditionsTestAlg::execute(const EventContext& ctx) const {
   ATH_MSG_INFO(m_DCSConditionsTool);
   
   try {
-    gettempworks = (m_DCSConditionsTool->sensorTemperature(Identifier{141015041}, InDetConditions::SCT_STRIP));
+    gettempworks = (m_DCSConditionsTool->sensorTemperature(Identifier{141015041}, ctx, InDetConditions::SCT_STRIP));
     isgoodworks =(m_DCSConditionsTool->isGood(Identifier{208584704}, ctx, InDetConditions::SCT_SIDE));
     module = (m_DCSConditionsTool->canReportAbout(InDetConditions::SCT_MODULE));
     strip = (m_DCSConditionsTool->canReportAbout(InDetConditions::SCT_STRIP));
@@ -55,14 +55,14 @@ StatusCode SCT_DCSConditionsTestAlg::execute(const EventContext& ctx) const {
   ATH_MSG_INFO("gettemp(141015041,Strip) " << gettempworks);
 
   try {
-    gethvworks = (m_DCSConditionsTool->modHV(Identifier{141015041}, InDetConditions::SCT_STRIP));
+    gethvworks = (m_DCSConditionsTool->modHV(Identifier{141015041}, ctx, InDetConditions::SCT_STRIP));
   } catch(...) {
     ATH_MSG_FATAL("Exception caught while trying to the modHV method");
     return StatusCode::FAILURE;
   }
 
   ATH_MSG_INFO("gethv(141015041,Strip) " << (gethvworks ? "successful" : "failed"));
-  ATH_MSG_INFO("gethv(141015041,Strip) " << (m_DCSConditionsTool->modHV(Identifier{141015041}, InDetConditions::SCT_STRIP)));
+  ATH_MSG_INFO("gethv(141015041,Strip) " << (m_DCSConditionsTool->modHV(Identifier{141015041}, ctx, InDetConditions::SCT_STRIP)));
 
   try {
     isgoodworks = (m_DCSConditionsTool->isGood(Identifier{208584704}, ctx, InDetConditions::SCT_SIDE));
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconHVCondAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconHVCondAlg.cxx
index 6c1ab5f66c027eec5540f9cafbdb1a616aa6c13b..3e2beea77a1508311ad1ea22cd353304822fe9a7 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconHVCondAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconHVCondAlg.cxx
@@ -99,7 +99,7 @@ StatusCode SCT_SiliconHVCondAlg::execute(const EventContext& ctx) const {
   std::unique_ptr<SCT_DCSFloatCondData> writeCdo{std::make_unique<SCT_DCSFloatCondData>()};
   const SCT_ID::size_type wafer_hash_max{m_pHelper->wafer_hash_max()};
   for (SCT_ID::size_type hash{0}; hash<wafer_hash_max; hash++) {
-    writeCdo->setValue(hash, m_sctDCSTool->modHV(IdentifierHash(hash)));
+    writeCdo->setValue(hash, m_sctDCSTool->modHV(IdentifierHash(hash), ctx));
   }
 
   // Record the output cond object
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconTempCondAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconTempCondAlg.cxx
index 3b7fd66f69b519eaf7ceeb2a391605164251fa1d..a6a802d687c12839d6e037969df7599a9b74cb0e 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconTempCondAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_SiliconTempCondAlg.cxx
@@ -99,7 +99,7 @@ StatusCode SCT_SiliconTempCondAlg::execute(const EventContext& ctx) const {
   std::unique_ptr<SCT_DCSFloatCondData> writeCdo{std::make_unique<SCT_DCSFloatCondData>()};
   const SCT_ID::size_type wafer_hash_max{m_pHelper->wafer_hash_max()};
   for (SCT_ID::size_type hash{0}; hash<wafer_hash_max; hash++) {
-    writeCdo->setValue(hash, m_sctDCSTool->sensorTemperature(IdentifierHash(hash)));
+    writeCdo->setValue(hash, m_sctDCSTool->sensorTemperature(IdentifierHash(hash), ctx));
   }
 
   // Record the output cond object
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h
index 0350b90af779d2a6f4d0b800e6cd06cc13e52ce5..c8764ed0a83ca2dc30e01217351abe7c213ff4cc 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ByteStreamErrorsTool.h
@@ -43,15 +43,21 @@ class ISCT_ByteStreamErrorsTool: virtual public ISCT_ConditionsTool {
   virtual const std::set<IdentifierHash>* getErrorSet(int errorType, const EventContext& ctx) const =0;
 
   virtual bool isRODSimulatedData() const =0;
+  virtual bool isRODSimulatedData(const EventContext& ctx) const =0;
   virtual bool isRODSimulatedData(const IdentifierHash& elementIdHash) const =0;
+  virtual bool isRODSimulatedData(const IdentifierHash& elementIdHash, const EventContext& ctx) const =0;
 
   virtual bool isCondensedReadout() const =0;
-  virtual bool HVisOn() const =0;
+  virtual bool isCondensedReadout(const EventContext& ctx) const =0;
+  virtual bool isHVOn() const =0;
+  virtual bool isHVOn(const EventContext& ctx) const =0;
 
   /** Temporary status of chips for a particular module (packed as 1st 12 bits of unsigned int) */
   virtual unsigned int tempMaskedChips(const Identifier& moduleId) const =0;
+  virtual unsigned int tempMaskedChips(const Identifier& moduleId, const EventContext& ctx) const =0;
   /** Status ABCD errors of chips for a particular module (packed as 1st 12 bits of unsigned int) */
   virtual unsigned int abcdErrorChips(const Identifier& moduleId) const =0;
+  virtual unsigned int abcdErrorChips(const Identifier& moduleId, const EventContext& ctx) const =0;
 
  private:
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ChargeTrappingTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ChargeTrappingTool.h
index cc19ca50f7adbf8de85885202571e1fce88aa505..10640ca78b31f11ed1373a8e09c977edd0989562 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ChargeTrappingTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ChargeTrappingTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -16,6 +16,7 @@
 #include "SCT_ConditionsData/SCT_ChargeTrappingCondData.h"
 
 //Gaudi Includes
+#include "GaudiKernel/EventContext.h"
 #include "GaudiKernel/IAlgTool.h"
 
 //forward declarations
@@ -34,7 +35,9 @@ class ISCT_ChargeTrappingTool: virtual public IAlgTool
   /// Creates the InterfaceID and interfaceID() method
   DeclareInterfaceID(ISCT_ChargeTrappingTool, 1, 0);
 
+  virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, double pos, const EventContext& ctx) const =0;
   virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, double pos) const =0;
+  virtual void getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& ctx) const =0;
   virtual void getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const =0;
 
 };
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConditionsParameterTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConditionsParameterTool.h
index 23527da02f868b18e9d63fa91ed0bb9d1d702519..d14b82470f8ef2847fb68c99b2eaeda521e81e7c 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConditionsParameterTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConditionsParameterTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -11,15 +11,16 @@
 #ifndef ISCT_ConditionsParameterTool_h
 #define ISCT_ConditionsParameterTool_h
 
-//STL includes
-#include <vector>
+//Athena includes
+#include "SCT_ConditionsData/SCT_CondParameterData.h"
+#include "Identifier/IdentifierHash.h"
 
 //Gaudi Includes
+#include "GaudiKernel/EventContext.h"
 #include "GaudiKernel/IAlgTool.h"
 
-//Athena includes
-#include "SCT_ConditionsData/SCT_CondParameterData.h"
-#include "Identifier/IdentifierHash.h"
+//STL includes
+#include <vector>
 
 /**
  * @class ISCT_ConditionsParameterSvc
@@ -33,39 +34,51 @@ class ISCT_ConditionsParameterTool: virtual public IAlgTool {
   DeclareInterfaceID(ISCT_ConditionsParameterTool, 1, 0);
   
   ///Is the required parameter available?
+  virtual bool available(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual bool available(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Give the indicated value for a module identifier hash
+  virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
+  virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Is a given value within acceptable limits?
+  virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///What is the default error value for this parameter?
+  virtual float invalid(const unsigned int iparam, const EventContext& ctx) const =0;
   virtual float invalid(const unsigned int iparam) const =0;
   
   ///Maximum value read in from the database
+  virtual float max(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float max(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Minimum value read in from the database
+  virtual float min(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float min(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Average value
+  virtual float avg(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float avg(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Standard deviation
+  virtual float sd(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual float sd(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Number of values read in
+  virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam) const =0;
   
   ///Fill a user-provided vector with the values (hopefully won't be needed?)
+  virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const =0;
   virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const =0;
  
   ///Report whether the structure was filled
+  virtual bool filled(const EventContext& ctx) const =0;
   virtual bool filled() const =0;
 };
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
index 22117eb57fbf413fd931fb34963e4b954930ba57..ab6abe8f7968926c1b392f7018fea63e7bda8d18 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -39,24 +39,32 @@ class ISCT_ConfigurationConditionsTool: virtual public ISCT_ConditionsTool {
   //@}
 
   /** Set of bad module Identifiers */
+  virtual const std::set<Identifier>* badModules(const EventContext& ctx) const =0;
   virtual const std::set<Identifier>* badModules() const =0;
 
   /** Map of link status for all modules with at least one bad link (true = good, false = bad)*/
+  virtual const std::map<IdentifierHash, std::pair<bool, bool> >* badLinks(const EventContext& ctx) const =0;
   virtual const std::map<IdentifierHash, std::pair<bool, bool> >* badLinks() const =0;
   /** Link status for a particluar module (true = good, false = bad)*/
+  virtual std::pair<bool, bool> badLinks(const IdentifierHash& hash, const EventContext& ctx) const =0;
   virtual std::pair<bool, bool> badLinks(const IdentifierHash& hash) const =0;
 
   /** Map of chips status for all modules with at least one bad chip (packed as 1st 12 bits of unsigned int)*/
+  virtual const std::map<Identifier, unsigned int>* badChips(const EventContext& ctx) const =0;
   virtual const std::map<Identifier, unsigned int>* badChips() const =0;
   /** Chips status for a particular module (packed as 1st 12 bits of unsigned int)*/ 
+  virtual unsigned int badChips(const Identifier& moduleId, const EventContext& ctx) const =0;
   virtual unsigned int badChips(const Identifier& moduleId) const =0;
 
   /** Set of bad strip Identifiers */ 
+  virtual void badStrips(std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const =0;
   virtual void badStrips(std::set<Identifier>& strips, bool ignoreBadModules=false, bool ignoreBadChips=false) const =0;
   /** Set of bad strip Identifiers for a particular module*/
+  virtual void badStrips(const Identifier& moduleId, std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const =0;
   virtual void badStrips(const Identifier& moduleId, std::set<Identifier>& strips, bool ignoreBadModules=false, bool ignoreBadChips=false) const =0;
 
   /** Get the chip number containing a particular strip*/
+  virtual int getChip(const Identifier& stripId, const EventContext& ctx) const =0;
   virtual int getChip(const Identifier& stripId) const =0;
 
  private:
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_DCSConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_DCSConditionsTool.h
index c0d11530fe6f2c8ea5650eb4a015f426c2ae83fc..f56f8847b65ed12e9fc25bd333ce0c04cd1a0200 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_DCSConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_DCSConditionsTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -34,16 +34,22 @@ class ISCT_DCSConditionsTool: virtual public ISCT_ConditionsTool {
   DeclareInterfaceID(ISCT_DCSConditionsTool, 1, 0);
 
   //@}
+  virtual float modHV(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   virtual float modHV(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   //Does the same for hashIds
+  virtual float modHV(const IdentifierHash& hashId, const EventContext& ctx) const =0;
   virtual float modHV(const IdentifierHash& hashId) const =0;
   //Returns temp0 (0 if there is no information)
+  virtual float hybridTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   virtual float hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   //Does the same for hashIds
+  virtual float hybridTemperature(const IdentifierHash& hashId, const EventContext& ctx) const =0;
   virtual float hybridTemperature(const IdentifierHash& hashId) const =0;
   //Returns temp0 + correction for Lorentz angle calculation (0 if there is no information)
+  virtual float sensorTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   virtual float sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const =0;
   //Does the same for hashIds
+  virtual float sensorTemperature(const IdentifierHash& hashId, const EventContext& ctx) const =0;
   virtual float sensorTemperature(const IdentifierHash& hashId) const =0;
 
  private:
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h
index 5401d36a5ae9e82badfe61dbe48d6f53f69a2db2..72e40dd887f2ed8d65e4a806be23de7143bec20b 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -12,12 +12,13 @@
 #ifndef ISCT_RadDamageSummaryTool_h
 #define ISCT_RadDamageSummaryTool_h
 
-//Gaudi Includes
-#include "GaudiKernel/IAlgTool.h"
-
 //Athena include
 #include "SCT_ConditionsData/SCT_ChargeTrappingCondData.h"
 
+//Gaudi Includes
+#include "GaudiKernel/EventContext.h"
+#include "GaudiKernel/IAlgTool.h"
+
 //forward declarations
 class IdentifierHash;
 
@@ -34,7 +35,9 @@ class ISCT_RadDamageSummaryTool: virtual public IAlgTool
   /// Creates the InterfaceID and interfaceID() method
   DeclareInterfaceID(ISCT_RadDamageSummaryTool, 1, 0);
 
+  virtual void holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& ctx) const =0;
   virtual void holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const =0;
+  virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, const double& zpos, const EventContext& ctx) const =0;
   virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, const double& zpos) const =0;
 };
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
index a66025bc224e57cd1ff6400127486a6987d75af2..6e183f6890f71cb711798c370077e4ef80c1467e 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
@@ -67,19 +67,31 @@ SCT_ByteStreamErrorsTool::finalize() {
 ////////////////////////////////////////////////////////////////////////////////////
 
 bool
-SCT_ByteStreamErrorsTool::isCondensedReadout() const {
-  const SCT_ByteStreamFractionContainer* fracData{getFracData()};
+SCT_ByteStreamErrorsTool::isCondensedReadout(const EventContext& ctx) const {
+  const SCT_ByteStreamFractionContainer* fracData{getFracData(ctx)};
   if (fracData==nullptr) return false;
   return fracData->majority(SCT_ByteStreamFractionContainer::CondensedMode);
 }
 
 bool
-SCT_ByteStreamErrorsTool::HVisOn() const {
-  const SCT_ByteStreamFractionContainer* fracData{getFracData()};
+SCT_ByteStreamErrorsTool::isCondensedReadout() const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return isCondensedReadout(ctx);
+}
+
+bool
+SCT_ByteStreamErrorsTool::isHVOn(const EventContext& ctx) const {
+  const SCT_ByteStreamFractionContainer* fracData{getFracData(ctx)};
   if (fracData==nullptr) return true;
   return fracData->majority(SCT_ByteStreamFractionContainer::HVOn);
 }
 
+bool
+SCT_ByteStreamErrorsTool::isHVOn() const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return isHVOn(ctx);
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 /** Used by ConditionsSummayTool to decide whether to call isGood() for a particular
@@ -104,7 +116,7 @@ SCT_ByteStreamErrorsTool::canReportAbout(InDetConditions::Hierarchy h) const {
  
 bool 
 SCT_ByteStreamErrorsTool::isGood(const IdentifierHash& elementIdHash, const EventContext& ctx) const {
-  if (m_checkRODSimulatedData and isRODSimulatedData(elementIdHash)) return false;
+  if (m_checkRODSimulatedData and isRODSimulatedData(elementIdHash, ctx)) return false;
   
   bool result{true};
 
@@ -117,9 +129,9 @@ SCT_ByteStreamErrorsTool::isGood(const IdentifierHash& elementIdHash, const Even
   // If all 6 chips of a link issue ABCD errors or are bad chips or temporarily masked chips, the link is treated as bad one. 
   const Identifier wafer_id{m_sct_id->wafer_id(elementIdHash)};
   const Identifier module_id{m_sct_id->module_id(wafer_id)};
-  unsigned int badChips{m_config->badChips(module_id)};
-  unsigned int abcdErrorChips2{abcdErrorChips(module_id)};
-  unsigned int tempMaskedChips2{tempMaskedChips(module_id)};
+  unsigned int badChips{m_config->badChips(module_id, ctx)};
+  unsigned int abcdErrorChips2{abcdErrorChips(module_id, ctx)};
+  unsigned int tempMaskedChips2{tempMaskedChips(module_id, ctx)};
   const int side{m_sct_id->side(wafer_id)};
   bool allChipsBad{true};
   const int idMax{static_cast<short>(side==0 ? 6 : 12)};
@@ -151,7 +163,7 @@ SCT_ByteStreamErrorsTool::isGood(const Identifier& elementId, const EventContext
     return isGood(elementIdHash, ctx);
   }
   if (h==InDetConditions::SCT_CHIP) {
-    return isGoodChip(elementId);
+    return isGoodChip(elementId, ctx);
   }
 
   return true;
@@ -165,7 +177,7 @@ SCT_ByteStreamErrorsTool::isGood(const Identifier& elementId, InDetConditions::H
 }
 
 bool
-SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId) const {
+SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId, const EventContext& ctx) const {
   // This check assumes present SCT.
   // Get module number
   const Identifier moduleId{m_sct_id->module_id(stripId)};
@@ -176,7 +188,7 @@ SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId) const {
 
   const Identifier waferId{m_sct_id->wafer_id(stripId)};
   const IdentifierHash waferHash{m_sct_id->wafer_hash(waferId)};
-  if (m_checkRODSimulatedData and isRODSimulatedData(waferHash)) return false;
+  if (m_checkRODSimulatedData and isRODSimulatedData(waferHash, ctx)) return false;
 
   // tempMaskedChips and abcdErrorChips hold 12 bits.
   // bit 0 (LSB) is chip 0 for side 0.
@@ -184,9 +196,9 @@ SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId) const {
   // bit 6 is chip 6 for side 1.
   // bit 11 is chip 11 for side 1.
   // Temporarily masked chip information
-  const unsigned int v_tempMaskedChips{tempMaskedChips(moduleId)};
+  const unsigned int v_tempMaskedChips{tempMaskedChips(moduleId, ctx)};
   // Information of chips with ABCD errors
-  const unsigned int v_abcdErrorChips{abcdErrorChips(moduleId)};
+  const unsigned int v_abcdErrorChips{abcdErrorChips(moduleId, ctx)};
   // Take 'OR' of tempMaskedChips and abcdErrorChips
   const unsigned int badChips{v_tempMaskedChips | v_abcdErrorChips};
 
@@ -200,7 +212,7 @@ SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId) const {
   // If there is no bad chip on the side, this check is done.
   if ((side==0 and (badChips & 0x3F)==0) or (side==1 and (badChips & 0xFC0)==0)) return true;
 
-  int chip{getChip(stripId)};
+  int chip{getChip(stripId, ctx)};
   if (chip<0 or chip>=12) {
     ATH_MSG_WARNING("chip number is invalid: " << chip);
     return false;
@@ -213,10 +225,10 @@ SCT_ByteStreamErrorsTool::isGoodChip(const Identifier& stripId) const {
 }
 
 int
-SCT_ByteStreamErrorsTool::getChip(const Identifier& stripId) const {
+SCT_ByteStreamErrorsTool::getChip(const Identifier& stripId, const EventContext& ctx) const {
   const Identifier waferId{m_sct_id->wafer_id(stripId)};
   const IdentifierHash waferHash{m_sct_id->wafer_hash(waferId)};
-  const InDetDD::SiDetectorElement* siElement{getDetectorElement(waferHash)};
+  const InDetDD::SiDetectorElement* siElement{getDetectorElement(waferHash, ctx)};
   if (siElement==nullptr) {
     ATH_MSG_DEBUG ("InDetDD::SiDetectorElement is not obtained from stripId " << stripId);
     return -1;
@@ -273,15 +285,25 @@ SCT_ByteStreamErrorsTool::resetSets(const EventContext& ctx) const {
  * e.g. for monitoring plots.
  */
 
-const std::set<IdentifierHash>* 
-SCT_ByteStreamErrorsTool::getErrorSet(int errorType) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
+const std::set<IdentifierHash>*
+SCT_ByteStreamErrorsTool::getErrorSet(int errorType, const EventContext& ctx) const {
   if (errorType>=0 and errorType<SCT_ByteStreamErrors::NUM_ERROR_TYPES) {
-    return getErrorSet(errorType, ctx);
+    StatusCode sc{fillData(ctx)};
+    if (sc.isFailure()) {
+      ATH_MSG_ERROR("fillData in getErrorSet fails");
+    }
+
+    return &m_bsErrors[errorType][ctx.slot()];
   }
   return nullptr;
 }
 
+const std::set<IdentifierHash>* 
+SCT_ByteStreamErrorsTool::getErrorSet(int errorType) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return getErrorSet(errorType, ctx);
+}
+
 ////////////////////////////////////////////////////////////////////////
 
 /** this function is used to populate the data of this tool from 
@@ -347,7 +369,7 @@ SCT_ByteStreamErrorsTool::fillData(const EventContext& ctx) const {
     } else if (elt->second>=SCT_ByteStreamErrors::TempMaskedChip0 and elt->second<=SCT_ByteStreamErrors::TempMaskedChip5) {
       m_tempMaskedChips[slot][module_id] |= (1 << (elt->second-SCT_ByteStreamErrors::TempMaskedChip0 + side*6));
     } else {
-      std::pair<bool, bool> badLinks{m_config->badLinks(elt->first)};
+      std::pair<bool, bool> badLinks{m_config->badLinks(elt->first, ctx)};
       bool result{(side==0 ? badLinks.first : badLinks.second) and (badLinks.first xor badLinks.second)};
       if (result) {
         /// error in a module using RX redundancy - add an error for the other link as well!!
@@ -385,40 +407,59 @@ SCT_ByteStreamErrorsTool::addError(const IdentifierHash& id, int errorType, cons
 /** A bit from a particular word in the ByteStream if the data
  * is coming from the ROD simulator rather than real modules. */
 bool
-SCT_ByteStreamErrorsTool::isRODSimulatedData() const {
-  const SCT_ByteStreamFractionContainer* fracData{getFracData()};
+SCT_ByteStreamErrorsTool::isRODSimulatedData(const EventContext& ctx) const {
+  const SCT_ByteStreamFractionContainer* fracData{getFracData(ctx)};
   if (fracData==nullptr) return false;
   return fracData->majority(SCT_ByteStreamFractionContainer::SimulatedData);
 }
 
-///////////////////////////////////////////////////////////////////////////////
 bool
-SCT_ByteStreamErrorsTool::isRODSimulatedData(const IdentifierHash& elementIdHash) const {
+SCT_ByteStreamErrorsTool::isRODSimulatedData() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return isRODSimulatedData(ctx);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+bool
+SCT_ByteStreamErrorsTool::isRODSimulatedData(const IdentifierHash& elementIdHash, const EventContext& ctx) const {
   const std::set<IdentifierHash>* errorSet{getErrorSet(SCT_ByteStreamErrors::RODSimulatedData, ctx)};
   return (errorSet->count(elementIdHash)!=0);
 }
 
+bool
+SCT_ByteStreamErrorsTool::isRODSimulatedData(const IdentifierHash& elementIdHash) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return isRODSimulatedData(elementIdHash, ctx);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
-unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips(const Identifier& moduleId) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
+unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips(const Identifier& moduleId, const EventContext& ctx) const {
   const std::map<Identifier, unsigned int>& v_tempMaskedChips{getTempMaskedChips(ctx)};
   std::map<Identifier, unsigned int>::const_iterator it{v_tempMaskedChips.find(moduleId)};
   if (it!=v_tempMaskedChips.end()) return it->second;
   return 0;
 }
 
-unsigned int SCT_ByteStreamErrorsTool::abcdErrorChips(const Identifier& moduleId) const {
+unsigned int SCT_ByteStreamErrorsTool::tempMaskedChips(const Identifier& moduleId) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return tempMaskedChips(moduleId, ctx);
+}
+
+unsigned int SCT_ByteStreamErrorsTool::abcdErrorChips(const Identifier& moduleId, const EventContext& ctx) const {
   const std::map<Identifier, unsigned int>& v_abcdErrorChips{getAbcdErrorChips(ctx)};
   std::map<Identifier, unsigned int>::const_iterator it{v_abcdErrorChips.find(moduleId)};
   if (it!=v_abcdErrorChips.end()) return it->second;
   return 0;
 }
 
-const SCT_ByteStreamFractionContainer* SCT_ByteStreamErrorsTool::getFracData() const {
-  SG::ReadHandle<SCT_ByteStreamFractionContainer> fracCont{m_bsFracContainerName};
+unsigned int SCT_ByteStreamErrorsTool::abcdErrorChips(const Identifier& moduleId) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return abcdErrorChips(moduleId, ctx);
+}
+
+const SCT_ByteStreamFractionContainer* SCT_ByteStreamErrorsTool::getFracData(const EventContext& ctx) const {
+  SG::ReadHandle<SCT_ByteStreamFractionContainer> fracCont{m_bsFracContainerName, ctx};
   if (not fracCont.isValid()) {
     ATH_MSG_INFO(m_bsFracContainerName.key() << " cannot be retrieved");
     return nullptr;
@@ -426,9 +467,7 @@ const SCT_ByteStreamFractionContainer* SCT_ByteStreamErrorsTool::getFracData() c
   return fracCont.ptr();
 }
 
-const InDetDD::SiDetectorElement* SCT_ByteStreamErrorsTool::getDetectorElement(const IdentifierHash& waferHash) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
-
+const InDetDD::SiDetectorElement* SCT_ByteStreamErrorsTool::getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const {
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
@@ -448,15 +487,6 @@ const InDetDD::SiDetectorElement* SCT_ByteStreamErrorsTool::getDetectorElement(c
   return m_detectorElements->getDetectorElement(waferHash);
 }
 
-const std::set<IdentifierHash>* SCT_ByteStreamErrorsTool::getErrorSet(int errorType, const EventContext& ctx) const {
-  StatusCode sc{fillData(ctx)};
-  if (sc.isFailure()) {
-    ATH_MSG_ERROR("fillData in getErrorSet fails");
-  }
-
-  return &m_bsErrors[errorType][ctx.slot()];
-}
-
 const std::map<Identifier, unsigned int>& SCT_ByteStreamErrorsTool::getTempMaskedChips(const EventContext& ctx) const { 
   StatusCode sc{fillData(ctx)};
   if (sc.isFailure()) {
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.h
index 7a612ce579d8b3e6e001d695df878fcaabc37bc5..1a25f175a4a147277ab65e6ad2b54fb65b23436a 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.h
@@ -63,14 +63,20 @@ public:
   virtual bool isGood(const IdentifierHash& elementIdHash) const override;
   virtual bool isGood(const IdentifierHash& elementIdHash, const EventContext& ctx) const override;
   
-  const std::set<IdentifierHash>* getErrorSet(int errorType) const override; // Used by SCTRawDataProviderTool and others
   const std::set<IdentifierHash>* getErrorSet(int errorType, const EventContext& ctx) const override; // Used by SCTRawDataProviderTool and others
+  const std::set<IdentifierHash>* getErrorSet(int errorType) const override; // Used by SCTRawDataProviderTool and others
 
-  virtual unsigned int tempMaskedChips(const Identifier& moduleId) const override; // Internally used
+  virtual unsigned int tempMaskedChips(const Identifier& moduleId, const EventContext& ctx) const override; // Internally used
+  virtual unsigned int tempMaskedChips(const Identifier& moduleId) const override;
   virtual unsigned int abcdErrorChips(const Identifier& moduleId) const override; // Internally used
+  virtual unsigned int abcdErrorChips(const Identifier& moduleId, const EventContext& ctx) const override; // Internally used
+  virtual bool isRODSimulatedData(const EventContext& ctx) const override; // Internally used
   virtual bool isRODSimulatedData() const override; // Internally used
+  virtual bool isRODSimulatedData(const IdentifierHash& elementIdHash, const EventContext& ctx) const override;
   virtual bool isRODSimulatedData(const IdentifierHash& elementIdHash) const override;
-  virtual bool HVisOn() const override; // Internally used
+  virtual bool isHVOn(const EventContext& ctx) const override; // Not used
+  virtual bool isHVOn() const override; // Not used
+  virtual bool isCondensedReadout(const EventContext& ctx) const override; // Not used
   virtual bool isCondensedReadout() const override; // Not used
 
 private:
@@ -107,12 +113,12 @@ private:
   void addError(const IdentifierHash& id, int errorType, const EventContext& ctx) const;
   void resetSets(const EventContext& ctx) const;
 
-  bool isGoodChip(const Identifier& stripId) const;
-  int getChip(const Identifier& stripId) const;
+  bool isGoodChip(const Identifier& stripId, const EventContext& ctx) const;
+  int getChip(const Identifier& stripId, const EventContext& ctx) const;
 
   // For isRODSimulatedData, HVisOn and isCondensedReadout
-  const SCT_ByteStreamFractionContainer* getFracData() const;
-  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash) const;
+  const SCT_ByteStreamFractionContainer* getFracData(const EventContext& ctx) const;
+  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const;
 
   const std::map<Identifier, unsigned int>& getTempMaskedChips(const EventContext& ctx) const;
   const std::map<Identifier, unsigned int>& getAbcdErrorChips(const EventContext& ctx) const;
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
index 73a5c94412c904dae7d2e137282553f20603baeb..b586e11a1d2d4edabe0722040fa2392fcf5d0bfc 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -89,17 +89,30 @@ StatusCode SCT_ChargeTrappingTool::finalize()
   return StatusCode::SUCCESS;
 }
 
+SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::getCondData(const IdentifierHash& elementHash, double pos, const EventContext& ctx) const
+{
+  return calculate(elementHash, pos, ctx);
+}
+
 SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::getCondData(const IdentifierHash& elementHash, double pos) const
 {
-  return calculate(elementHash, pos);
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return getCondData(elementHash, pos, ctx);
 }
 
-void SCT_ChargeTrappingTool::getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const
+void SCT_ChargeTrappingTool::getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& /*ctx*/) const
 {
   holeTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2);
 }
 
-SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::calculate(const IdentifierHash& elementHash, double pos) const
+void SCT_ChargeTrappingTool::getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const
+{
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  getHoleTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2, ctx);
+}
+
+
+SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::calculate(const IdentifierHash& elementHash, double pos, const EventContext& ctx) const
 {
   ATH_MSG_VERBOSE("Updating cache  for elementHash = " << elementHash);
   
@@ -113,7 +126,7 @@ SCT_ChargeTrappingCondData SCT_ChargeTrappingTool::calculate(const IdentifierHas
   
   SCT_ChargeTrappingCondData condData;
 
-  const InDetDD::SiDetectorElement* element{getDetectorElement(elementHash)};
+  const InDetDD::SiDetectorElement* element{getDetectorElement(elementHash, ctx)};
   
   double temperature{0.};
   double deplVoltage{0.};
@@ -339,9 +352,7 @@ void SCT_ChargeTrappingTool::holeTransport(double& x0, double& y0, double& xfin,
   return;
 }
 
-const InDetDD::SiDetectorElement* SCT_ChargeTrappingTool::getDetectorElement(const IdentifierHash& waferHash) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
-
+const InDetDD::SiDetectorElement* SCT_ChargeTrappingTool::getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const {
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.h
index 6300fbc9798174a9c44e7876340bc3d271d31d62..cebfbdee1ce426cae11b242ab32537e5b3ada716 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -48,11 +48,13 @@ class SCT_ChargeTrappingTool: public extends<AthAlgTool, ISCT_ChargeTrappingTool
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
 
+  virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, double pos, const EventContext& ctx) const override;
   virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, double pos) const override;
+  virtual void getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& ctx) const override;
   virtual void getHoleTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const override;
   
  private:
-  SCT_ChargeTrappingCondData calculate(const IdentifierHash& elementHash, double pos) const;
+  SCT_ChargeTrappingCondData calculate(const IdentifierHash& elementHash, double pos, const EventContext& ctx) const;
   double induced(int istrip, double x, double y) const;
   double getPotentialValue(int& ix, int& iy);
   void holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const;
@@ -90,7 +92,7 @@ class SCT_ChargeTrappingTool: public extends<AthAlgTool, ISCT_ChargeTrappingTool
   mutable std::vector<EventContext::ContextEvt_t> m_cacheElements;
   // Pointer of InDetDD::SiDetectorElementCollection
   mutable Gaudi::Hive::ContextSpecificPtr<const InDetDD::SiDetectorElementCollection> m_detectorElements;
-  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash) const;
+  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const;
 };
 
 #endif // SCT_ChargeTrappingTool_h
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.cxx
index 54da696e7ad51d0d7d191a6a7818f499f3daa6a1..832394676e10ef50318af0294ac6e65e0224b1be 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.cxx
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 /**
@@ -32,35 +32,59 @@ SCT_ConditionsParameterTool::finalize() {
 
 ///Is the required parameter available?
 bool
-SCT_ConditionsParameterTool::available(const SCT_CondParameterData::ParameterIndex iparam) const {
+SCT_ConditionsParameterTool::available(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& /*ctx*/) const {
   return (iparam==SCT_CondParameterData::AVG_THRESHOLD);
 }
 
+bool
+SCT_ConditionsParameterTool::available(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return available(iparam, ctx);
+}
+
 ///Give the indicated value for a module identifier hash
 float
-SCT_ConditionsParameterTool::value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->getValue(idHash, iparam);
 }
 
+float
+SCT_ConditionsParameterTool::value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return value(idHash, iparam, ctx);
+}
+
 ///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
 float
-SCT_ConditionsParameterTool::validity(const IdentifierHash& /*idHash*/, const SCT_CondParameterData::ParameterIndex /*iparam*/) const {
+SCT_ConditionsParameterTool::validity(const IdentifierHash& /*idHash*/, const SCT_CondParameterData::ParameterIndex /*iparam*/, const EventContext& /*ctx*/) const {
   return 1.0;
 }
 
+float
+SCT_ConditionsParameterTool::validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return validity(idHash, iparam, ctx);
+}
+
 ///Is a given value within acceptable limits?
 bool 
-SCT_ConditionsParameterTool::isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->isValid(parameterValue, iparam);
 }
 
+bool 
+SCT_ConditionsParameterTool::isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return isValid(parameterValue, iparam, ctx);
+}
+
 ///What is the default error value for this parameter?
 float
-SCT_ConditionsParameterTool::invalid(const unsigned int iparam) const {
+SCT_ConditionsParameterTool::invalid(const unsigned int iparam, const EventContext& /*ctx*/) const {
   float result{0.0};
   if (iparam==SCT_CondParameterData::AVG_THRESHOLD) {
     result=std::numeric_limits<float>::quiet_NaN();
@@ -68,63 +92,111 @@ SCT_ConditionsParameterTool::invalid(const unsigned int iparam) const {
   return result;
 }
 
+float
+SCT_ConditionsParameterTool::invalid(const unsigned int iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return invalid(iparam, ctx);
+}
+
 ///Maximum value read in from the database
 float
-SCT_ConditionsParameterTool::max(const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::max(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->max(iparam);
 }
 
+float
+SCT_ConditionsParameterTool::max(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return max(iparam, ctx);
+}
+
 ///Minimum value read in from the database
 float
-SCT_ConditionsParameterTool::min(const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::min(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->min(iparam);
 }
 
+float
+SCT_ConditionsParameterTool::min(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return min(iparam, ctx);
+}
+
 ///Average value
 float
-SCT_ConditionsParameterTool::avg(const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::avg(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->avg(iparam);
 }
 
+float
+SCT_ConditionsParameterTool::avg(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return avg(iparam, ctx);
+}
+
 ///Standard deviation
 float
-SCT_ConditionsParameterTool::sd(const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::sd(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return invalid(iparam);
   return data->sd(iparam);
 }
 
+float
+SCT_ConditionsParameterTool::sd(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return sd(iparam, ctx);
+}
+
 ///Number of values read in
 unsigned int
-SCT_ConditionsParameterTool::n(const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::n(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data==nullptr) return 0;
   return data->n(iparam);
 }
 
+unsigned int
+SCT_ConditionsParameterTool::n(const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return n(iparam, ctx);
+}
+
 ///Fill a user-provided vector with the values (hopefully won't be needed?)
 void
-SCT_ConditionsParameterTool::getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   if (data!=nullptr) data->getValues(userVector, iparam);
   //no return value
 }
 
+void
+SCT_ConditionsParameterTool::getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  getValues(userVector, iparam, ctx);
+}
+
 ///Report whether the structure was filled
 bool
-SCT_ConditionsParameterTool::filled() const {
-  const SCT_CondParameterData* data{getCondData()};
+SCT_ConditionsParameterTool::filled(const EventContext& ctx) const {
+  const SCT_CondParameterData* data{getCondData(ctx)};
   return (data!=nullptr);
 }
 
-const SCT_CondParameterData* SCT_ConditionsParameterTool::getCondData() const {
-  SG::ReadCondHandle<SCT_CondParameterData> condData{m_condKey};
+bool
+SCT_ConditionsParameterTool::filled() const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return filled(ctx);
+}
+
+const SCT_CondParameterData* SCT_ConditionsParameterTool::getCondData(const EventContext& ctx) const {
+  SG::ReadCondHandle<SCT_CondParameterData> condData{m_condKey, ctx};
   if (not condData.isValid()) {
     ATH_MSG_ERROR("Failed to get " << m_condKey.key());
     return nullptr;
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.h
index e0b59cc218dad15f16aaff9d110a3614a90c6690..e7bf7ae37e276f99d837d54e5a87f6def73828a8 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConditionsParameterTool.h
@@ -47,45 +47,57 @@ class SCT_ConditionsParameterTool: public extends<AthAlgTool, ISCT_ConditionsPar
   //@}
   
   ///Is the required parameter available?
+  virtual bool available(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual bool available(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Give the indicated value for a module identifier hash
+  virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float value(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Measure of how many valid values went to calculate it. Should be 1 but if, say, 3 chip values were valid out of 6, it could be less (0.5 in this case)
+  virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float validity(const IdentifierHash& idHash, const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Is a given value within acceptable limits?
+  virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual bool isValid(const float parameterValue, const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///What is the default error value for this parameter?
+  virtual float invalid(const unsigned int iparam, const EventContext& ctx) const override;
   virtual float invalid(const unsigned int iparam) const override;
   
   ///Maximum value read in from the database
+  virtual float max(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float max(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Minimum value read in from the database
+  virtual float min(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float min(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Average value
+  virtual float avg(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float avg(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Standard deviation
+  virtual float sd(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual float sd(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Number of values read in
+  virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual unsigned int n(const SCT_CondParameterData::ParameterIndex iparam) const override;
   
   ///Fill a user-provided vector with the values (hopefully won't be needed?)
+  virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam, const EventContext& ctx) const override;
   virtual void getValues(std::vector<float>& userVector, const SCT_CondParameterData::ParameterIndex iparam) const override;
  
   ///Report whether the structure was filled
+  virtual bool filled(const EventContext& ctx) const override;
   virtual bool filled() const override;
   
  private:
   //the data structure
   SG::ReadCondHandleKey<SCT_CondParameterData> m_condKey{this, "CondKey", "SCT_CondParameterData", "SCT parameters"};
-  const SCT_CondParameterData* getCondData() const;
+  const SCT_CondParameterData* getCondData(const EventContext& ctx) const;
 };
 
 #endif // SCT_ConditionsParameterTool_h
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
index d141efb67a106dd40e072e3e4da0c8c0f25d1382..67fce0bc26ffdf34d1cabcaa5346e2738fcf8c48 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
@@ -67,13 +67,13 @@ bool SCT_ConfigurationConditionsTool::isGood(const Identifier& elementId, const
     result = (not condData->isBadStrip(m_pHelper->wafer_hash(m_pHelper->wafer_id(elementId)),
                                        m_pHelper->strip(elementId)));
     // If strip itself is not bad, check if it's in a bad module
-    if (result and m_checkStripsInsideModules) result = (not isStripInBadModule(elementId));
+    if (result and m_checkStripsInsideModules) result = (not isStripInBadModule(elementId, ctx));
   } else if (h == InDetConditions::SCT_MODULE) {
     result = (not condData->isBadModuleId(elementId));
   } else if (h == InDetConditions::SCT_SIDE or h == InDetConditions::DEFAULT) {
     result = (not condData->isBadWaferId(elementId));
   } else if (h == InDetConditions::SCT_CHIP) {
-    result = isGoodChip(elementId);
+    result = isGoodChip(elementId, ctx);
   }
   return result;
 }
@@ -92,12 +92,11 @@ bool SCT_ConfigurationConditionsTool::isGood(const IdentifierHash& hashId, const
 
 bool SCT_ConfigurationConditionsTool::isGood(const IdentifierHash& hashId) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
-
   return isGood(hashId, ctx);
 }
 
 // Is a chip with this Identifier good?
-bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId) const {
+bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId, const EventContext& ctx) const {
   // This check assumes present SCT.
   // Get module number
   const Identifier moduleId{m_pHelper->module_id(stripId)};
@@ -107,7 +106,7 @@ bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId) cons
   }
 
   // badChips word for the module
-  const unsigned int v_badChips{badChips(moduleId)};
+  const unsigned int v_badChips{badChips(moduleId, ctx)};
   // badChips holds 12 bits.
   // bit 0 (LSB) is chip 0 for side 0.
   // bit 5 is chip 5 for side 0.
@@ -124,7 +123,7 @@ bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId) cons
   // If there is no bad chip on the side, this check is done.
   if ((side==0 and (v_badChips & 0x3F)==0) or (side==1 and (v_badChips & 0xFC0)==0)) return true;
 
-  int chip{getChip(stripId)};
+  int chip{getChip(stripId, ctx)};
   if (chip<0 or chip>=12) {
     ATH_MSG_WARNING("chip number is invalid: " << chip);
     return false;
@@ -137,8 +136,7 @@ bool SCT_ConfigurationConditionsTool::isGoodChip(const Identifier& stripId) cons
 }
 
 // Check if a strip is within a bad module
-bool SCT_ConfigurationConditionsTool::isStripInBadModule(const Identifier& stripId) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
+bool SCT_ConfigurationConditionsTool::isStripInBadModule(const Identifier& stripId, const EventContext& ctx) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In isStripInBadModule, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -150,8 +148,7 @@ bool SCT_ConfigurationConditionsTool::isStripInBadModule(const Identifier& strip
 }
 
 // Check if a wafer is within a bad module
-bool SCT_ConfigurationConditionsTool::isWaferInBadModule(const Identifier& waferId) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
+bool SCT_ConfigurationConditionsTool::isWaferInBadModule(const Identifier& waferId, const EventContext& ctx) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In isWaferInBadModule, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -163,15 +160,14 @@ bool SCT_ConfigurationConditionsTool::isWaferInBadModule(const Identifier& wafer
 }
 
 // Find the chip number containing a particular strip Identifier
-int SCT_ConfigurationConditionsTool::getChip(const Identifier& stripId) const {
-
+int SCT_ConfigurationConditionsTool::getChip(const Identifier& stripId, const EventContext& ctx) const {
   // Find side and strip number
   const int side{m_pHelper->side(stripId)};
   int strip{m_pHelper->strip(stripId)};
 
   // Check for swapped readout direction
   const IdentifierHash waferHash{m_pHelper->wafer_hash(m_pHelper->wafer_id(stripId))};
-  const InDetDD::SiDetectorElement* pElement{getDetectorElement(waferHash)};
+  const InDetDD::SiDetectorElement* pElement{getDetectorElement(waferHash, ctx)};
   if (pElement==nullptr) {
     ATH_MSG_FATAL("Element pointer is NULL in 'badStrips' method");
     return invalidChipNumber;
@@ -182,8 +178,12 @@ int SCT_ConfigurationConditionsTool::getChip(const Identifier& stripId) const {
   return (side==0 ? strip/stripsPerChip : strip/stripsPerChip + 6);
 }
 
-const std::set<Identifier>* SCT_ConfigurationConditionsTool::badModules() const {
+int SCT_ConfigurationConditionsTool::getChip(const Identifier& stripId) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return getChip(stripId, ctx);
+}
+
+const std::set<Identifier>* SCT_ConfigurationConditionsTool::badModules(const EventContext& ctx) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badModules, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -193,8 +193,12 @@ const std::set<Identifier>* SCT_ConfigurationConditionsTool::badModules() const
   return condData->getBadModuleIds();
 }
 
-void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std::set<Identifier>& strips, bool ignoreBadModules, bool ignoreBadChips) const {
+const std::set<Identifier>* SCT_ConfigurationConditionsTool::badModules() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badModules(ctx);
+}
+
+void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules, bool ignoreBadChips) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badStrips, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -219,11 +223,15 @@ void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std:
     if (m_pHelper->module_id(m_pHelper->wafer_id(badStripId)) == moduleId) strips.insert(badStripId);
   }
 }
+
+void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std::set<Identifier>& strips, bool ignoreBadModules, bool ignoreBadChips) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badStrips(moduleId, strips, ctx, ignoreBadModules, ignoreBadChips);
+}
        
-std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const IdentifierHash& hash) const {
+std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const IdentifierHash& hash, const EventContext& ctx) const {
   // Bad links for a given module
   // Bad convetion is used. true is for good link and false is for bad link...
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badLinks, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -233,8 +241,12 @@ std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const Identifier
   return condData->areBadLinks(hash);
 }
 
-const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks() const {
+std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const IdentifierHash& hash) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badLinks(hash, ctx);
+}
+
+const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks(const EventContext& ctx) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badLinks, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -244,8 +256,12 @@ const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditio
   return condData->getBadLinks();
 }
 
-const std::map<Identifier, unsigned int>* SCT_ConfigurationConditionsTool::badChips() const {
+const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badLinks(ctx);
+}
+
+const std::map<Identifier, unsigned int>* SCT_ConfigurationConditionsTool::badChips(const EventContext& ctx) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badChips, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -255,9 +271,13 @@ const std::map<Identifier, unsigned int>* SCT_ConfigurationConditionsTool::badCh
   return condData->getBadChips();
 }
 
-unsigned int SCT_ConfigurationConditionsTool::badChips(const Identifier& moduleId) const {
-  // Bad chips for a given module
+const std::map<Identifier, unsigned int>* SCT_ConfigurationConditionsTool::badChips() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badChips(ctx);
+}
+
+unsigned int SCT_ConfigurationConditionsTool::badChips(const Identifier& moduleId, const EventContext& ctx) const {
+  // Bad chips for a given module
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badChips, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -267,9 +287,12 @@ unsigned int SCT_ConfigurationConditionsTool::badChips(const Identifier& moduleI
   return condData->getBadChips(moduleId);
 }
 
-void 
-SCT_ConfigurationConditionsTool::badStrips(std::set<Identifier>& strips, bool ignoreBadModules, bool ignoreBadChips) const {
+unsigned int SCT_ConfigurationConditionsTool::badChips(const Identifier& moduleId) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return badChips(moduleId, ctx);
+}
+void 
+SCT_ConfigurationConditionsTool::badStrips(std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules, bool ignoreBadChips) const {
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
     ATH_MSG_ERROR("In badStrips, SCT_ConfigurationCondData pointer cannot be retrieved");
@@ -298,6 +321,12 @@ SCT_ConfigurationConditionsTool::badStrips(std::set<Identifier>& strips, bool ig
   }
 }
 
+void 
+SCT_ConfigurationConditionsTool::badStrips(std::set<Identifier>& strips, bool ignoreBadModules, bool ignoreBadChips) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  badStrips(strips, ctx, ignoreBadModules, ignoreBadChips);
+}
+
 const SCT_ConfigurationCondData*
 SCT_ConfigurationConditionsTool::getCondData(const EventContext& ctx) const {
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
@@ -319,9 +348,7 @@ SCT_ConfigurationConditionsTool::getCondData(const EventContext& ctx) const {
   return m_condData.get();
 }
 
-const InDetDD::SiDetectorElement* SCT_ConfigurationConditionsTool::getDetectorElement(const IdentifierHash& waferHash) const {
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
-
+const InDetDD::SiDetectorElement* SCT_ConfigurationConditionsTool::getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const {
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
index f688f55a0d39fe19016bfcb106474dced5cc583c..ca07eea7ddaca91113e963c1fb298150039c8481 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
@@ -60,20 +60,28 @@ class SCT_ConfigurationConditionsTool: public extends<AthAlgTool, ISCT_Configura
   virtual bool                          isGood(const IdentifierHash& hashId, const EventContext& ctx) const override;
 
   /**List of bad modules*/
+  virtual const std::set<Identifier>*   badModules(const EventContext& ctx) const override;
   virtual const std::set<Identifier>*   badModules() const override;
   /**List of bad strips*/
+  virtual void                          badStrips(std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const override;
   virtual void                          badStrips(std::set<Identifier>& strips, bool ignoreBadModules=false, bool ignoreBadChips=false) const override;
   /**List of bad strips for a given module*/
+  virtual void                          badStrips(const Identifier& moduleId, std::set<Identifier>& strips, const EventContext& ctx, bool ignoreBadModules=false, bool ignoreBadChips=false) const override;
   virtual void                          badStrips(const Identifier& moduleId, std::set<Identifier>& strips, bool ignoreBadModules=false, bool ignoreBadChips=false) const override;
   /**List of bad links*/
+  virtual std::pair<bool, bool>         badLinks(const IdentifierHash& hash, const EventContext& ctx) const override;
   virtual std::pair<bool, bool>         badLinks(const IdentifierHash& hash) const override;
   /**Bad links for a given module*/
+  virtual const std::map<IdentifierHash, std::pair<bool, bool>>* badLinks(const EventContext& ctx) const override;
   virtual const std::map<IdentifierHash, std::pair<bool, bool>>* badLinks() const override;
   /**List of bad chips*/
+  virtual const std::map<Identifier, unsigned int>* badChips(const EventContext& ctx) const override;
   virtual const std::map<Identifier, unsigned int>* badChips() const override;
   /**Bad chips for a given module*/
+  virtual unsigned int                  badChips(const Identifier& moduleId, const EventContext& ctx) const override;
   virtual unsigned int                  badChips(const Identifier& moduleId) const override;
   /** Get the chip number containing a particular strip*/
+  virtual int                           getChip(const Identifier& stripId, const EventContext& ctx) const override;
   virtual int                           getChip(const Identifier& stripId) const override;
 
  private:
@@ -93,18 +101,18 @@ class SCT_ConfigurationConditionsTool: public extends<AthAlgTool, ISCT_Configura
   bool                                  m_checkStripsInsideModules; //!< Do we want to check if a strip is bad because it is inside a bad module
 
   /** Is a strip within a bad module*/
-  bool                                  isStripInBadModule(const Identifier& stripId) const;
+  bool                                  isStripInBadModule(const Identifier& stripId, const EventContext& ctx) const;
   /** Is a wafer in a bad module*/
-  bool                                  isWaferInBadModule(const Identifier& waferId) const;
+  bool                                  isWaferInBadModule(const Identifier& waferId, const EventContext& ctx) const;
   
   /**Is a chip with this Identifier good?*/
-  bool isGoodChip(const Identifier& stripId) const;
+  bool isGoodChip(const Identifier& stripId, const EventContext& ctx) const;
 
   /** enum for constants*/
   enum {stripsPerChip=128, lastStrip=767, invalidChipNumber=-1};
 
   const SCT_ConfigurationCondData* getCondData(const EventContext& ctx) const;
-  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash) const;
+  const InDetDD::SiDetectorElement* getDetectorElement(const IdentifierHash& waferHash, const EventContext& ctx) const;
 };
 
 #endif // SCT_ConfigurationConditionsTool_h
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
index d4ee921748556eb63a0fc148094458598537fa02..15af99ca714150a2db8d2a0e89b41915c4d8da21 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
@@ -87,7 +87,7 @@ Identifier SCT_DCSConditionsTool::getModuleID(const Identifier& elementId, InDet
 
 //Returns if element Id is good or bad
 bool SCT_DCSConditionsTool::isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
-  Identifier moduleId=getModuleID(elementId, h);
+  Identifier moduleId{getModuleID(elementId, h)};
   if (not moduleId.is_valid()) return true; // not canreportabout
 
   if ((m_readAllDBFolders and m_returnHVTemp) or (not m_readAllDBFolders and not m_returnHVTemp)) {
@@ -102,7 +102,6 @@ bool SCT_DCSConditionsTool::isGood(const Identifier& elementId, const EventConte
 
 bool SCT_DCSConditionsTool::isGood(const Identifier& elementId, InDetConditions::Hierarchy h) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
-
   return isGood(elementId, ctx, h);
 }
 
@@ -115,7 +114,6 @@ bool SCT_DCSConditionsTool::isGood(const IdentifierHash& hashId, const EventCont
 
 bool SCT_DCSConditionsTool::isGood(const IdentifierHash& hashId) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
-
   return isGood(hashId, ctx);
 }
 
@@ -123,11 +121,10 @@ bool SCT_DCSConditionsTool::isGood(const IdentifierHash& hashId) const {
 
 // some lame helper methods: 
 // returns HV (s_defaultHV(-30) if there is no information)
-float SCT_DCSConditionsTool::modHV(const Identifier& elementId, InDetConditions::Hierarchy h) const {
-  Identifier moduleId = getModuleID(elementId, h);
+float SCT_DCSConditionsTool::modHV(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+  Identifier moduleId{getModuleID(elementId, h)};
   if (not moduleId.is_valid()) return s_defaultHV; // not canreportabout, return s_defaultHV(-30)
 
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_DCSFloatCondData* condDataHV{getCondDataHV(ctx)};
   if (!condDataHV) return s_defaultHV; // no cond data
 
@@ -138,19 +135,28 @@ float SCT_DCSConditionsTool::modHV(const Identifier& elementId, InDetConditions:
   return s_defaultHV; //didn't find the module, return s_defaultHV(-30)
 }
 
+float SCT_DCSConditionsTool::modHV(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return modHV(elementId, ctx, h);
+}
+
 //Does the same for hashIds
+float SCT_DCSConditionsTool::modHV(const IdentifierHash& hashId, const EventContext& ctx) const {
+  Identifier waferId{m_pHelper->wafer_id(hashId)};
+  Identifier moduleId{m_pHelper->module_id(waferId)};
+  return modHV(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
 float SCT_DCSConditionsTool::modHV(const IdentifierHash& hashId) const {
-  Identifier waferId = m_pHelper->wafer_id(hashId);
-  Identifier moduleId = m_pHelper->module_id(waferId);
-  return modHV(moduleId,InDetConditions::SCT_MODULE);
-} 
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return modHV(hashId, ctx);
+}
 
 //Returns temp0 (s_defaultTemperature(-40) if there is no information)
-float SCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
-  Identifier moduleId = getModuleID(elementId, h);
+float SCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+  Identifier moduleId{getModuleID(elementId, h)};
   if (not moduleId.is_valid()) return s_defaultTemperature; // not canreportabout
 
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_DCSFloatCondData* condDataTemp0{getCondDataTemp0(ctx)};
   if (!condDataTemp0) return s_defaultTemperature; // no cond data
 
@@ -159,21 +165,30 @@ float SCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, InDe
     return temperature;
   }
   return s_defaultTemperature;//didn't find the module, return -40. 
-} 
+}
+
+float SCT_DCSConditionsTool::hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return hybridTemperature(elementId, ctx, h);
+}
 
 //Does the same for hashIds
+float SCT_DCSConditionsTool::hybridTemperature(const IdentifierHash& hashId, const EventContext& ctx) const {
+  Identifier waferId{m_pHelper->wafer_id(hashId)};
+  Identifier moduleId{m_pHelper->module_id(waferId)};
+  return hybridTemperature(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
 float SCT_DCSConditionsTool::hybridTemperature(const IdentifierHash& hashId) const {
-  Identifier waferId = m_pHelper->wafer_id(hashId);
-  Identifier moduleId = m_pHelper->module_id(waferId);
-  return hybridTemperature(moduleId, InDetConditions::SCT_MODULE);
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return hybridTemperature(hashId, ctx);
 }
 
 //Returns temp0 + correction for Lorentz angle calculation (s_defaultTemperature(-40) if there is no information)
-float SCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
-  Identifier moduleId = getModuleID(elementId, h);
+float SCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h) const {
+  Identifier moduleId{getModuleID(elementId, h)};
   if (not moduleId.is_valid()) return s_defaultTemperature; // not canreportabout
 
-  const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_DCSFloatCondData* condDataTemp0{getCondDataTemp0(ctx)};
   if (!condDataTemp0) return s_defaultTemperature; // no cond data
 
@@ -194,11 +209,21 @@ float SCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, InDe
   return s_defaultTemperature;  //didn't find the module, return s_defaultTemperature(-40).
 } 
 
+float SCT_DCSConditionsTool::sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h) const {
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return sensorTemperature(elementId, ctx, h);
+}
+
 //Does the same for hashIds
+float SCT_DCSConditionsTool::sensorTemperature(const IdentifierHash& hashId, const EventContext& ctx) const {
+  Identifier waferId{m_pHelper->wafer_id(hashId)};
+  Identifier moduleId{m_pHelper->module_id(waferId)};
+  return sensorTemperature(moduleId, ctx, InDetConditions::SCT_MODULE);
+}
+
 float SCT_DCSConditionsTool::sensorTemperature(const IdentifierHash& hashId) const {
-  Identifier waferId = m_pHelper->wafer_id(hashId);
-  Identifier moduleId = m_pHelper->module_id(waferId);
-  return sensorTemperature(moduleId, InDetConditions::SCT_MODULE);
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return sensorTemperature(hashId, ctx);
 }
 
 ///////////////////////////////////
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.h
index 6ba11daf85ae9e8117bbf17804a3fdc508b4eee1..3ec9168265c045b600a8f7a31101f9e7b79cd854 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.h
@@ -51,22 +51,28 @@ public:
   //returns the module ID (int), or returns 9999 (not a valid module number) if not able to report
   virtual Identifier getModuleID(const Identifier& elementId, InDetConditions::Hierarchy h) const;
   ///Summarise the result from the service as good/bad
-  virtual bool isGood(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   virtual bool isGood(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
+  virtual bool isGood(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   ///is it good?, using wafer hash
-  virtual bool isGood(const IdentifierHash& hashId) const override;
   virtual bool isGood(const IdentifierHash& hashId, const EventContext& ctx) const override;
+  virtual bool isGood(const IdentifierHash& hashId) const override;
   //Returns HV (0 if there is no information)
+  virtual float modHV(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   virtual float modHV(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   //Does the same for hashIds
+  virtual float modHV(const IdentifierHash& hashId, const EventContext& ctx) const override;
   virtual float modHV(const IdentifierHash& hashId) const override;
   //Returns temp0 (0 if there is no information)
+  virtual float hybridTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   virtual float hybridTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   //Does the same for hashIds
+  virtual float hybridTemperature(const IdentifierHash& hashId, const EventContext& ctx) const override;
   virtual float hybridTemperature(const IdentifierHash& hashId) const override;
   //Returns temp0 + correction for Lorentz angle calculation (0 if there is no information)
+  virtual float sensorTemperature(const Identifier& elementId, const EventContext& ctx, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   virtual float sensorTemperature(const Identifier& elementId, InDetConditions::Hierarchy h=InDetConditions::DEFAULT) const override;
   //Does the same for hashIds
+  virtual float sensorTemperature(const IdentifierHash& hashId, const EventContext& ctx) const override;
   virtual float sensorTemperature(const IdentifierHash& hashId) const override;
   //@}
     
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.cxx
index 34bc2fd7395cc62a10dd7a0e274d38b1ef599e23..146f84f61b6d2af50ebeddc07d4374800650ee7f 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.cxx
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "SCT_RadDamageSummaryTool.h"
@@ -31,11 +31,20 @@ StatusCode SCT_RadDamageSummaryTool::finalize() {
   return StatusCode::SUCCESS;
 }
 
+SCT_ChargeTrappingCondData SCT_RadDamageSummaryTool::getCondData(const IdentifierHash& elementHash, const double& zpos, const EventContext& ctx) const {
+  return m_chargeTrappingTool->getCondData(elementHash, zpos, ctx);
+}
+
 SCT_ChargeTrappingCondData SCT_RadDamageSummaryTool::getCondData(const IdentifierHash& elementHash, const double& zpos) const {
-  return m_chargeTrappingTool->getCondData(elementHash, zpos);
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  return getCondData(elementHash, zpos, ctx);
+}
+
+void SCT_RadDamageSummaryTool::holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& ctx) const {
+  m_chargeTrappingTool->getHoleTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2, ctx);
 }
 
 void SCT_RadDamageSummaryTool::holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const {
-  m_chargeTrappingTool->getHoleTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2);
-  return;
+  const EventContext& ctx{Gaudi::Hive::currentContext()};
+  holeTransport(x0, y0, xfin, yfin, Q_m2, Q_m1, Q_00, Q_p1, Q_p2, ctx);
 }
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.h
index 67965df183623c26bdcc8106f11b2eb3b21dab54..1716f5b09cf423b7c19a3c2d5ad9ed2f274f5693 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_RadDamageSummaryTool.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef SCT_RADDAMAGESUMMARYTOOL_H
@@ -7,11 +7,11 @@
 
 #include "SCT_ConditionsTools/ISCT_RadDamageSummaryTool.h"
 
-#include <string>
-
 #include "AthenaBaseComps/AthAlgTool.h"
 #include "SCT_ConditionsTools/ISCT_ChargeTrappingTool.h"
 
+#include <string>
+
 class IdentifierHash;
 
 // ----------------------------------------------------------------------------- //
@@ -32,7 +32,9 @@ class SCT_RadDamageSummaryTool: public extends<AthAlgTool, ISCT_RadDamageSummary
   virtual StatusCode initialize() override;
   virtual StatusCode finalize() override;
  
+  virtual void holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2, const EventContext& ctx) const override;
   virtual void holeTransport(double& x0, double& y0, double& xfin, double& yfin, double& Q_m2, double& Q_m1, double& Q_00, double& Q_p1, double& Q_p2) const override;
+  virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, const double& zpos, const EventContext& ctx) const override;
   virtual SCT_ChargeTrappingCondData getCondData(const IdentifierHash& elementHash, const double& zpos) const override;
 
  private: