diff --git a/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/AFP_ByteStream2RawCnv/AFP_RawDataProvider.h b/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/AFP_ByteStream2RawCnv/AFP_RawDataProvider.h
index 1c817be5b9d83c6f5cc3b3b36b1a06c527641024..2eefd289515c7d7141f9fd8951a01a178f33c87d 100644
--- a/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/AFP_ByteStream2RawCnv/AFP_RawDataProvider.h
+++ b/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/AFP_ByteStream2RawCnv/AFP_RawDataProvider.h
@@ -42,10 +42,11 @@ public:
   
 private:
   ServiceHandle<IROBDataProviderSvc> m_robDataProvider;
-  ToolHandle<AFP_RawDataProviderTool> m_rawDataTool;
+  ToolHandle<AFP_RawDataProviderTool> m_rawDataTool{this, "ProviderTool", "AFP_RawDataProviderTool"};
 
   /// name used to store AFP_RawContainer in StoreGate
-  std::string m_AFP_RawContainerKey;
+  SG::WriteHandleKey<AFP_RawContainer> m_AFP_RawContainerKey{this, "AFP_RawContainerKey", "AFP_RawData",
+      		  "Name under which AFP_RawContainer object will be saved in StoreGate"};
   
   /// vector of robIDs from which data should be processed
   static const std::vector<unsigned int> s_robIDs;
diff --git a/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/src/AFP_RawDataProvider.cxx b/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/src/AFP_RawDataProvider.cxx
index 4d3531b29929d9ca14e47d7ce1e04ee4000b956f..c8eef0c884bc54c03950091db2771221c320f3d9 100644
--- a/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/src/AFP_RawDataProvider.cxx
+++ b/ForwardDetectors/AFP/AFP_ByteStream2RawCnv/src/AFP_RawDataProvider.cxx
@@ -14,15 +14,8 @@ const std::vector<unsigned int> AFP_RawDataProvider::s_robIDs = {AFP_ROBID::side
 AFP_RawDataProvider::AFP_RawDataProvider(const std::string &name,
                                          ISvcLocator *pSvcLocator)
     : AthAlgorithm(name, pSvcLocator),
-      m_robDataProvider("ROBDataProviderSvc", name),
-      m_rawDataTool("AFP_RawDataProviderTool")
+      m_robDataProvider("ROBDataProviderSvc", name)
 {
-
-  declareProperty("AFP_RawContainerKey",
-                  m_AFP_RawContainerKey = "AFP_RawData",
-		  "Name under which AFP_RawContainer object will be saved in StoreGate");
-  
-  declareProperty("ProviderTool", m_rawDataTool);
 }
 
 AFP_RawDataProvider::~AFP_RawDataProvider() {}
@@ -43,30 +36,23 @@ StatusCode AFP_RawDataProvider::initialize() {
     ATH_MSG_DEBUG("Retrieved service " << m_rawDataTool);
   }
 
+  ATH_CHECK(m_AFP_RawContainerKey.initialize());
+
   return StatusCode::SUCCESS;
 }
 
 StatusCode AFP_RawDataProvider::execute() {
   ATH_MSG_DEBUG("AFP_RawDataProvider::EXECUTE");
-  AFP_RawContainer *container = new AFP_RawContainer;
+  auto container = std::make_unique<AFP_RawContainer>();
   ATH_MSG_DEBUG("Created AFP RDO Container");
 
-  StatusCode recordSC =
-      evtStore()->record(container, m_AFP_RawContainerKey);
-  if (recordSC.isFailure()) {
-    ATH_MSG_WARNING("Unable to record AFP RDO Container");
-    return StatusCode::SUCCESS;
-  } else {
-    ATH_MSG_DEBUG("AFP RDO Container recorded");
-  }
-
   std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *> listOfRobf;
 
   m_robDataProvider->getROBData(s_robIDs, listOfRobf);
   ATH_MSG_DEBUG(" ROB ID " << std::hex << s_robIDs<<std::dec);
   ATH_MSG_DEBUG(" Number of ROB fragments is " << listOfRobf.size());
 
-  if (m_rawDataTool->convert(listOfRobf, container).isFailure()) {
+  if (m_rawDataTool->convert(listOfRobf, container.get()).isFailure()) {
     ATH_MSG_WARNING("Bytestream conversion into raw failed");
     return StatusCode::SUCCESS;
   } else {
@@ -76,5 +62,14 @@ StatusCode AFP_RawDataProvider::execute() {
                   << container->collectionsSi().size());
   }
 
+  SG::WriteHandle<AFP_RawContainer> writeHandle{m_AFP_RawContainerKey};
+  StatusCode recordSC = writeHandle.record(std::move(container));
+  if (recordSC.isFailure()) {
+    ATH_MSG_WARNING("Unable to record AFP RDO Container");
+    return StatusCode::SUCCESS;
+  } else {
+    ATH_MSG_DEBUG("AFP RDO Container recorded");
+  }
+
   return StatusCode::SUCCESS;
 }
diff --git a/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.cxx b/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.cxx
index 6a89502d627e10288f5967ab53c22d2fd8314e64..bc024196581ca80a3c6ee1864eb3e2cf96c0fb73 100644
--- a/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.cxx
+++ b/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.cxx
@@ -22,17 +22,17 @@ AFP_Raw2DigiTool::AFP_Raw2DigiTool(const std::string &type,
 				   const IInterface *parent)
   : base_class(type, name, parent),
     m_totToChargeTransformation ("totToChargeTransformation", "1909 + x*363 + x*x*141")
-{
-  declareProperty( "rawDataContainerName", m_rawDataContainerName = "AFP_RawData");
-  declareProperty( "AFPSiHitsContainerName", m_AFPSiHitsContainerName = "AFPSiHitContainer" );
-  declareProperty( "AFPHitsContainerNameToF", m_AFPHitsContainerNameToF = "AFPToFHitContainer" );
-}		
+{}		
 
 AFP_Raw2DigiTool::~AFP_Raw2DigiTool() {}
 
 StatusCode AFP_Raw2DigiTool::initialize()
 {
-  ATH_MSG_INFO("Initializing " << name() << "...");
+  ATH_MSG_DEBUG("Initializing " << name() << "...");
+
+  ATH_CHECK( m_rawDataContainerName.initialize() );
+  ATH_CHECK( m_AFPSiHitsContainerName.initialize() );
+  ATH_CHECK( m_AFPHitsContainerNameToF.initialize() );
 
   return StatusCode::SUCCESS;
 }
@@ -50,15 +50,13 @@ StatusCode AFP_Raw2DigiTool::recoSiHits()
   ATH_MSG_DEBUG("AFP_Raw2DigiTool recoSiHits ");
 
   // create output containers
-  xAOD::AFPSiHitContainer* siHitContainer = new xAOD::AFPSiHitContainer();
-  ATH_CHECK( evtStore()->record(siHitContainer, m_AFPSiHitsContainerName) );
-  xAOD::AFPSiHitAuxContainer* siHitAuxContainer = new xAOD::AFPSiHitAuxContainer();
-  ATH_CHECK( evtStore()->record(siHitAuxContainer, m_AFPSiHitsContainerName + "Aux.") );
-  siHitContainer->setStore(siHitAuxContainer);
+  auto siHitContainer = std::make_unique<xAOD::AFPSiHitContainer>();
+  auto siHitAuxContainer = std::make_unique<xAOD::AFPSiHitAuxContainer>();
+  siHitContainer->setStore(siHitAuxContainer.get());
 
   // retrieve raw data
-  const AFP_RawContainer *container = nullptr;
-  if (evtStore()->retrieve(container, m_rawDataContainerName).isFailure()) {
+  SG::ReadHandle<AFP_RawContainer> container{m_rawDataContainerName};
+  if (!container.isValid()) {
     ATH_MSG_WARNING("AFP_Raw2DigiTool: Could not find raw data container");
     return StatusCode::SUCCESS;
   }
@@ -67,7 +65,10 @@ StatusCode AFP_Raw2DigiTool::recoSiHits()
 
   for (const AFP_SiRawCollection& collection: container->collectionsSi())
     for (const AFP_SiRawData& data : collection.dataRecords())
-      newXAODHitSi (siHitContainer, collection, data);
+      newXAODHitSi (siHitContainer.get(), collection, data);
+
+  SG::WriteHandle<xAOD::AFPSiHitContainer> writeHandle{m_AFPSiHitsContainerName};
+  ATH_CHECK( writeHandle.record(std::move(siHitContainer), std::move(siHitAuxContainer)) );
 
   return StatusCode::SUCCESS;
 }
@@ -77,15 +78,13 @@ StatusCode AFP_Raw2DigiTool::recoToFHits()
   ATH_MSG_DEBUG("AFP_Raw2DigiTool recoToFHits ");
 
   // create output containers
-  xAOD::AFPToFHitContainer* tofHitContainer = new xAOD::AFPToFHitContainer();
-  ATH_CHECK( evtStore()->record(tofHitContainer, m_AFPHitsContainerNameToF) );
-  xAOD::AFPToFHitAuxContainer* tofHitAuxContainer = new xAOD::AFPToFHitAuxContainer();
-  ATH_CHECK( evtStore()->record(tofHitAuxContainer, m_AFPHitsContainerNameToF + "Aux.") );
-  tofHitContainer->setStore(tofHitAuxContainer);
+  auto tofHitContainer = std::make_unique<xAOD::AFPToFHitContainer>();
+  auto tofHitAuxContainer = std::make_unique<xAOD::AFPToFHitAuxContainer>();
+  tofHitContainer->setStore(tofHitAuxContainer.get());
 
   // retrieve raw data
-  const AFP_RawContainer *container = nullptr;
-  if (evtStore()->retrieve(container, m_rawDataContainerName).isFailure()) {
+  SG::ReadHandle<AFP_RawContainer> container{m_rawDataContainerName};
+  if (!container.isValid()) {
     ATH_MSG_WARNING("AFP_Raw2DigiTool: Could not find raw data container");
     return StatusCode::SUCCESS;
   }
@@ -95,7 +94,10 @@ StatusCode AFP_Raw2DigiTool::recoToFHits()
   for (const AFP_ToFRawCollection& collection: container->collectionsToF())
     for (const AFP_ToFRawData& data : collection.dataRecords())
       if (data.hitDiscConfig() == 3 && data.header() == 2) 
-	newXAODHitToF (tofHitContainer, collection, data);
+	newXAODHitToF (tofHitContainer.get(), collection, data);
+
+  SG::WriteHandle<xAOD::AFPToFHitContainer> writeHandle{m_AFPHitsContainerNameToF};
+  ATH_CHECK( writeHandle.record(std::move(tofHitContainer), std::move(tofHitAuxContainer)) );
 
   return StatusCode::SUCCESS;
 }
diff --git a/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.h b/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.h
index ea894f5aff90e57c8a1846c65d35fd3e142b7f85..11df139f27d875e3c778f290b29defa18eccc897 100644
--- a/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.h
+++ b/ForwardDetectors/AFP/AFP_Raw2Digi/src/AFP_Raw2DigiTool.h
@@ -42,9 +42,9 @@ public:
   unsigned int decodeTimeOverThresholdSi (const unsigned int input, const unsigned int discConfig) const;
   
 protected:
-  std::string m_rawDataContainerName;
-  std::string m_AFPSiHitsContainerName;
-  std::string m_AFPHitsContainerNameToF;
+  SG::ReadHandleKey<AFP_RawContainer> m_rawDataContainerName{this, "rawDataContainerName", "AFP_RawData"};
+  SG::WriteHandleKey<xAOD::AFPSiHitContainer> m_AFPSiHitsContainerName{this, "AFPSiHitsContainerName", "AFPSiHitContainer"};
+  SG::WriteHandleKey<xAOD::AFPToFHitContainer> m_AFPHitsContainerNameToF{this, "AFPHitsContainerNameToF", "AFPToFHitContainer"};
 
   /// @brief Factor converting signal to time
   ///