diff --git a/Calorimeter/CaloMonitoring/share/CaloBaselineMon_jobOpt.py b/Calorimeter/CaloMonitoring/share/CaloBaselineMon_jobOpt.py
index a363ce96e208d4a637b3086c9b86e8c28ba76c69..b786efe6f99b9a1de5d32d680b301409ba123cfd 100644
--- a/Calorimeter/CaloMonitoring/share/CaloBaselineMon_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/CaloBaselineMon_jobOpt.py
@@ -13,7 +13,7 @@ if not 'rec' in dir():
    from RecExConfig.RecFlags import rec
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 from TrigBunchCrossingTool.BunchCrossingTool import BunchCrossingTool
 
@@ -45,7 +45,7 @@ CaloBaseline = CaloBaselineMon(
    BadLBTool = GetLArBadLBFilterTool(),
    BunchCrossingTool=BunchCrossingTool(),
    useReadyFilterTool = tmp_CaloBaselineMon["useReadyFilterTool"],
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
    useLArCollisionFilterTool = tmp_CaloBaselineMon["useLArCollisionFilter"],
    useLArNoisyAlg = tmp_CaloBaselineMon["useLArNoisyAlg"],
    useBeamBackgroundRemoval = tmp_CaloBaselineMon["useBeamBackgroundRemoval"],
diff --git a/Calorimeter/CaloMonitoring/share/CaloCellVecMonCollisions_jobOpt.py b/Calorimeter/CaloMonitoring/share/CaloCellVecMonCollisions_jobOpt.py
index ca1af5ec23cd5d2464649a0127a590ae5affb49b..80a14fff564631336c1b615ec554f72099e6d797 100644
--- a/Calorimeter/CaloMonitoring/share/CaloCellVecMonCollisions_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/CaloCellVecMonCollisions_jobOpt.py
@@ -14,7 +14,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
 theCaloNoiseTool=CaloNoiseToolDefault()
@@ -48,7 +48,7 @@ LArCellMon = LArCellMonTool(
 
     BadLBTool = GetLArBadLBFilterTool(),
 
-    ReadyFilterTool = monAtlasReadyFilterTool,
+    ReadyFilterTool = GetAtlasReadyFilterTool(),
 
     useElectronicNoiseOnly = False,
     #useTwoGaus = True, Tile-only
@@ -164,7 +164,9 @@ LArCellMon = LArCellMonTool(
 #Tile monitoring:
 from CaloMonitoring.CaloMonitoringConf import TileCalCellMonTool
 TileCalCellMon=TileCalCellMonTool("TileCalCellMon",
-                             CaloNoiseTool=theCaloNoiseTool
+                             CaloNoiseTool=theCaloNoiseTool,
+                                  BadLBTool = GetLArBadLBFilterTool(),
+                                  ReadyFilterTool = GetAtlasReadyFilterTool(),
                             )
 
 
diff --git a/Calorimeter/CaloMonitoring/share/CaloCellVecMonCosmics_jobOpt.py b/Calorimeter/CaloMonitoring/share/CaloCellVecMonCosmics_jobOpt.py
index e3a75d0f57c4eb6b1f0a6554b359cf8d36aa6484..3f8e369a2844431c662bb3816b21397f6dd4a7b1 100755
--- a/Calorimeter/CaloMonitoring/share/CaloCellVecMonCosmics_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/CaloCellVecMonCosmics_jobOpt.py
@@ -14,6 +14,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
 theCaloNoiseTool=CaloNoiseToolDefault()
@@ -38,7 +39,7 @@ LArCellMon = LArCellMonTool(
 
     BadLBTool = GetLArBadLBFilterTool(),
 
-    ReadyFilterTool = monAtlasReadyFilterTool,
+    ReadyFilterTool = GetAtlasReadyFilterTool(),
 
     useElectronicNoiseOnly = False,
     #useTwoGaus = True, Tile-only
diff --git a/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCollisions_jobOpt.py b/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCollisions_jobOpt.py
index 7fb007a8c1db52432f2f3c6784233364a0b14095..9f93ab17d98079d52521620091ab5bc2b9506892 100644
--- a/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCollisions_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCollisions_jobOpt.py
@@ -19,7 +19,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 if DQMonFlags.monManEnvironment() == 'online':
    tmp_timeGran = "run"
@@ -64,7 +64,7 @@ CaloClusterMonNoTA = CaloClusterVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
    useLArNoisyAlg = tmp_useLArNoisyAlg,
 
    useBeamBackgroundRemoval = tmp_useBeamBackgroundRemoval,
diff --git a/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCosmics_jobOpt.py b/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCosmics_jobOpt.py
index 40dfea3b48a14aa0d78fb4f86476fc98f3da24b7..b19a40f70ae740c74ede25155e132d32e90847d7 100755
--- a/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCosmics_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/CaloClusterVecMonCosmics_jobOpt.py
@@ -20,7 +20,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 if DQMonFlags.monManEnvironment() == 'online':
    tmp_timeGran = "run"
@@ -65,7 +65,7 @@ CaloClustMonCosmicsNoTA = CaloClusterVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
 
    useLArNoisyAlg = tmp_useLArNoisyAlg,
   
diff --git a/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCollisions_jobOptions.py b/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCollisions_jobOptions.py
index b41074e564392a398f59f06265fdf42d9b7287ea..e8a93cffe752483707937e50c797fb5dbd564016 100755
--- a/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCollisions_jobOptions.py
+++ b/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCollisions_jobOptions.py
@@ -8,7 +8,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 if DQMonFlags.monManEnvironment() == 'online':
    tmp_timeGran = "run"
@@ -46,7 +46,7 @@ CaloTowerMonNoTA = CaloTowerVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
 
    useLArNoisyAlg = tmp_useLArNoisyAlg,
 
diff --git a/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCosmics_jobOptions.py b/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCosmics_jobOptions.py
index 1658dd6c0c69acd3b2a1ac66f644c59752687449..84fb1a17557c7045ba9e4e7ac9ffabd9c99abe5f 100755
--- a/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCosmics_jobOptions.py
+++ b/Calorimeter/CaloMonitoring/share/CaloTowerVecMonCosmics_jobOptions.py
@@ -7,7 +7,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 if DQMonFlags.monManEnvironment() == 'online':
    tmp_timeGran = "run"
@@ -45,7 +45,7 @@ CaloTowerMonCosmicsNoTA = CaloTowerVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
 
    useLArNoisyAlg = tmp_useLArNoisyAlg,
 
diff --git a/Calorimeter/CaloMonitoring/share/EMClusterVecMonCollisions_jobOpt.py b/Calorimeter/CaloMonitoring/share/EMClusterVecMonCollisions_jobOpt.py
index 72386e7ff3a1df8758cfee9fcd75bd0e2f9432ca..488427fbbb33fb468f251e1e779d5e2ef60f62f6 100644
--- a/Calorimeter/CaloMonitoring/share/EMClusterVecMonCollisions_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/EMClusterVecMonCollisions_jobOpt.py
@@ -21,7 +21,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 #if DQMonFlags.monManEnvironment() == 'online':
 #   tmp_CaloClusterContainer = "EMTopoCluster430"
@@ -71,7 +71,7 @@ EMCaloClusterMonNoTA = CaloClusterVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
 
    useLArNoisyAlg = tmp_useLArNoisyAlg,
 
diff --git a/Calorimeter/CaloMonitoring/share/EMClusterVecMonCosmics_jobOpt.py b/Calorimeter/CaloMonitoring/share/EMClusterVecMonCosmics_jobOpt.py
index 9c98ab45a86bb41c4a96f3df2d24163f0fa74916..10378f9c43df41513725f25ef97e3d053306b337 100755
--- a/Calorimeter/CaloMonitoring/share/EMClusterVecMonCosmics_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/EMClusterVecMonCosmics_jobOpt.py
@@ -21,7 +21,7 @@ from AthenaMonitoring.DQMonFlags import DQMonFlags
 from AthenaCommon.GlobalFlags  import globalflags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 #if DQMonFlags.monManEnvironment() == 'online':
 #   tmp_CaloClusterContainer = "EMTopoCluster430"
@@ -71,7 +71,7 @@ EMCaloClusterMonCosmicsNoTA = CaloClusterVecMon(
    BadLBTool = GetLArBadLBFilterTool(),
 
    useReadyFilterTool = tmp_useReadyFilterTool,
-   ReadyFilterTool = monAtlasReadyFilterTool,
+   ReadyFilterTool = GetAtlasReadyFilterTool(),
 
    useLArNoisyAlg = tmp_useLArNoisyAlg,
   
diff --git a/Calorimeter/CaloMonitoring/share/LArMuIDClusterVecMonCosmics_jobOpt.py b/Calorimeter/CaloMonitoring/share/LArMuIDClusterVecMonCosmics_jobOpt.py
index 69c569f1dc7d6503d3ef532504230f1710be5057..b3e79f3a2f540a65fd487b417f6e894f443cde74 100755
--- a/Calorimeter/CaloMonitoring/share/LArMuIDClusterVecMonCosmics_jobOpt.py
+++ b/Calorimeter/CaloMonitoring/share/LArMuIDClusterVecMonCosmics_jobOpt.py
@@ -12,7 +12,7 @@ from AthenaCommon.GlobalFlags  import globalflags
 from AthenaMonitoring.DQMonFlags import DQMonFlags
 
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 if (DQMonFlags.monManEnvironment == 'online' or globalflags.DataSource.get_Value() == 'geant4' or globalflags.DataSource.get_Value() == 'geant3'):
   tmp_useBadLBTool=FALSE
@@ -51,7 +51,7 @@ LArCosmicsClusterMon = CaloClusterVecMon(
   BadLBTool = GetLArBadLBFilterTool(),
 
   useReadyFilterTool = tmp_useReadyFilterTool,
-  ReadyFilterTool = monAtlasReadyFilterTool,
+  ReadyFilterTool = GetAtlasReadyFilterTool(),
 
   useLArNoisyAlg = tmp_useLArNoisyAlg,
   
diff --git a/Calorimeter/CaloMonitoring/src/CaloMonToolBase.cxx b/Calorimeter/CaloMonitoring/src/CaloMonToolBase.cxx
index cec93a4e2eccb8f689f69190de24f463b2d2e0fb..f5fdee62837c02cf0e69c745a25d7f70f824dae1 100644
--- a/Calorimeter/CaloMonitoring/src/CaloMonToolBase.cxx
+++ b/Calorimeter/CaloMonitoring/src/CaloMonToolBase.cxx
@@ -13,8 +13,8 @@ CaloMonToolBase::CaloMonToolBase(const std::string& type, const std::string& nam
    m_lb(0),
    m_passBeamBackgroundRemoval(false),
    m_h_EvtRejSumm(nullptr),
-   m_BadLBTool("DQBadLBFilterTool"),
-   m_ReadyFilterTool("DQAtlasReadyFilterTool")
+   m_BadLBTool(this, "DQBadLBFilterTool"),
+   m_ReadyFilterTool(this, "DQAtlasReadyFilterTool")
  {
   declareProperty("useBadLBTool", m_useBadLBTool=false);
   declareProperty("BadLBTool", m_BadLBTool);
diff --git a/Control/AthenaMonitoring/AthenaMonitoring/DQAtlasReadyFilterTool.h b/Control/AthenaMonitoring/AthenaMonitoring/DQAtlasReadyFilterTool.h
index 09bdbe24c639cb094b6b6173df4c0b71b2633030..6f6c5c4b14263e4eabcfd96ad3d4831d97e58a71 100644
--- a/Control/AthenaMonitoring/AthenaMonitoring/DQAtlasReadyFilterTool.h
+++ b/Control/AthenaMonitoring/AthenaMonitoring/DQAtlasReadyFilterTool.h
@@ -8,6 +8,8 @@
 #include "AthenaMonitoring/IDQFilterTool.h"
 #include "AthenaBaseComps/AthAlgTool.h"
 #include "GaudiKernel/StatusCode.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
 
 // This filter tool rejects events where the ATLAS READY flag is not set
 // @author Peter Onyisi <ponyisi@cern.ch>
@@ -22,14 +24,11 @@ class DQAtlasReadyFilterTool :  public AthAlgTool, virtual public IDQFilterTool
         
   virtual bool accept() const override;
 
-  virtual StatusCode updateCache();
-
-  StatusCode callback( IOVSVC_CALLBACK_ARGS );
-
  private:
   bool m_fallbackValue;
   bool m_alwaysReturnTrue;
   bool m_valueCache;
+  SG::ReadCondHandleKey<AthenaAttributeList> m_key;
 };
 
 #endif //DQATLASREADYFILTERTOOL_H
diff --git a/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterAlg.h b/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterAlg.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7a3f3488e686ffb4be370abc5f1369110c538e6
--- /dev/null
+++ b/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterAlg.h
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DQBadLBFILTERALG_H
+#define DQBadLBFILTERALG_H
+
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+#include "AthenaPoolUtilities/AthenaAttributeList.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "CoralBase/AttributeListSpecification.h"
+#include "GaudiKernel/ICondSvc.h"
+
+#include <string>
+#include <vector>
+
+// This filter tool rejects events where the a bad LB block is flagged from a given defect
+// @author Michele Petteni <mpetteni@sfu.ca>
+
+class DQBadLBFilterAlg :  public AthAlgorithm  {
+ public:
+  DQBadLBFilterAlg(const std::string&, ISvcLocator*);
+        
+  virtual ~DQBadLBFilterAlg () override;
+  
+  virtual StatusCode initialize() override;
+
+  virtual StatusCode execute() override;
+
+ private:
+  bool m_fallbackValue;
+  bool m_ignoreRecoverable;
+  bool m_alwaysReturnTrue;
+  std::vector<int> m_listofdefects;
+  std::vector<std::string> m_listofdefects_str;
+  SG::ReadCondHandleKey<CondAttrListCollection> m_readKey;
+  SG::WriteCondHandleKey<AthenaAttributeList> m_writeKey;
+  ServiceHandle<ICondSvc> m_condSvc;
+  coral::AttributeListSpecification* m_attribListSpec;
+};
+
+#endif //DQATLASREADYFILTERALG_H
diff --git a/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterTool.h b/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterTool.h
index 8e42add932fa182d4162bb4049778dfea098874d..e2e97b3c541eb38facb3bdfe9a59c6e5f37a5b67 100644
--- a/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterTool.h
+++ b/Control/AthenaMonitoring/AthenaMonitoring/DQBadLBFilterTool.h
@@ -8,6 +8,8 @@
 #include "AthenaMonitoring/IDQFilterTool.h"
 #include "AthenaBaseComps/AthAlgTool.h"
 #include "GaudiKernel/StatusCode.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "AthenaPoolUtilities/AthenaAttributeList.h"
 
 #include <string>
 #include <vector>
@@ -25,17 +27,10 @@ class DQBadLBFilterTool :  public AthAlgTool, virtual public IDQFilterTool   {
         
   virtual bool accept() const override;
 
-  virtual StatusCode updateCache();
-
-  StatusCode callback( IOVSVC_CALLBACK_ARGS );
-
  private:
   bool m_fallbackValue;
-  bool m_ignoreRecoverable;
   bool m_alwaysReturnTrue;
-  bool m_valueCache;
-  std::vector<int> m_listofdefects;
-  std::vector<std::string> m_listofdefects_str;
+  SG::ReadCondHandleKey<AthenaAttributeList> m_key;
 };
 
 #endif //DQATLASREADYFILTERTOOL_H
diff --git a/Control/AthenaMonitoring/python/AtlasReadyFilterTool.py b/Control/AthenaMonitoring/python/AtlasReadyFilterTool.py
new file mode 100644
index 0000000000000000000000000000000000000000..c08ada017ad22ea340ffabf1bb6f4ab1650eb223
--- /dev/null
+++ b/Control/AthenaMonitoring/python/AtlasReadyFilterTool.py
@@ -0,0 +1,23 @@
+# Set up the ATLAS Ready filter tool
+def GetAtlasReadyFilterTool():
+   from AthenaCommon.Logging import logging
+   arft_local_logger = logging.getLogger('AtlasReadyFilterTool')
+
+   from AthenaMonitoring.DQMonFlags import DQMonFlags
+   from AthenaCommon.GlobalFlags  import globalflags
+
+   if (DQMonFlags.monManEnvironment == 'online'
+       or globalflags.DataSource.get_Value() == 'geant4'
+       or 'collisions' not in DQMonFlags.monManDataType.get_Value()
+       or DQMonFlags.disableAtlasReadyFilter.get_Value()):
+      arft_local_logger.info("Disabling ATLAS Ready monitoring filter")
+      from AthenaMonitoring.AthenaMonitoringConf import DQDummyFilterTool
+      return DQDummyFilterTool()
+
+   if globalflags.DataSource.get_Value() != 'geant4':
+      from IOVDbSvc.CondDB import conddb
+      if not conddb.folderRequested('/TDAQ/RunCtrl/DataTakingMode'):
+         conddb.addFolder('TDAQ', '/TDAQ/RunCtrl/DataTakingMode', className='AthenaAttributeList')
+
+   from AthenaMonitoring.AthenaMonitoringConf import DQAtlasReadyFilterTool
+   return DQAtlasReadyFilterTool()
diff --git a/Control/AthenaMonitoring/python/BadLBFilterTool.py b/Control/AthenaMonitoring/python/BadLBFilterTool.py
index e9ecbf49d803a68aa752087e8e65bfc7693d3a85..498a82f8ced9b0cd52482241f1e0de9bbd2eee26 100644
--- a/Control/AthenaMonitoring/python/BadLBFilterTool.py
+++ b/Control/AthenaMonitoring/python/BadLBFilterTool.py
@@ -29,39 +29,26 @@ def _InstanceFromProjectName():
     else:
         return "COMP200"
 
-# Set up the bad lb filter tool
-# Cache instances that are already created
+# Set up the bad lb filter conditions algorithm
+# Cache instance once already created
 @memoize
-def GetBadLBFilterTool(name, defects, alwaysReturnTrue=False, ignoreRecoverable=False, autoconfigure=True, origDbTag=None):
+def GetBadLBFilterAlg(name, defects, writekey, ignoreRecoverable=False, origDbTag=None):
     """
-    Configure an instance of the bad LB filter tool.  If called twice with the same options, will return the same instance.
+    Configure an instance of the bad LB filter conditions algorithm. Not intended to be called directly by users.
     Arguments:
         - name: name of instance to create
         - defects: the defects to use for LB rejection.  Tool will return false if any of these defects is present.  These may be virtual defects.  NOTE: the value you pass must be a 'hashable' type.  The best choice is to pass a tuple; you can create a tuple from any iterable object with tuple(obj).
-        - alwaysReturnTrue (optional; default=False): if True, the tool will never reject any LBs.
-        - ignoreRecoverable (optional; default=False): if True, the tool will ignore defects that are marked as recoverable
-        - autoconfigure (optional; default=True): automatically handle certain cases, e.g. Monte Carlo, where we want to always return True
+        - ignoreRecoverable (optional; default=False): if True, the algorithm will ignore defects that are marked as recoverable
         - origDbTag (optional): if set, will override automatic configuration of database tag (only for testing)
     """
     import operator
     from AthenaMonitoring.DQMonFlags import DQMonFlags
     from AthenaCommon.GlobalFlags  import globalflags
-    from AthenaCommon.AppMgr import ToolSvc
     from AthenaCommon.Logging import logging
-    log = logging.getLogger('BadLBFilterTool')
-
-    # if online or MC, we don't want to do any filtering, or even access
-    # the DBs
-    if autoconfigure and (DQMonFlags.monManEnvironment == 'online'
-                          or globalflags.DataSource.get_Value() == 'geant4'
-                          ):
-        log.info('Disabling bad LB filter tool due to inappropriate environment; returning dummy')
-        from AthenaMonitoring.AthenaMonitoringConf import DQDummyFilterTool
-        monFilterTool = DQDummyFilterTool(name)
-        ToolSvc += monFilterTool
-        return monFilterTool
+    from AthenaCommon.AlgSequence import AthSequencer 
+    log = logging.getLogger('BadLBFilterAlg')
 
-    from AthenaMonitoring.AthenaMonitoringConf import DQBadLBFilterTool
+    from AthenaMonitoring.AthenaMonitoringConf import DQBadLBFilterAlg
     from DQDefects import DefectsDB
     dbtag = _resolve_db_tag(origDbTag)
     dbname=_InstanceFromProjectName()
@@ -76,30 +63,95 @@ def GetBadLBFilterTool(name, defects, alwaysReturnTrue=False, ignoreRecoverable=
         else:
             raise ValueError('%s is not a known defect' % defect)
         
-    log.info ("Tool name %s to be configured with intolerable defects %s" % (name, list(primary_defects)))
+    log.info ("Algorithm name %s to be configured with intolerable defects %s" % (name, list(primary_defects)))
 
     primary_defect_ids = [ddb.defect_id_map[id] for id in primary_defects]
 
-    monFilterTool = DQBadLBFilterTool(name)
-    monFilterTool.defectList = primary_defect_ids
-    monFilterTool.alwaysReturnTrue = alwaysReturnTrue
-    monFilterTool.ignoreRecoverable = ignoreRecoverable
+    monFilterAlg = DQBadLBFilterAlg(name)
+    monFilterAlg.defectList = primary_defect_ids
+    monFilterAlg.ignoreRecoverable = ignoreRecoverable
+    monFilterAlg.WriteKey = writekey
 
     if globalflags.DataSource.get_Value() != 'geant4':
         from IOVDbSvc.CondDB import conddb
         if not conddb.folderRequested('/GLOBAL/DETSTATUS/DEFECTS'):
-            conddb.addFolder('GLOBAL_OFL', '/GLOBAL/DETSTATUS/DEFECTS')
+            conddb.addFolder('GLOBAL_OFL', '/GLOBAL/DETSTATUS/DEFECTS',
+                             className='CondAttrListCollection')
+
+    condSequence = AthSequencer("AthCondSeq")
+    condSequence += monFilterAlg
+    return monFilterAlg
+
+# Set up the bad lb filter tool
+def GetBadLBFilterTool(name, defects, alwaysReturnTrue=False, ignoreRecoverable=False, autoconfigure=True, origDbTag=None):
+    """
+    Configure an instance of the bad LB filter tool.  If called twice with the same options, will return the same instance.
+    Arguments:
+        - name: name of *algorithm* instance to create
+        - defects: the defects to use for LB rejection.  Tool will return false if any of these defects is present.  These may be virtual defects.  NOTE: the value you pass must be a 'hashable' type.  The best choice is to pass a tuple; you can create a tuple from any iterable object with tuple(obj).
+        - alwaysReturnTrue (optional; default=False): if True, the tool will never reject any LBs.
+        - ignoreRecoverable (optional; default=False): if True, the tool will ignore defects that are marked as recoverable
+        - autoconfigure (optional; default=True): automatically handle certain cases, e.g. Monte Carlo, where we want to always return True
+        - origDbTag (optional): if set, will override automatic configuration of database tag (only for testing)
+    """
+    import operator
+    from AthenaMonitoring.DQMonFlags import DQMonFlags
+    from AthenaCommon.GlobalFlags  import globalflags
+    from AthenaCommon.Logging import logging
+    log = logging.getLogger('BadLBFilterTool')
+
+    # if online or MC, we don't want to do any filtering, or even access
+    # the DBs
+    if autoconfigure and (DQMonFlags.monManEnvironment == 'online'
+                          or globalflags.DataSource.get_Value() == 'geant4'
+                          ):
+        log.info('Disabling bad LB filter tool due to inappropriate environment; returning dummy')
+        from AthenaMonitoring.AthenaMonitoringConf import DQDummyFilterTool
+        monFilterTool = DQDummyFilterTool(name)
+        return monFilterTool
+
+    sgkey = 'DQBadLBFilterAlgResult_%s' % name
+    GetBadLBFilterAlg('DQBadLBFilterAlg_%s' % name, 
+                      defects, sgkey, ignoreRecoverable, origDbTag)
+    from AthenaMonitoring.AthenaMonitoringConf import DQBadLBFilterTool
+
+    monFilterTool = DQBadLBFilterTool(name)
+    monFilterTool.alwaysReturnTrue = alwaysReturnTrue
+    monFilterTool.ReadKey = sgkey
 
-    ToolSvc += monFilterTool
     return monFilterTool
 
+@memoize
+def LArBadDefectList(origDbTag=None):
+    """
+    Get the defects to configure for LAr - cache results to avoid lots of DB lookups
+    Arguments:
+        - origDbTag (optional): if set, will override automatic configuration of database tag (only for testing)
+    """
+    import operator
+    from DQDefects import DefectsDB
+    dbtag = _resolve_db_tag(origDbTag)
+    dbname = _InstanceFromProjectName()
+    ddb = DefectsDB('COOLOFL_GLOBAL/'+dbname, tag=dbtag)
+    defects = ddb.defect_names
+    defectliststr = []
+    defectlist = []
+    lar_defects = reduce(operator.or_, [set(ddb.virtual_defect_logics[z].clauses) for z in \
+                                            ('EMBA', 'EMBC', 'EMECA', 'EMECC', 
+                                             'HECA', 'HECC', 'FCALA',
+                                             'FCALC')])-set(['LAR_UNCHECKED','LAR_GENERAL','DISABLED','NONGREEN'])
+    lar_defects = set(defect for defect in lar_defects
+                          if ('LAR' in defect and
+                              (('HVTRIP' in defect) or ('SEV' in defect) or
+                               ('CORRUPT' in defect))))
+    return lar_defects
+
 def GetLArBadLBFilterTool(origDbTag=None):
     """
     Configure a LAr defect-specific instance of the bad LB filter tool.  If called twice with the same options, will return the same instance.
     Arguments:
         - origDbTag (optional): if set, will override automatic configuration of database tag (only for testing)
     """
-    import operator
     from AthenaCommon.Logging import logging
     log = logging.getLogger('BadLBFilterTool/LAr')
 
@@ -113,20 +165,7 @@ def GetLArBadLBFilterTool(origDbTag=None):
         log.info('Disabling LAr bad LB filter tool due to inappropriate environment')
         lar_defects = []
     else:
-        from DQDefects import DefectsDB
-        dbtag = _resolve_db_tag(origDbTag)
-        dbname = _InstanceFromProjectName()
-        ddb = DefectsDB('COOLOFL_GLOBAL/'+dbname, tag=dbtag)
-        defects = ddb.defect_names
-        defectliststr = []
-        defectlist = []
-        lar_defects = reduce(operator.or_, [set(ddb.virtual_defect_logics[z].clauses) for z in \
-    ('EMBA', 'EMBC', 'EMECA', 'EMECC', 'HECA', 'HECC', 'FCALA', \
-    'FCALC')])-set(['LAR_UNCHECKED','LAR_GENERAL','DISABLED','NONGREEN'])
-        lar_defects = set(defect for defect in lar_defects
-                          if ('LAR' in defect and
-                              (('HVTRIP' in defect) or ('SEV' in defect) or
-                               ('CORRUPT' in defect))))
+        lar_defects = LArBadDefectList(origDbTag)
 
     return GetBadLBFilterTool('LArBadLBFilterTool', tuple(lar_defects),
                               origDbTag=origDbTag)
diff --git a/Control/AthenaMonitoring/python/FilledBunchFilterTool.py b/Control/AthenaMonitoring/python/FilledBunchFilterTool.py
new file mode 100644
index 0000000000000000000000000000000000000000..76e247ea56d231a46d06147bf8b951e2371297b8
--- /dev/null
+++ b/Control/AthenaMonitoring/python/FilledBunchFilterTool.py
@@ -0,0 +1,26 @@
+# Set up the filled bunch filter tool
+def GetFilledBunchFilterTool():
+   from AthenaCommon.Logging import logging
+
+   fbft_local_logger = logging.getLogger('FilledBunchFilterTool')
+   fbft_local_logger.verbose('Configuring monFilledBunchFilterTool')
+
+   from AthenaMonitoring.DQMonFlags import DQMonFlags
+   from AthenaCommon.GlobalFlags  import globalflags
+   from RecExConfig.RecFlags import rec
+
+   if (rec.triggerStream() == 'CosmicCalo'
+       or globalflags.DataSource.get_Value() == 'geant4'
+       or 'collisions' not in DQMonFlags.monManDataType.get_Value()
+       or DQMonFlags.disableFilledBunchFilter.get_Value()):
+      fbft_local_logger.verbose('Filled bunch filter being configured to always return true')
+      from AthenaMonitoring.AthenaMonitoringConf import DQDummyFilterTool
+      return DQDummyFilterTool()
+
+   from AthenaMonitoring.AthenaMonitoringConf import DQFilledBunchFilterTool
+   from TrigBunchCrossingTool.BunchCrossingTool import BunchCrossingTool
+   monFilledBunchFilterTool = DQFilledBunchFilterTool()
+   monFilledBunchFilterTool.bunchCrossingTool = BunchCrossingTool()
+
+   return monFilledBunchFilterTool
+
diff --git a/Control/AthenaMonitoring/share/AtlasReadyFilterTool_jobOptions.py b/Control/AthenaMonitoring/share/AtlasReadyFilterTool_jobOptions.py
deleted file mode 100644
index 8ec92fcebbef9b1be5d0ef926eafffefa6e23d63..0000000000000000000000000000000000000000
--- a/Control/AthenaMonitoring/share/AtlasReadyFilterTool_jobOptions.py
+++ /dev/null
@@ -1,27 +0,0 @@
-include.block('AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py')
-
-# Set up the ATLAS Ready filter tool
-from AthenaCommon.Logging import logging
-
-arft_local_logger = logging.getLogger('AtlasReadyFilterTool_jobOptions')
-
-if not 'DQMonFlags' in dir():
-   arft_local_logger.debug("AtlasReadyFilterTool_jobOptions.py: DQMonFlags not yet imported - I import them now")
-   from AthenaMonitoring.DQMonFlags import DQMonFlags
-
-if not 'monAtlasReadyFilterTool' in dir():
-   if globalflags.DataSource.get_Value() != 'geant4':
-      from IOVDbSvc.CondDB import conddb
-      conddb.addFolder('TDAQ', '/TDAQ/RunCtrl/DataTakingMode')
-
-   from AthenaMonitoring.AthenaMonitoringConf import DQAtlasReadyFilterTool
-   monAtlasReadyFilterTool = DQAtlasReadyFilterTool()
-   if (DQMonFlags.monManEnvironment == 'online'
-       or globalflags.DataSource.get_Value() == 'geant4'
-       or 'collisions' not in DQMonFlags.monManDataType.get_Value()
-       or DQMonFlags.disableAtlasReadyFilter.get_Value()):
-      arft_local_logger.info("Disabling ATLAS Ready monitoring filter")
-      monAtlasReadyFilterTool.alwaysReturnTrue = True
-   ToolSvc += monAtlasReadyFilterTool
-
-del arft_local_logger
diff --git a/Control/AthenaMonitoring/share/DataQualitySteering_jobOptions.py b/Control/AthenaMonitoring/share/DataQualitySteering_jobOptions.py
index 226531f5e14d9f248811da349383eabb5155a461..0819c9b039d8829d3035c887f2081d7ef1ff75ba 100644
--- a/Control/AthenaMonitoring/share/DataQualitySteering_jobOptions.py
+++ b/Control/AthenaMonitoring/share/DataQualitySteering_jobOptions.py
@@ -34,8 +34,8 @@ if DQMonFlags.doMonitoring():
          from LumiBlockComps.TrigLivefractionToolDefault import TrigLivefractionToolDefault 
          ToolSvc+=TrigLivefractionToolDefault()
 
-   include("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
-   include("AthenaMonitoring/FilledBunchFilterTool_jobOptions.py")
+   from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
+   from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
 
    #---------------------------#
    # Inner detector monitoring #
@@ -247,9 +247,6 @@ if DQMonFlags.doMonitoring():
    #--------------------------#
    # Post-setup configuration #
    #--------------------------#
-   if rec.triggerStream()=='express':
-      include("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
-
    local_logger.debug('DQ Post-Setup Configuration')
 
    # now the DQ tools are private, extract them from the set of monitoring algorithms
@@ -273,7 +270,7 @@ if DQMonFlags.doMonitoring():
          local_logger.debug('Setting up filters for tool %s', tool)
          if rec.triggerStream()=='express':
             local_logger.info('Stream is express and we will add ready tool for %s', tool)
-            tool.FilterTools += [monAtlasReadyFilterTool]
+            tool.FilterTools += [GetAtlasReadyFilterTool()]
          # give all the tools the trigger translator
          if DQMonFlags.useTrigger():
             tool.TrigDecisionTool = monTrigDecTool
diff --git a/Control/AthenaMonitoring/share/FilledBunchFilterTool_jobOptions.py b/Control/AthenaMonitoring/share/FilledBunchFilterTool_jobOptions.py
deleted file mode 100644
index c72e6941286bc0cd285b827a00bc4b839dd0e522..0000000000000000000000000000000000000000
--- a/Control/AthenaMonitoring/share/FilledBunchFilterTool_jobOptions.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# Set up the filled bunch filter tool
-include.block('AthenaMonitoring/FilledBunchFilterTool_jobOptions.py')
-from AthenaCommon.Logging import logging
-
-fbft_local_logger = logging.getLogger('FilledBunchFilterTool_jobOptions')
-
-if not 'DQMonFlags' in dir():
-   fbft_local_logger.info("FilledBunchFilterTool_jobOptions.py: DQMonFlags not yet imported - I import them now")
-   from AthenaMonitoring.DQMonFlags import DQMonFlags
-
-if not 'monFilledBunchFilterTool' in dir():
-   fbft_local_logger.info('Configuring monFilledBunchFilterTool')
-   from AthenaMonitoring.AthenaMonitoringConf import DQFilledBunchFilterTool
-   from TrigBunchCrossingTool.BunchCrossingTool import BunchCrossingTool
-   monFilledBunchFilterTool = DQFilledBunchFilterTool()
-   monFilledBunchFilterTool.bunchCrossingTool = BunchCrossingTool()
-   if (rec.triggerStream() == 'CosmicCalo'
-       or globalflags.DataSource.get_Value() == 'geant4'
-       or 'collisions' not in DQMonFlags.monManDataType.get_Value()
-       or DQMonFlags.disableFilledBunchFilter.get_Value()):
-      fbft_local_logger.info('Filled bunch filter being configured to always return true')
-      monFilledBunchFilterTool.alwaysReturnTrue = True
-   ToolSvc += monFilledBunchFilterTool
-
-del fbft_local_logger
diff --git a/Control/AthenaMonitoring/src/AthenaMonManager.cxx b/Control/AthenaMonitoring/src/AthenaMonManager.cxx
index 84b54ae598e2d26c0e74d7fdd6ad05c7c9c4206f..811743a9ce84bedb9bff901c92a736aaede990e1 100755
--- a/Control/AthenaMonitoring/src/AthenaMonManager.cxx
+++ b/Control/AthenaMonitoring/src/AthenaMonManager.cxx
@@ -492,35 +492,21 @@ initialize()
     if( root_backend_for_lwhists != LWHistControls::hasROOTBackend() )
         LWHistControls::setROOTBackend(root_backend_for_lwhists);
 
-//    if( m_monTools.size() > 0 ) {
-//       sc = m_monTools.retrieve();
-//       if( !sc.isSuccess() ) {
-//          msg(MSG::ERROR) << "!! Unable to retrieve monitoring tool " << m_monTools << endmsg;
-//          return sc;
-//       }
-//       if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "  --> Retrieved AthenaMonTools" << endmsg;
-//    }
+    if( m_monTools.size() > 0 ) {
+      sc = m_monTools.retrieve();
+      if( !sc.isSuccess() ) {
+	msg(MSG::ERROR) << "!! Unable to retrieve monitoring tool " << m_monTools << endmsg;
+	return sc;
+      }
+      if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "  --> Retrieved AthenaMonTools" << endmsg;
+    }
 
     m_d->m_eventCounter = m_d->m_everyNevents;
 
     ToolHandleArray<IMonitorToolBase>::iterator monToolsEnd = m_monTools.end();
     for( ToolHandleArray<IMonitorToolBase>::iterator i = m_monTools.begin(); i != monToolsEnd; ++i ) {
         ToolHandle<IMonitorToolBase>& tool = *i;
-        m_d->toolAudStart(tool);
         AthMonBench bench_tmp;
-        if (m_d->m_doResourceMon)
-            bench_tmp.startMeasurement();
-        StatusCode sc_toolret = tool.retrieve();
-        if (m_d->m_doResourceMon)
-            bench_tmp.finishMeasurement();
-        m_d->toolAudEnd();
-        if( sc_toolret.isFailure() ) {
-            msg(MSG::ERROR) << "Failed to retrieve monitoring tool " << tool << endmsg;
-            return StatusCode::FAILURE;
-        }
-        else {
-            msg(MSG::INFO) << "Retrieved tool " << tool << endmsg;
-        }
         IMonitorToolBase* mon = tool.operator->();
         ManagedMonitorToolBase* managed = dynamic_cast<ManagedMonitorToolBase*>( mon );
         if( managed != 0 ) {
diff --git a/Control/AthenaMonitoring/src/DQAtlasReadyFilterTool.cxx b/Control/AthenaMonitoring/src/DQAtlasReadyFilterTool.cxx
index 065bb069ad95d10f9b58643de9d50586873272f8..3ffed3a070d4541cbd400e55b403b133496e4aa0 100644
--- a/Control/AthenaMonitoring/src/DQAtlasReadyFilterTool.cxx
+++ b/Control/AthenaMonitoring/src/DQAtlasReadyFilterTool.cxx
@@ -3,13 +3,13 @@
 */
 
 #include "AthenaMonitoring/DQAtlasReadyFilterTool.h"
-#include "AthenaPoolUtilities/AthenaAttributeList.h"
 
 DQAtlasReadyFilterTool::DQAtlasReadyFilterTool(const std::string& type,const std::string& name,const IInterface* parent)
 : AthAlgTool( type, name, parent )
 , m_fallbackValue(true)
 , m_alwaysReturnTrue(false)
 , m_valueCache(true)
+, m_key("/TDAQ/RunCtrl/DataTakingMode")
 {
   declareInterface<IDQFilterTool>(this);
  declareProperty("fallbackValue", m_fallbackValue);
@@ -21,49 +21,24 @@ DQAtlasReadyFilterTool::~DQAtlasReadyFilterTool () {}
 StatusCode DQAtlasReadyFilterTool::initialize()
 {
   ATH_MSG_VERBOSE("ATLAS Ready initialize");
-  // don't register callback if we always return true anyway
+  // don't register if we always return true anyway
   if (m_alwaysReturnTrue) return StatusCode::SUCCESS;
 
-  const DataHandle<AthenaAttributeList> attrList;
-  StatusCode sc = detStore()->regFcn(&DQAtlasReadyFilterTool::callback, 
-  				     this, attrList,
-  				     "/TDAQ/RunCtrl/DataTakingMode");
-  if (sc.isFailure()) {
-    ATH_MSG_ERROR("Unable to register ATLAS Ready filter tool callback");
-    return StatusCode::FAILURE;
-  }
-  if (sc.isFailure()) {
-    ATH_MSG_ERROR("Unable to set up ready value cache");
-    return StatusCode::FAILURE;
-  }
+  ATH_CHECK( m_key.initialize() );
   return StatusCode::SUCCESS;
 }
 
-StatusCode DQAtlasReadyFilterTool::updateCache() {
-  const AthenaAttributeList* attrList(0);
-  StatusCode sc = detStore()->retrieve(attrList, "/TDAQ/RunCtrl/DataTakingMode");
-  if (sc.isFailure()) {
-    ATH_MSG_WARNING("Unable to retrieve DataTakingMode information; falling back to" << m_fallbackValue);
-    m_valueCache = m_fallbackValue;
-    return StatusCode::SUCCESS;
-  }
-  if (attrList != 0) {
-    ATH_MSG_VERBOSE("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
-    m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
-  }
-  return StatusCode::SUCCESS;
-}
-        
 bool DQAtlasReadyFilterTool::accept() const {
   if (m_alwaysReturnTrue) {
     return true;
   } else {
-    ATH_MSG_DEBUG("ATLAS Ready accept called, value " << m_valueCache);
-    return m_valueCache;
+    SG::ReadCondHandle<AthenaAttributeList> rch(m_key);
+    const AthenaAttributeList* attrList{*rch};
+    if (attrList == 0) {
+      ATH_MSG_WARNING("Unable to retrieve DataTakingMode information; falling back to" << m_fallbackValue);
+      return m_fallbackValue;
+    }
+    ATH_MSG_DEBUG("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
+    return ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
   }
 }
-
-StatusCode DQAtlasReadyFilterTool::callback( IOVSVC_CALLBACK_ARGS) {
-  ATH_MSG_VERBOSE("ATLAS Ready callback called");
-  return updateCache();
-}
diff --git a/Control/AthenaMonitoring/src/DQBadLBFilterAlg.cxx b/Control/AthenaMonitoring/src/DQBadLBFilterAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..71a1063f1740cbe1b6403dcd891eda5366933801
--- /dev/null
+++ b/Control/AthenaMonitoring/src/DQBadLBFilterAlg.cxx
@@ -0,0 +1,110 @@
+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "AthenaMonitoring/DQBadLBFilterAlg.h"
+#include "AthenaPoolUtilities/AthenaAttributeList.h"
+#include "AthenaPoolUtilities/AthenaAttributeListSpecification.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+#include "CoralBase/AttributeListException.h"
+
+DQBadLBFilterAlg::DQBadLBFilterAlg(const std::string& name, ISvcLocator* pSvcLocator)
+: AthAlgorithm( name, pSvcLocator )
+, m_ignoreRecoverable(true)
+, m_readKey("/GLOBAL/DETSTATUS/DEFECTS")
+, m_writeKey("")
+, m_condSvc("CondSvc",name)
+{
+  declareProperty("ignoreRecoverable", m_ignoreRecoverable);
+  declareProperty("defectListStr", m_listofdefects_str);
+  declareProperty("defectList", m_listofdefects);
+  declareProperty("ReadKey", m_readKey);
+  declareProperty("WriteKey", m_writeKey);
+}
+        
+DQBadLBFilterAlg::~DQBadLBFilterAlg () {}
+        
+StatusCode DQBadLBFilterAlg::initialize()
+{
+
+  ATH_MSG_DEBUG("size of defects list in Bad DB " << m_listofdefects_str.size()<< " : " << m_listofdefects.size()); 
+
+  ATH_MSG_VERBOSE("ATLAS Ready initialize");
+  // define attributes to upload
+  m_attribListSpec = new coral::AttributeListSpecification;
+  m_attribListSpec->extend("Accept", "bool");
+
+  // CondSvc
+  ATH_CHECK( m_condSvc.retrieve() );
+  // Handles
+  ATH_CHECK( m_readKey.initialize() );
+  ATH_CHECK( m_writeKey.initialize() );
+  // Register write handle
+  if (m_condSvc->regHandle(this, m_writeKey).isFailure()) {
+    ATH_MSG_ERROR("unable to register WriteCondHandle " << m_writeKey.fullKey() << " with CondSvc");
+    return StatusCode::FAILURE;
+  }
+
+  return StatusCode::SUCCESS;
+}
+
+StatusCode DQBadLBFilterAlg::execute() {
+  // from pixel example code ...
+  // Write Cond Handle
+  SG::WriteCondHandle<AthenaAttributeList> writeHandle{m_writeKey};
+  // Do we have a valid Write Cond Handle for current time?
+  if(writeHandle.isValid()) {
+    // in theory this should never be called in MT
+    ATH_MSG_DEBUG("CondHandle " << writeHandle.fullKey() << " is already valid.");
+    return StatusCode::SUCCESS; 
+  }
+
+  ATH_MSG_DEBUG( "Creating AthenaAttributeList object."  );
+  std::unique_ptr<AthenaAttributeList> attribListW = std::make_unique<AthenaAttributeList>(*m_attribListSpec);
+  (*attribListW)["Accept"].setValue(true);
+
+  SG::ReadCondHandle<CondAttrListCollection> readHandle{m_readKey};
+  const CondAttrListCollection* attrListCol{*readHandle};
+  if (attrListCol == nullptr) {
+    ATH_MSG_ERROR("Unable to retrieve defect information");
+    return StatusCode::FAILURE;
+  }
+
+  ATH_MSG_DEBUG("Col range " <<  " iov min " << attrListCol->minRange().start().event() << " iov max " << attrListCol->minRange().stop().event());
+
+  std::vector<int>::const_iterator defect_iter = m_listofdefects.begin();
+  
+  for ( ; defect_iter != m_listofdefects.end();++defect_iter){
+    if (attrListCol->chanAttrListPair(*defect_iter) != attrListCol->end()){
+      const CondAttrListCollection::AttributeList* attrList = 
+	&(attrListCol->attributeList( (*defect_iter) ));
+      ATH_MSG_DEBUG("FOUND CHANNEL " << (*defect_iter) << " is: " << (*attrList)["present"].data<bool>());
+      ATH_MSG_DEBUG("current channel : " << (*defect_iter) << " Name : " << attrListCol->chanName(*defect_iter) << " : iovrange " << attrListCol->iovRange(*defect_iter).start().event() << " : " <<  attrListCol->iovRange(*defect_iter).stop().event());
+      ATH_MSG_DEBUG( "Check address " << attrList << " : " << *attrList);
+      if ((*attrList)["present"].data<bool>() != 0){
+	if ((*attrList)["recoverable"].data<bool>() == 1 && m_ignoreRecoverable){
+	  continue;
+	}
+	(*attribListW)["Accept"].setValue(false);
+      }
+    }
+  }    
+
+  // Define validity of the output cond object and record it
+  EventIDRange rangeW;
+  if(!readHandle.range(rangeW)) {
+    ATH_MSG_ERROR("Failed to retrieve validity range for " << readHandle.key());
+    return StatusCode::FAILURE;
+  }
+ 
+  if(writeHandle.record(rangeW,attribListW.release()).isFailure()) {
+    ATH_MSG_ERROR("Could not record DQ AthenaAttributeList object with " 
+		  << writeHandle.key() 
+		  << " with EventRange " << rangeW
+		  << " into Conditions Store");
+    return StatusCode::FAILURE;
+  }
+  ATH_MSG_INFO("recorded new " << writeHandle.key() << " with range " << rangeW << " into Conditions Store");
+
+  return StatusCode::SUCCESS;
+}
diff --git a/Control/AthenaMonitoring/src/DQBadLBFilterTool.cxx b/Control/AthenaMonitoring/src/DQBadLBFilterTool.cxx
index dbd433f3f6c3f2adb7c0d3c73e5742924fb009e0..8e3f98a08a69d59ce42a1a0f4be32f07aabb45ba 100644
--- a/Control/AthenaMonitoring/src/DQBadLBFilterTool.cxx
+++ b/Control/AthenaMonitoring/src/DQBadLBFilterTool.cxx
@@ -10,101 +10,41 @@
 DQBadLBFilterTool::DQBadLBFilterTool(const std::string& type,const std::string& name,const IInterface* parent)
 : AthAlgTool( type, name, parent )
 , m_fallbackValue(true)
-, m_ignoreRecoverable(true)
 , m_alwaysReturnTrue(false)
-, m_valueCache(true)
-//, m_listofdefects(0)
-//, m_listofdefects_str(0)
+, m_key("")
 {
-
   declareInterface<IDQFilterTool>(this);
   declareProperty("fallbackValue", m_fallbackValue);
-  declareProperty("ignoreRecoverable", m_ignoreRecoverable);
   declareProperty("alwaysReturnTrue", m_alwaysReturnTrue);
-  declareProperty("defectListStr", m_listofdefects_str);
-  declareProperty("defectList", m_listofdefects);
-
+  declareProperty("ReadKey", m_key);
 }
         
 DQBadLBFilterTool::~DQBadLBFilterTool () {}
         
 StatusCode DQBadLBFilterTool::initialize()
 {
-
-  ATH_MSG_DEBUG("size of defects list in Bad DB " << m_listofdefects_str.size()<< " : " << m_listofdefects.size()); 
-  ATH_MSG_DEBUG("test other params fall and def " << m_fallbackValue << " : " << m_alwaysReturnTrue );
+  ATH_MSG_DEBUG("DQ Bad LB Filter tool: fallback and force: " << m_fallbackValue << "; " << m_alwaysReturnTrue );
 
   ATH_MSG_VERBOSE("ATLAS Ready initialize");
-  // don't register callback if we always return true anyway
+  // don't register key if we always return true anyway
   if (m_alwaysReturnTrue) return StatusCode::SUCCESS;
 
-  const DataHandle<CondAttrListCollection> attrList;
-//  const DataHandle<AthenaAttributeList> attrList;
-  StatusCode sc = detStore()->regFcn(&DQBadLBFilterTool::callback, 
-  				     this, attrList,
-  				     "/GLOBAL/DETSTATUS/DEFECTS");
-  if (sc.isFailure()) {
-    ATH_MSG_ERROR("Unable to register Bad LB filter tool callback");
-    return StatusCode::FAILURE;
-  }
-  if (sc.isFailure()) {
-    ATH_MSG_ERROR("Unable to set up ready value cache");
-    return StatusCode::FAILURE;
-  }
+  ATH_CHECK( m_key.initialize() );
   return StatusCode::SUCCESS;
 }
 
-StatusCode DQBadLBFilterTool::updateCache() {
-
-  const CondAttrListCollection* attrListCol(0);
-  StatusCode sc = detStore()->retrieve(attrListCol, "/GLOBAL/DETSTATUS/DEFECTS");
-  if (sc.isFailure()) {
-    ATH_MSG_WARNING("Unable to retrieve defect information; falling back to" << m_fallbackValue);
-    m_valueCache = m_fallbackValue;
-    return StatusCode::SUCCESS;
-  }
-
-  m_valueCache = m_fallbackValue;
-  if (attrListCol != 0) {
-
-          ATH_MSG_DEBUG("Col range " <<  " iov min " << attrListCol->minRange().start().event() << " iov max " << attrListCol->minRange().stop().event());
-
-      std::vector<int>::const_iterator defect_iter = m_listofdefects.begin();
-
-      for ( ; defect_iter != m_listofdefects.end();++defect_iter){
-
-          if (attrListCol->chanAttrListPair(*defect_iter) != attrListCol->end()){
-
-              const CondAttrListCollection::AttributeList* attrList = 
-                  &(attrListCol->attributeList( (*defect_iter) ));
-
-              ATH_MSG_DEBUG("FOUND CHANNEL " << (*defect_iter) << " is: " << (*attrList)["present"].data<bool>());
-              ATH_MSG_DEBUG("current channel : " << (*defect_iter) << " Name : " << attrListCol->chanName(*defect_iter) << " : iovrange " << attrListCol->iovRange(*defect_iter).start().event() << " : " <<  attrListCol->iovRange(*defect_iter).stop().event());
-              ATH_MSG_DEBUG( "Check address " << attrList << " : " << *attrList);
-              if ((*attrList)["present"].data<bool>() != 0){
-                if ((*attrList)["recoverable"].data<bool>() == 1 && m_ignoreRecoverable){
-                    continue;
-                }
-                m_valueCache =  0;
-                return StatusCode::SUCCESS;
-              }
-          }
-      }    
-    
-  }
-  return StatusCode::SUCCESS;
-}
-        
 bool DQBadLBFilterTool::accept() const {
   if (m_alwaysReturnTrue) {
     return true;
   } else {
-    ATH_MSG_VERBOSE("Bad LB accept called, value " << m_valueCache);
-    return m_valueCache;
+    SG::ReadCondHandle<AthenaAttributeList> rch(m_key);
+    const AthenaAttributeList* attrList{*rch};
+    if (attrList == 0) {
+      ATH_MSG_WARNING("Unable to retrieve DataTakingMode information; falling back to" << m_fallbackValue);
+      return m_fallbackValue;
+    }
+    bool value = (*attrList)["Accept"].data<bool>();
+    ATH_MSG_VERBOSE("Bad LB accept called, value " << value);
+    return value;
   }
 }
-
-StatusCode DQBadLBFilterTool::callback( IOVSVC_CALLBACK_ARGS ) {
-  ATH_MSG_VERBOSE("Bad LB callback called");
-  return updateCache();
-}
diff --git a/Control/AthenaMonitoring/src/ManagedMonitorToolBase.cxx b/Control/AthenaMonitoring/src/ManagedMonitorToolBase.cxx
index 6243627792071047f92ed164c1482198b85dda4e..81ac384f4af64fc14ba07a57b9785ba17656b122 100755
--- a/Control/AthenaMonitoring/src/ManagedMonitorToolBase.cxx
+++ b/Control/AthenaMonitoring/src/ManagedMonitorToolBase.cxx
@@ -397,7 +397,7 @@ ManagedMonitorToolBase( const std::string & type, const std::string & name,
    , m_THistSvc("THistSvc",name)
    , m_trigDecTool("")
    , m_trigTranslator("")
-   , m_DQFilterTools()
+   , m_DQFilterTools(this)
    , m_procNEventsProp(0)
    , m_path("")
    , m_preScaleProp(0)
diff --git a/Control/AthenaMonitoring/src/components/AthenaMonitoring_entries.cxx b/Control/AthenaMonitoring/src/components/AthenaMonitoring_entries.cxx
index 1bdeff7ac7f9cf0cd5e90384b72a58674c68c36a..c4924ca33ce288ad366ae7e2daa49e33094498ba 100644
--- a/Control/AthenaMonitoring/src/components/AthenaMonitoring_entries.cxx
+++ b/Control/AthenaMonitoring/src/components/AthenaMonitoring_entries.cxx
@@ -5,6 +5,7 @@
 #include "AthenaMonitoring/DQFilledBunchFilterTool.h"
 #include "AthenaMonitoring/DQDummyFilterTool.h"
 #include "AthenaMonitoring/DQBadLBFilterTool.h"
+#include "AthenaMonitoring/DQBadLBFilterAlg.h"
 #include "AthenaMonitoring/TriggerTranslatorSimple.h"
 #include "AthenaMonitoring/GenericMonitoringTool.h"
 
@@ -16,6 +17,6 @@ DECLARE_COMPONENT( DQAtlasReadyFilterTool )
 DECLARE_COMPONENT( DQFilledBunchFilterTool )
 DECLARE_COMPONENT( DQDummyFilterTool )
 DECLARE_COMPONENT( DQBadLBFilterTool )
+DECLARE_COMPONENT( DQBadLBFilterAlg )
 DECLARE_COMPONENT( TriggerTranslatorToolSimple )
 DECLARE_COMPONENT( GenericMonitoringTool )
-
diff --git a/InnerDetector/InDetExample/InDetAlignExample/ErrorScaling/InDetMonitoringAlignment.py b/InnerDetector/InDetExample/InDetAlignExample/ErrorScaling/InDetMonitoringAlignment.py
index 1a43536a99b3a0a86011e122354ab112a2ccc4f7..4ef34f1cf866dd75643b49af943391ee6a5be18b 100755
--- a/InnerDetector/InDetExample/InDetAlignExample/ErrorScaling/InDetMonitoringAlignment.py
+++ b/InnerDetector/InDetExample/InDetAlignExample/ErrorScaling/InDetMonitoringAlignment.py
@@ -381,12 +381,13 @@ else:
                                                    vxContainerName               = InDetKeys.PrimaryVertices(),
                                                    vxContainerWithBeamConstraint = InDetFlags.useBeamConstraint())
 
-    if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-        InDetAlignMonSivsTRT.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonResiduals.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonEfficiencies.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonGenericTracks.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonBeamSpot.FilterTools += [monFilledBunchFilterTool]
+    if jobproperties.Beam.beamType()=='collisions':
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+        InDetAlignMonSivsTRT.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonResiduals.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonEfficiencies.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonGenericTracks.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonBeamSpot.FilterTools += [GetFilledBunchFilterTool()]
 
     InDetAlignMonSivsTRT.TrigDecisionTool         = monTrigDecTool
     InDetAlignMonResiduals.TrigDecisionTool       = monTrigDecTool
@@ -451,12 +452,13 @@ InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonResiduals_noTrig ]
 InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonEfficiencies_noTrig ]
 InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonGenericTracks_noTrig ]
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetAlignMonSivsTRT_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonResiduals_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonEfficiencies_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonGenericTracks_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonBeamSpot_noTrig.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetAlignMonSivsTRT_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonResiduals_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonEfficiencies_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonGenericTracks_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonBeamSpot_noTrig.FilterTools += [GetFilledBunchFilterTool()]
 
 
 if InDetAlignMonDoTruth:
diff --git a/InnerDetector/InDetExample/InDetBeamSpotExample/share/MonitoringFragment.py b/InnerDetector/InDetExample/InDetBeamSpotExample/share/MonitoringFragment.py
index 8e83700844ad1fd69e34d02d0f22c86c41c8c72e..7e3da987b791f411f883a192934a5b2c38d2a29f 100644
--- a/InnerDetector/InDetExample/InDetBeamSpotExample/share/MonitoringFragment.py
+++ b/InnerDetector/InDetExample/InDetBeamSpotExample/share/MonitoringFragment.py
@@ -57,7 +57,7 @@ if not jobConfig['doMonitoringGlobal']:
         monFilledBunchFilterTool = DQFilledBunchFilterTool()
         monFilledBunchFilterTool.bunchCrossingTool  = bunchCrossingTool
         #ToolSvc += monFilledBunchFilterTool
-        InDetGlobalBeamSpotMonTool.FilterTools.append(monFilledBunchFilterTool)
+        InDetGlobalBeamSpotMonTool.FilterTools += [monFilledBunchFilterTool]
 
 
     print ToolSvc.InDetGlobalBeamSpotMonTool
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
index 5d2278459e02cc2f373e626a087f4be7b9905b22..25fb8bfc2461bd2ce34029c4c4194b4decfa6955 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
@@ -382,12 +382,13 @@ else:
                                                    vxContainerName               = InDetKeys.PrimaryVertices(),
                                                    vxContainerWithBeamConstraint = InDetFlags.useBeamConstraint())
 
-    if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-        InDetAlignMonSivsTRT.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonResiduals.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonEfficiencies.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonGenericTracks.FilterTools += [monFilledBunchFilterTool]
-        InDetAlignMonBeamSpot.FilterTools += [monFilledBunchFilterTool]
+    if jobproperties.Beam.beamType()=='collisions':
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+        InDetAlignMonSivsTRT.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonResiduals.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonEfficiencies.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonGenericTracks.FilterTools += [GetFilledBunchFilterTool()]
+        InDetAlignMonBeamSpot.FilterTools += [GetFilledBunchFilterTool()]
 
     InDetAlignMonSivsTRT.TrigDecisionTool         = monTrigDecTool
     InDetAlignMonResiduals.TrigDecisionTool       = monTrigDecTool
@@ -460,12 +461,13 @@ InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonResiduals_noTrig ]
 InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonEfficiencies_noTrig ]
 InDetAlignMonManager.AthenaMonTools         += [ InDetAlignMonGenericTracks_noTrig ]
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetAlignMonSivsTRT_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonResiduals_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonEfficiencies_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonGenericTracks_noTrig.FilterTools += [monFilledBunchFilterTool]
-    InDetAlignMonBeamSpot_noTrig.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetAlignMonSivsTRT_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonResiduals_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonEfficiencies_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonGenericTracks_noTrig.FilterTools += [GetFilledBunchFilterTool()]
+    InDetAlignMonBeamSpot_noTrig.FilterTools += [GetFilledBunchFilterTool()]
 
 
 if InDetAlignMonDoTruth:
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringGlobal.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringGlobal.py
index ed01c9192e03787fd093a07b778a437f1482c2f5..70fc848c06b565c57b8236b1fecff8f3a5dffee9 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringGlobal.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringGlobal.py
@@ -36,8 +36,9 @@ if InDetFlags.doMonitoringGlobal():
                                                     histoPathBase = "/GLOBAL",
                                                     checkRate     = 2000)
   
-  if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetGlobalSynchMonTool.FilterTools += [monFilledBunchFilterTool]
+  if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetGlobalSynchMonTool.FilterTools += [GetFilledBunchFilterTool()]
   
   #ToolSvc += InDetGlobalSynchMonTool
   if (InDetFlags.doPrintConfigurables()):
@@ -100,8 +101,9 @@ if InDetFlags.doMonitoringGlobal():
     InDetGlobalTrackMonTool.trackMax = 10
     InDetGlobalTrackMonTool.trackBin = 10
 
-  if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetGlobalTrackMonTool.FilterTools += [monFilledBunchFilterTool]
+  if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetGlobalTrackMonTool.FilterTools += [GetFilledBunchFilterTool()]
       
   #ToolSvc += InDetGlobalTrackMonTool
   if (InDetFlags.doPrintConfigurables()):
@@ -116,8 +118,9 @@ if InDetFlags.doMonitoringGlobal():
       from InDetGlobalMonitoring.InDetGlobalMonitoringConf import InDetGlobalPixelTool
       InDetGlobalPixelTool=InDetGlobalPixelTool( name          = "InDetGlobalPixelTool")
 
-      if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-        InDetGlobalPixelTool.FilterTools += [monFilledBunchFilterTool]
+      if jobproperties.Beam.beamType()=='collisions':
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+        InDetGlobalPixelTool.FilterTools += [GetFilledBunchFilterTool()]
       #ToolSvc += InDetGlobalPixelTool
       if (InDetFlags.doPrintConfigurables()):
           print InDetGlobalPixelTool
@@ -130,8 +133,9 @@ if InDetFlags.doMonitoringGlobal():
   # from InDetGlobalMonitoring.InDetGlobalMonitoringConf import InDetGlobalBCMTool
   # InDetGlobalBCMTool=InDetGlobalBCMTool( name          = "InDetGlobalBCMTool")
 
-  # if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  #   InDetGlobalBCMTool.FilterTools += [monFilledBunchFilterTool]
+  # if jobproperties.Beam.beamType()=='collisions':
+  #   from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  #   InDetGlobalBCMTool.FilterTools += [GetFilledBunchFilterTool()]
   # ToolSvc += InDetGlobalBCMTool
   # if (InDetFlags.doPrintConfigurables()):
   #     print InDetGlobalBCMTool
@@ -149,8 +153,9 @@ if InDetFlags.doMonitoringGlobal():
                                                              trackContainerName = InDetKeys.xAODTrackParticleContainer(),
                                                              useBeamspot = InDetFlags.useBeamConstraint()) 
       
-      if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-        InDetGlobalBeamSpotMonTool.FilterTools += [monFilledBunchFilterTool]
+      if jobproperties.Beam.beamType()=='collisions':
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+        InDetGlobalBeamSpotMonTool.FilterTools += [GetFilledBunchFilterTool()]
       #ToolSvc += InDetGlobalBeamSpotMonTool
       if (InDetFlags.doPrintConfigurables()):
           print InDetGlobalBeamSpotMonTool
@@ -189,8 +194,9 @@ if InDetFlags.doMonitoringGlobal() or InDetFlags.doMonitoringPrimaryVertexingEnh
                                                                    vxContainerNameWithOutBeamConstraint = InDetKeys.PrimaryVerticesWithoutBeamConstraint(),
                                                                    vxContainerNameSplit = InDetKeys.PrimaryVerticesSplitStream(),
                                                                    doEnhancedMonitoring = InDetFlags.doMonitoringPrimaryVertexingEnhanced())
-  if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-     InDetGlobalPrimaryVertexMonTool.FilterTools += [monFilledBunchFilterTool]
+  if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetGlobalPrimaryVertexMonTool.FilterTools += [GetFilledBunchFilterTool()]
 
   #ToolSvc += InDetGlobalPrimaryVertexMonTool
   if (InDetFlags.doPrintConfigurables()):
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringPixel.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringPixel.py
index 620e21a5e48147c4b2b55c0ea3aeae07bc536d84..8d30e15f460ea9193dfe0abb26952903a1ce28d6 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringPixel.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringPixel.py
@@ -48,8 +48,9 @@ if doAllHits:
     
   ##Other parameters                                                                                                                  
 
-  if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetPixelMainsMon.FilterTools += [monFilledBunchFilterTool]
+  if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetPixelMainsMon.FilterTools += [GetFilledBunchFilterTool()]
                                                                                                                                        
   #ToolSvc += InDetPixelMainsMon                 
   if (InDetFlags.doPrintConfigurables()): 
@@ -114,8 +115,9 @@ if doHitsOnTrack:
   InDetPixelMainsMonOnTrack.TrackSelectionTool.Extrapolator        = InDetExtrapolator
   ##Other parameters                                                                                                                  
 
-  if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-    InDetPixelMainsMonOnTrack.FilterTools += [monFilledBunchFilterTool]
+  if jobproperties.Beam.beamType()=='collisions':
+    from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+    InDetPixelMainsMonOnTrack.FilterTools += [GetFilledBunchFilterTool()]
   
   #ToolSvc += InDetPixelMainsMonOnTrack                
   if (InDetFlags.doPrintConfigurables()): 
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringSCT.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringSCT.py
index f096a7097ca72320c092611b404d0354f30ad172..234338c74d9b8455794eb1c55e1d7ff84c0e9827 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringSCT.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringSCT.py
@@ -40,8 +40,9 @@ InDetSCTTracksMonTool = SCTTracksMonTool ( name             = "InDetSCTTracksMon
 
 InDetSCTTracksMonTool.tracksName = InDetKeys.SCTTracks() if  InDetFlags.doTrackSegmentsSCT() else InDetKeys.UnslimmedTracks()
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  InDetSCTTracksMonTool.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+  from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  InDetSCTTracksMonTool.FilterTools += [GetFilledBunchFilterTool()]
 
 #ToolSvc += InDetSCTTracksMonTool
 if (InDetFlags.doPrintConfigurables()):
@@ -56,8 +57,9 @@ InDetSCTErrMonTool = SCTErrMonTool ( name             = "InDetSCTErrMonTool",
                                      doPositiveEndcap = True,
                                      doNegativeEndcap = True)
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  InDetSCTErrMonTool.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+  from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  InDetSCTErrMonTool.FilterTools += [GetFilledBunchFilterTool()]
   
 #ToolSvc += InDetSCTErrMonTool
 if (InDetFlags.doPrintConfigurables()):
@@ -91,8 +93,9 @@ InDetSCTHitEffMonTool = SCTHitEffMonTool(name = "InDetSCTHitEffMonTool",
 
 InDetSCTHitEffMonTool.TrackName = InDetKeys.SCTTracks() if  InDetFlags.doTrackSegmentsSCT() else InDetKeys.UnslimmedTracks()
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  InDetSCTHitEffMonTool.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+  from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  InDetSCTHitEffMonTool.FilterTools += [GetFilledBunchFilterTool()]
   
 #ToolSvc += InDetSCTHitEffMonTool
 if (InDetFlags.doPrintConfigurables()):
@@ -109,8 +112,9 @@ InDetSCTLorentzMonTool = SCTLorentzMonTool ( name             = "InDetSCTLorentz
 
 InDetSCTLorentzMonTool.tracksName = InDetKeys.SCTTracks() if  InDetFlags.doTrackSegmentsSCT() else InDetKeys.UnslimmedTracks()
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  InDetSCTLorentzMonTool.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+  from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  InDetSCTLorentzMonTool.FilterTools += [GetFilledBunchFilterTool()]
   
 #ToolSvc += InDetSCTLorentzMonTool
 if (InDetFlags.doPrintConfigurables()):
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringTRT.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringTRT.py
index bfcfda5ad39a3c5e7cc7bef52f4f41c7e5c57899..11a3e375096dd64478b1a5ad50cf506eb3d0a0c4 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringTRT.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringTRT.py
@@ -91,8 +91,9 @@ InDetTRT_Monitoring_Tool = TRT_Monitoring_Tool (name                         = "
                                                 min_trt_hits                 = 10
                                                 )
 
-if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-  InDetTRT_Monitoring_Tool.FilterTools += [monFilledBunchFilterTool]
+if jobproperties.Beam.beamType()=='collisions':
+  from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+  InDetTRT_Monitoring_Tool.FilterTools += [GetFilledBunchFilterTool()]
   
 #ToolSvc += InDetTRT_Monitoring_Tool
 if (InDetFlags.doPrintConfigurables()):
diff --git a/LArCalorimeter/LArMonTools/share/LArRawChannelMonTool_jobOptions.py b/LArCalorimeter/LArMonTools/share/LArRawChannelMonTool_jobOptions.py
index e35295c70d4fe13f8fe5feeb7ff33b1cf1b3657f..385cd15d307a384f8762adaff5eea0f07037cf66 100755
--- a/LArCalorimeter/LArMonTools/share/LArRawChannelMonTool_jobOptions.py
+++ b/LArCalorimeter/LArMonTools/share/LArRawChannelMonTool_jobOptions.py
@@ -1,6 +1,6 @@
 # --- for athena online running ---
 # For Atlas Ready Filter. Not needed.
-#include ("AthenaMonitoring/AtlasReadyFilterTool_jobOptions.py")
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 # --- CaloNoiseTool configuration ---
 from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
@@ -23,7 +23,7 @@ LArRawChannelMon = LArRawChannelMonTool(
     OutputLevel               = 3,
     # ATLAS Ready Filter Tool
 
-    ATLASReadyFilterTool     = [monAtlasReadyFilterTool],
+    ATLASReadyFilterTool     = [GetAtlasReadyFilterTool()],
 
     # --- specify trigger options ---
     # These will be specified for different streams below
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/share/MdtRaw_MonitoringOptions.py b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/share/MdtRaw_MonitoringOptions.py
index f68866a0dee13dc180251b34ec5271d5397dd08e..c92833a68a59d0ec0aa6562ba091eb17174784e4 100755
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/share/MdtRaw_MonitoringOptions.py
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/share/MdtRaw_MonitoringOptions.py
@@ -19,6 +19,8 @@ if not 'MuonDQAFlags' in dir():
     print "MuonDQAFlags.py: MuonDQAFlags not yet imported - I import them now"
     from MuonDQAMonFlags.MuonDQAFlags import MuonDQAFlags as MuonDQAFlags
 
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
+
 mdtRawMonMan = AthenaMonManager(name="MdtRawMonManager",
                                 FileKey             = DQMonFlags.monManFileKey(),
                                 Environment         = DQMonFlags.monManEnvironment(),
@@ -42,7 +44,7 @@ mdtRawDataValAlg_main = MdtRawDataValAlg(name='mdtRawDataValAlg_main',
                                          #MaxTDCCutForBackground = 0.,
                                          #TGCTrigKey = 136,                                    
                                          #RPCTrigKey = 144,
-                                         AtlasFilterTool = [ monAtlasReadyFilterTool ],
+                                         AtlasFilterTool = [ GetAtlasReadyFilterTool() ],
                                          do_mdtChamberHits = isTier0Flag,
                                          do_mdttdccut_sector = isTier0Flag,  
                                          do_mdtchamberstatphislice = isTier0Flag,
@@ -91,7 +93,7 @@ if( isTier0Flag ) :
                                                 #MaxTDCCutForBackground = 0.,
                                                 #TGCTrigKey = 136,       
                                                 #RPCTrigKey = 144,
-                                                AtlasFilterTool = [ monAtlasReadyFilterTool ],
+                                                AtlasFilterTool = [ GetAtlasReadyFilterTool() ],
                                                 do_mdtChamberHits = False,
                                                 do_mdttdccut_sector = False,                                         
                                                 do_mdtchamberstatphislice = False,
diff --git a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/src/MdtRawDataValAlg.cxx b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/src/MdtRawDataValAlg.cxx
index 293357905076a8fc6cc24bd8fa0b3646047580da..d9dea9a9cb25b006f6a6a98c1bb12fbf4603076a 100755
--- a/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/src/MdtRawDataValAlg.cxx
+++ b/MuonSpectrometer/MuonValidation/MuonDQA/MuonRawDataMonitoring/MdtRawDataMonitoring/src/MdtRawDataValAlg.cxx
@@ -83,6 +83,7 @@ MdtRawDataValAlg::MdtRawDataValAlg( const std::string & type, const std::string
  m_masked_tubes(NULL),
  m_idHelper("Muon::MuonIdHelperTool/MuonIdHelperTool"),
  m_muonSelectionTool("CP::MuonSelectionTool/MuonSelectionTool"),
+ m_DQFilterTools(this),
  m_atlas_ready(0),
  m_trig_BARREL(false),
  m_trig_ENDCAP(false),
diff --git a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
index d347130fd81b5798a9a108e87d89d8425349308a..748966e9ac24ccec22472dcfd0f6099c516b828e 100644
--- a/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
+++ b/PhysicsAnalysis/JetTagging/JetTagMonitoring/share/JetTagMonitoring_jobOptions.py
@@ -19,12 +19,12 @@ jetTagMonTool = JetTagMonitoring (
     )
 # remove events with non-collision BCIDs from your monitoring tools 
 # see https://indico.cern.ch/getFile.py/access?contribId=1&resId=1&materialId=slides&confId=135968
-jetTagMonTool.FilterTools += [ monFilledBunchFilterTool ]
+from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
+jetTagMonTool.FilterTools += [ GetFilledBunchFilterTool() ]
 
 # remove events with intolerable LAr defects
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-monbadlb = GetLArBadLBFilterTool()
-jetTagMonTool.FilterTools += [ monbadlb ] 
+jetTagMonTool.FilterTools += [ GetLArBadLBFilterTool() ] 
 
 jetTagMonTool.OutputLevel = INFO
 jetTagMonTool.JetContainer = "AntiKt4EMTopoJets"
diff --git a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringHistos.py b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringHistos.py
index c03ca58032e4ee8c8625535b0509d91f25ec6732..8766d4d3de2bfcf8f3b0cbabbf03aee7e4f0f4a5 100644
--- a/Reconstruction/Jet/JetMonitoring/python/JetMonitoringHistos.py
+++ b/Reconstruction/Jet/JetMonitoring/python/JetMonitoringHistos.py
@@ -8,7 +8,6 @@ from JetSelectorTools.JetSelectorToolsConf import JetCleaningTool
 from RecExConfig.ObjKeyStore import cfgKeyStore
 #New AthenaMonitoring filter tool to be added to filter out events in non-filled BCIDs
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-monbadlb = GetLArBadLBFilterTool()
 
 monitorTracks = cfgKeyStore.isInTransient('xAOD::JetContainer','AntiKt3PV0TrackJets')
 
@@ -145,14 +144,14 @@ if monitorTracks :
 #    athenaMonTool.HistoTools += [ commonMonitoringTool( "AntiKt3PV0TrackJets" ) ]
 
 #cbg
-athenaMonTool.FilterTools += [ monbadlb ]
+athenaMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
 #ToolSvc += athenaMonTool
 
 athenaMonTool_LB = JetMonitoringTool("JetMonitoring_LB", HistoTools = [commonMonitoringTool_LB("AntiKt4EMTopoJets") ], IntervalType = 2)
 
 #cbg
-athenaMonTool_LB.FilterTools += [ monbadlb ]
+athenaMonTool_LB.FilterTools += [ GetLArBadLBFilterTool() ]
 
 #ToolSvc += athenaMonTool_LB
 
@@ -165,7 +164,7 @@ if DQMonFlags.useTrigger() :
                                                commonMonitoringTool( "AntiKt10LCTopoJets", pathSuffix='_trig' )
                                                ] , IntervalType = 6 )
     #cbg
-    athenaMonTool_trig.FilterTools += [ monbadlb ]
+    athenaMonTool_trig.FilterTools += [ GetLArBadLBFilterTool() ]
     #ToolSvc += athenaMonTool_trig
     athenaMonTool_trig.TrigDecisionTool =  getattr(ToolSvc, DQMonFlags.nameTrigDecTool())
     athenaMonTool_trig.TriggerChain =  "CATEGORY_monitoring_jet"
diff --git a/Reconstruction/MissingETMonitoring/share/MissingET_Monitoring.py b/Reconstruction/MissingETMonitoring/share/MissingET_Monitoring.py
index 5c23f40643ae79fb1486df3eaaa2c39330f9e7cb..e446bc648f792ab1ebddfd5cedb2e61434a29a0b 100755
--- a/Reconstruction/MissingETMonitoring/share/MissingET_Monitoring.py
+++ b/Reconstruction/MissingETMonitoring/share/MissingET_Monitoring.py
@@ -2,12 +2,12 @@ from AthenaCommon.AlgSequence import AlgSequence
 from AthenaMonitoring.AthenaMonitoringConf import AthenaMonManager
 from MissingETMonitoring.MissingETMonitoringConf import *
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
+from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
 
 from JetSelectorTools.JetSelectorToolsConf import JetCleaningTool
 cleaningTool = JetCleaningTool( "LooseBadJets" , CutLevel = "LooseBad")
 ToolSvc += cleaningTool
 
-monbadlb = GetLArBadLBFilterTool()
 
 
 
@@ -49,8 +49,8 @@ for trigger in triggerList:
     metMonTool.TriggerChain = trigger
    
     #New AthenaMonitoring filter tool to be added to filter out events in non-filled BCIDs
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
 
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
@@ -74,8 +74,8 @@ for trigger in triggerList:
 #    metMonTool.doMetCut80 = True
 #    metMonTool.metCut       = 10
 #    #New AthenaMonitoring filter tool to be added to filter out events in non-filled BCIDs
-    #    metMonTool.FilterTools += [monFilledBunchFilterTool]
-#    metMonTool.FilterTools += [monbadlb]
+    #    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+#    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
 
 #    if trigger != "":
 #        metMonTool.TrigDecisionTool = monTrigDecTool
@@ -100,8 +100,8 @@ for trigger in triggerList:
     metMonTool.muoColKey    = ""
     metMonTool.jetColKey    = "AntiKt4LCTopoJets"
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     metMonTool.JetSelectorTool = cleaningTool
     metMonTool.badJets = True
     if trigger != "":
@@ -126,8 +126,8 @@ for trigger in triggerList:
     metMonTool.eleColKey    = ""
     metMonTool.muoColKey    = ""
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -145,8 +145,8 @@ for trigger in triggerList:
     metMonTool.eleColKey    = ""
     metMonTool.muoColKey    = ""
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -164,8 +164,8 @@ for trigger in triggerList:
     metMonTool.eleColKey    = ""
     metMonTool.muoColKey    = ""
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -188,8 +188,8 @@ for trigger in triggerList:
     metMonTool.doJetcleaning = True
     metMonTool.JetSelectorTool = cleaningTool
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -209,8 +209,8 @@ for trigger in triggerList:
     metMonTool.doJetcleaning = True
     metMonTool.JetSelectorTool = cleaningTool
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -231,8 +231,8 @@ for trigger in triggerList:
     metMonTool.doJetcleaning = True
     metMonTool.JetSelectorTool = cleaningTool
     metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-    metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+    metMonTool.FilterTools += [GetLArBadLBFilterTool()]
     if trigger != "":
         metMonTool.TrigDecisionTool = monTrigDecTool
     #ToolSvc += metMonTool
@@ -254,8 +254,8 @@ metMonTool.muoColKey    = ""
 metMonTool.doMetCut80 = True
 metMonTool.metCut       = 80.0
 #    metMonTool.TriggerChain = trigger
-#    metMonTool.FilterTools += [monFilledBunchFilterTool]
-metMonTool.FilterTools += [monbadlb]
+#    metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+metMonTool.FilterTools += [GetLArBadLBFilterTool()]
 if trigger != "":
     metMonTool.TrigDecisionTool = monTrigDecTool
 #ToolSvc += metMonTool
@@ -274,8 +274,8 @@ metMonTool.muoColKey    = ""
 metMonTool.doMetCut80 = True
 metMonTool.metCut       = 80.0
 #metMonTool.TriggerChain = trigger
-metMonTool.FilterTools += [monFilledBunchFilterTool]
-metMonTool.FilterTools += [monbadlb]
+metMonTool.FilterTools += [GetFilledBunchFilterTool()]
+metMonTool.FilterTools += [GetLArBadLBFilterTool()]
 if trigger != "":
     metMonTool.TrigDecisionTool = monTrigDecTool
 #ToolSvc += metMonTool
diff --git a/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions.py b/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions.py
index 1ff2a9c6bcb71e43f5f16c2ba27b2218f460c889..c3c37c9fd96455e23b969126150ebb6ccbac7609 100644
--- a/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions.py
+++ b/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions.py
@@ -18,7 +18,7 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
         topSequence += monManEgamma
 
         from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-        monbadlb = GetLArBadLBFilterTool()
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
         
         egammaMonOutputLevel = INFO
         #egammaMonOutputLevel = VERBOSE
@@ -112,11 +112,10 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                       OutputLevel = egammaMonOutputLevel,
                                       )
             
-            phMonTool.FilterTools += [ monbadlb ]
+            phMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                phMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=phMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                phMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ phMonTool ]
 
             if DQMonFlags.useTrigger():
@@ -129,11 +128,10 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                                      OutputLevel = egammaMonOutputLevel,
                                                      )
             
-                phMonToolWithTrigger.FilterTools += [ monbadlb ]
+                phMonToolWithTrigger.FilterTools += [ GetLArBadLBFilterTool() ]
                 
-                if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                    phMonToolWithTrigger.FilterTools += [monFilledBunchFilterTool]
-                #ToolSvc+=phMonToolWithTrigger
+                if jobproperties.Beam.beamType()=='collisions':
+                    phMonToolWithTrigger.FilterTools += [GetFilledBunchFilterTool()]
                 monManEgamma.AthenaMonTools += [ phMonToolWithTrigger ]
 
 
@@ -147,10 +145,9 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                         ElectronContainer = "Electrons",
                                         OutputLevel = egammaMonOutputLevel,
                                         )
-            elMonTool.FilterTools += [ monbadlb ]
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                elMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=elMonTool
+            elMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
+            if jobproperties.Beam.beamType()=='collisions':
+                elMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ elMonTool ]
             print elMonTool
 
@@ -163,10 +160,9 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                                        ElectronContainer = "Electrons",
                                                        OutputLevel = egammaMonOutputLevel,
                                                        )
-                elMonToolWithTrigger.FilterTools += [ monbadlb ]
-                if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                    elMonToolWithTrigger.FilterTools += [monFilledBunchFilterTool]
-                #ToolSvc+=elMonToolWithTrigger
+                elMonToolWithTrigger.FilterTools += [ GetLArBadLBFilterTool() ]
+                if jobproperties.Beam.beamType()=='collisions':
+                    elMonToolWithTrigger.FilterTools += [GetFilledBunchFilterTool()]
                 monManEgamma.AthenaMonTools += [ elMonToolWithTrigger ]
                 print elMonToolWithTrigger
             
@@ -181,11 +177,10 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                                 OutputLevel = egammaMonOutputLevel,
                                               )
             
-            fwdMonTool.FilterTools += [ monbadlb ]
+            fwdMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
             
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                fwdMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=fwdMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                fwdMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ fwdMonTool ]    
 
         if(egammaMonitorZee):
@@ -204,9 +199,8 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                        OutputLevel = egammaMonOutputLevel,
                                        )
             
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                ZeeMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=ZeeMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                ZeeMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ ZeeMonTool ]
 
         if(egammaMonitorJPsi):
@@ -224,9 +218,8 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                         #PhiBinning = 40,
                                         OutputLevel = egammaMonOutputLevel,
                                         )
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(ToolSvc, 'DQFilledBunchFilterTool'):
-                JPsiMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=JPsiMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                JPsiMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ JPsiMonTool ]
 
         if(egammaMonitorUpsilon1S):
@@ -245,7 +238,6 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                               TrigDecisionTool = MyTrigDecisionTool,
                                               UseTrigger = MyDoTrigger)
             
-            #ToolSvc+=Upsilon1SMonTool
             monManEgamma.AthenaMonTools += [ Upsilon1SMonTool ]
 
 
@@ -265,7 +257,6 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                               TrigDecisionTool = MyTrigDecisionTool,
                                               UseTrigger = MyDoTrigger)
             
-            #ToolSvc+=Upsilon2SMonTool
             monManEgamma.AthenaMonTools += [ Upsilon2SMonTool ]
 
         if(egammaMonitorWenu):
@@ -290,7 +281,6 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                           TrigDecisionTool = MyTrigDecisionTool,
                                           UseTrigger = MyDoTrigger)
             
-            #ToolSvc+=WenuMonTool
             monManEgamma.AthenaMonTools += [ WenuMonTool ]
 
         if(egammaMonitorTop):
@@ -315,7 +305,6 @@ if  DQMonFlags.monManEnvironment() in ('tier0','tier0ESD','online', 'AOD'):
                                           TrigDecisionTool = MyTrigDecisionTool,
                                           UseTrigger = MyDoTrigger)
 
-            #ToolSvc+=TopMonTool
             monManEgamma.AthenaMonTools += [ TopMonTool ]
         
             
diff --git a/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions_aod.py b/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions_aod.py
index d318840a25c1bfa71df64e4b14c3c2e15f6a6e9e..d63f40bd6f2fd79f9f1fc7c10bac225491180f26 100644
--- a/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions_aod.py
+++ b/Reconstruction/egamma/egammaPerformance/share/egammaMonitoring_jobOptions_aod.py
@@ -16,7 +16,7 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
         topSequence += monManEgamma
 
         from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-        monbadlb = GetLArBadLBFilterTool()
+        from AthenaMonitoring.FilledBunchFilterTool import GetFilledBunchFilterTool
         
         egammaMonOutputLevel = INFO
 ### Setup which objects will be monitored
@@ -95,11 +95,10 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                       TrigDecisionTool = MyTrigDecisionTool,
                                       UseTrigger = DQMonFlags.useTrigger() )
 
-            phMonTool.FilterTools += [ monbadlb ]
+            phMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(#ToolSvc, 'DQFilledBunchFilterTool'):
-                phMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=phMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                phMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ phMonTool ]
 
         if(egammaMonitorElectrons):
@@ -116,11 +115,10 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                         TrigDecisionTool = MyTrigDecisionTool,
                                         UseTrigger = DQMonFlags.useTrigger())
 
-            elMonTool.FilterTools += [ monbadlb ]
+            elMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(#ToolSvc, 'DQFilledBunchFilterTool'):
-                elMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=elMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                elMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ elMonTool ]
 
 
@@ -133,11 +131,10 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                               TrigDecisionTool = MyTrigDecisionTool,
                                               UseTrigger = DQMonFlags.useTrigger())
 
-            fwdMonTool.FilterTools += [ monbadlb ]
+            fwdMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(#ToolSvc, 'DQFilledBunchFilterTool'):
-                fwdMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=fwdMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                fwdMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ fwdMonTool ]    
 
         if(egammaMonitorSoftEg):
@@ -153,11 +150,10 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                      TrigDecisionTool = MyTrigDecisionTool,
                                      UseTrigger = DQMonFlags.useTrigger())
 
-            sfMonTool.FilterTools += [ monbadlb ]
+            sfMonTool.FilterTools += [ GetLArBadLBFilterTool() ]
 
-            if jobproperties.Beam.beamType()=='collisions' and hasattr(#ToolSvc, 'DQFilledBunchFilterTool'):
-                sfMonTool.FilterTools += [monFilledBunchFilterTool]
-            #ToolSvc+=sfMonTool
+            if jobproperties.Beam.beamType()=='collisions':
+                sfMonTool.FilterTools += [GetFilledBunchFilterTool()]
             monManEgamma.AthenaMonTools += [ sfMonTool ]
 
 
@@ -177,7 +173,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                         TrigDecisionTool = MyTrigDecisionTool,
                                         UseTrigger = DQMonFlags.useTrigger())
         
-            #ToolSvc+=ZeeMonTool
             monManEgamma.AthenaMonTools += [ ZeeMonTool ]
 
         if(egammaMonitorJPsi):
@@ -196,7 +191,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                          TrigDecisionTool = MyTrigDecisionTool,
                                          UseTrigger = DQMonFlags.useTrigger())
         
-            #ToolSvc+=JPsiMonTool
             monManEgamma.AthenaMonTools += [ JPsiMonTool ]
 
 
@@ -216,7 +210,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                               TrigDecisionTool = MyTrigDecisionTool,
                                               UseTrigger = DQMonFlags.useTrigger())
             
-            #ToolSvc+=Upsilon1SMonTool
             monManEgamma.AthenaMonTools += [ Upsilon1SMonTool ]
 
 
@@ -236,7 +229,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                               TrigDecisionTool = MyTrigDecisionTool,
                                               UseTrigger = DQMonFlags.useTrigger())
             
-            #ToolSvc+=Upsilon2SMonTool
             monManEgamma.AthenaMonTools += [ Upsilon2SMonTool ]
 
         if(egammaMonitorWenu):
@@ -261,7 +253,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                           TrigDecisionTool = MyTrigDecisionTool,
                                           UseTrigger = DQMonFlags.useTrigger())
             
-            #ToolSvc+=WenuMonTool
             monManEgamma.AthenaMonTools += [ WenuMonTool ]
 
 
@@ -287,7 +278,6 @@ if DQMonFlags.monManEnvironment() == 'tier0ESD':
                                           TrigDecisionTool = MyTrigDecisionTool,
                                           UseTrigger = DQMonFlags.useTrigger())
             
-            #ToolSvc+=TopMonTool
             monManEgamma.AthenaMonTools += [ TopMonTool ]
         
             
diff --git a/Reconstruction/tauMonitoring/share/tauMonitoring_jobOptions.py b/Reconstruction/tauMonitoring/share/tauMonitoring_jobOptions.py
index 1c9ad311afcc01c5271183812d01293e8a8b0e9f..c9729166756db17b74b77716d0465b4f3e9d5540 100644
--- a/Reconstruction/tauMonitoring/share/tauMonitoring_jobOptions.py
+++ b/Reconstruction/tauMonitoring/share/tauMonitoring_jobOptions.py
@@ -10,7 +10,7 @@ topSequence += monManTau
 
 from tauMonitoring.tauMonitoringConf import *
 from AthenaMonitoring.BadLBFilterTool import GetLArBadLBFilterTool
-monbadlb = GetLArBadLBFilterTool()
+from AthenaMonitoring.AtlasReadyFilterTool import GetAtlasReadyFilterTool
 
 LowStat = True
 if DQMonFlags.monManEnvironment() == 'online' :
@@ -40,8 +40,7 @@ print "doTrigger " , tauMonTool.doTrigger
 if tauMonTool.doTrigger :
     tauMonTool.TauEleJetMbtsTriggerItems = [ [ "L1_TAU1.*" , "L1_TAU2.*" , "L1_TAU60" , "L1_EM15VHI_2TAU.*" , "L1_EM15VHI_TAU40.*" , "L1_MU10_TAU.*" , "L1_J25_3J12_EM15-TAU.*" ] , [ "HLT_e2.*" , "L1_EM2.*" , "L1_2EM15" ] , [ "HLT_j55" , "HLT_j60" , "HLT_j85" , "HLT_j110" , "HLT_j175" , "HLT_4j85" , "HLT_4j10.*" ] , [ "HLT_mb_sp2000_trk70_hmt" ] ]
 
-tauMonTool.FilterTools = [ monAtlasReadyFilterTool ]
-tauMonTool.FilterTools += [monbadlb]
-#ToolSvc += tauMonTool
+tauMonTool.FilterTools = [ GetAtlasReadyFilterTool() ]
+tauMonTool.FilterTools += [GetLArBadLBFilterTool()]
 monManTau.AthenaMonTools += [ tauMonTool ]