diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
index 4cb9f4d4b3d481c1d24b17d443f7372a48e41bad..1cf043857d943d299c7f859c491fec94d23d5625 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.cxx
@@ -65,11 +65,7 @@ namespace Muon {
       m_pullCalculator("Trk::ResidualPullCalculator/ResidualPullCalculator"),
       m_idHelperTool("Muon::MuonIdHelperTool/MuonIdHelperTool"), 
       m_helperTool("Muon::MuonEDMHelperTool/MuonEDMHelperTool"),
-      m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
-      m_mdtPrdContainer(0),
-      m_cscPrdContainer(0),
-      m_tgcPrdContainer(0),
-      m_rpcPrdContainer(0)
+      m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool")
   {
     declareInterface<IMuonHoleRecoveryTool>(this);
     declareInterface<MuonChamberHoleRecoveryTool>(this);
@@ -166,6 +162,10 @@ namespace Muon {
       return StatusCode::FAILURE;
     }
 
+    ATH_CHECK(m_key_mdt.initialize());
+    ATH_CHECK(m_key_csc.initialize());
+    ATH_CHECK(m_key_tgc.initialize());
+    ATH_CHECK(m_key_rpc.initialize());
     
     return StatusCode::SUCCESS;
   }
@@ -1206,15 +1206,20 @@ MuonChamberHoleRecoveryTool::insertMdtsWithHoleSearch( std::vector<const Trk::Tr
 
   const MdtPrepDataCollection* MuonChamberHoleRecoveryTool::findMdtPrdCollection( const Identifier& chId ) const {
 
-    if (evtStore()->retrieve(m_mdtPrdContainer,m_key_mdt).isFailure()) {
-      ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt );
+    SG::ReadHandle<Muon::MdtPrepDataContainer> h_mdtPrdCont(m_key_mdt);
+    const Muon::MdtPrepDataContainer *mdtPrdContainer;
+    if (h_mdtPrdCont.isValid()) {
+      mdtPrdContainer = h_mdtPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt.key() );
       return 0;
     }
     IdentifierHash hash_id;
     m_idHelperTool->mdtIdHelper().get_module_hash(chId,hash_id );
 
-    MdtPrepDataContainer::const_iterator colIt = m_mdtPrdContainer->indexFind(hash_id);
-    if( colIt == m_mdtPrdContainer->end() ){
+    MdtPrepDataContainer::const_iterator colIt = mdtPrdContainer->indexFind(hash_id);
+    if( colIt == mdtPrdContainer->end() ){
       ATH_MSG_DEBUG(" MdtPrepDataCollection for:   " << m_idHelperTool->toStringChamber(chId) 
 			   << "  not found in container " );
       return 0;
@@ -1224,15 +1229,20 @@ MuonChamberHoleRecoveryTool::insertMdtsWithHoleSearch( std::vector<const Trk::Tr
 
   const CscPrepDataCollection* MuonChamberHoleRecoveryTool::findCscPrdCollection( const Identifier& detElId ) const {
 
-    if (evtStore()->retrieve(m_cscPrdContainer,m_key_csc).isFailure()) {
-      ATH_MSG_WARNING("Cannot retrieve cscPrepDataContainer " << m_key_csc );
+    SG::ReadHandle<Muon::CscPrepDataContainer> h_cscPrdCont(m_key_csc);
+    const Muon::CscPrepDataContainer *cscPrdContainer;
+    if (h_cscPrdCont.isValid()) {
+      cscPrdContainer = h_cscPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve cscPrepDataContainer " << m_key_csc.key() );
       return 0;
     }
     IdentifierHash hash_id;
     m_idHelperTool->cscIdHelper().get_module_hash(detElId,hash_id );
       
-    CscPrepDataContainer::const_iterator colIt = m_cscPrdContainer->indexFind(hash_id);
-    if( colIt == m_cscPrdContainer->end() ){
+    CscPrepDataContainer::const_iterator colIt = cscPrdContainer->indexFind(hash_id);
+    if( colIt == cscPrdContainer->end() ){
       ATH_MSG_DEBUG(" CscPrepDataCollection for:   " << m_idHelperTool->toStringChamber(detElId) 
 			   << "  not found in container " );
       return 0;
@@ -1241,16 +1251,21 @@ MuonChamberHoleRecoveryTool::insertMdtsWithHoleSearch( std::vector<const Trk::Tr
   }
 
   const TgcPrepDataCollection* MuonChamberHoleRecoveryTool::findTgcPrdCollection( const Identifier& detElId ) const {
-    
-    if (evtStore()->retrieve(m_tgcPrdContainer,m_key_tgc).isFailure()) {
-      ATH_MSG_WARNING("Cannot retrieve tgcPrepDataContainer " << m_key_tgc );
+
+    SG::ReadHandle<Muon::TgcPrepDataContainer> h_tgcPrdCont(m_key_tgc);
+    const Muon::TgcPrepDataContainer *tgcPrdContainer;
+    if (h_tgcPrdCont.isValid()) {
+      tgcPrdContainer = h_tgcPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve tgcPrepDataContainer " << m_key_tgc.key() );
       return 0;
     }
     IdentifierHash hash_id;
     m_idHelperTool->tgcIdHelper().get_module_hash(detElId,hash_id );
 
-    TgcPrepDataContainer::const_iterator colIt = m_tgcPrdContainer->indexFind(hash_id);
-    if( colIt == m_tgcPrdContainer->end() ){
+    TgcPrepDataContainer::const_iterator colIt = tgcPrdContainer->indexFind(hash_id);
+    if( colIt == tgcPrdContainer->end() ){
       ATH_MSG_DEBUG(" TgcPrepDataCollection for:   " << m_idHelperTool->toStringChamber(detElId)
 		    << "  not found in container " );
       return 0;
@@ -1260,15 +1275,19 @@ MuonChamberHoleRecoveryTool::insertMdtsWithHoleSearch( std::vector<const Trk::Tr
 
   const RpcPrepDataCollection* MuonChamberHoleRecoveryTool::findRpcPrdCollection( const Identifier& detElId ) const {
     
-    
-    if(evtStore()->retrieve(m_rpcPrdContainer,m_key_rpc).isFailure()) {
-      ATH_MSG_WARNING("Cannot retrieve rpcPrepDataContainer " << m_key_rpc );
+    SG::ReadHandle<Muon::RpcPrepDataContainer> h_rpcPrdCont(m_key_rpc);
+    const Muon::RpcPrepDataContainer *rpcPrdContainer;
+    if(h_rpcPrdCont.isValid()) {
+      rpcPrdContainer = h_rpcPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve rpcPrepDataContainer " << m_key_rpc.key() );
       return 0;
     }
     IdentifierHash hash_id;
     m_idHelperTool->rpcIdHelper().get_module_hash(detElId,hash_id );
-    RpcPrepDataContainer::const_iterator colIt = m_rpcPrdContainer->indexFind(hash_id);
-    if( colIt == m_rpcPrdContainer->end() ){
+    RpcPrepDataContainer::const_iterator colIt = rpcPrdContainer->indexFind(hash_id);
+    if( colIt == rpcPrdContainer->end() ){
       ATH_MSG_DEBUG(" RpcPrepDataCollection for:   " << m_idHelperTool->toStringChamber(detElId) << "  not found in container " );
       return 0;
     }
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
index 6d6399a0168a7a47043415ed001eb794cef4c28b..cabbd677b80a868e9c63774a06bf3021f2e1040e 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonChamberHoleRecoveryTool.h
@@ -180,15 +180,11 @@ namespace Muon {
 
     const MuonGM::MuonDetectorManager*  m_detMgr;
 
-    std::string m_key_mdt;                                //!< storegate location of the MdtPrepData
-    std::string m_key_csc;                                //!< storegate location of the CscPrepData
-    std::string m_key_tgc;                                //!< storegate location of the TgcPrepData
-    std::string m_key_rpc;                                //!< storegate location of the RpcPrepData
-
-    mutable const Muon::MdtPrepDataContainer* m_mdtPrdContainer;  //!< pointer to the MdtPrepData container    
-    mutable const Muon::CscPrepDataContainer* m_cscPrdContainer;  //!< pointer to the CscPrepData container    
-    mutable const Muon::TgcPrepDataContainer* m_tgcPrdContainer;  //!< pointer to the TgcPrepData container    
-    mutable const Muon::RpcPrepDataContainer* m_rpcPrdContainer;  //!< pointer to the RpcPrepData container    
+    SG::ReadHandleKey<Muon::MdtPrepDataContainer> m_key_mdt;                                //!< storegate location of the MdtPrepData
+    SG::ReadHandleKey<Muon::CscPrepDataContainer> m_key_csc;                                //!< storegate location of the CscPrepData
+    SG::ReadHandleKey<Muon::TgcPrepDataContainer> m_key_tgc;                                //!< storegate location of the TgcPrepData
+    SG::ReadHandleKey<Muon::RpcPrepDataContainer> m_key_rpc;                                //!< storegate location of the RpcPrepData
+
 
     bool m_addMeasurements;
     double m_associationPullCutEta;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.cxx b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.cxx
index 85c5efeb78bb9d7c38ac41c4d720dfe27508fffb..0b399bb00ba46f7b0b86fb7f4426ab5bd8cd6ab9 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.cxx
@@ -48,11 +48,7 @@ namespace Muon {
       m_mdtRotCreator("Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"),
       m_magFieldProperties(Trk::NoField),
       m_idHelper("Muon::MuonIdHelperTool/MuonIdHelperTool"), 
-      m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
-      m_mdtPrdContainer(0),
-      m_rpcPrdContainer(0),
-      m_tgcPrdContainer(0),
-      m_cscPrdContainer(0)
+      m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool")
   {
     declareInterface<IMuonSeededSegmentFinder>(this);
 
@@ -108,6 +104,11 @@ namespace Muon {
       ATH_MSG_ERROR("Could not retrieve "<<m_idHelper<<". Exiting.");
       return StatusCode::FAILURE;
     }
+
+    ATH_CHECK(m_key_mdt.initialize());
+    ATH_CHECK(m_key_csc.initialize());
+    ATH_CHECK(m_key_rpc.initialize());
+    ATH_CHECK(m_key_tgc.initialize());
     
     return StatusCode::SUCCESS;
   }
@@ -228,8 +229,13 @@ namespace Muon {
   
   std::vector<const MdtPrepData*> MuonSeededSegmentFinder::extractPrds( const std::set<IdentifierHash>& chIdHs ) const {
 
-    if (evtStore()->retrieve(m_mdtPrdContainer,m_key_mdt).isFailure()) {
-      ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt);
+    SG::ReadHandle<Muon::MdtPrepDataContainer> h_mdtPrdCont(m_key_mdt);
+    const Muon::MdtPrepDataContainer *mdtPrdContainer;
+    if (h_mdtPrdCont.isValid()) {
+      mdtPrdContainer = h_mdtPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt.key());
       return std::vector<const MdtPrepData*>();
     }
       
@@ -240,8 +246,8 @@ namespace Muon {
     std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
     std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
     for( ;chit!=chit_end;++chit ){
-      MdtPrepDataContainer::const_iterator colIt = m_mdtPrdContainer->indexFind(*chit);
-      if( colIt == m_mdtPrdContainer->end() ){
+      MdtPrepDataContainer::const_iterator colIt = mdtPrdContainer->indexFind(*chit);
+      if( colIt == mdtPrdContainer->end() ){
 	//ATH_MSG_DEBUG(" MdtPrepDataCollection for:   " 
 	//	     << m_idHelper->toStringChamber(*chit) << "  not found in container ");
 	continue;
@@ -257,19 +263,23 @@ namespace Muon {
   void MuonSeededSegmentFinder::extractMdtPrdCols( const std::set<IdentifierHash>& chIdHs, 
 						   std::vector<const MdtPrepDataCollection*>& target ) const {
 
-    if( evtStore()->contains<Muon::MdtPrepDataContainer>(m_key_mdt) ) {
-      if (evtStore()->retrieve(m_mdtPrdContainer,m_key_mdt).isFailure()) {
-        ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt);
-        return;
-      }
-    }else return;
+    SG::ReadHandle<Muon::MdtPrepDataContainer> h_mdtPrdCont(m_key_mdt);
+    const Muon::MdtPrepDataContainer *mdtPrdContainer;
+    if (h_mdtPrdCont.isValid()) {
+      mdtPrdContainer = h_mdtPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve mdtPrepDataContainer " << m_key_mdt.key());
+      return;
+    }
+
 
     // loop over chambers and get collections
     std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
     std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
     for( ;chit!=chit_end;++chit ){
-      MdtPrepDataContainer::const_iterator colIt = m_mdtPrdContainer->indexFind(*chit);
-      if( colIt == m_mdtPrdContainer->end() || (*colIt)->empty() ){
+      MdtPrepDataContainer::const_iterator colIt = mdtPrdContainer->indexFind(*chit);
+      if( colIt == mdtPrdContainer->end() || (*colIt)->empty() ){
 	continue;
       }
       ATH_MSG_DEBUG(" Adding for:   " 
@@ -284,20 +294,23 @@ namespace Muon {
   void MuonSeededSegmentFinder::extractRpcPrdCols( const std::set<IdentifierHash>& chIdHs, 
 						   std::vector<const RpcPrepDataCollection*>& target ) const {
 
-    if( evtStore()->contains<Muon::RpcPrepDataContainer>(m_key_rpc) ) {
-      if (evtStore()->retrieve(m_rpcPrdContainer,m_key_rpc).isFailure()) {
-        ATH_MSG_WARNING("Cannot retrieve rpcPrepDataContainer " << m_key_rpc);
-        return;
-      }
-    }else return;
+    SG::ReadHandle<Muon::RpcPrepDataContainer> h_rpcPrdCont(m_key_rpc);
+    const Muon::RpcPrepDataContainer *rpcPrdContainer;
+    if (h_rpcPrdCont.isValid()){
+      rpcPrdContainer = h_rpcPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve rpcPrepDataContainer " << m_key_rpc.key());
+      return;
+    }
 
       
     // loop over chambers and get collections
     std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
     std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
     for( ;chit!=chit_end;++chit ){
-      RpcPrepDataContainer::const_iterator colIt = m_rpcPrdContainer->indexFind(*chit);
-      if( colIt == m_rpcPrdContainer->end() || (*colIt)->empty() ){
+      RpcPrepDataContainer::const_iterator colIt = rpcPrdContainer->indexFind(*chit);
+      if( colIt == rpcPrdContainer->end() || (*colIt)->empty() ){
 	//ATH_MSG_DEBUG(" RpcPrepDataCollection for:   " 
 	//	     << m_idHelper->toStringChamber(*chit) << "  not found in container ");
 	continue;
@@ -314,19 +327,23 @@ namespace Muon {
   void MuonSeededSegmentFinder::extractTgcPrdCols( const std::set<IdentifierHash>& chIdHs, 
 						   std::vector<const TgcPrepDataCollection*>& target ) const {
 
-    if( evtStore()->contains<Muon::TgcPrepDataContainer>(m_key_tgc) ) {
-      if (evtStore()->retrieve(m_tgcPrdContainer,m_key_tgc).isFailure()) {
-        ATH_MSG_WARNING("Cannot retrieve tgcPrepDataContainer " << m_key_tgc);
-        return;
-      }
-    }else return;
+    SG::ReadHandle<Muon::TgcPrepDataContainer> h_tgcPrdCont(m_key_tgc);
+    const Muon::TgcPrepDataContainer *tgcPrdContainer;
+    if(h_tgcPrdCont.isValid()) {
+      tgcPrdContainer = h_tgcPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve tgcPrepDataContainer " << m_key_tgc.key());
+      return;
+    }
+
 
     // loop over chambers and get collections
     std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
     std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
     for( ;chit!=chit_end;++chit ){
-      TgcPrepDataContainer::const_iterator colIt = m_tgcPrdContainer->indexFind(*chit);
-      if( colIt == m_tgcPrdContainer->end() || (*colIt)->empty() ){
+      TgcPrepDataContainer::const_iterator colIt = tgcPrdContainer->indexFind(*chit);
+      if( colIt == tgcPrdContainer->end() || (*colIt)->empty() ){
 	//ATH_MSG_DEBUG(" TgcPrepDataCollection for:   " 
 	//	     << m_idHelper->toStringChamber(*chit) << "  not found in container ");
 	continue;
@@ -343,19 +360,23 @@ namespace Muon {
   void MuonSeededSegmentFinder::extractCscPrdCols( const std::set<IdentifierHash>& chIdHs,
 						   std::vector<const CscPrepDataCollection*>& target ) const {
 
-    if( evtStore()->contains<Muon::CscPrepDataContainer>(m_key_csc) ) {
-      if ( evtStore()->retrieve(m_cscPrdContainer,m_key_csc).isFailure()) {
-	ATH_MSG_WARNING("Cannot retrieve cscPrepDataContainer " << m_key_csc);
-	return;
-      }
-    }else return;
+    SG::ReadHandle<Muon::CscPrepDataContainer> h_cscPrdCont(m_key_csc);
+    const Muon::CscPrepDataContainer *cscPrdContainer;
+    if(h_cscPrdCont.isValid()) {
+      cscPrdContainer = h_cscPrdCont.cptr();
+    }
+    else{
+      ATH_MSG_WARNING("Cannot retrieve cscPrepDataContainer " << m_key_csc.key());
+      return;
+    }
+
 
     // loop over chambers and get collections
     std::set<IdentifierHash>::const_iterator chit = chIdHs.begin();
     std::set<IdentifierHash>::const_iterator chit_end = chIdHs.end();
     for( ;chit!=chit_end;++chit ){
-      CscPrepDataContainer::const_iterator colIt = m_cscPrdContainer->indexFind(*chit);
-      if( colIt == m_cscPrdContainer->end() || (*colIt)->empty() ){
+      CscPrepDataContainer::const_iterator colIt = cscPrdContainer->indexFind(*chit);
+      if( colIt == cscPrdContainer->end() || (*colIt)->empty() ){
 	//ATH_MSG_DEBUG(" CscPrepDataCollection for:   " 
 	//	     << m_idHelper->toStringChamber(*chit) << "  not found in container ");
 	continue;
diff --git a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.h b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.h
index 9848440a51dc8399531cdc46b4a9d0d0a1a160a8..c47ec1611d41da445ebd0d72bdd665c6d464fe51 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonTrackMakers/MuonTrackMakerTools/MuonTrackFinderTools/src/MuonSeededSegmentFinder.h
@@ -121,17 +121,10 @@ namespace Muon {
     ToolHandle<Muon::MuonIdHelperTool>               m_idHelper;       //!< IdHelper tool
     ToolHandle<Muon::MuonEDMPrinterTool>             m_printer;            //!< EDM printer tool
 
-    std::string m_key_mdt;                                //!< storegate location of the MdtPrepData
-    mutable const Muon::MdtPrepDataContainer* m_mdtPrdContainer;  //!< pointer to the MdtPrepData container    
-
-    std::string m_key_rpc;                                //!< storegate location of the RpcPrepData
-    mutable const Muon::RpcPrepDataContainer* m_rpcPrdContainer;  //!< pointer to the RpcPrepData container    
-
-    std::string m_key_tgc;                                //!< storegate location of the TgcPrepData
-    mutable const Muon::TgcPrepDataContainer* m_tgcPrdContainer;  //!< pointer to the TgcPrepData container    
-
-    std::string m_key_csc;                                //!< storegate location of the CscPrepData
-    mutable const Muon::CscPrepDataContainer* m_cscPrdContainer;  //!< pointer to the CscPrepData container    
+    SG::ReadHandleKey<Muon::MdtPrepDataContainer> m_key_mdt;                                //!< storegate location of the MdtPrepData
+    SG::ReadHandleKey<Muon::RpcPrepDataContainer> m_key_rpc;                                //!< storegate location of the RpcPrepData
+    SG::ReadHandleKey<Muon::TgcPrepDataContainer> m_key_tgc;                                //!< storegate location of the TgcPrepData
+    SG::ReadHandleKey<Muon::CscPrepDataContainer> m_key_csc;                                //!< storegate location of the CscPrepData
 
     double m_adcCut;
     double m_maxSigma;