diff --git a/InnerDetector/InDetCalibAlgs/SCT_CalibAlgs/src/SCTCalib.cxx b/InnerDetector/InDetCalibAlgs/SCT_CalibAlgs/src/SCTCalib.cxx
index 430745471b180c47defbbbc9aaf6891b35521b72..f8643b5bbafd719792eec27e2fe71f93b0e4eb5a 100644
--- a/InnerDetector/InDetCalibAlgs/SCT_CalibAlgs/src/SCTCalib.cxx
+++ b/InnerDetector/InDetCalibAlgs/SCT_CalibAlgs/src/SCTCalib.cxx
@@ -780,9 +780,9 @@ StatusCode SCTCalib::getDeadStrip() {
     std::set<Identifier>::const_iterator ModItr(badMods->begin());
     std::set<Identifier>::const_iterator ModEnd(badMods->end());
     // Bad links
-    const std::map<Identifier, std::pair<bool, bool> >* badLinks = m_ConfigurationConditionsTool->badLinks();
-    std::map<Identifier, std::pair<bool, bool> >::const_iterator linkItr(badLinks->begin());
-    std::map<Identifier, std::pair<bool, bool> >::const_iterator linkEnd(badLinks->end());
+    const std::map<IdentifierHash, std::pair<bool, bool> >* badLinks = m_ConfigurationConditionsTool->badLinks();
+    std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkItr(badLinks->begin());
+    std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkEnd(badLinks->end());
     // Bad chips
     const std::map<Identifier, unsigned int>* badChips = m_ConfigurationConditionsTool->badChips();
     std::map<Identifier, unsigned int>::const_iterator chipItr(badChips->begin());
@@ -928,7 +928,7 @@ StatusCode SCTCalib::getDeadStrip() {
         //check if module/link is disabled or not
         bool disabled=false;
         if(badMods->find(moduleId)!=badMods->end()) disabled=true;
-        linkItr=badLinks->find(moduleId);
+        linkItr=badLinks->find(waferHash);
         if(linkItr!=linkEnd) {
             std::pair<bool, bool> status = (*linkItr).second;
             if((side==0 && status.first==true) || (side==1 && status.second==true)) disabled=true;
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationCondAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationCondAlg.cxx
index 05a2bb1473935fc0011c8abbe550f9639bc83735..d3482955290fa2c926c182b89b97dcafefced1d7 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationCondAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationCondAlg.cxx
@@ -215,7 +215,7 @@ StatusCode SCT_ConfigurationCondAlg::fillChannelData(SCT_ConfigurationCondData*
 
     // Get link status 
     // Can maybe be smarter if both links are bad (but the module will probably be bad then)
-    std::pair<bool, bool> linkResults{writeCdo->areBadLinks(moduleId)};
+    std::pair<bool, bool> linkResults{writeCdo->areBadLinks(hash)};
     bool link0ok{linkResults.first};
     bool link1ok{linkResults.second};
     // Loop over chips within module
@@ -255,9 +255,11 @@ StatusCode SCT_ConfigurationCondAlg::fillChannelData(SCT_ConfigurationCondData*
         thisChip->appendBadStripsToVector(badStripsVec);
         // Loop over bad strips and insert strip ID into set
         for (const auto& thisBadStrip:badStripsVec) {
-          Identifier stripId{getStripId(truncatedSerialNumber, thisChip->id(), thisBadStrip, elements)};
+          const Identifier stripId{getStripId(truncatedSerialNumber, thisChip->id(), thisBadStrip, elements)};
           // If in rough order, may be better to call with itr of previous insertion as a suggestion    
-          if (stripId.is_valid()) writeCdo->setBadStripId(stripId);
+          if (stripId.is_valid()) writeCdo->setBadStripId(stripId, // strip Identifier
+                                                          thisChip->id()<6 ? hash : oppWaferHash, // wafer IdentifierHash
+                                                          m_pHelper->strip(stripId)); // strip number from 0 to 768
         }
       }
       // Bad chips (= all strips bad) bitpacked
@@ -420,7 +422,7 @@ StatusCode SCT_ConfigurationCondAlg::fillLinkStatus(SCT_ConfigurationCondData* w
 
     // Store the modules with bad links, represented by badLink (enum in header) = 255 = 0xFF 
     if (link0==badLink or link1==badLink) {
-      writeCdo->setBadLinks(moduleId, (link0!=badLink), (link1!=badLink));
+      writeCdo->setBadLinks(hash, (link0!=badLink), (link1!=badLink));
     }
   }
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
index fc226b73c068749bb86ed0910222614ac130d073..a5c2a809f8c6fcffea0ac631ac1ea9aa22d4d835 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_ConfigurationConditionsTestAlg.cxx
@@ -39,9 +39,9 @@ StatusCode SCT_ConfigurationConditionsTestAlg::execute(){
   unsigned int nBadMods = m_configConditions->badModules()->size();
 
   // Bad links
-  const std::map<Identifier, std::pair<bool, bool> >* badLinks = m_configConditions->badLinks();
-  std::map<Identifier, std::pair<bool, bool> >::const_iterator linkItr(badLinks->begin());
-  std::map<Identifier, std::pair<bool, bool> >::const_iterator linkEnd(badLinks->end());
+  const std::map<IdentifierHash, std::pair<bool, bool> >* badLinks = m_configConditions->badLinks();
+  std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkItr(badLinks->begin());
+  std::map<IdentifierHash, std::pair<bool, bool> >::const_iterator linkEnd(badLinks->end());
 
   unsigned int nBadLink0(0), nBadLink1(0), nBadLinkBoth(0);
   while (linkItr != linkEnd) {
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.cxx b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.cxx
index 3eb96db2dd31563e27dc04be2438badf4dba76f8..b5fe4834fe1042de6c2aa4c05eadac297383e093 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.cxx
@@ -4,12 +4,15 @@
 
 #include "SCT_MonitorCondAlg.h"
 
+#include "InDetIdentifier/SCT_ID.h"
+
 #include "GaudiKernel/EventIDRange.h"
 
 #include <memory>
 
 SCT_MonitorCondAlg::SCT_MonitorCondAlg(const std::string& name, ISvcLocator* pSvcLocator)
   : ::AthAlgorithm(name, pSvcLocator)
+  , m_helper{nullptr}
   , m_condSvc{"CondSvc", name}
 {
 }
@@ -18,6 +21,8 @@ StatusCode SCT_MonitorCondAlg::initialize()
 {
   ATH_MSG_DEBUG("initialize " << name());
 
+  ATH_CHECK(detStore()->retrieve(m_helper, "SCT_ID"));
+
   // CondSvc
   ATH_CHECK(m_condSvc.retrieve());
 
@@ -76,7 +81,9 @@ StatusCode SCT_MonitorCondAlg::execute()
   for (; iter!=last; ++iter) {
     const AthenaAttributeList& list{iter->second};
     if (list.size()>defectListIndex) {
-      writeCdo->insert(iter->first, list[defectListIndex].data<std::string>());
+      const Identifier moduleId{m_helper->module_id(Identifier{iter->first})};
+      const IdentifierHash moduleHash{m_helper->wafer_hash(moduleId)};
+      writeCdo->insert(moduleHash, list[defectListIndex].data<std::string>());
     }
   }
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.h b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.h
index d61ddc5039e67b7978cabde1396503e9b5773a9e..ce62c02635f681deb8f6b2f706f8347448596629 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsAlgorithms/src/SCT_MonitorCondAlg.h
@@ -12,6 +12,8 @@
 #include "SCT_ConditionsData/SCT_MonitorCondData.h"
 #include "GaudiKernel/ICondSvc.h"
 
+class SCT_ID;
+
 class SCT_MonitorCondAlg : public AthAlgorithm 
 {  
  public:
@@ -24,6 +26,7 @@ class SCT_MonitorCondAlg : public AthAlgorithm
  private:
   SG::ReadCondHandleKey<CondAttrListCollection> m_readKey{this, "ReadKey", "/SCT/Derived/Monitoring", "Key of input (raw) noisy strip conditions folder"};
   SG::WriteCondHandleKey<SCT_MonitorCondData> m_writeKey{this, "WriteKey", "SCT_MonitorCondData", "Key of output (derived) noisy strip conditions data"};
+  const SCT_ID* m_helper;
   ServiceHandle<ICondSvc> m_condSvc; 
 };
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_ConfigurationCondData.h b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_ConfigurationCondData.h
index 6c9251868766d7f6ffae2fa027c7bbac76bf3d66..9afb5b55108c279b4de36a0fdf4d21143ae746ed 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_ConfigurationCondData.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_ConfigurationCondData.h
@@ -11,12 +11,15 @@
 #ifndef SCT_CONFIGURATIONCONDDATA_H
 #define SCT_CONFIGURATIONCONDDATA_H
 
-#include <set>
+#include <array>
+#include <bitset>
 #include <map>
+#include <set>
 
 // Include Athena stuff
 #include "AthenaKernel/CLASS_DEF.h"
 #include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
 
 class SCT_ConfigurationCondData {
 public:
@@ -28,13 +31,13 @@ public:
   virtual ~SCT_ConfigurationCondData();
 
   // Set a bad strip identifier
-  void setBadStripId(const Identifier& badStripId);
+  void setBadStripId(const Identifier& badStripId, const IdentifierHash& hash, const int strip);
   // Get all bad strip identifiers
   const std::set<Identifier>* getBadStripIds() const;
   // Clear all bad strip identifiers
   void clearBadStripIds();
   // Check if a strip identifier is bad one
-  bool isBadStripId(const Identifier& stripId) const;
+  bool isBadStrip(const IdentifierHash& hash, const int strip) const;
 
   // Set a bad wafer identifier
   void setBadWaferId(const Identifier& badWaferId);
@@ -55,13 +58,13 @@ public:
   bool isBadModuleId(const Identifier& moduleId) const;
 
   // Set bad links for a module
-  void setBadLinks(const Identifier& moduleId, const bool isBadLink0, const bool isBadLink1);
+  void setBadLinks(const IdentifierHash& hash, const bool isBadLink0, const bool isBadLink1);
   // Get all bad links
-  const std::map<Identifier, std::pair<bool, bool>>* getBadLinks() const;
+  const std::map<IdentifierHash, std::pair<bool, bool>>* getBadLinks() const;
   // Clear all bad links
   void clearBadLinks();
   // Check if a module has bad links
-  std::pair<bool, bool> areBadLinks(const Identifier& moduleId) const;
+  std::pair<bool, bool> areBadLinks(const IdentifierHash& hash) const;
 
   // Set bad chips for a module
   void setBadChips(const Identifier& moduleId, const unsigned int chipStatus);
@@ -76,11 +79,14 @@ public:
   void clear();
 
 private:
+  enum {N_MODULES=4088, N_STRIPS=768, N_SIDES=2};
 
   std::set<Identifier> m_badStripIds;
+  std::array<std::bitset<N_STRIPS>, N_MODULES*N_SIDES> m_badStripArray;
   std::set<Identifier> m_badWaferIds;
   std::set<Identifier> m_badModuleIds;
-  std::map<Identifier, std::pair<bool, bool>> m_badLinks;
+  std::map<IdentifierHash, std::pair<bool, bool>> m_badLinks;
+  std::array<std::pair<bool, bool>, N_MODULES> m_badLinksArray;
   std::map<Identifier, unsigned int> m_badChips;
 };
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_MonitorCondData.h b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_MonitorCondData.h
index 80f67f758f481e3f9c69c4cbc4eb36e4b0da5405..72e619c8e673d38b1c2f63b50b2ac92402dbd99a 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_MonitorCondData.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/SCT_ConditionsData/SCT_MonitorCondData.h
@@ -11,11 +11,12 @@
 #ifndef SCT_MONITORCONDDATA_H
 #define SCT_MONITORCONDDATA_H
 
-#include <map>
-#include <string>
-
 // Include Athena stuff
 #include "AthenaKernel/CLASS_DEF.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <array>
+#include <string>
 
 class SCT_MonitorCondData {
 public:
@@ -24,20 +25,21 @@ public:
   SCT_MonitorCondData();
 
   // Destructor
-  virtual ~SCT_MonitorCondData();
+  virtual ~SCT_MonitorCondData() = default;
 
   // Check if a module has a defect (a list of bad strips). If it does not have defect return false.
-  bool find(const int& channelNumber, std::string& defectList) const;
+  bool find(const IdentifierHash& hash, std::string& defectList) const;
 
   // Insert a new defect (a list of bad strips) for a module
-  void insert(const int& channelNumber, const std::string& defectList);
+  void insert(const IdentifierHash& hash, const std::string& defectList);
 
-  // Clear m_defectListMap
+  // Clear m_defectListArray
   void clear();
 
 private:
+  enum {N_MODULES=4088};
   // Store the relation between modules and defects (lists of bad strips).
-  std::map<const int, const std::string> m_defectListMap;
+  std::array<std::string, N_MODULES> m_defectListArray;
 
 };
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_ConfigurationCondData.cxx b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_ConfigurationCondData.cxx
index be48b108c7d5e20611f99149a086509db4bfa031..1bf14b5b40a29aac240ddd1ab1b6ca4e666569c8 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_ConfigurationCondData.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_ConfigurationCondData.cxx
@@ -15,11 +15,13 @@
 // Constructor
 SCT_ConfigurationCondData::SCT_ConfigurationCondData():
   m_badStripIds{},
+  m_badStripArray{},
   m_badWaferIds{},
   m_badModuleIds{},
-  m_badLinks{},
   m_badChips{}
-{}
+{
+  clearBadLinks();
+}
 
 //----------------------------------------------------------------------
 // Destructor
@@ -28,8 +30,9 @@ SCT_ConfigurationCondData::~SCT_ConfigurationCondData()
 
 //----------------------------------------------------------------------
 // Set a bad strip identifier
-void SCT_ConfigurationCondData::setBadStripId(const Identifier& badStripId) {
+void SCT_ConfigurationCondData::setBadStripId(const Identifier& badStripId, const IdentifierHash& hash, const int strip) {
   m_badStripIds.insert(badStripId);
+  m_badStripArray[hash].set(strip);
 }
 
 //----------------------------------------------------------------------
@@ -42,12 +45,13 @@ const std::set<Identifier>* SCT_ConfigurationCondData::getBadStripIds() const {
 // Clear all bad strip identifiers
 void SCT_ConfigurationCondData::clearBadStripIds() {
   m_badStripIds.clear();
+  m_badStripArray.fill(std::bitset<N_STRIPS>());
 }
 
 //----------------------------------------------------------------------
 // Check if a strip identifier is bad one
-bool SCT_ConfigurationCondData::isBadStripId(const Identifier& stripId) const {
-  return (m_badStripIds.find(stripId)!=m_badStripIds.end());
+bool SCT_ConfigurationCondData::isBadStrip(const IdentifierHash& hash, const int strip) const {
+  return m_badStripArray[hash][strip];
 }
 
 //----------------------------------------------------------------------
@@ -100,14 +104,18 @@ bool SCT_ConfigurationCondData::isBadModuleId(const Identifier& moduleId) const
 
 //----------------------------------------------------------------------
 // Set bad links for a module
-void SCT_ConfigurationCondData::setBadLinks(const Identifier& moduleId, const bool isBadLink0, const bool isBadLink1) {
-  m_badLinks[moduleId].first  |= isBadLink0;
-  m_badLinks[moduleId].second |= isBadLink1;
+void SCT_ConfigurationCondData::setBadLinks(const IdentifierHash& hash, const bool isBadLink0, const bool isBadLink1) {
+  unsigned int iHash{hash};
+  iHash = (iHash/2)*2; // Make iHash even
+  m_badLinks[iHash].first  &= isBadLink0;
+  m_badLinks[iHash].second &= isBadLink1;
+  m_badLinksArray[iHash/2].first  &= isBadLink0;
+  m_badLinksArray[iHash/2].second &= isBadLink1;
 }
 
 //----------------------------------------------------------------------
 // Get all bad links
-const std::map<Identifier, std::pair<bool, bool>>* SCT_ConfigurationCondData::getBadLinks() const {
+const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationCondData::getBadLinks() const {
   return &m_badLinks;
 }
 
@@ -115,14 +123,14 @@ const std::map<Identifier, std::pair<bool, bool>>* SCT_ConfigurationCondData::ge
 // Clear all bad links
 void SCT_ConfigurationCondData::clearBadLinks() {
   m_badLinks.clear();
+  m_badLinksArray.fill(std::make_pair(true, true));
 }
 
 //----------------------------------------------------------------------
 // Check if a module has bad links
-std::pair<bool, bool> SCT_ConfigurationCondData::areBadLinks(const Identifier& moduleId) const {
+std::pair<bool, bool> SCT_ConfigurationCondData::areBadLinks(const IdentifierHash& hash) const {
   // Bad convetion is used. true is for good link and false is for bad link...
-  std::map<Identifier, std::pair<bool, bool>>::const_iterator it{m_badLinks.find(moduleId)};
-  return (it!=m_badLinks.end()) ? (*it).second : std::make_pair(true, true);
+  return m_badLinksArray[hash/2];
 }
 
 //----------------------------------------------------------------------
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_MonitorCondData.cxx b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_MonitorCondData.cxx
index 3f8d5f769deda5d3ffe7fb9abf72f4748c3620a0..f66582efd67696800fa500f7fa5afd0e46e9b303 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_MonitorCondData.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsData/src/SCT_MonitorCondData.cxx
@@ -12,39 +12,31 @@
 
 //----------------------------------------------------------------------
 // Constructor
-SCT_MonitorCondData::SCT_MonitorCondData():
-  m_defectListMap{}
-{}
-
-//----------------------------------------------------------------------
-// Destructor
-SCT_MonitorCondData::~SCT_MonitorCondData()
-{}
+SCT_MonitorCondData::SCT_MonitorCondData()
+{
+  clear();
+}
 
 //----------------------------------------------------------------------
 // Check if a module has a defect (a list of bad strips). If it does not have defect return false.
-bool SCT_MonitorCondData::find(const int& channelNumber, std::string& defectList) const
+bool SCT_MonitorCondData::find(const IdentifierHash& hash, std::string& defectList) const
 {
-  std::map<const int, const std::string>::const_iterator it{m_defectListMap.find(channelNumber)};
-  if(it!=m_defectListMap.end()) {
-    // A defect is found, set the defect to defectList and return true.
-    defectList = it->second;
-    return true;
-  }
-  // Any defect is not found and return true.
-  return false;
+  std::string result{m_defectListArray[hash/2]};
+  if (result.empty()) return false;
+  defectList = result;
+  return true;
 }
 
 //----------------------------------------------------------------------
 // Insert a new defect (a list of bad strips) for a module
-void SCT_MonitorCondData::insert(const int& channelNumber, const std::string& defectList)
+void SCT_MonitorCondData::insert(const IdentifierHash& hash, const std::string& defectList)
 {
-  m_defectListMap.insert(std::make_pair(channelNumber, defectList));
+  m_defectListArray[hash/2] = defectList;
 }
 
 //----------------------------------------------------------------------
 // Clear m_defectListMap
 void SCT_MonitorCondData::clear()
 {
-  m_defectListMap.clear();
+  m_defectListArray.fill("");
 }
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
index 571d7dd11b4611cea858c1a46d98d1605d5cfc3e..22117eb57fbf413fd931fb34963e4b954930ba57 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/SCT_ConditionsTools/ISCT_ConfigurationConditionsTool.h
@@ -18,6 +18,7 @@
 #include "SCT_ConditionsTools/ISCT_ConditionsTool.h"
 
 class Identifier;
+class IdentifierHash;
 
 /**
  * @class SCT_ConfigurationConditionsTool
@@ -41,9 +42,9 @@ class ISCT_ConfigurationConditionsTool: virtual public ISCT_ConditionsTool {
   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<Identifier, std::pair<bool, bool> >* badLinks() 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 Identifier& moduleId) 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 =0;
@@ -51,7 +52,7 @@ class ISCT_ConfigurationConditionsTool: virtual public ISCT_ConditionsTool {
   virtual unsigned int badChips(const Identifier& moduleId) const =0;
 
   /** Set of bad strip Identifiers */ 
-  virtual void badStrips(std::set<Identifier>& strips, 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, bool ignoreBadModules=false, bool ignoreBadChips=false) const =0;
 
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
index feb6277f680d4fecee5cbb21613087204671fdbf..44330c086328e4ddfbafc9b14d21448f1bddd109 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ByteStreamErrorsTool.cxx
@@ -326,7 +326,7 @@ SCT_ByteStreamErrorsTool::fillData(const EventContext& ctx) const {
    */
   ATH_MSG_DEBUG("size of error container is " << errCont->size());
   for (const auto* elt : *errCont) {
-    addError(elt->first,elt->second, ctx);
+    addError(elt->first, elt->second, ctx);
     Identifier wafer_id{m_sct_id->wafer_id(elt->first)};
     Identifier module_id{m_sct_id->module_id(wafer_id)};
     int side{m_sct_id->side(m_sct_id->wafer_id(elt->first))};
@@ -335,7 +335,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(module_id)};
+      std::pair<bool, bool> badLinks{m_config->badLinks(elt->first)};
       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!!
@@ -420,11 +420,12 @@ const InDetDD::SiDetectorElement* SCT_ByteStreamErrorsTool::getDetectorElement(c
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheElements.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheElements.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheElements[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_SCTDetEleCollKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
index 5642afb9d3e363ac4fa4677653b51938930c43a0..73a5c94412c904dae7d2e137282553f20603baeb 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ChargeTrappingTool.cxx
@@ -345,11 +345,12 @@ const InDetDD::SiDetectorElement* SCT_ChargeTrappingTool::getDetectorElement(con
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheElements.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheElements.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheElements[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_SCTDetEleCollKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
index c89567eedede0c515a7c62e1c5ea5400e759b72c..cbce7855b989ff31e8e34f612795609f0021385e 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.cxx
@@ -65,7 +65,8 @@ bool SCT_ConfigurationConditionsTool::isGood(const Identifier& elementId, InDetC
 
   bool result{true};
   if (h == InDetConditions::SCT_STRIP) {
-    result = (not condData->isBadStripId(elementId));
+    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));
   } else if (h == InDetConditions::SCT_MODULE) {
@@ -181,7 +182,7 @@ 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 {
+void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId, std::set<Identifier>& strips, bool ignoreBadModules, bool ignoreBadChips) const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
@@ -208,7 +209,7 @@ void SCT_ConfigurationConditionsTool::badStrips(const Identifier& moduleId,  std
   }
 }
        
-std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const Identifier& moduleId) const {
+std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const IdentifierHash& hash) 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()};
@@ -218,10 +219,10 @@ std::pair<bool, bool> SCT_ConfigurationConditionsTool::badLinks(const Identifier
     return std::pair<bool, bool>{false, false};
   }
 
-  return condData->areBadLinks(moduleId);
+  return condData->areBadLinks(hash);
 }
 
-const std::map<Identifier, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks() const {
+const std::map<IdentifierHash, std::pair<bool, bool>>* SCT_ConfigurationConditionsTool::badLinks() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_ConfigurationCondData* condData{getCondData(ctx)};
   if (condData==nullptr) {
@@ -291,11 +292,12 @@ SCT_ConfigurationConditionsTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_ConfigurationCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
@@ -312,11 +314,12 @@ const InDetDD::SiDetectorElement* SCT_ConfigurationConditionsTool::getDetectorEl
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheElements.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheElements.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheElements[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_SCTDetEleCollKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
index ee3fb315769f9639348e39a4d58112a9318c271f..3c62d34d62b1137e4c61a22b23a314de91ccf590 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ConfigurationConditionsTool.h
@@ -64,9 +64,9 @@ class SCT_ConfigurationConditionsTool: public extends<AthAlgTool, ISCT_Configura
   /**List of bad strips for a given module*/
   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 Identifier& moduleId) const override;
+  virtual std::pair<bool, bool>         badLinks(const IdentifierHash& hash) const override;
   /**Bad links for a given module*/
-  virtual const std::map<Identifier, std::pair<bool, bool>>* badLinks() 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 override;
   /**Bad chips for a given module*/
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
index e4328212b5389f041a7451757f9fd9b14a6972a6..6a8f83d3324be91f6239f8c3900e731457c48a04 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_DCSConditionsTool.cxx
@@ -197,11 +197,12 @@ SCT_DCSConditionsTool::getCondDataState(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheState.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheState.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheState[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_DCSStatCondData> condData{m_condKeyState};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyState.key());
@@ -217,11 +218,12 @@ SCT_DCSConditionsTool::getCondDataHV(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheHV.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheHV.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheHV[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_DCSFloatCondData> condData{m_condKeyHV};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyHV.key());
@@ -237,11 +239,12 @@ SCT_DCSConditionsTool::getCondDataTemp0(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheTemp0.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheTemp0.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheTemp0[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_DCSFloatCondData> condData{m_condKeyTemp0};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyTemp0.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_LinkMaskingTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_LinkMaskingTool.cxx
index 1e4045fcb748e163cab96f3bf50428b3800a91f9..82103b7472a598d608a5dce85bb62ee7843c4237 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_LinkMaskingTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_LinkMaskingTool.cxx
@@ -68,11 +68,12 @@ SCT_LinkMaskingTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_ModuleVetoCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MajorityConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MajorityConditionsTool.cxx
index 3ad991e4c187662cc76bc8aaf8c4bd12559a7237..34b56190bd5b22b7487026b9f3a721c4f0350c3a 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MajorityConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MajorityConditionsTool.cxx
@@ -85,11 +85,12 @@ const SCT_MajorityCondData* SCT_MajorityConditionsTool::getCondData(const EventC
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_MajorityCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ModuleVetoTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ModuleVetoTool.cxx
index 7b056d49906458b4ac3acda3237667bd9ea28ac3..d5fc6dc7ba3be0a79712ede025b6da97d12c9894 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ModuleVetoTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ModuleVetoTool.cxx
@@ -172,11 +172,12 @@ SCT_ModuleVetoTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_ModuleVetoCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MonitorConditionsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MonitorConditionsTool.cxx
index 1b8c31d73cef0fe5d66d9b43cb4ed27698cd133e..9ccec0acf2a863b2786485edcf2a0b9e5f15038b 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MonitorConditionsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_MonitorConditionsTool.cxx
@@ -171,18 +171,17 @@ SCT_MonitorConditionsTool::badStripsAsString(const Identifier& moduleId) const {
 //////////////////////////////////////////////////////////////////////////////////////////
 
 std::string
-SCT_MonitorConditionsTool::getList(const Identifier& imodule) const {
-  string currentDefectList = "";
-  int channelNumber{static_cast<int>(imodule.get_identifier32().get_compact())};
+SCT_MonitorConditionsTool::getList(const Identifier& moduleId) const {
+  string currentDefectList{""};
   const EventContext& ctx{Gaudi::Hive::currentContext()};
   const SCT_MonitorCondData* condData{getCondData(ctx)};
   if (condData) {
-    condData->find(channelNumber, currentDefectList);
+    const IdentifierHash moduleHash{m_pHelper->wafer_hash(moduleId)};
+    condData->find(moduleHash, currentDefectList);
   } else {
     ATH_MSG_ERROR("In getList - no data");
   }
   return currentDefectList;
-
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -374,11 +373,12 @@ SCT_MonitorConditionsTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_MonitorCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibChipDataTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibChipDataTool.cxx
index 11ac434fd022bbc4b96dbd16539b4192a23e4ef5..a3be15a7211d074185f314de8859bb70dcc07e8a 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibChipDataTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibChipDataTool.cxx
@@ -223,11 +223,12 @@ SCT_ReadCalibChipDataTool::getCondDataGain(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheGain.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheGain.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheGain[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_GainCalibData> condData{m_condKeyGain};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyGain.key());
@@ -243,11 +244,12 @@ SCT_ReadCalibChipDataTool::getCondDataNoise(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheNoise.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheNoise.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheNoise[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_NoiseCalibData> condData{m_condKeyNoise};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyNoise.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibDataTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibDataTool.cxx
index aece404a9757c7117f0f206bd360f01dc478525a..f17e40e1b21954e36f2108ca7b4b3a04849c7068 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibDataTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_ReadCalibDataTool.cxx
@@ -355,11 +355,12 @@ SCT_ReadCalibDataTool::getCondDataGain(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheGain.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheGain.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheGain[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_CalibDefectData> condData{m_condKeyGain};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyGain.key());
@@ -377,11 +378,12 @@ SCT_ReadCalibDataTool::getCondDataNoise(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheNoise.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheNoise.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheNoise[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_CalibDefectData> condData{m_condKeyNoise};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyNoise.key());
@@ -399,11 +401,12 @@ SCT_ReadCalibDataTool::getCondDataInfo(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheInfo.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheInfo.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheInfo[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_AllGoodStripInfo> condData{m_condKeyInfo};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKeyInfo.key());
@@ -421,11 +424,12 @@ SCT_ReadCalibDataTool::getDetectorElement(const IdentifierHash& waferHash, const
   static const EventContext::ContextEvt_t invalidValue{EventContext::INVALID_CONTEXT_EVT};
   EventContext::ContextID_t slot{ctx.slot()};
   EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cacheElements.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cacheElements.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cacheElements[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> condData{m_SCTDetEleCollKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_SCTDetEleCollKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_SensorsTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_SensorsTool.cxx
index 1caba0de0bbbb8050d57beb89da9408aa1fc178f..55ffb28e1e575a2869bfaa358d46dd01299e21d5 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_SensorsTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_SensorsTool.cxx
@@ -75,11 +75,12 @@ SCT_SensorsTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_SensorsCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_TdaqEnabledTool.cxx b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_TdaqEnabledTool.cxx
index 1194f9e4c0ccdeb89282f24ff742bd2c2a6b99a1..1128a81daca5d5c22bd8c907f3d509f4ba494ae4 100644
--- a/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_TdaqEnabledTool.cxx
+++ b/InnerDetector/InDetConditions/SCT_ConditionsTools/src/SCT_TdaqEnabledTool.cxx
@@ -79,11 +79,12 @@ SCT_TdaqEnabledTool::getCondData(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()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock{m_mutex};
     SG::ReadCondHandle<SCT_TdaqEnabledCondData> condData{m_condKey};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_condKey.key());
diff --git a/InnerDetector/InDetDetDescr/SCT_Cabling/src/SCT_CablingTool.cxx b/InnerDetector/InDetDetDescr/SCT_Cabling/src/SCT_CablingTool.cxx
index 440d98b5e9ed300c38425cba801c5f0ac094e03b..4062118a51331b894dc2effa35c26b6b338e2c42 100644
--- a/InnerDetector/InDetDetDescr/SCT_Cabling/src/SCT_CablingTool.cxx
+++ b/InnerDetector/InDetDetDescr/SCT_Cabling/src/SCT_CablingTool.cxx
@@ -189,11 +189,12 @@ SCT_CablingTool::getData() const {
   const EventContext& ctx{Gaudi::Hive::currentContext()};
   const EventContext::ContextID_t slot{ctx.slot()};
   const EventContext::ContextEvt_t evt{ctx.evt()};
-  std::lock_guard<std::mutex> lock{m_mutex};
   if (slot>=m_cache.size()) {
+    std::lock_guard<std::mutex> lock(m_mutex);
     m_cache.resize(slot+1, invalidValue); // Store invalid values in order to go to the next IF statement.
   }
   if (m_cache[slot]!=evt) {
+    std::lock_guard<std::mutex> lock(m_mutex);
     SG::ReadCondHandle<SCT_CablingData> condData{m_data};
     if (not condData.isValid()) {
       ATH_MSG_ERROR("Failed to get " << m_data.key());
diff --git a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.cxx b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.cxx
index 979240a049c4e4f61030ade1d08fac4d2bd11765..5dfc25ef11e99c6532e5e4a85d6c63c713f40ab6 100644
--- a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.cxx
+++ b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.cxx
@@ -55,11 +55,13 @@ StatusCode SCTRawDataProviderTool::convert(std::vector<const ROBFragment*>& vecR
 
   // loop over the ROB fragments
 
+  std::set<uint32_t> tmpRobIdSet;
+
   for (const ROBFragment* rob_it : vecRobs) {
     // get the ID of this ROB/ROD
     uint32_t robid{(rob_it)->rod_source_id()};
     // check if this ROBFragment was already decoded (EF case in ROIs)
-    if (m_robIdSet.count(robid)) {
+    if (m_robIdSet.count(robid) or tmpRobIdSet.count(robid)) {
       ATH_MSG_DEBUG(" ROB Fragment with ID  "
                     << std::hex<<robid << std::dec
                     << " already decoded, skip");
@@ -67,9 +69,7 @@ StatusCode SCTRawDataProviderTool::convert(std::vector<const ROBFragment*>& vecR
     }
 
     // Insert the new ROBID to the set.
-    m_mutex.lock();
-    m_robIdSet.insert(robid);
-    m_mutex.unlock();
+    tmpRobIdSet.insert(robid);
 
     sc = m_decoder->fillCollection(*rob_it, rdoIdc, errs, bsFracCont);
     if (sc==StatusCode::FAILURE) {
@@ -80,13 +80,15 @@ StatusCode SCTRawDataProviderTool::convert(std::vector<const ROBFragment*>& vecR
         else {
           ATH_MSG_ERROR("Problem with SCT ByteStream Decoding!");
         }
-        m_mutex.lock();
         m_decodeErrCount++;
-        m_mutex.unlock();
       }
     }
   }
 
+  m_mutex.lock();
+  m_robIdSet.insert(tmpRobIdSet.begin(), tmpRobIdSet.end());
+  m_mutex.unlock();
+
   if (sc==StatusCode::FAILURE) {
     ATH_MSG_ERROR("There was a problem with SCT ByteStream conversion");
     return sc;
@@ -100,7 +102,6 @@ StatusCode SCTRawDataProviderTool::convert(std::vector<const ROBFragment*>& vecR
 
 void SCTRawDataProviderTool::beginNewEvent() const {
   // reset list of known robIds
-  m_mutex.lock();
+  std::lock_guard<std::mutex> lock(m_mutex);
   m_robIdSet.clear();
-  m_mutex.unlock();
 }
diff --git a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.h b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.h
index 64bf4fac6e80abe0d70ab19d9ef99fa0602469a2..d6a87401a0129a4d83eca55aa7ce1ba4dcc6e461 100644
--- a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.h
+++ b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProviderTool.h
@@ -19,6 +19,7 @@
 
 #include "GaudiKernel/ToolHandle.h"
 
+#include <atomic>
 #include <mutex>
 #include <set>
 
@@ -74,7 +75,7 @@ class SCTRawDataProviderTool : public extends<AthAlgTool, ISCTRawDataProviderToo
 
   /** Number of decode errors encountered in decoding. 
    * Turning off error message after 100 errors are counted */
-  mutable int m_decodeErrCount;
+  mutable std::atomic_int m_decodeErrCount;
 
   mutable std::mutex m_mutex;
 };
diff --git a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCT_RodDecoder.cxx b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCT_RodDecoder.cxx
index cfebfaf2f283534e0a030cc2c753c51d485af2f1..73e12cea32394d58acffa6840c1addf480efd1eb 100644
--- a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCT_RodDecoder.cxx
+++ b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCT_RodDecoder.cxx
@@ -961,7 +961,7 @@ SCT_RodDecoder::setFirstTempMaskedChip(const IdentifierHash& hashId, unsigned in
 
   int type{0};
   // Check if Rx redundancy is used or not in this module
-  const std::pair<bool, bool> badLinks{m_configTool->badLinks(moduleId)};
+  const std::pair<bool, bool> badLinks{m_configTool->badLinks(hashId)};
   if (badLinks.first xor badLinks.second) {
     // Rx redundancy is used in this module.
     if (badLinks.first and not badLinks.second) {
diff --git a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
index 3345d950b992dd99a0f5660e93db88da401113e0..780d261255ae9fc8e3b54f2f47818ba863a0c4bd 100755
--- a/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
+++ b/InnerDetector/InDetMonitoring/SCT_Monitoring/src/SCTErrMonTool.cxx
@@ -2405,7 +2405,7 @@ SCTErrMonTool::fillConfigurationDetails() {
     msg(MSG::DEBUG) << "Inside fillConfigurationDetails()" << endmsg;
   }
   unsigned int nBadMods = m_ConfigurationTool->badModules()->size(); // bad modules
-  const std::map<Identifier, std::pair<bool, bool> > *badLinks = m_ConfigurationTool->badLinks(); // bad links
+  const std::map<IdentifierHash, std::pair<bool, bool> > *badLinks = m_ConfigurationTool->badLinks(); // bad links
   unsigned int nBadLink0(0), nBadLink1(0), nBadLinkBoth(0);
   for (auto link: *badLinks) {
     std::pair<bool, bool> status = link.second;