diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
index 27885bae46339a33d07da1998c3172a0b0e28fee..8991ef4f47bb2f54470ce9c97586007f2f0ed805 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileCisDefaultCalibTool.h
@@ -18,6 +18,8 @@
 #include "TileConditions/TileCablingService.h"
 #include "TileEvent/TileDQstatus.h"
 #include "StoreGate/ReadHandleKey.h"
+#include "TileEvent/TileRawChannelContainer.h"
+#include "TileEvent/TileDigitsContainer.h"
 
 
 #include "TString.h"
@@ -89,6 +91,10 @@ class TileCisDefaultCalibTool: public AthAlgTool
     ToolHandle<ITileStuckBitsProbsTool> m_stuckBitsProbs;
     SG::ReadHandleKey<TileDQstatus> m_dqStatusKey;
 
+    SG::ReadHandleKey<TileDigitsContainer> m_DigitsContainerKey{this,
+      "TileDigitsContainer", "TileDigitsContainer", "Input Tile digits container"};
+    SG::ReadHandleKey<TileRawChannelContainer> m_RawChannelContainerKey{this,
+      "TileRawChannelContainer", "TileRawChannelContainer", "Input Tile raw channel container"};
     // jobOptions
     std::string m_rawChannelContainerName;
     std::string m_ntupleID;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
index 68f8cc753a4972510b7ded9f03716de0735fbbb5..23978ed5e0961cd24a4407757a0aabe099eaafba 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileDigiNoiseCalibAlg.h
@@ -25,6 +25,7 @@
 #include "TileConditions/TileCablingService.h"
 #include "TileEvent/TileDQstatus.h"
 #include "StoreGate/ReadHandleKey.h"
+#include "TileEvent/TileDigitsContainer.h"
 
 #include <cmath>
 #include <vector>
@@ -83,6 +84,8 @@ class TileDigiNoiseCalibAlg: public AthAlgorithm {
     bool m_doRobustCov;
 
     SG::ReadHandleKey<TileDQstatus> m_dqStatusKey;
+    SG::ReadHandleKey<TileDigitsContainer> m_DigitsContainerKey{this,
+      "TileDigitsContainer", "TileDigitsContainer", "Input Tile digits container"};
 
   // Tools / storegate info
     ToolHandle<TileRawChannelBuilderFlatFilter> m_adderFilterAlgTool;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserDefaultCalibTool.h
index a65829244a79afe6223894d2f1d1bf00e6909c0d..3204d60f4d850c4681243688051f4e1bea761519 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserDefaultCalibTool.h
@@ -13,6 +13,8 @@
 #include "TileConditions/TileCondToolEmscale.h"
 #include "TileConditions/ITileBadChanTool.h"
 #include "TileConditions/ITileDCSTool.h"
+#include "TileEvent/TileRawChannelContainer.h"
+#include "TileEvent/TileLaserObject.h"
 
 // Athena includes
 #include "AthenaBaseComps/AthAlgTool.h"
@@ -76,6 +78,11 @@ class TileLaserDefaultCalibTool : public AthAlgTool, virtual public ITileCalibTo
   ToolHandle<ITileStuckBitsProbsTool> m_stuckBitsProbs;
   SG::ReadHandleKey<TileDQstatus> m_dqStatusKey;
 
+  SG::ReadHandleKey<TileRawChannelContainer> m_RawChannelContainerKey{this,
+      "TileRawChannelContainer", "TileRawChannelContainer", "Input Tile raw channel container"};
+  SG::ReadHandleKey<TileLaserObject> m_LaserContainerKey{this,
+      "TileLaserObject", "TileLaserObject", "Input Tile laser object"};
+
   ToolHandle<ITileDCSTool> m_tileDCS{this, "TileDCSTool", "TileDCSTool", "Tile DCS tool"};
 
   // Parameter which will end up in the ROOTuple
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
index 7c69e0edd9a76ead97e15efd3f2e946ec2ddfac2..471c6d431919c01597029d48ee6e7c70fe217a49 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserLinearityCalibTool.h
@@ -15,6 +15,8 @@
 #include "TileConditions/TileCondToolEmscale.h"
 #include "TileCalibAlgs/TileLaserDefaultCalibTool.h"
 #include "TileEvent/TileDQstatus.h"
+#include "TileEvent/TileRawChannelContainer.h"
+#include "TileEvent/TileLaserObject.h"
 #include "StoreGate/ReadHandleKey.h"
 
 class TileRawChannelContainer;
@@ -45,6 +47,11 @@ class TileLaserLinearityCalibTool : public AthAlgTool, virtual public ITileCalib
   std::string m_laserContainerName;
   SG::ReadHandleKey<TileDQstatus> m_dqStatusKey;
 
+  SG::ReadHandleKey<TileRawChannelContainer> m_RawChannelContainerKey{this,
+      "TileRawChannelContainer", "TileRawChannelContainer", "Input Tile raw channel container"};
+  SG::ReadHandleKey<TileLaserObject> m_LaserContainerKey{this,
+      "TileLaserObject", "TileLaserObject", "Input Tile laser object"};
+
   const TileHWID* m_tileHWID;    
   const TileCablingService* m_cabling;
   ToolHandle<TileCondToolEmscale>  m_tileToolEmscale;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
index 4cf198b994799de1105e56d0e5719f6ec4486b4d..5115b8132e9a7bdf4ca73bd2f21d69ec8e45b77a 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileLaserTimingTool.h
@@ -36,12 +36,15 @@
 // Athena includes
 #include "AthenaBaseComps/AthAlgTool.h"
 #include "Identifier/HWIdentifier.h"
+#include "StoreGate/ReadHandleKey.h"
 
 // Tile includes
 #include "TileCalibAlgs/ITileCalibTool.h"
 #include "TileCalibAlgs/TileSimpleStat.h"
 #include "TileConditions/TileCondToolTiming.h"
 #include "TileConditions/TileCablingService.h"
+#include "TileEvent/TileRawChannelContainer.h"
+#include "TileEvent/TileDigitsContainer.h"
 
 #include "TH1F.h"
 #include "TH2F.h"
@@ -230,6 +233,12 @@ class TileLaserTimingTool: public AthAlgTool, virtual public ITileCalibTool {
       return m_drawerData[ros - 1][drawer];
     }
 
+    //StoreGate
+    SG::ReadHandleKey<TileRawChannelContainer> m_RawChannelContainerKey{this,
+      "TileRawChannelContainer", "TileRawChannelContainer", "Input Tile raw channel container"};
+    SG::ReadHandleKey<TileDigitsContainer> m_DigitsContainerKey{this,
+      "TileDigitsContainer", "TileDigitsContainer", "Input Tile digits container"};
+
     // Tools info
     const TileHWID* m_tileHWID;
     const TileCablingService* m_cabling;
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
index 6f9d56baf4b369a5e00b462bed87d746193a9423..3c77d4a0977b76839e499df502178a0c5d1ce3ab 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTOFTool.h
@@ -10,9 +10,12 @@
 #include "GaudiKernel/ObjectVector.h"
 #include "GaudiKernel/IHistogramSvc.h"
 #include "GaudiKernel/ITHistSvc.h"
+#include "CaloEvent/CaloCellContainer.h"
+#include "StoreGate/ReadHandleKey.h"
 
 #include "TileCalibAlgs/ITileCalibTool.h"
 
+
 class StoreGateSvc;
 class TileID;
 
@@ -34,6 +37,10 @@ class TileTOFTool : public AthAlgTool, virtual public ITileCalibTool
   const TileID* m_tileID;
 
  private:
+
+  SG::ReadHandleKey<CaloCellContainer> m_CaloCellContainerKey{this,
+      "CaloCellContainer", "CaloCellContainer", "Calo cell container"};
+
   float timeCor(int mod_ref1, int mod_ref2, int part_ref1, int part_ref2);
 
   float m_TimeCor[4][64];
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
index b6e764b4e03f067a4c9f0a0e28445542b5ea3c85..ecedb377fbb3ad8e52701e495bb2f6a3a273862a 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/TileCalibAlgs/TileTriggerDefaultCalibTool.h
@@ -8,10 +8,12 @@
 #include "AthenaBaseComps/AthAlgTool.h"
 #include "GaudiKernel/ToolHandle.h"
 
+#include "xAODTrigL1Calo/TriggerTowerContainer.h"
 #include "TileCalibAlgs/ITileCalibTool.h"
 #include "TrigT1CaloCalibToolInterfaces/IL1CaloTTIdTools.h" 
 //#include "TrigT1CaloToolInterfaces/IL1TriggerTowerTool.h"
 #include "TileEvent/TileDQstatus.h"
+#include "TileEvent/TileRawChannelContainer.h"
 #include "StoreGate/ReadHandleKey.h"
 
 #include <string> 
@@ -58,6 +60,10 @@ class TileTriggerDefaultCalibTool : public AthAlgTool, virtual public ITileCalib
   const TileCablingService* m_tileCablingService;
   ToolHandle<TileCondToolEmscale> m_tileToolEmscale; //!< main Tile Calibration tool
   SG::ReadHandleKey<TileDQstatus> m_dqStatusKey;
+  SG::ReadHandleKey<TileRawChannelContainer> m_RawChannelContainerKey{this,
+      "TileRawChannelContainer", "TileRawChannelContainer", "Input Tile raw channel container"};
+  SG::ReadHandleKey<xAOD::TriggerTowerContainer> m_TriggerTowerContainerKey{this,
+      "TriggerTowerContainer", "TriggerTowerContainer", "Trigger Tower container"};
  
   // Results Tile
   float m_meanTile[5][64][48];
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
index ad49a74c82769a3745ec507b4563aa6638dd27d2..6f89baa931a81338d43b95d0dad74214f434ff6c 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileCisDefaultCalibTool.cxx
@@ -49,7 +49,7 @@ TileCisDefaultCalibTool::TileCisDefaultCalibTool(const std::string& type, const
 {
   declareInterface<ITileCalibTool>(this);
 
-  declareProperty("rawChannelContainer", m_rawChannelContainerName = "TileRawChannelFit");
+  //declareProperty("rawChannelContainer", m_rawChannelContainerName = "TileRawChannelFit");
   declareProperty("NtupleID", m_ntupleID = "h3000");
 
   declareProperty("removePed", m_removePed = false);
@@ -65,7 +65,7 @@ TileCisDefaultCalibTool::TileCisDefaultCalibTool(const std::string& type, const
   declareProperty("linfitMinLo", m_linfitMinLo = 300.0);
 
   declareProperty("doSampleChecking", m_doSampleChecking = true); // do sample checking by default
-  declareProperty("DigitsContainer", m_DigitsContainerName = "TileDigitsCnt");
+  //declareProperty("DigitsContainer", m_DigitsContainerName = "TileDigitsCnt");
   declareProperty("StuckBitsProbsTool", m_stuckBitsProbs);
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 }
@@ -100,6 +100,9 @@ StatusCode TileCisDefaultCalibTool::initialize() {
 
   CHECK( m_dqStatusKey.initialize() );
 
+  ATH_CHECK( m_RawChannelContainerKey.initialize() );
+  ATH_CHECK( m_DigitsContainerKey.initialize() );
+
   return StatusCode::SUCCESS;
 }
 
@@ -139,8 +142,8 @@ StatusCode TileCisDefaultCalibTool::execute() {
                                    : (double) dac * c_dac2ChargeSmall;
 
   // Get TileRawChannelContainer
-  const TileRawChannelContainer *container;
-  CHECK( evtStore()->retrieve(container, m_rawChannelContainerName) );
+  SG::ReadHandle<TileRawChannelContainer> container(m_RawChannelContainerKey);
+  ATH_CHECK( container.isValid() );
 
   // Create iterator over RawChannelContainer
   TileRawChannelContainer::const_iterator itColl = (*container).begin();
@@ -227,8 +230,8 @@ StatusCode TileCisDefaultCalibTool::execute() {
 
   if (m_doSampleChecking) {
     // Get TileDigitsContainer
-    const TileDigitsContainer *digContainer;
-    CHECK( evtStore()->retrieve(digContainer, m_DigitsContainerName) );
+    SG::ReadHandle<TileDigitsContainer> digContainer(m_DigitsContainerKey);
+    ATH_CHECK( digContainer.isValid() );
 
     // Create iterator over RawDigitsContainer
     TileDigitsContainer::const_iterator digItColl = digContainer->begin();
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
index b5da646dd5dd8d92f4fba4730638fe774b81ead2..131b7e6d91a65afab8156d2c2f97ab276b449bdc 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileDigiNoiseCalibAlg.cxx
@@ -66,7 +66,6 @@ TileDigiNoiseCalibAlg::TileDigiNoiseCalibAlg(const std::string& name, ISvcLocato
   , m_trigType(0)
 {
   declareProperty("TileAdderFlatFilter", m_adderFilterAlgTool);
-  declareProperty("TileDigitsContainer", m_digitsContainer = "TileDigitsCnt");
   declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
   /*  declareProperty("TileRawChannelContainerFlat", m_flatRawChannelContainer = "TileRawChannelFlat");
    declareProperty("TileRawChannelContainerFit", m_fitRawChannelContainer = ""); // don't create
@@ -121,6 +120,9 @@ StatusCode TileDigiNoiseCalibAlg::FirstEvt_initialize() {
   // find TileCablingService
   m_cabling = TileCablingService::getInstance();
 
+  // TileDigitsContainer initialization
+  ATH_CHECK( m_DigitsContainerKey.initialize() );
+
   // retrieve TileID helper from det store
   CHECK( detStore()->retrieve(m_tileID) );
 
@@ -347,8 +349,8 @@ void TileDigiNoiseCalibAlg::StoreRunInfo (const TileDQstatus* dqStatus) {
 StatusCode TileDigiNoiseCalibAlg::fillDigits (const TileDQstatus* theDQstatus) {
 /*---------------------------------------------------------*/
 
-  const TileDigitsContainer* DigitsCnt;
-  CHECK( evtStore()->retrieve(DigitsCnt, "TileDigitsCnt") );
+  SG::ReadHandle<TileDigitsContainer> DigitsCnt(m_DigitsContainerKey);
+  ATH_CHECK( DigitsCnt.isValid() );
 
   TileDigitsContainer::const_iterator collItr = DigitsCnt->begin();
   TileDigitsContainer::const_iterator lastColl = DigitsCnt->end();
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserDefaultCalibTool.cxx
index 650d7f9bf165d24394c456e2f6f8866d57e0023a..e07bf98b611131b56391c2dea90230091853ea01 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserDefaultCalibTool.cxx
@@ -119,8 +119,6 @@ TileLaserDefaultCalibTool::TileLaserDefaultCalibTool(const std::string& type, co
 {
   declareInterface<ITileCalibTool>( this );
   declareProperty("toolNtuple", m_toolNtuple="h3000");
-  declareProperty("rawChannelContainer", m_rawChannelContainerName="");
-  declareProperty("laserObjContainer", m_laserContainerName="");
   declareProperty("pisaMethod2", m_pisaMethod2=true);
   declareProperty("StuckBitsProbsTool", m_stuckBitsProbs);
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
@@ -270,6 +268,8 @@ StatusCode TileLaserDefaultCalibTool::initialize(){
   ATH_CHECK( m_tileToolEmscale.retrieve() );
   ATH_CHECK( m_tileBadChanTool.retrieve() );
   
+  ATH_CHECK( m_RawChannelContainerKey.initialize() );
+  ATH_CHECK( m_LaserContainerKey.initialize() );
 
   ATH_CHECK( m_tileDCS.retrieve() );
 
@@ -296,11 +296,12 @@ StatusCode TileLaserDefaultCalibTool::execute(){
   // Store laser object and rawchannel information into maps
   ATH_MSG_DEBUG ( "execute() TileLaserDefaultCalibTool" );
   
-  const TileRawChannelContainer * rawCnt = 0;
-  const TileLaserObject* laserObj;
+  SG::ReadHandle<TileRawChannelContainer> rawCnt(m_RawChannelContainerKey);
+  SG::ReadHandle<TileLaserObject> laserObj(m_LaserContainerKey);
+  
+  ATH_CHECK( rawCnt.isValid() );
+  ATH_CHECK( laserObj.isValid() );
   
-  ATH_CHECK( evtStore()->retrieve(rawCnt,   m_rawChannelContainerName) );
-  ATH_CHECK( evtStore()->retrieve(laserObj, m_laserContainerName) );
   
   m_LASERII = laserObj->isLASERII();
 
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
index 0533ddb5b943c332e55e371c91a13a7aebe1fd81..34c6154aa9e769845c4dcf991e0fabc074cdfbcc 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserLinearityCalibTool.cxx
@@ -81,8 +81,6 @@ TileLaserLinearityCalibTool::TileLaserLinearityCalibTool(const std::string& type
 {
   declareInterface<ITileCalibTool>( this );
   declareProperty("toolNtuple", m_toolNtuple="h3000");
-  declareProperty("rawChannelContainer", m_rawChannelContainerName="");
-  declareProperty("laserObjContainer", m_laserContainerName="");
   declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 }
 
@@ -191,6 +189,9 @@ StatusCode TileLaserLinearityCalibTool::initialize()
   ATH_CHECK( detStore()->retrieve(m_tileHWID) );
   ATH_CHECK( m_tileToolEmscale.retrieve() );
 
+  ATH_CHECK( m_RawChannelContainerKey.initialize() );
+  ATH_CHECK( m_LaserContainerKey.initialize() );
+
   m_cabling = TileCablingService::getInstance();
 
   CHECK( m_dqStatusKey.initialize() );
@@ -236,11 +237,11 @@ StatusCode TileLaserLinearityCalibTool::execute()
 
   ATH_MSG_DEBUG ( "Retrieving the LASER object and RawChannel" );
 
-  const TileRawChannelContainer * rawCnt = 0;
-  const TileLaserObject* laserObj;
-
-  ATH_CHECK( evtStore()->retrieve(rawCnt, m_rawChannelContainerName) );
-  ATH_CHECK( evtStore()->retrieve(laserObj, m_laserContainerName) );
+  SG::ReadHandle<TileRawChannelContainer> rawCnt(m_RawChannelContainerKey);
+  SG::ReadHandle<TileLaserObject> laserObj(m_LaserContainerKey);
+  
+  ATH_CHECK( rawCnt.isValid() );
+  ATH_CHECK( laserObj.isValid() );
 
   // First we got event time (From 1/1/70)
 
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
index 1817f9dbcc1d07926a28e7a766aeff8912ef12d5..51fd239250628b1bda8375dab7a989c4f9b3b9b3 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileLaserTimingTool.cxx
@@ -8,6 +8,7 @@
 #include "CoralBase/AttributeListSpecification.h"
 #include "AthenaPoolUtilities/CondAttrListCollection.h"
 #include "AthenaKernel/errorcheck.h"
+#include "StoreGate/ReadHandle.h"
 
 // Tile includes
 #include "TileCalibAlgs/TileLaserTimingTool.h"
@@ -130,8 +131,8 @@ TileLaserTimingTool::TileLaserTimingTool(const std::string& type, const std::str
   declareInterface<ITileCalibTool>( this );
 
   declareProperty("TileCondToolTiming", m_tileToolTiming);
-  declareProperty("RawChannelContainer", m_rawChannelContainerName = "TileRawChannelFit");
-  declareProperty("DigitsContainer", m_digitsContainerName = "TileDigitsCnt");
+  //declareProperty("RawChannelContainer", m_rawChannelContainerName = "TileRawChannelFit");
+  //declareProperty("DigitsContainer", m_digitsContainerName = "TileDigitsCnt");
   declareProperty("NtupleID", m_ntupleID = "h3000");
   declareProperty("FiberLightSpeed", m_fiberLightSpeed);
   declareProperty("NSamples", m_nSamples = 9);
@@ -237,6 +238,9 @@ StatusCode TileLaserTimingTool::initialize() {
     }
   }
 
+  ATH_CHECK( m_RawChannelContainerKey.initialize() );
+  ATH_CHECK( m_DigitsContainerKey.initialize() );
+
   // gauss fit function
   m_gaussf = new TF1("GainGauss", "[0]*exp(- (x-[1])*(x-[1])/(2*[2]*[2]))", -60, 60);
 
@@ -293,12 +297,12 @@ StatusCode TileLaserTimingTool::execute() {
   bool pass = true;
 
   // Get TileRawChannelContainer
-  const TileRawChannelContainer *container = 0;
-  CHECK( evtStore()->retrieve(container, m_rawChannelContainerName) );
+  SG::ReadHandle<TileRawChannelContainer> container(m_RawChannelContainerKey);
+  ATH_CHECK( container.isValid() );
 
   // Get TileDigitsContainer
-  const TileDigitsContainer* digitsCnt = 0;
-  CHECK( evtStore()->retrieve(digitsCnt, m_digitsContainerName) );
+  SG::ReadHandle<TileDigitsContainer> digitsCnt(m_DigitsContainerKey);
+  ATH_CHECK( digitsCnt.isValid() );
 
   // Create iterator over RawChannelContainer
   TileRawChannelContainer::const_iterator itColl = (*container).begin();
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
index 0835bd553b582513f4d290d7bc4ca8e304fe5abf..8e7b427691ce0286deab2b09841cfee402d9b38a 100755
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTOFTool.cxx
@@ -5,6 +5,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "StoreGate/StoreGate.h"
+#include "StoreGate/ReadHandle.h"
 
 #include "TileCalibAlgs/TileTOFTool.h"
 #include "CaloEvent/CaloCellContainer.h"
@@ -44,6 +45,9 @@ TileTOFTool::~TileTOFTool() {}
 StatusCode TileTOFTool::initialize()
 {
   ATH_MSG_INFO ( "initialize()" );
+
+  ATH_CHECK( m_CaloCellContainerKey.initialize() );
+
   return StatusCode::SUCCESS;  
 } 
 
@@ -57,8 +61,8 @@ StatusCode TileTOFTool::execute()
 {
   ATH_MSG_INFO ( "execute()" );
 
-  const CaloCellContainer* cellCONT = nullptr;
-  ATH_CHECK( evtStore()->retrieve( cellCONT, "AllCalo") );
+  SG::ReadHandle<CaloCellContainer> cellCONT(m_CaloCellContainerKey);
+  ATH_CHECK( cellCONT.isValid() );
   ATH_MSG_DEBUG ( "Cell container found" );
 
   CaloCellContainer::const_iterator iCell  = cellCONT->begin();
diff --git a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
index 812cba33fd48fa0bdff467b2c711969ddec8fe87..663f1873058df754f4f043a978f35cf786b2bcad 100644
--- a/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
+++ b/TileCalorimeter/TileCalib/TileCalibAlgs/src/TileTriggerDefaultCalibTool.cxx
@@ -88,9 +88,7 @@ TileTriggerDefaultCalibTool::TileTriggerDefaultCalibTool(const std::string& type
   , m_beamElemCnt(nullptr)
 {
   declareInterface<ITileCalibTool>( this );
-  declareProperty("TriggerTowerLocation", m_triggerTowerLocation="xAODTriggerTowers");
   declareProperty("MaxNTriggerTowers", m_maxNTT=7200);
-  declareProperty("rawChannelContainer", m_rawChannelContainerName="TileRawChannelFit");
   declareProperty("NtupleID", m_ntupleID="h3000");
   declareProperty("NumEventPerPMT", m_nevpmt=195); // changed from 200 to 195
   declareProperty("TileBeamElemContainer",m_TileBeamContainerID);
@@ -112,6 +110,9 @@ StatusCode TileTriggerDefaultCalibTool::initialize()
   m_ipmtOld = 0;
   m_ipmtCount = 0;
 
+  ATH_CHECK( m_RawChannelContainerKey.initialize() );
+  ATH_CHECK( m_TriggerTowerContainerKey.initialize() );
+
   ATH_CHECK( m_l1CaloTTIdTools.retrieve() );
   ATH_MSG_DEBUG("L1CaloTTIdTools retrieved");
 
@@ -143,8 +144,8 @@ StatusCode TileTriggerDefaultCalibTool::execute()
   const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
   // Get TileRawChannelContainer
-  const TileRawChannelContainer *container;
-  ATH_CHECK( evtStore()->retrieve(container, m_rawChannelContainerName) );
+  SG::ReadHandle<TileRawChannelContainer> container(m_RawChannelContainerKey);
+         ATH_CHECK( container.isValid() );
 
   ATH_MSG_DEBUG ( "second executeTrigger()" );
   // declare an array of pmt id for the trigger tower loop
@@ -278,8 +279,8 @@ StatusCode TileTriggerDefaultCalibTool::execute()
   } // end of loop over raw channels for Tile
   
   // loop over all L1Calo trigger channels, calculate the average and RMS
-  const xAOD::TriggerTowerContainer* triggerTowers = 0;
-  CHECK(evtStore()->retrieve(triggerTowers, m_triggerTowerLocation));
+  SG::ReadHandle<xAOD::TriggerTowerContainer> triggerTowers(m_TriggerTowerContainerKey);
+  ATH_CHECK( triggerTowers.isValid() );
 
   int ntt = 0;