diff --git a/Event/EventContainers/EventContainers/I_InternalIDC.h b/Event/EventContainers/EventContainers/I_InternalIDC.h
index 2300f952670a1d253f2a110f1143454d6795d496..c336d4b964b0e4e5b47e9862b9aff113f065b705 100644
--- a/Event/EventContainers/EventContainers/I_InternalIDC.h
+++ b/Event/EventContainers/EventContainers/I_InternalIDC.h
@@ -31,19 +31,21 @@ public:
     virtual InternalConstItr cend() const=0;
     virtual InternalConstItr indexFind( IdentifierHash hashId ) const =0;
     virtual ~I_InternalIDC() = default;
-    virtual void Wait() const = 0;
+    virtual void wait() const = 0;
     virtual bool tryAddFromCache(IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) = 0;
     virtual bool tryAddFromCache(IdentifierHash hashId) = 0;
-    virtual std::vector<IdentifierHash> GetAllCurrentHashes() const =0;
-    virtual const std::vector < hashPair >& GetAllHashPtrPair() const = 0;
+    virtual std::vector<IdentifierHash> getAllCurrentHashes() const =0;
+    virtual const std::vector < hashPair >& getAllHashPtrPair() const = 0;
     virtual size_t numberOfCollections() const = 0;
     virtual size_t fullSize() const noexcept =0;
     virtual StatusCode fetchOrCreate(IdentifierHash hashId) =0;
     virtual StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashIds) =0;
     virtual bool insert(IdentifierHash hashId, const void* ptr) =0;
-    virtual const void* FindIndexPtr(IdentifierHash hashId) const noexcept = 0;
+    virtual const void* findIndexPtr(IdentifierHash hashId) const noexcept = 0;
     virtual StatusCode addLock(IdentifierHash hashId, const void* ptr) = 0;
     virtual void* removeCollection( IdentifierHash hashId ) =0;
+    virtual void destructor(deleter_f*) noexcept =0;
+    virtual void cleanUp(deleter_f*) noexcept =0;
 };
 
 }
diff --git a/Event/EventContainers/EventContainers/IdentifiableContainerBase.h b/Event/EventContainers/EventContainers/IdentifiableContainerBase.h
index 3e6d14b424fe9822dfabab63166459d25654639f..b3b1d6d7ab0f0407bbfc7d48e63781f676a225c6 100644
--- a/Event/EventContainers/EventContainers/IdentifiableContainerBase.h
+++ b/Event/EventContainers/EventContainers/IdentifiableContainerBase.h
@@ -10,21 +10,23 @@
 
 
 namespace EventContainers{ class IdentifiableCacheBase; 
-
+enum class Mode { OfflineLowMemory, OfflineFast };
 class IdentifiableContainerBase{
 public:
 #include "EventContainers/deleter.h"
+    
     typedef std::vector<IdentifierHash> Hash_Container;
     IdentifiableContainerBase(EventContainers::IdentifiableCacheBase *cache);
     IdentifiableContainerBase(size_t maxsize);
+    IdentifiableContainerBase(size_t maxsize, Mode mode);
     ~IdentifiableContainerBase() = default;
 protected:
     bool m_OnlineMode;
     typedef EventContainers::IdentifiableCacheBase IdentifiableCacheBase;
     std::unique_ptr<I_InternalIDC> m_link;
-    std::vector<IdentifierHash> GetAllCurrentHashes() const { return m_link->GetAllCurrentHashes(); }
+    std::vector<IdentifierHash> GetAllCurrentHashes() const { return m_link->getAllCurrentHashes(); }
     bool insert(IdentifierHash hashId, const void* ptr) { return m_link->insert(hashId, ptr); }
-    void Wait() const { m_link->Wait(); }
+    void Wait() const { m_link->wait(); }
     bool tryAddFromCache(IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) { 
         return m_link->tryAddFromCache(hashId, lock); }
     bool tryAddFromCache(IdentifierHash hashId){ return m_link->tryAddFromCache(hashId); }
@@ -33,7 +35,7 @@ protected:
     void ResetMask();
     StatusCode fetchOrCreate(IdentifierHash hashId){ return m_link->fetchOrCreate(hashId); }
     StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashIds) { return m_link->fetchOrCreate(hashIds); }
-    const void* indexFindPtr( IdentifierHash hashId ) const { return m_link->FindIndexPtr(hashId); }
+    const void* indexFindPtr( IdentifierHash hashId ) const { return m_link->findIndexPtr(hashId); }
 };
 
 }
diff --git a/Event/EventContainers/EventContainers/IdentifiableContainerMT.h b/Event/EventContainers/EventContainers/IdentifiableContainerMT.h
index 054d29a93609fbdb9363748e676ceadec3d06cf4..8791b57b881f699fa51b2edad021676cc006f323 100644
--- a/Event/EventContainers/EventContainers/IdentifiableContainerMT.h
+++ b/Event/EventContainers/EventContainers/IdentifiableContainerMT.h
@@ -23,7 +23,6 @@
 #include "EventContainers/IDC_WriteHandleBase.h"
 #include "CxxUtils/AthUnlikelyMacros.h"
 #include "EventContainers/IdentifiableCache.h"
-#include "EventContainers/InternalOffline.h"
 
 template < class T>
 class IdentifiableContainerMT : public DataObject, public EventContainers::IdentifiableContainerBase, public EventContainers::IIdentifiableCont<T>
@@ -143,10 +142,12 @@ public:
     /// constructor initializes the collection the hashmax, OFFLINE usages pattern
     IdentifiableContainerMT(IdentifierHash hashMax);
 
+    IdentifiableContainerMT(IdentifierHash hashMax, EventContainers::Mode);
+
     /// constructor initializes with a link to a cache, ONLINE usage pattern
     IdentifiableContainerMT(ICACHE *cache);
 
-    ~IdentifiableContainerMT() { if(!m_OnlineMode) static_cast<EventContainers::InternalOffline*>(m_link.get())->cleanUp(void_unique_ptr::Deleter<T>::deleter); }
+    ~IdentifiableContainerMT() { m_link->destructor(void_unique_ptr::Deleter<T>::deleter); }
 
     virtual bool hasExternalCache() const override final { return m_OnlineMode; }
 
@@ -215,7 +216,7 @@ public:
     const std::vector < std::pair<IdentifierHash::value_type, const T*> >& GetAllHashPtrPair() const{
         static_assert(sizeof(const T*) == sizeof(const void*) && std::is_pointer<const T*>::value);
         return reinterpret_cast<const std::vector < std::pair<IdentifierHash::value_type, const T*> >&>
-                (m_link->GetAllHashPtrPair());
+                (m_link->getAllHashPtrPair());
     }
     
     ///Returns a collection of all hashes availiable in this IDC.
@@ -263,6 +264,12 @@ IdentifiableContainerMT<T>::IdentifiableContainerMT(IdentifierHash maxHash) :  I
 {
 }
 
+template < class T>
+IdentifiableContainerMT<T>::IdentifiableContainerMT(IdentifierHash maxHash, EventContainers::Mode mode) :
+     IdentifiableContainerBase(maxHash, mode)
+{
+}
+
 // Constructor for ONLINE style IDC
 template < class T>
 IdentifiableContainerMT<T>::IdentifiableContainerMT(ICACHE *cache) : IdentifiableContainerBase(cache)
@@ -327,7 +334,7 @@ IdentifiableContainerMT<T>::naughtyRetrieve(IdentifierHash hashId, T* &collToRet
 {
    if(ATH_UNLIKELY(m_OnlineMode)) return StatusCode::FAILURE;//NEVER ALLOW FOR EXTERNAL CACHE
    else {
-      auto p = reinterpret_cast<const T* > (static_cast<EventContainers::InternalOffline*>(m_link.get())->FindIndexPtr(hashId));//collToRetrieve can be null on success
+      auto p = reinterpret_cast<const T* > (m_link->findIndexPtr(hashId));//collToRetrieve can be null on success
       collToRetrieve = const_cast<T*>(p);
       return StatusCode::SUCCESS;
    }
diff --git a/Event/EventContainers/EventContainers/InternalOffline.h b/Event/EventContainers/EventContainers/InternalOffline.h
index 1bb03226ce26db3f4bb857ba2683b01c3ef084ce..ad24332d624588b5ba4f2b7d856278bcb142b27d 100644
--- a/Event/EventContainers/EventContainers/InternalOffline.h
+++ b/Event/EventContainers/EventContainers/InternalOffline.h
@@ -22,22 +22,23 @@ public:
     virtual InternalConstItr cbegin() const override;
     virtual InternalConstItr cend() const override;
     virtual InternalConstItr indexFind( IdentifierHash hashId ) const override;
-    virtual const std::vector < hashPair >& GetAllHashPtrPair() const override;
+    virtual const std::vector < hashPair >& getAllHashPtrPair() const override;
     std::vector<std::pair<IdentifierHash::value_type, const void*>> m_map;
     size_t m_maximumSize;
     virtual bool tryAddFromCache(IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override;
     virtual bool tryAddFromCache(IdentifierHash hashId) override;
-    virtual void Wait() const override;
-    virtual std::vector<IdentifierHash> GetAllCurrentHashes() const override;
+    virtual void wait() const override;
+    virtual std::vector<IdentifierHash> getAllCurrentHashes() const override;
     virtual size_t numberOfCollections() const override;
-    void cleanUp(deleter_f* deleter) noexcept;
+    virtual void cleanUp(deleter_f* deleter) noexcept override;
     virtual size_t fullSize() const noexcept override {return m_maximumSize;}
     virtual StatusCode fetchOrCreate(IdentifierHash hashId) override;
     virtual StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashIds) override;
     virtual bool insert(IdentifierHash hashId, const void* ptr) override;
-    virtual const void* FindIndexPtr(IdentifierHash hashId) const noexcept override;
+    virtual const void* findIndexPtr(IdentifierHash hashId) const noexcept override;
     virtual StatusCode addLock(IdentifierHash hashId, const void* ptr) override;
     virtual void* removeCollection( IdentifierHash hashId ) override;
+    virtual void destructor(deleter_f*) noexcept override;
 
 };
 
diff --git a/Event/EventContainers/EventContainers/InternalOfflineFast.h b/Event/EventContainers/EventContainers/InternalOfflineFast.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f247efefa1f6d21b68d357544aac5f81aadf4c6
--- /dev/null
+++ b/Event/EventContainers/EventContainers/InternalOfflineFast.h
@@ -0,0 +1,44 @@
+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef EVENTCONTAINERS_INTERNALOFFLINEFAST_H
+#define EVENTCONTAINERS_INTERNALOFFLINEFAST_H
+#include "EventContainers/I_InternalIDC.h"
+
+namespace EventContainers{
+/*
+This class implements the IdentifiableContainer code for the offline case.
+This class may use excess memory for fast random access purposes
+
+Fast random access.
+*/
+class InternalOfflineFast final : public I_InternalIDC {
+public:
+    InternalOfflineFast(size_t max);
+    virtual ~InternalOfflineFast()=default;
+    virtual InternalConstItr cbegin() const override;
+    virtual InternalConstItr cend() const override;
+    virtual InternalConstItr indexFind( IdentifierHash hashId ) const override;
+    virtual const std::vector < hashPair >& getAllHashPtrPair() const override;
+    std::vector<std::pair<IdentifierHash::value_type, const void*>> m_map;
+    std::vector<const void*> m_fullMap;
+    virtual bool tryAddFromCache(IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override;
+    virtual bool tryAddFromCache(IdentifierHash hashId) override;
+    virtual void wait() const override;
+    virtual std::vector<IdentifierHash> getAllCurrentHashes() const override;
+    virtual size_t numberOfCollections() const override;
+    virtual void cleanUp(deleter_f* deleter) noexcept override;
+    virtual size_t fullSize() const noexcept override {return m_fullMap.size();}
+    virtual StatusCode fetchOrCreate(IdentifierHash hashId) override;
+    virtual StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashIds) override;
+    virtual bool insert(IdentifierHash hashId, const void* ptr) override;
+    virtual const void* findIndexPtr(IdentifierHash hashId) const noexcept override;
+    virtual StatusCode addLock(IdentifierHash hashId, const void* ptr) override;
+    virtual void* removeCollection( IdentifierHash hashId ) override;
+    virtual void destructor(deleter_f*) noexcept override;
+
+};
+
+}
+#endif
diff --git a/Event/EventContainers/EventContainers/InternalOnline.h b/Event/EventContainers/EventContainers/InternalOnline.h
index eb78185ff9c1002301b7f404f6001b671c16f17d..aa90b41816b3bac1d250e42651792e9f91043731 100644
--- a/Event/EventContainers/EventContainers/InternalOnline.h
+++ b/Event/EventContainers/EventContainers/InternalOnline.h
@@ -29,21 +29,23 @@ public:
     virtual InternalConstItr cbegin() const override;
     virtual InternalConstItr cend() const override;
     virtual InternalConstItr indexFind( IdentifierHash hashId ) const override;
-    virtual const std::vector < hashPair >& GetAllHashPtrPair() const override;
+    virtual const std::vector < hashPair >& getAllHashPtrPair() const override;
     virtual ~InternalOnline()=default;
-    virtual void Wait() const override;
+    virtual void wait() const override;
     virtual bool tryAddFromCache(IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override;
     virtual bool tryAddFromCache(IdentifierHash hashId) override;
-    virtual std::vector<IdentifierHash> GetAllCurrentHashes() const override;
+    virtual std::vector<IdentifierHash> getAllCurrentHashes() const override;
     virtual size_t numberOfCollections() const override;
-    void ResetMask();
+    void resetMask();
     virtual size_t fullSize() const noexcept override { return m_mask.size(); }
     virtual StatusCode fetchOrCreate(IdentifierHash hashId) override;
     virtual StatusCode fetchOrCreate(const std::vector<IdentifierHash> &hashIds) override;
     virtual bool insert(IdentifierHash hashId, const void* ptr) override;
-    virtual const void* FindIndexPtr(IdentifierHash hashId) const noexcept override;
+    virtual const void* findIndexPtr(IdentifierHash hashId) const noexcept override;
     virtual StatusCode addLock(IdentifierHash hashId, const void* ptr) override;
     virtual void* removeCollection( IdentifierHash hashId ) override;
+    virtual void destructor(deleter_f*) noexcept override;
+    virtual void cleanUp(deleter_f*) noexcept override;
 private:
     EventContainers::IdentifiableCacheBase *m_cacheLink;
     mutable std::vector< IdentifierHash > m_waitlist ATLAS_THREAD_SAFE;
diff --git a/Event/EventContainers/src/IdentifiableContainerBase.cxx b/Event/EventContainers/src/IdentifiableContainerBase.cxx
index b01279096f3ebe424d1067c7ba749ca964954878..3c6fdcc09acb4f510c297fd022165761455de6c5 100644
--- a/Event/EventContainers/src/IdentifiableContainerBase.cxx
+++ b/Event/EventContainers/src/IdentifiableContainerBase.cxx
@@ -7,13 +7,13 @@
 #include "CxxUtils/AthUnlikelyMacros.h"
 #include "EventContainers/InternalOnline.h"
 #include "EventContainers/InternalOffline.h"
-
+#include "EventContainers/InternalOfflineFast.h"
 
 using namespace EventContainers;
 
   IdentifiableContainerBase::IdentifiableContainerBase(EventContainers::IdentifiableCacheBase *cache)
   {
-  	m_link = std::make_unique<EventContainers::InternalOnline>(cache);
+    m_link = std::make_unique<EventContainers::InternalOnline>(cache);
     m_OnlineMode = true;
   }
 
@@ -22,7 +22,17 @@ using namespace EventContainers;
     m_link = std::make_unique<EventContainers::InternalOffline>(max);
   }
 
+
+  IdentifiableContainerBase::IdentifiableContainerBase(size_t max, Mode mode){
+    m_OnlineMode = false;
+    if(mode == Mode::OfflineLowMemory) m_link = std::make_unique<EventContainers::InternalOffline>(max);
+    else if(mode == Mode::OfflineFast) m_link = std::make_unique<EventContainers::InternalOfflineFast>(max);
+    else{
+      throw std::runtime_error("Invalid Mode specified");
+    }
+  }
+
   void  IdentifiableContainerBase::cleanup(deleter_f* deleter){
     if(m_OnlineMode) throw std::runtime_error("Not implemented in online mode");
-    static_cast<EventContainers::InternalOffline*>(m_link.get())->cleanUp(deleter);
+    m_link->cleanUp(deleter);
   }
diff --git a/Event/EventContainers/src/InternalOffline.cxx b/Event/EventContainers/src/InternalOffline.cxx
index 2eb5bb12e35e0cd7bb7abd0296e01d6c2376eac2..000b7629a7f90d8e393ecf1ab14d6558796e42dd 100644
--- a/Event/EventContainers/src/InternalOffline.cxx
+++ b/Event/EventContainers/src/InternalOffline.cxx
@@ -20,11 +20,11 @@ bool InternalOffline::tryAddFromCache(IdentifierHash hash)
     return indexFind(hash) != m_map.cend();//No Cache in offline mode
 }
 
-void InternalOffline::Wait() const {
+void InternalOffline::wait() const {
     //No need to wait in offline, deliberately empty method
 }
 
-std::vector<IdentifierHash> InternalOffline::GetAllCurrentHashes() const {
+std::vector<IdentifierHash> InternalOffline::getAllCurrentHashes() const {
     std::vector<IdentifierHash> ids;
     ids.reserve(m_map.size());
     for(auto &x : m_map) {
@@ -38,7 +38,7 @@ InternalConstItr
     return m_map.cend();
 }
 
-const std::vector < I_InternalIDC::hashPair >& InternalOffline::GetAllHashPtrPair() const{ return m_map; }
+const std::vector < I_InternalIDC::hashPair >& InternalOffline::getAllHashPtrPair() const{ return m_map; }
 
 InternalConstItr
  InternalOffline::cbegin() const {
@@ -75,7 +75,7 @@ bool InternalOffline::insert(IdentifierHash hashId, const void* ptr) {
     return false;
 }
 
-const void* InternalOffline::FindIndexPtr(IdentifierHash hashId) const noexcept{
+const void* InternalOffline::findIndexPtr(IdentifierHash hashId) const noexcept{
     auto itr = indexFind(hashId);
     if(itr != m_map.end()) return itr->second;
     return nullptr;
@@ -108,3 +108,6 @@ StatusCode InternalOffline::fetchOrCreate(const std::vector<IdentifierHash>&)
     throw std::runtime_error("Not implemented in offline mode");
 }
 
+void InternalOffline::destructor(deleter_f* deleter) noexcept {
+    for(const auto& x : m_map)  deleter(x.second);
+}
diff --git a/Event/EventContainers/src/InternalOfflineFast.cxx b/Event/EventContainers/src/InternalOfflineFast.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..3cdb1a163277239e51df10e98a9dbd6b02f93755
--- /dev/null
+++ b/Event/EventContainers/src/InternalOfflineFast.cxx
@@ -0,0 +1,117 @@
+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "EventContainers/InternalOfflineFast.h"
+#include <algorithm>
+#include "EventContainers/IDC_WriteHandleBase.h"
+
+using namespace EventContainers;
+typedef I_InternalIDC::InternalConstItr InternalConstItr;
+InternalOfflineFast::InternalOfflineFast(size_t max) : m_fullMap(max, nullptr) {}
+
+
+bool InternalOfflineFast::tryAddFromCache(IdentifierHash hash, EventContainers::IDC_WriteHandleBase&) {
+    return m_fullMap[hash] != nullptr;
+}
+
+bool InternalOfflineFast::tryAddFromCache(IdentifierHash hash)
+{
+    return m_fullMap[hash] != nullptr;
+}
+
+void InternalOfflineFast::wait() const {
+
+}
+
+std::vector<IdentifierHash> InternalOfflineFast::getAllCurrentHashes() const {
+    std::vector<IdentifierHash> ids;
+    ids.reserve(m_map.size());
+    for(auto &x : m_map) {
+        ids.emplace_back(x.first);
+    }
+    return ids;
+}
+
+InternalConstItr
+ InternalOfflineFast::cend() const {
+    return m_map.cend();
+}
+
+const std::vector < I_InternalIDC::hashPair >& InternalOfflineFast::getAllHashPtrPair() const{ return m_map; }
+
+InternalConstItr
+ InternalOfflineFast::cbegin() const {
+    return m_map.cbegin();
+}
+
+InternalConstItr InternalOfflineFast::indexFind( IdentifierHash hashId ) const{
+   auto itr = std::lower_bound( m_map.cbegin(), m_map.cend(), hashId.value(), [](const hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
+   if(itr!= m_map.cend() && itr->first==hashId) return itr;
+   return m_map.cend();
+//  return std::find_if(m_map.begin(), m_map.end(), [hashId](const hashPair &lhs) -> bool { return lhs.first == hashId; });
+}
+
+size_t InternalOfflineFast::numberOfCollections() const {
+    return m_map.size();
+}
+
+void InternalOfflineFast::cleanUp(deleter_f* deleter) noexcept {
+    for(const auto& x : m_map) { deleter(x.second); m_fullMap[x.first] = nullptr; }
+    m_map.clear();
+}
+
+bool InternalOfflineFast::insert(IdentifierHash hashId, const void* ptr) {
+    if(hashId >= m_fullMap.size()) return false;
+    if(m_fullMap[hashId]!= nullptr) return false; //already in
+    if(m_map.empty() || m_map.back().first < hashId){
+        m_map.emplace_back(hashId, ptr);
+        m_fullMap[hashId] = ptr;
+        return true;
+    }
+    auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](const hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
+    if(itr == std::end(m_map) || itr->first != hashId)
+    {
+        m_map.emplace(itr, hashId, ptr);
+        m_fullMap[hashId] = ptr;
+        return true;
+    }
+    return false;
+}
+
+const void* InternalOfflineFast::findIndexPtr(IdentifierHash hashId) const noexcept{
+    if(hashId >= m_fullMap.size()) return nullptr;
+    return m_fullMap[hashId];
+}
+
+StatusCode InternalOfflineFast::addLock(IdentifierHash hashId, const void* ptr) {
+    bool added = insert(hashId, ptr);
+    if(!added) {
+#ifndef NDEBUG
+        std::cout << "IDC WARNING Deletion shouldn't occur in addLock paradigm" << std::endl;
+#endif
+        return StatusCode::FAILURE;
+    }
+    return StatusCode::SUCCESS;
+}
+
+void* InternalOfflineFast::removeCollection( IdentifierHash hashId ) {
+   auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
+   if(itr== m_map.end() || itr->first!=hashId) return nullptr;
+   void* ptr = const_cast< void* > (itr->second);
+   m_map.erase(itr);
+   m_fullMap[hashId] = nullptr;
+   return ptr;
+}
+
+StatusCode InternalOfflineFast::fetchOrCreate(IdentifierHash) {
+    throw std::runtime_error("Not implemented in offline mode");
+}
+StatusCode InternalOfflineFast::fetchOrCreate(const std::vector<IdentifierHash>&)
+{
+    throw std::runtime_error("Not implemented in offline mode");
+}
+
+void InternalOfflineFast::destructor(deleter_f* deleter) noexcept {
+    for(const auto& x : m_map)  deleter(x.second);
+}
diff --git a/Event/EventContainers/src/InternalOnline.cxx b/Event/EventContainers/src/InternalOnline.cxx
index 7c721d1f003219f67347f7306ef304f88991ee19..9c175b30c0d5bee499af8f69bbd416c57d14beec 100644
--- a/Event/EventContainers/src/InternalOnline.cxx
+++ b/Event/EventContainers/src/InternalOnline.cxx
@@ -16,32 +16,32 @@ typedef I_InternalIDC::InternalConstItr InternalConstItr;
 InternalOnline::InternalOnline(EventContainers::IdentifiableCacheBase *cache) : m_cacheLink(cache),
     m_mask(cache->fullSize(), false), m_waitNeeded(false) {}
 
-const std::vector < I_InternalIDC::hashPair >& InternalOnline::GetAllHashPtrPair() const{
-  if(m_waitNeeded) Wait();
+const std::vector < I_InternalIDC::hashPair >& InternalOnline::getAllHashPtrPair() const{
+  if(m_waitNeeded) wait();
   return m_map; 
 }
 
 
 InternalConstItr
  InternalOnline::cend() const {
-    if(m_waitNeeded) Wait();
+    if(m_waitNeeded) wait();
     return m_map.cend();
 }
 
 InternalConstItr
  InternalOnline::cbegin() const {
-    if(m_waitNeeded) Wait();
+    if(m_waitNeeded) wait();
     return m_map.cbegin();
 }
 
 InternalConstItr InternalOnline::indexFind( IdentifierHash hashId ) const{
-  if(m_waitNeeded) Wait();
+  if(m_waitNeeded) wait();
    auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
    if(itr!= m_map.end() && itr->first==hashId) return itr;
    return m_map.end();
 }
 
-void InternalOnline::Wait() const {
+void InternalOnline::wait() const {
     //lockguard to protect m_waitlist from multiple wait calls
     std::lock_guard lock (m_waitMutex);
     if(m_waitNeeded == false) return;
@@ -87,8 +87,8 @@ bool InternalOnline::tryAddFromCache(IdentifierHash hashId)
     return true;
 }
 
-std::vector<IdentifierHash> InternalOnline::GetAllCurrentHashes() const {
-    if(m_waitNeeded) Wait();
+std::vector<IdentifierHash> InternalOnline::getAllCurrentHashes() const {
+    if(m_waitNeeded) wait();
     std::vector<IdentifierHash> ids;
     ids.reserve(m_map.size());
     for(auto &x : m_map) {
@@ -98,12 +98,12 @@ std::vector<IdentifierHash> InternalOnline::GetAllCurrentHashes() const {
 }
 
 size_t InternalOnline::numberOfCollections() const {
-    if(m_waitNeeded) Wait();
+    if(m_waitNeeded) wait();
     return m_map.size();
 }
 
-void InternalOnline::ResetMask() {
-    if(m_waitNeeded) Wait();
+void InternalOnline::resetMask() {
+    if(m_waitNeeded) wait();
     m_mask.assign(m_cacheLink->fullSize(), false);
     m_map.clear();
     m_waitNeeded.store(true, std::memory_order_relaxed);
@@ -131,7 +131,7 @@ bool InternalOnline::insert(IdentifierHash hashId, const void* ptr) {
     return ptr == cacheinserted.second;
 }
 
-const void* InternalOnline::FindIndexPtr(IdentifierHash hashId) const noexcept {
+const void* InternalOnline::findIndexPtr(IdentifierHash hashId) const noexcept {
     if(hashId < m_mask.size() and m_mask[hashId]) return m_cacheLink->findWait(hashId);
     return nullptr;
 }
@@ -152,3 +152,11 @@ StatusCode InternalOnline::addLock(IdentifierHash hashId, const void* ptr) {
 void* InternalOnline::removeCollection( IdentifierHash  ) {
     throw std::runtime_error("Do not remove things from an online IDC");
 }
+
+void InternalOnline::destructor(deleter_f*) noexcept {
+    //deliberately empty
+}
+
+void InternalOnline::cleanUp(deleter_f*) noexcept {
+    resetMask();
+}
diff --git a/Event/EventContainers/test/IDC_Benchmark.cxx b/Event/EventContainers/test/IDC_Benchmark.cxx
index 5c577317ff2d1dcdba9c1f515920a91fe5696c00..806359c8259fbabb24ea18976b73632dc5de99df 100644
--- a/Event/EventContainers/test/IDC_Benchmark.cxx
+++ b/Event/EventContainers/test/IDC_Benchmark.cxx
@@ -61,11 +61,22 @@ int main(){
    auto end2 = std::chrono::steady_clock::now();
    std::chrono::duration<double> onlinefill = end2-start2;
    std::cout << "online fill time " << onlinefill.count() << std::endl;
+
+   auto start3 = std::chrono::steady_clock::now();
+   auto offlinefast = new IdentifiableContainerMT<long unsigned int>(50000, EventContainers::Mode::OfflineFast);
+   for(size_t i =3;i<50000;i+=3){
+      offlinefast->addCollection(new long unsigned int(i) ,i).ignore();
+   }
+   auto end3 = std::chrono::steady_clock::now();
+   std::chrono::duration<double> offlinefillfast = end3-start3;
+   std::cout << "offlinefast fill time " << offlinefillfast.count() << std::endl;
    accessTime("online ", *online);
    accessTime("offline ", *offline);
+   accessTime("offlinefast ", *offlinefast);
    timedelete("onlineCont ", online);
    timedelete("onlineCache ", cache);
    timedelete("offline ", offline);
+   timedelete("offlinefast ", offlinefast);
    std::cout << "Test Successful" << std::endl;
    return 0;
 }
diff --git a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProvider.cxx b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProvider.cxx
index ebe8e1dc15c0a78bde98ada29d714fc9abb372de..799c13013d55e87df77a3f8901e75ce55b846c69 100644
--- a/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProvider.cxx
+++ b/InnerDetector/InDetEventCnv/SCT_RawDataByteStreamCnv/src/SCTRawDataProvider.cxx
@@ -64,7 +64,7 @@ StatusCode SCTRawDataProvider::execute(const EventContext& ctx) const
   SG::WriteHandle<SCT_RDO_Container> rdoContainer(m_rdoContainerKey, ctx);
   bool externalCacheRDO = !m_rdoContainerCacheKey.key().empty();
   if (not externalCacheRDO) {
-    ATH_CHECK(rdoContainer.record (std::make_unique<SCT_RDO_Container>(m_sctID->wafer_hash_max())));
+    ATH_CHECK(rdoContainer.record (std::make_unique<SCT_RDO_Container>(m_sctID->wafer_hash_max(), EventContainers::Mode::OfflineFast)));
     ATH_MSG_DEBUG("Created container for " << m_sctID->wafer_hash_max());
   }
   else {
diff --git a/InnerDetector/InDetEventCnv/TRT_RawDataByteStreamCnv/src/TRTRawDataProvider.cxx b/InnerDetector/InDetEventCnv/TRT_RawDataByteStreamCnv/src/TRTRawDataProvider.cxx
index b0b934bbf7750f1daf96ece1f4b87c006005501c..e246c6d68548de8afe8cf0375c9129351b3d02a3 100644
--- a/InnerDetector/InDetEventCnv/TRT_RawDataByteStreamCnv/src/TRTRawDataProvider.cxx
+++ b/InnerDetector/InDetEventCnv/TRT_RawDataByteStreamCnv/src/TRTRawDataProvider.cxx
@@ -95,7 +95,7 @@ StatusCode TRTRawDataProvider::initialize() {
 StatusCode TRTRawDataProvider::execute() 
 {
   SG::WriteHandle<TRT_RDO_Container> rdoContainer(m_rdoContainerKey);
-  rdoContainer = std::make_unique<TRT_RDO_Container>(m_trt_id->straw_hash_max()); 
+  rdoContainer = std::make_unique<TRT_RDO_Container>(m_trt_id->straw_hash_max(), EventContainers::Mode::OfflineFast); 
   ATH_CHECK(rdoContainer.isValid());
 
   
diff --git a/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.h b/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.h
index 06679175767d9d12f912010a444c8906f85a0729..4b0952141628d549297a7a664bfa4e85a4565811 100755
--- a/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.h
+++ b/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.h
@@ -34,6 +34,8 @@ public:
   // Constructor with parameters:
   InDetRawDataContainer(unsigned int max);
 
+  InDetRawDataContainer(unsigned int max, EventContainers::Mode);
+
   InDetRawDataContainer(EventContainers::IdentifiableCache<CollectionT>*);
   
   // Destructor:
diff --git a/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.icc b/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.icc
index e0acbeb4e1418ce9afe502b93a1a93e56ca7eb09..359344e42c96056974c4a4d589cebcdae34312cc 100755
--- a/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.icc
+++ b/InnerDetector/InDetRawEvent/InDetRawData/InDetRawData/InDetRawDataContainer.icc
@@ -20,6 +20,13 @@ InDetRawDataContainer< CollectionT>::InDetRawDataContainer(unsigned int max) :
 {
 }
 
+template< class CollectionT>
+// Constructor with parameters:
+InDetRawDataContainer< CollectionT>::InDetRawDataContainer(unsigned int max, EventContainers::Mode mode) :
+  IdentifiableContainer<CollectionT>(max, mode)
+{
+}
+
 template< class CollectionT>
 InDetRawDataContainer< CollectionT>::InDetRawDataContainer(EventContainers::IdentifiableCache<CollectionT> *cache) :
   IdentifiableContainer<CollectionT>(cache)
diff --git a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigPixRawDataProvider.cxx b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigPixRawDataProvider.cxx
index 09e026709559a19b013b16165a1c217fe351dee1..f7e531d826b57bd3205d4f387268d6a919aaf261 100644
--- a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigPixRawDataProvider.cxx
+++ b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigPixRawDataProvider.cxx
@@ -77,7 +77,7 @@ namespace InDet {
     } 
 
     //RDO container
-    m_container = new PixelRDO_Container(m_id->wafer_hash_max()); 
+    m_container = new PixelRDO_Container(m_id->wafer_hash_max(), EventContainers::Mode::OfflineFast); 
     m_container ->addRef();       // make sure it is never deleted
 
 
diff --git a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigSCTRawDataProvider.cxx b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigSCTRawDataProvider.cxx
index f700a0d7d786c2588a790b92a3d5f104e706e84b..e919472bbc15b9f29dc755099f5ced1cca4b79a1 100644
--- a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigSCTRawDataProvider.cxx
+++ b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigSCTRawDataProvider.cxx
@@ -81,7 +81,7 @@ namespace InDet {
       msg(MSG::INFO) << "Retrieved tool " << m_cablingTool << endmsg;
 
     //RDO Container
-    m_container = new SCT_RDO_Container(m_id->wafer_hash_max()); 
+    m_container = new SCT_RDO_Container(m_id->wafer_hash_max(), EventContainers::Mode::OfflineFast); 
     m_container ->addRef();   // make sure it is never deleted
     
     IIncidentSvc* pIncsvc;
diff --git a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigTRTRawDataProvider.cxx b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigTRTRawDataProvider.cxx
index 04ac7e97435c1bbbbf5f0e54b991f983afa723c3..151170bccb0e1ad040b4c1e85ec02e4213e8474c 100644
--- a/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigTRTRawDataProvider.cxx
+++ b/InnerDetector/InDetTrigRecAlgs/InDetTrigRawDataProvider/src/TrigTRTRawDataProvider.cxx
@@ -80,7 +80,7 @@ namespace InDet {
     } else 
       msg(MSG::INFO) << "Retrieved service " << m_IdMapping << endmsg;
 
-    m_container = new TRT_RDO_Container(m_id->straw_layer_hash_max()); 
+    m_container = new TRT_RDO_Container(m_id->straw_layer_hash_max(), EventContainers::Mode::OfflineFast); 
     m_container ->addRef();     // make sure it is never deleted
 
     return StatusCode::SUCCESS;