diff --git a/CUDADataFormats/HcalCommon/BuildFile.xml b/CUDADataFormats/CaloCommon/BuildFile.xml
similarity index 100%
rename from CUDADataFormats/HcalCommon/BuildFile.xml
rename to CUDADataFormats/CaloCommon/BuildFile.xml
diff --git a/CUDADataFormats/HcalCommon/interface/Common.h b/CUDADataFormats/CaloCommon/interface/Common.h
similarity index 55%
rename from CUDADataFormats/HcalCommon/interface/Common.h
rename to CUDADataFormats/CaloCommon/interface/Common.h
index 1a2592889a6c7..ca5ce8ed734bb 100644
--- a/CUDADataFormats/HcalCommon/interface/Common.h
+++ b/CUDADataFormats/CaloCommon/interface/Common.h
@@ -1,11 +1,12 @@
-#ifndef CUDADataFormats_HcalCommon_interface_Common_h
-#define CUDADataFormats_HcalCommon_interface_Common_h
+#ifndef CUDADataFormats_CaloCommon_interface_Common_h
+#define CUDADataFormats_CaloCommon_interface_Common_h
 
 #include <vector>
 
 #include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
 
-namespace hcal {
+namespace calo {
   namespace common {
 
     // FIXME: not able to get enums to work with genreflex
@@ -13,6 +14,7 @@ namespace hcal {
 
       struct Vec {};
       struct Ptr {};
+      struct DevPtr {};
 
     }  // namespace tags
 
@@ -24,6 +26,11 @@ namespace hcal {
       uint32_t size;
     };
 
+    template<>
+    struct AddSize<tags::DevPtr> {
+        uint32_t size;
+    };
+
     struct ViewStoragePolicy {
       using TagType = tags::Ptr;
 
@@ -33,6 +40,15 @@ namespace hcal {
       };
     };
 
+    struct DevStoragePolicy {
+      using TagType = tags::DevPtr;
+
+      template<typename T>
+      struct StorageSelector {
+          using type = cms::cuda::device::unique_ptr<T[]>;
+      };
+    };
+
     template <template <typename> typename Allocator = std::allocator>
     struct VecStoragePolicy {
       using TagType = tags::Vec;
@@ -42,16 +58,11 @@ namespace hcal {
         using type = std::vector<T, Allocator<T>>;
       };
     };
+  
+    template <typename T>
+    using CUDAHostAllocatorAlias = cms::cuda::HostAllocator<T>;
 
   }  // namespace common
-}  // namespace hcal
-
-// FIXME: move into common namespace
-namespace hcal {
-
-  template <typename T>
-  using CUDAHostAllocatorAlias = cms::cuda::HostAllocator<T>;
-
-}
+}  // namespace calo
 
-#endif  // CUDADataFormats_HcalCommon_interface_Common_h
+#endif  // CUDADataFormats_CaloCommon_interface_Common_h
diff --git a/CUDADataFormats/CaloCommon/src/classes.h b/CUDADataFormats/CaloCommon/src/classes.h
new file mode 100644
index 0000000000000..8eff4378875a9
--- /dev/null
+++ b/CUDADataFormats/CaloCommon/src/classes.h
@@ -0,0 +1,2 @@
+#include "DataFormats/Common/interface/Wrapper.h"
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
diff --git a/CUDADataFormats/CaloCommon/src/classes_def.xml b/CUDADataFormats/CaloCommon/src/classes_def.xml
new file mode 100644
index 0000000000000..6ac0b60762027
--- /dev/null
+++ b/CUDADataFormats/CaloCommon/src/classes_def.xml
@@ -0,0 +1,8 @@
+<lcgdict>
+    <enum name="calo::common::tags::Ptr"/>
+    <enum name="calo::common::tags::Vec"/>
+    <enum name="calo::common::tags::DevPtr"/>
+    <class name="calo::common::AddSize<calo::common::tags::Ptr>"/>
+    <class name="calo::common::AddSize<calo::common::tags::Vec>"/>
+    <class name="calo::common::AddSize<calo::common::tags::DevPtr>"/>
+</lcgdict>
diff --git a/CUDADataFormats/EcalDigi/BuildFile.xml b/CUDADataFormats/EcalDigi/BuildFile.xml
index 4a5c646e3a1b3..b7d25b0872646 100644
--- a/CUDADataFormats/EcalDigi/BuildFile.xml
+++ b/CUDADataFormats/EcalDigi/BuildFile.xml
@@ -1,4 +1,5 @@
 <use name="CUDADataFormats/Common"/>
+<use name="CUDADataFormats/CaloCommon"/>
 <use name="DataFormats/Common"/>
 <use name="HeterogeneousCore/CUDAUtilities"/>
 
diff --git a/CUDADataFormats/EcalDigi/interface/DigisCollection.h b/CUDADataFormats/EcalDigi/interface/DigisCollection.h
index 865a456cb06e4..89ea561bfcaaa 100644
--- a/CUDADataFormats/EcalDigi/interface/DigisCollection.h
+++ b/CUDADataFormats/EcalDigi/interface/DigisCollection.h
@@ -1,15 +1,13 @@
 #ifndef CUDADataFormats_EcalDigi_interface_DigisCollection_h
 #define CUDADataFormats_EcalDigi_interface_DigisCollection_h
 
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+
 namespace ecal {
 
-  //
-  // this is basically a view
-  // it does not own the actual memory -> does not reclaim
-  //
-  struct DigisCollection {
+  template<typename StoragePolicy>
+  struct DigisCollection : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
     DigisCollection() = default;
-    DigisCollection(uint32_t *ids, uint16_t *data, uint32_t ndigis) : ids{ids}, data{data}, ndigis{ndigis} {}
     DigisCollection(DigisCollection const &) = default;
     DigisCollection &operator=(DigisCollection const &) = default;
 
@@ -17,9 +15,8 @@ namespace ecal {
     DigisCollection &operator=(DigisCollection &&) = default;
 
     // stride is statically known
-    uint32_t *ids = nullptr;
-    uint16_t *data = nullptr;
-    uint32_t ndigis;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type ids;
+    typename StoragePolicy::template StorageSelector<uint16_t>::type data;
   };
 
 }  // namespace ecal
diff --git a/CUDADataFormats/EcalDigi/src/classes_def.xml b/CUDADataFormats/EcalDigi/src/classes_def.xml
index 07beed46d89d0..6a3adfe4b41c5 100644
--- a/CUDADataFormats/EcalDigi/src/classes_def.xml
+++ b/CUDADataFormats/EcalDigi/src/classes_def.xml
@@ -1,4 +1,6 @@
 <lcgdict>
-    <class name="cms::cuda::Product<ecal::DigisCollection>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<ecal::DigisCollection>>" persistent="false"/>
+    <class name="cms::cuda::Product<ecal::DigisCollection<calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::DigisCollection<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>>" persistent="false"/>
 </lcgdict>
diff --git a/CUDADataFormats/EcalRecHitSoA/BuildFile.xml b/CUDADataFormats/EcalRecHitSoA/BuildFile.xml
index de31c3f42a961..a684d9a23f1c6 100644
--- a/CUDADataFormats/EcalRecHitSoA/BuildFile.xml
+++ b/CUDADataFormats/EcalRecHitSoA/BuildFile.xml
@@ -1,5 +1,6 @@
 <use name="cuda"/>
 <use name="CUDADataFormats/Common"/>
+<use name="CUDADataFormats/CaloCommon"/>
 <use name="DataFormats/Common"/>
 <use name="DataFormats/EcalDigi"/>
 <use name="HeterogeneousCore/CUDAUtilities"/>
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h
new file mode 100644
index 0000000000000..710505ef0e4cd
--- /dev/null
+++ b/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h
@@ -0,0 +1,45 @@
+#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_soa_h
+#define CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_soa_h
+
+#include <vector>
+#include <array>
+
+#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+
+namespace ecal {
+
+  template <typename StoragePolicy>
+  struct RecHit : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    RecHit() = default;
+    RecHit(const RecHit&) = default;
+    RecHit& operator=(const RecHit&) = default;
+
+    RecHit(RecHit&&) = default;
+    RecHit& operator=(RecHit&&) = default;
+
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type energy;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type time;
+    // should we remove the following, since already included in "extra" ?
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type chi2;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type extra;     // packed uint32_t for timeError, chi2, energyError
+    typename StoragePolicy::template StorageSelector<uint32_t>::type flagBits;  // store rechit condition (see Flags enum) in a bit-wise way
+
+    typename StoragePolicy::template StorageSelector<uint32_t>::type did;
+
+    template <typename U = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<U, ::calo::common::tags::Vec>::value, void>::type resize(size_t size) {
+      energy.resize(size);
+      time.resize(size);
+      chi2.resize(size);
+      extra.resize(size);
+      flagBits.resize(size);
+      did.resize(size);
+    }
+  };
+
+}  // namespace ecal
+
+#endif
+// RecoLocalCalo_EcalRecAlgos_interface_EcalRecHit_soa_h
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h
deleted file mode 100644
index d4a8d027767f4..0000000000000
--- a/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_soa_h
-#define CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_soa_h
-
-#include <vector>
-#include <array>
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-
-// needed for "soa" definition
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
-
-namespace ecal {
-
-  template <typename L = Tag::soa>
-  struct RecHit : public Detail::Base<L> {
-    RecHit() = default;
-    RecHit(const RecHit&) = default;
-    RecHit& operator=(const RecHit&) = default;
-
-    RecHit(RecHit&&) = default;
-    RecHit& operator=(RecHit&&) = default;
-
-    typename type_wrapper<reco::StorageScalarType, L>::type energy;
-    typename type_wrapper<reco::StorageScalarType, L>::type time;
-    // should we remove the following, since already included in "extra" ?
-    typename type_wrapper<reco::StorageScalarType, L>::type chi2;
-    typename type_wrapper<uint32_t, L>::type extra;     // packed uint32_t for timeError, chi2, energyError
-    typename type_wrapper<uint32_t, L>::type flagBits;  // store rechit condition (see Flags enum) in a bit-wise way
-
-    typename type_wrapper<uint32_t, L>::type did;
-
-    template <typename U = L>
-    typename std::enable_if<std::is_same<U, Tag::soa>::value, void>::type resize(size_t size) {
-      energy.resize(size);
-      time.resize(size);
-      chi2.resize(size);
-      extra.resize(size);
-      flagBits.resize(size);
-      did.resize(size);
-    }
-  };
-
-  using SoARecHitCollection = RecHit<Tag::soa>;
-
-}  // namespace ecal
-
-#endif
-// RecoLocalCalo_EcalRecAlgos_interface_EcalRecHit_soa_h
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h
new file mode 100644
index 0000000000000..c98d2e112fd50
--- /dev/null
+++ b/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h
@@ -0,0 +1,47 @@
+#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
+#define CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
+
+#include <vector>
+#include <array>
+
+#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
+
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
+
+namespace ecal {
+
+  template <typename StoragePolicy>
+  struct UncalibratedRecHit : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    UncalibratedRecHit() = default;
+    UncalibratedRecHit(const UncalibratedRecHit&) = default;
+    UncalibratedRecHit& operator=(const UncalibratedRecHit&) = default;
+
+    UncalibratedRecHit(UncalibratedRecHit&&) = default;
+    UncalibratedRecHit& operator=(UncalibratedRecHit&&) = default;
+
+    typename StoragePolicy::template StorageSelector<reco::ComputationScalarType>::type amplitudesAll;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type amplitude;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type chi2;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type pedestal;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type jitter;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type jitterError;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type did;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type flags;
+
+    template <typename U = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<U, ::calo::common::tags::Vec>::value, void>::type resize(size_t size) {
+      amplitudesAll.resize(size * EcalDataFrame::MAXSAMPLES);
+      amplitude.resize(size);
+      pedestal.resize(size);
+      chi2.resize(size);
+      did.resize(size);
+      flags.resize(size);
+      jitter.resize(size);
+      jitterError.resize(size);
+    }
+  };
+
+}  // namespace ecal
+
+#endif  // RecoLocalCalo_EcalRecAlgos_interface_EcalUncalibratedRecHit_h
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h
deleted file mode 100644
index acaa6545180ba..0000000000000
--- a/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h
+++ /dev/null
@@ -1,83 +0,0 @@
-#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_soa_h
-#define CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_soa_h
-
-#include <vector>
-#include <array>
-
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-
-namespace ecal {
-
-  namespace Tag {
-
-    struct soa {};
-    struct ptr {};
-
-  }  // namespace Tag
-
-  namespace Detail {
-
-    // empty base
-    template <typename T>
-    struct Base {};
-
-    // add number of values for ptr case
-    template <>
-    struct Base<::ecal::Tag::ptr> {
-      uint32_t size;
-    };
-
-  }  // namespace Detail
-
-  template <typename T, typename L = Tag::soa>
-  struct type_wrapper {
-    using type = std::vector<T, cms::cuda::HostAllocator<T>>;
-  };
-
-  template <typename T>
-  struct type_wrapper<T, Tag::ptr> {
-    using type = T*;
-  };
-
-  template <typename L = Tag::soa>
-  struct UncalibratedRecHit : public Detail::Base<L> {
-    UncalibratedRecHit() = default;
-    UncalibratedRecHit(const UncalibratedRecHit&) = default;
-    UncalibratedRecHit& operator=(const UncalibratedRecHit&) = default;
-
-    UncalibratedRecHit(UncalibratedRecHit&&) = default;
-    UncalibratedRecHit& operator=(UncalibratedRecHit&&) = default;
-
-    // TODO: std::array causes root's dictionary problems
-    typename type_wrapper<reco::ComputationScalarType, L>::type amplitudesAll;
-    //    typename type_wrapper<std::array<reco::ComputationScalarType,
-    //        EcalDataFrame::MAXSAMPLES>, L>::type amplitudesAll;
-    typename type_wrapper<reco::StorageScalarType, L>::type amplitude;
-    typename type_wrapper<reco::StorageScalarType, L>::type chi2;
-    typename type_wrapper<reco::StorageScalarType, L>::type pedestal;
-    typename type_wrapper<reco::StorageScalarType, L>::type jitter;
-    typename type_wrapper<reco::StorageScalarType, L>::type jitterError;
-    typename type_wrapper<uint32_t, L>::type did;
-    typename type_wrapper<uint32_t, L>::type flags;
-
-    template <typename U = L>
-    typename std::enable_if<std::is_same<U, Tag::soa>::value, void>::type resize(size_t size) {
-      amplitudesAll.resize(size * EcalDataFrame::MAXSAMPLES);
-      amplitude.resize(size);
-      pedestal.resize(size);
-      chi2.resize(size);
-      did.resize(size);
-      flags.resize(size);
-      jitter.resize(size);
-      jitterError.resize(size);
-    }
-  };
-
-  using SoAUncalibratedRecHitCollection = UncalibratedRecHit<Tag::soa>;
-
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecAlgos_interface_EcalUncalibratedRecHit_soa_h
diff --git a/CUDADataFormats/EcalRecHitSoA/src/classes.h b/CUDADataFormats/EcalRecHitSoA/src/classes.h
index 5c03667c7c43b..e7841e555a662 100644
--- a/CUDADataFormats/EcalRecHitSoA/src/classes.h
+++ b/CUDADataFormats/EcalRecHitSoA/src/classes.h
@@ -1,4 +1,4 @@
 #include "DataFormats/Common/interface/Wrapper.h"
 #include "CUDADataFormats/Common/interface/Product.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
\ No newline at end of file
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
diff --git a/CUDADataFormats/EcalRecHitSoA/src/classes_def.xml b/CUDADataFormats/EcalRecHitSoA/src/classes_def.xml
index e50282bc643df..3d68d98c5cc8c 100644
--- a/CUDADataFormats/EcalRecHitSoA/src/classes_def.xml
+++ b/CUDADataFormats/EcalRecHitSoA/src/classes_def.xml
@@ -1,14 +1,20 @@
 <lcgdict>
-    <class name="ecal::Tag::soa"/>
-    <class name="ecal::Detail::Base<ecal::Tag::soa>"/>
-
-    <class name="cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>" persistent="false"/>
-    <class name="edm::Wrapper<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>" persistent="false"/>
-    <class name="cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>" persistent="false"/>
-    <class name="edm::Wrapper<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>>" persistent="false"/>
-
-    <class name="ecal::RecHit<ecal::Tag::soa>"/>
-    <class name="edm::Wrapper<ecal::RecHit<ecal::Tag::soa>>"/>
-    <class name="ecal::UncalibratedRecHit<ecal::Tag::soa>"/>
-    <class name="edm::Wrapper<ecal::UncalibratedRecHit<ecal::Tag::soa>>"/>
+    <class name="cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::ViewStoragePolicy>>" persistent="false"/>
+    <class name="cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>>" persistent="false"/>
+                
+    <class name="cms::cuda::Product<ecal::RecHit<calo::common::ViewStoragePolicy>>" persistent="false"/>
+    <class name="cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::RecHit<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>>" persistent="false"/>
+        
+    <class name="ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>"/>
+    <class name="edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>"/>
+    <class name="ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>"/>
+    <class name="edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>"/>
+    <class name="ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<std::allocator>>"/>
+    <class name="edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<std::allocator>>>"/>
+    <class name="ecal::RecHit<calo::common::VecStoragePolicy<std::allocator>>"/>
+    <class name="edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<std::allocator>>>"/>
 </lcgdict>
diff --git a/CUDADataFormats/HcalCommon/src/classes.h b/CUDADataFormats/HcalCommon/src/classes.h
deleted file mode 100644
index d039fb95e1d03..0000000000000
--- a/CUDADataFormats/HcalCommon/src/classes.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "DataFormats/Common/interface/Wrapper.h"
-#include "CUDADataFormats/HcalCommon/interface/Common.h"
diff --git a/CUDADataFormats/HcalCommon/src/classes_def.xml b/CUDADataFormats/HcalCommon/src/classes_def.xml
deleted file mode 100644
index 173576a43950b..0000000000000
--- a/CUDADataFormats/HcalCommon/src/classes_def.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<lcgdict>
-    <enum name="hcal::common::tags::Ptr"/>
-    <enum name="hcal::common::tags::Vec"/>
-    <class name="hcal::common::AddSize<hcal::common::tags::Ptr>"/>
-    <class name="hcal::common::AddSize<hcal::common::tags::Vec>"/>
-</lcgdict>
diff --git a/CUDADataFormats/HcalDigi/BuildFile.xml b/CUDADataFormats/HcalDigi/BuildFile.xml
index 8feae467742c0..fb871f16b69f0 100644
--- a/CUDADataFormats/HcalDigi/BuildFile.xml
+++ b/CUDADataFormats/HcalDigi/BuildFile.xml
@@ -1,5 +1,5 @@
 <use name="DataFormats/Common"/>
-<use name="CUDADataFormats/HcalCommon"/>
+<use name="CUDADataFormats/CaloCommon"/>
 <use name="HeterogeneousCore/CUDAUtilities"/>
 <use name="cuda"/>
 
diff --git a/CUDADataFormats/HcalDigi/interface/DigiCollection.h b/CUDADataFormats/HcalDigi/interface/DigiCollection.h
index cbb9da410f801..f5ae63d0954c6 100644
--- a/CUDADataFormats/HcalDigi/interface/DigiCollection.h
+++ b/CUDADataFormats/HcalDigi/interface/DigiCollection.h
@@ -1,7 +1,7 @@
 #ifndef CUDADataFormats_HcalDigi_interface_DigiCollection_h
 #define CUDADataFormats_HcalDigi_interface_DigiCollection_h
 
-#include "CUDADataFormats/HcalCommon/interface/Common.h"
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
 
 namespace hcal {
 
@@ -108,7 +108,7 @@ namespace hcal {
 
   //
   template <typename StoragePolicy>
-  struct DigiCollectionBase : public common::AddSize<typename StoragePolicy::TagType> {
+  struct DigiCollectionBase : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
     DigiCollectionBase() = default;
     DigiCollectionBase(DigiCollectionBase const&) = default;
     DigiCollectionBase& operator=(DigiCollectionBase const&) = default;
@@ -117,19 +117,19 @@ namespace hcal {
     DigiCollectionBase& operator=(DigiCollectionBase&&) = default;
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type resize(std::size_t size) {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type resize(std::size_t size) {
       ids.resize(size);
       data.resize(size * stride);
     }
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type reserve(std::size_t size) {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type reserve(std::size_t size) {
       ids.reserve(size);
       data.reserve(size * stride);
     }
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type clear() {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type clear() {
       ids.clear();
       data.clear();
     }
@@ -161,19 +161,19 @@ namespace hcal {
     DigiCollection& operator=(DigiCollection&&) = default;
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type resize(std::size_t size) {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type resize(std::size_t size) {
       DigiCollectionBase<StoragePolicy>::resize(size);
       npresamples.resize(size);
     }
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type reserve(std::size_t size) {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type reserve(std::size_t size) {
       DigiCollectionBase<StoragePolicy>::reserve(size);
       npresamples.reserve(size);
     }
 
     template <typename T = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<T, common::tags::Vec>::value, void>::type clear() {
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type clear() {
       DigiCollectionBase<StoragePolicy>::clear();
       npresamples.clear();
     }
diff --git a/CUDADataFormats/HcalDigi/src/classes_def.xml b/CUDADataFormats/HcalDigi/src/classes_def.xml
index 33e9b28a49b49..3291c7f6d22ec 100644
--- a/CUDADataFormats/HcalDigi/src/classes_def.xml
+++ b/CUDADataFormats/HcalDigi/src/classes_def.xml
@@ -1,40 +1,52 @@
 <lcgdict>
-    <class name="hcal::DigiCollectionBase<hcal::common::VecStoragePolicy<std::allocator>>" />
-    <class name="hcal::DigiCollectionBase<hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollectionBase<calo::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollectionBase<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
 
-    <class name="hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<std::allocator>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor2, hcal::common::VecStoragePolicy<std::allocator>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<std::allocator>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor4, hcal::common::VecStoragePolicy<std::allocator>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor2, calo::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor4, calo::common::VecStoragePolicy<std::allocator>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<std::allocator>>" />
             
-    <class name="hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor2, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor4, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
-    <class name="hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor2, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor4, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
+    <class name="hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>" />
 
-    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>>" persistent="false" />
-    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, hcal::common::ViewStoragePolicy>>" persistent="false" />
-    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>>" persistent="false" />
-    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, hcal::common::ViewStoragePolicy>>" persistent="false" />
-    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::ViewStoragePolicy>>" persistent="false" />
             
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>>>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, hcal::common::ViewStoragePolicy>>>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>>>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, hcal::common::ViewStoragePolicy>>>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>" persistent="false" />
+            
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, calo::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, calo::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::ViewStoragePolicy>>>" persistent="false" />
+                
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor2, calo::common::DevStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor4, calo::common::DevStoragePolicy>>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>>" persistent="false" />
 
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<std::allocator>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor2, hcal::common::VecStoragePolicy<std::allocator>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<std::allocator>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor4, hcal::common::VecStoragePolicy<std::allocator>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<std::allocator>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<std::allocator>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor2, calo::common::VecStoragePolicy<std::allocator>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<std::allocator>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor4, calo::common::VecStoragePolicy<std::allocator>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<std::allocator>>>" />
                 
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor2, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor4, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>" />
-    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor2, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor4, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>" />
+    <class name="edm::Wrapper<hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>" />
 </lcgdict>
diff --git a/CUDADataFormats/HcalRecHitSoA/interface/RecHitCollection.h b/CUDADataFormats/HcalRecHitSoA/interface/RecHitCollection.h
index a17c8a51073be..424b2c0813b4c 100644
--- a/CUDADataFormats/HcalRecHitSoA/interface/RecHitCollection.h
+++ b/CUDADataFormats/HcalRecHitSoA/interface/RecHitCollection.h
@@ -3,13 +3,13 @@
 
 #include <vector>
 
-#include "CUDADataFormats/HcalCommon/interface/Common.h"
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
 
 namespace hcal {
 
   template <typename StoragePolicy>
-  struct RecHitCollection : public common::AddSize<typename StoragePolicy::TagType> {
+  struct RecHitCollection : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
     RecHitCollection() = default;
     RecHitCollection(const RecHitCollection&) = default;
     RecHitCollection& operator=(const RecHitCollection&) = default;
@@ -24,7 +24,7 @@ namespace hcal {
     typename StoragePolicy::template StorageSelector<uint32_t>::type did;
 
     template <typename U = typename StoragePolicy::TagType>
-    typename std::enable_if<std::is_same<U, common::tags::Vec>::value, void>::type resize(size_t size) {
+    typename std::enable_if<std::is_same<U, ::calo::common::tags::Vec>::value, void>::type resize(size_t size) {
       energy.resize(size);
       chi2.resize(size);
       energyM0.resize(size);
diff --git a/CUDADataFormats/HcalRecHitSoA/src/classes_def.xml b/CUDADataFormats/HcalRecHitSoA/src/classes_def.xml
index f9b6eb4ecc130..71dd18a7daddb 100644
--- a/CUDADataFormats/HcalRecHitSoA/src/classes_def.xml
+++ b/CUDADataFormats/HcalRecHitSoA/src/classes_def.xml
@@ -1,10 +1,13 @@
 <lcgdict>
-    <class name="hcal::RecHitCollection<hcal::common::VecStoragePolicy<std::allocator>>"/>
-    <class name="edm::Wrapper<hcal::RecHitCollection<hcal::common::VecStoragePolicy<std::allocator>>>"/>
+    <class name="hcal::RecHitCollection<calo::common::VecStoragePolicy<std::allocator>>"/>
+    <class name="edm::Wrapper<hcal::RecHitCollection<calo::common::VecStoragePolicy<std::allocator>>>"/>
 
-    <class name="hcal::RecHitCollection<hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>"/>
-    <class name="edm::Wrapper<hcal::RecHitCollection<hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>>"/>
+    <class name="hcal::RecHitCollection<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>"/>
+    <class name="edm::Wrapper<hcal::RecHitCollection<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>"/>
 
-    <class name="cms::cuda::Product<hcal::RecHitCollection<hcal::common::ViewStoragePolicy>>" persistent="false" />
-    <class name="edm::Wrapper<cms::cuda::Product<hcal::RecHitCollection<hcal::common::ViewStoragePolicy>>>" persistent="false" />
+    <class name="cms::cuda::Product<hcal::RecHitCollection<calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::RecHitCollection<calo::common::ViewStoragePolicy>>>" persistent="false" />
+                
+    <class name="cms::cuda::Product<hcal::RecHitCollection<calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<hcal::RecHitCollection<calo::common::DevStoragePolicy>>>" persistent="false" />
 </lcgdict>
diff --git a/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h b/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
index 9eab30a33fb3c..5c6f6dbb1375f 100644
--- a/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
+++ b/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
@@ -7,6 +7,10 @@
 #include "EventFilter/EcalRawToDigi/interface/ElectronicsMappingGPU.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/host_unique_ptr.h"
+
+#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
 
 namespace ecal {
   namespace raw {
@@ -16,16 +20,9 @@ namespace ecal {
     constexpr uint32_t nbytes_per_fed_max = 10 * 1024;
 
     struct InputDataCPU {
-      std::vector<unsigned char, cms::cuda::HostAllocator<unsigned char>> data;
-      std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> offsets;
-      std::vector<int, cms::cuda::HostAllocator<int>> feds;
-
-      void allocate() {
-        // 2KB per FED resize
-        data.resize(nfeds_max * sizeof(unsigned char) * nbytes_per_fed_max);
-        offsets.resize(nfeds_max, 0);
-        feds.resize(nfeds_max, 0);
-      }
+      cms::cuda::host::unique_ptr<unsigned char[]> data;
+      cms::cuda::host::unique_ptr<uint32_t[]> offsets;
+      cms::cuda::host::unique_ptr<int[]> feds;
     };
 
     struct ConfigurationParameters {
@@ -34,68 +31,36 @@ namespace ecal {
 
     struct OutputDataCPU {
       // [0] - eb, [1] - ee
-      std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> nchannels;
-
-      void allocate() { nchannels.resize(2); }
+      cms::cuda::host::unique_ptr<uint32_t[]> nchannels;
     };
 
     struct OutputDataGPU {
-      uint16_t *samplesEB = nullptr, *samplesEE = nullptr;
-      uint32_t *idsEB = nullptr, *idsEE = nullptr;
+        DigisCollection<::calo::common::DevStoragePolicy> digisEB, digisEE;
 
       // FIXME: we should separate max channels parameter for eb and ee
       // FIXME: replace hardcoded values
-      void allocate(ConfigurationParameters const &config) {
-        cudaCheck(cudaMalloc((void **)&samplesEB, config.maxChannels * sizeof(uint16_t) * 10));
-        cudaCheck(cudaMalloc((void **)&samplesEE, config.maxChannels * sizeof(uint16_t) * 10));
-        cudaCheck(cudaMalloc((void **)&idsEB, config.maxChannels * sizeof(uint32_t)));
-        cudaCheck(cudaMalloc((void **)&idsEE, config.maxChannels * sizeof(uint32_t)));
-      }
-
-      void deallocate(ConfigurationParameters const &config) {
-        if (samplesEB) {
-          cudaCheck(cudaFree(samplesEB));
-          cudaCheck(cudaFree(samplesEE));
-          cudaCheck(cudaFree(idsEB));
-          cudaCheck(cudaFree(idsEE));
-        }
+      void allocate(ConfigurationParameters const &config, cudaStream_t cudaStream) {
+        digisEB.data = cms::cuda::make_device_unique<uint16_t[]>(
+          config.maxChannels, cudaStream);
+        digisEE.data = cms::cuda::make_device_unique<uint16_t[]>(
+          config.maxChannels, cudaStream);
+        
+        digisEB.ids = cms::cuda::make_device_unique<uint32_t[]>(
+          config.maxChannels, cudaStream);
+        digisEE.ids = cms::cuda::make_device_unique<uint32_t[]>( config.maxChannels, cudaStream);
       }
     };
 
     struct ScratchDataGPU {
       // [0] = EB
       // [1] = EE
-      uint32_t *pChannelsCounter = nullptr;
-
-      void allocate(ConfigurationParameters const &config) {
-        cudaCheck(cudaMalloc((void **)&pChannelsCounter, sizeof(uint32_t) * 2));
-      }
-
-      void deallocate(ConfigurationParameters const &config) {
-        if (pChannelsCounter) {
-          cudaCheck(cudaFree(pChannelsCounter));
-        }
-      }
+      cms::cuda::device::unique_ptr<uint32_t[]> pChannelsCounter;
     };
 
     struct InputDataGPU {
-      unsigned char *data = nullptr;
-      uint32_t *offsets = nullptr;
-      int *feds = nullptr;
-
-      void allocate() {
-        cudaCheck(cudaMalloc((void **)&data, sizeof(unsigned char) * nbytes_per_fed_max * nfeds_max));
-        cudaCheck(cudaMalloc((void **)&offsets, sizeof(uint32_t) * nfeds_max));
-        cudaCheck(cudaMalloc((void **)&feds, sizeof(int) * nfeds_max));
-      }
-
-      void deallocate() {
-        if (data) {
-          cudaCheck(cudaFree(data));
-          cudaCheck(cudaFree(offsets));
-          cudaCheck(cudaFree(feds));
-        }
-      }
+      cms::cuda::device::unique_ptr<unsigned char[]> data;
+      cms::cuda::device::unique_ptr<uint32_t[]> offsets;
+      cms::cuda::device::unique_ptr<int[]> feds;
     };
 
     struct ConditionsProducts {
diff --git a/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc b/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
index fa53efe6286f1..e74a55cd583bd 100644
--- a/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
+++ b/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
@@ -31,8 +31,9 @@ class EcalCPUDigisProducer : public edm::stream::EDProducer<edm::ExternalWork> {
 
 private:
   // input digi collections in GPU-friendly format
-  edm::EDGetTokenT<cms::cuda::Product<ecal::DigisCollection>> digisInEBToken_;
-  edm::EDGetTokenT<cms::cuda::Product<ecal::DigisCollection>> digisInEEToken_;
+  using InputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
+  edm::EDGetTokenT<InputProduct> digisInEBToken_;
+  edm::EDGetTokenT<InputProduct> digisInEEToken_;
 
   // output digi collections in legacy format
   edm::EDPutTokenT<EBDigiCollection> digisOutEBToken_;
@@ -81,9 +82,9 @@ void EcalCPUDigisProducer::fillDescriptions(edm::ConfigurationDescriptions& conf
 EcalCPUDigisProducer::EcalCPUDigisProducer(const edm::ParameterSet& ps)
     :  // input digi collections in GPU-friendly format
       digisInEBToken_{
-          consumes<cms::cuda::Product<ecal::DigisCollection>>(ps.getParameter<edm::InputTag>("digisInLabelEB"))},
+          consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisInLabelEB"))},
       digisInEEToken_{
-          consumes<cms::cuda::Product<ecal::DigisCollection>>(ps.getParameter<edm::InputTag>("digisInLabelEE"))},
+          consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisInLabelEE"))},
       // output digi collections in legacy format
       digisOutEBToken_{produces<EBDigiCollection>(ps.getParameter<std::string>("digisOutLabelEB"))},
       digisOutEEToken_{produces<EEDigiCollection>(ps.getParameter<std::string>("digisOutLabelEE"))},
@@ -134,22 +135,22 @@ void EcalCPUDigisProducer::acquire(edm::Event const& event,
   auto const& ebdigis = ctx.get(ebdigisProduct);
   auto const& eedigis = ctx.get(eedigisProduct);
 
-  // resize out tmp buffers
+  // resize tmp buffers
   // FIXME remove hardcoded values
-  idsebtmp.resize(ebdigis.ndigis);
-  dataebtmp.resize(ebdigis.ndigis * 10);
-  idseetmp.resize(eedigis.ndigis);
-  dataeetmp.resize(eedigis.ndigis * 10);
+  idsebtmp.resize(ebdigis.size);
+  dataebtmp.resize(ebdigis.size * 10);
+  idseetmp.resize(eedigis.size);
+  dataeetmp.resize(eedigis.size * 10);
 
   // enqeue transfers
   cudaCheck(cudaMemcpyAsync(
-      dataebtmp.data(), ebdigis.data, dataebtmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
+      dataebtmp.data(), ebdigis.data.get(), dataebtmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
   cudaCheck(cudaMemcpyAsync(
-      dataeetmp.data(), eedigis.data, dataeetmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
+      dataeetmp.data(), eedigis.data.get(), dataeetmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
   cudaCheck(cudaMemcpyAsync(
-      idsebtmp.data(), ebdigis.ids, idsebtmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
+      idsebtmp.data(), ebdigis.ids.get(), idsebtmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
   cudaCheck(cudaMemcpyAsync(
-      idseetmp.data(), eedigis.ids, idseetmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
+      idseetmp.data(), eedigis.ids.get(), idseetmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
 }
 
 void EcalCPUDigisProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
diff --git a/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc b/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
index e2a127e950252..e86683da59bf9 100644
--- a/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
+++ b/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
@@ -28,18 +28,15 @@ class EcalRawToDigiGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 
 private:
   edm::EDGetTokenT<FEDRawDataCollection> rawDataToken_;
-  edm::EDPutTokenT<cms::cuda::Product<ecal::DigisCollection>> digisEBToken_, digisEEToken_;
+  using OutputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
+  edm::EDPutTokenT<OutputProduct> digisEBToken_, digisEEToken_;
 
   cms::cuda::ContextState cudaState_;
 
   std::vector<int> fedsToUnpack_;
 
   ecal::raw::ConfigurationParameters config_;
-  // FIXME move this to use raii
-  ecal::raw::InputDataCPU inputCPU_;
-  ecal::raw::InputDataGPU inputGPU_;
   ecal::raw::OutputDataGPU outputGPU_;
-  ecal::raw::ScratchDataGPU scratchGPU_;
   ecal::raw::OutputDataCPU outputCPU_;
 };
 
@@ -61,22 +58,13 @@ void EcalRawToDigiGPU::fillDescriptions(edm::ConfigurationDescriptions& confDesc
 
 EcalRawToDigiGPU::EcalRawToDigiGPU(const edm::ParameterSet& ps)
     : rawDataToken_{consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("InputLabel"))},
-      digisEBToken_{produces<cms::cuda::Product<ecal::DigisCollection>>(ps.getParameter<std::string>("digisLabelEB"))},
-      digisEEToken_{produces<cms::cuda::Product<ecal::DigisCollection>>(ps.getParameter<std::string>("digisLabelEE"))},
+      digisEBToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEB"))},
+      digisEEToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEE"))},
       fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
   config_.maxChannels = ps.getParameter<uint32_t>("maxChannels");
-
-  inputCPU_.allocate();
-  inputGPU_.allocate();
-  outputGPU_.allocate(config_);
-  scratchGPU_.allocate(config_);
-  outputCPU_.allocate();
 }
 
 EcalRawToDigiGPU::~EcalRawToDigiGPU() {
-  inputGPU_.deallocate();
-  outputGPU_.deallocate(config_);
-  scratchGPU_.deallocate(config_);
 }
 
 void EcalRawToDigiGPU::acquire(edm::Event const& event,
@@ -97,6 +85,40 @@ void EcalRawToDigiGPU::acquire(edm::Event const& event,
   edm::Handle<FEDRawDataCollection> rawDataHandle;
   event.getByToken(rawDataToken_, rawDataHandle);
 
+  // scratch
+  ecal::raw::ScratchDataGPU scratchGPU = {
+    cms::cuda::make_device_unique<uint32_t[]>(2, ctx.stream())
+  };
+
+  // input cpu data
+  ecal::raw::InputDataCPU inputCPU = {
+    cms::cuda::make_host_unique<unsigned char[]>(
+      ecal::raw::nfeds_max * ecal::raw::nbytes_per_fed_max, ctx.stream()),
+    cms::cuda::make_host_unique<uint32_t[]>(
+      ecal::raw::nfeds_max, ctx.stream()),
+    cms::cuda::make_host_unique<int[]>(
+      ecal::raw::nfeds_max, ctx.stream())
+  };
+
+  // input data gpu
+  ecal::raw::InputDataGPU inputGPU = {
+    cms::cuda::make_device_unique<unsigned char[]>(
+      ecal::raw::nfeds_max * ecal::raw::nbytes_per_fed_max, ctx.stream()),
+    cms::cuda::make_device_unique<uint32_t[]>(
+      ecal::raw::nfeds_max, ctx.stream()),
+    cms::cuda::make_device_unique<int[]>(
+      ecal::raw::nfeds_max, ctx.stream())
+  };
+
+  // output cpu
+  outputCPU_ = {
+    cms::cuda::make_host_unique<uint32_t[]>(
+      2, ctx.stream())
+  };
+
+  // output gpu
+  outputGPU_.allocate(config_, ctx.stream());
+
   // iterate over feds
   // TODO: another idea
   //   - loop over all feds to unpack and enqueue cuda memcpy
@@ -115,10 +137,10 @@ void EcalRawToDigiGPU::acquire(edm::Event const& event,
       continue;
 
     // copy raw data into plain buffer
-    std::memcpy(inputCPU_.data.data() + currentCummOffset, data.data(), nbytes);
+    std::memcpy(inputCPU.data.get() + currentCummOffset, data.data(), nbytes);
     // set the offset in bytes from the start
-    inputCPU_.offsets[counter] = currentCummOffset;
-    inputCPU_.feds[counter] = fed;
+    inputCPU.offsets[counter] = currentCummOffset;
+    inputCPU.feds[counter] = fed;
 
     // this is the current offset into the vector
     currentCummOffset += nbytes;
@@ -126,21 +148,24 @@ void EcalRawToDigiGPU::acquire(edm::Event const& event,
   }
 
   ecal::raw::entryPoint(
-      inputCPU_, inputGPU_, outputGPU_, scratchGPU_, outputCPU_, conditions, ctx.stream(), counter, currentCummOffset);
+      inputCPU, inputGPU, outputGPU_, scratchGPU, outputCPU_, conditions, ctx.stream(), counter, currentCummOffset);
 }
 
 void EcalRawToDigiGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
   cms::cuda::ScopedContextProduce ctx{cudaState_};
 
   // get the number of channels
-  auto const nchannelsEB = outputCPU_.nchannels[0];
-  auto const nchannelsEE = outputCPU_.nchannels[1];
+  outputGPU_.digisEB.size = outputCPU_.nchannels[0];
+  outputGPU_.digisEE.size = outputCPU_.nchannels[1];
+
+  //ecal::DigisCollection digisEB{outputGPU_.idsEB, outputGPU_.samplesEB, nchannelsEB};
+  //ecal::DigisCollection digisEE{outputGPU_.idsEE, outputGPU_.samplesEE, nchannelsEE};
 
-  ecal::DigisCollection digisEB{outputGPU_.idsEB, outputGPU_.samplesEB, nchannelsEB};
-  ecal::DigisCollection digisEE{outputGPU_.idsEE, outputGPU_.samplesEE, nchannelsEE};
+  ctx.emplace(event, digisEBToken_, std::move(outputGPU_.digisEB));
+  ctx.emplace(event, digisEEToken_, std::move(outputGPU_.digisEE));
 
-  ctx.emplace(event, digisEBToken_, std::move(digisEB));
-  ctx.emplace(event, digisEEToken_, std::move(digisEE));
+  // reset ptrs that are carried as members
+  outputCPU_.nchannels.reset();
 }
 
 DEFINE_FWK_MODULE(EcalRawToDigiGPU);
diff --git a/EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu b/EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu
index 79f916d510e72..05ba6a8904b8f 100644
--- a/EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu
+++ b/EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu
@@ -300,34 +300,34 @@ namespace ecal {
                     uint32_t const nbytesTotal) {
       // transfer
       cudaCheck(cudaMemcpyAsync(
-          inputGPU.data, inputCPU.data.data(), nbytesTotal * sizeof(unsigned char), cudaMemcpyHostToDevice, cudaStream));
-      cudaCheck(cudaMemcpyAsync(inputGPU.offsets,
-                                inputCPU.offsets.data(),
+          inputGPU.data.get(), inputCPU.data.get(), nbytesTotal * sizeof(unsigned char), cudaMemcpyHostToDevice, cudaStream));
+      cudaCheck(cudaMemcpyAsync(inputGPU.offsets.get(),
+                                inputCPU.offsets.get(),
                                 nfedsWithData * sizeof(uint32_t),
                                 cudaMemcpyHostToDevice,
                                 cudaStream));
-      cudaCheck(cudaMemsetAsync(scratchGPU.pChannelsCounter,
+      cudaCheck(cudaMemsetAsync(scratchGPU.pChannelsCounter.get(),
                                 0,
                                 sizeof(uint32_t) * 2,  // EB + EE
                                 cudaStream));
       cudaCheck(cudaMemcpyAsync(
-          inputGPU.feds, inputCPU.feds.data(), nfedsWithData * sizeof(int), cudaMemcpyHostToDevice, cudaStream));
-
-      kernel_unpack_test<32><<<nfedsWithData, 32, 0, cudaStream>>>(inputGPU.data,
-                                                                   inputGPU.offsets,
-                                                                   inputGPU.feds,
-                                                                   outputGPU.samplesEB,
-                                                                   outputGPU.samplesEE,
-                                                                   outputGPU.idsEB,
-                                                                   outputGPU.idsEE,
-                                                                   scratchGPU.pChannelsCounter,
+          inputGPU.feds.get(), inputCPU.feds.get(), nfedsWithData * sizeof(int), cudaMemcpyHostToDevice, cudaStream));
+
+      kernel_unpack_test<32><<<nfedsWithData, 32, 0, cudaStream>>>(inputGPU.data.get(),
+                                                                   inputGPU.offsets.get(),
+                                                                   inputGPU.feds.get(),
+                                                                   outputGPU.digisEB.data.get(),
+                                                                   outputGPU.digisEE.data.get(),
+                                                                   outputGPU.digisEB.ids.get(),
+                                                                   outputGPU.digisEE.ids.get(),
+                                                                   scratchGPU.pChannelsCounter.get(),
                                                                    conditions.eMappingProduct.eid2did,
                                                                    nbytesTotal);
       cudaCheck(cudaGetLastError());
 
       // transfer the counters for how many eb and ee channels we got
-      cudaCheck(cudaMemcpyAsync(outputCPU.nchannels.data(),
-                                scratchGPU.pChannelsCounter,
+      cudaCheck(cudaMemcpyAsync(outputCPU.nchannels.get(),
+                                scratchGPU.pChannelsCounter.get(),
                                 sizeof(uint32_t) * 2,
                                 cudaMemcpyDeviceToHost,
                                 cudaStream));
diff --git a/EventFilter/HcalRawToDigi/bin/makeHcalRaw2DigiGpuValidationPlots.cpp b/EventFilter/HcalRawToDigi/bin/makeHcalRaw2DigiGpuValidationPlots.cpp
index ff6a820a3525d..fd144ae452363 100644
--- a/EventFilter/HcalRawToDigi/bin/makeHcalRaw2DigiGpuValidationPlots.cpp
+++ b/EventFilter/HcalRawToDigi/bin/makeHcalRaw2DigiGpuValidationPlots.cpp
@@ -71,11 +71,11 @@ int main(int argc, char* argv[]) {
 
   // branches to use
   using Collectionf01 =
-      hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   using Collectionf5 =
-      hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   using Collectionf3 =
-      hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   edm::Wrapper<Collectionf01>* wgpuf01he = nullptr;
   edm::Wrapper<Collectionf5>* wgpuf5hb = nullptr;
   edm::Wrapper<Collectionf3>* wgpuf3hb = nullptr;
diff --git a/EventFilter/HcalRawToDigi/plugins/BuildFile.xml b/EventFilter/HcalRawToDigi/plugins/BuildFile.xml
index 025ea32125c82..3077a68a665e4 100644
--- a/EventFilter/HcalRawToDigi/plugins/BuildFile.xml
+++ b/EventFilter/HcalRawToDigi/plugins/BuildFile.xml
@@ -19,7 +19,7 @@
 <library file="HcalRawToDigiGPU.cc,DecodeGPU.cu,HcalESProducerGPUDefs.cc,ElectronicsMappingGPU.cc,HcalCPUDigisProducer.cc,HcalDigisProducerGPU.cc" name="EventFilterHcalRawToDigiGPUPlugins">
   <use name="cuda" />
   <use name="CUDADataFormats/Common" />
-  <use name="CUDADataFormats/HcalCommon"/>
+  <use name="CUDADataFormats/CaloCommon"/>
   <use name="CUDADataFormats/HcalDigi" />
   <use name="HeterogeneousCore/CUDACore"/>
   <use name="HeterogeneousCore/CUDAServices"/>
diff --git a/EventFilter/HcalRawToDigi/plugins/DeclsForKernels.h b/EventFilter/HcalRawToDigi/plugins/DeclsForKernels.h
index 606053edb6801..3808440f1449e 100644
--- a/EventFilter/HcalRawToDigi/plugins/DeclsForKernels.h
+++ b/EventFilter/HcalRawToDigi/plugins/DeclsForKernels.h
@@ -6,6 +6,8 @@
 #include "CUDADataFormats/HcalDigi/interface/DigiCollection.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/host_unique_ptr.h"
 
 #include "ElectronicsMappingGPU.h"
 
@@ -33,108 +35,75 @@ namespace hcal {
     };
 
     struct InputDataCPU {
-      std::vector<unsigned char, cms::cuda::HostAllocator<unsigned char>> data;
-      std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> offsets;
-      std::vector<int, cms::cuda::HostAllocator<int>> feds;
-
-      void allocate() {
-        data.resize(utca_nfeds_max * sizeof(unsigned char) * nbytes_per_fed_max);
-        offsets.resize(utca_nfeds_max, 0);
-        feds.resize(utca_nfeds_max, 0);
-      }
+      cms::cuda::host::unique_ptr<unsigned char[]> data;
+      cms::cuda::host::unique_ptr<uint32_t[]> offsets;
+      cms::cuda::host::unique_ptr<int[]> feds;
     };
 
     struct OutputDataCPU {
-      std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> nchannels;
-
-      void allocate() { nchannels.resize(numOutputCollections); }
+      cms::cuda::host::unique_ptr<uint32_t[]> nchannels;
     };
 
     struct ScratchDataGPU {
       // depends on tHE number of output collections
       // that is a statically known predefined number!!!
-      uint32_t *pChannelsCounters = nullptr;
-
-      void allocate(ConfigurationParameters const &) {
-        cudaCheck(cudaMalloc((void **)&pChannelsCounters, sizeof(uint32_t) * numOutputCollections));
-      }
-
-      void deallocate(ConfigurationParameters const &) {
-        if (pChannelsCounters) {
-          cudaCheck(cudaFree(pChannelsCounters));
-        }
-      }
+      cms::cuda::device::unique_ptr<uint32_t[]> pChannelsCounters;
     };
 
     struct OutputDataGPU {
-      DigiCollection<Flavor01, common::ViewStoragePolicy> digisF01HE;
-      DigiCollection<Flavor5, common::ViewStoragePolicy> digisF5HB;
-      DigiCollection<Flavor3, common::ViewStoragePolicy> digisF3HB;
-
-      // qie 11 HE
-      /*
-    uint16_t *digisF01HE = nullptr;
-    uint32_t *idsF01HE = nullptr;
-
-    // qie 8 HB
-    uint16_t *digisF5HB = nullptr;
-    uint32_t *idsF5HB = nullptr;
-    uint8_t *npresamplesF5HB = nullptr
-    */
-
-      void allocate(ConfigurationParameters const &config) {
-        cudaCheck(
-            cudaMalloc((void **)&digisF01HE.data,
-                       config.maxChannelsF01HE * sizeof(uint16_t) * compute_stride<Flavor01>(config.nsamplesF01HE)));
-        cudaCheck(cudaMalloc((void **)&digisF01HE.ids, sizeof(uint32_t) * config.maxChannelsF01HE));
-
-        cudaCheck(cudaMalloc((void **)&digisF5HB.data,
-                             config.maxChannelsF5HB * sizeof(uint16_t) * compute_stride<Flavor5>(config.nsamplesF5HB)));
-        cudaCheck(cudaMalloc((void **)&digisF5HB.ids, sizeof(uint32_t) * config.maxChannelsF5HB));
-        cudaCheck(cudaMalloc((void **)&digisF5HB.npresamples, sizeof(uint8_t) * config.maxChannelsF5HB));
-
-        cudaCheck(cudaMalloc((void **)&digisF3HB.data,
-                             config.maxChannelsF3HB * sizeof(uint16_t) * compute_stride<Flavor3>(config.nsamplesF3HB)));
-        cudaCheck(cudaMalloc((void **)&digisF3HB.ids, config.maxChannelsF3HB * sizeof(uint32_t)));
-      }
-
-      void deallocate(ConfigurationParameters const &config) {
-        if (digisF01HE.data) {
-          cudaCheck(cudaFree(digisF01HE.data));
-          cudaCheck(cudaFree(digisF01HE.ids));
-        }
-
-        if (digisF5HB.data) {
-          cudaCheck(cudaFree(digisF5HB.data));
-          cudaCheck(cudaFree(digisF5HB.ids));
-          cudaCheck(cudaFree(digisF5HB.npresamples));
-        }
-
-        if (digisF3HB.data) {
-          cudaCheck(cudaFree(digisF3HB.data));
-          cudaCheck(cudaFree(digisF3HB.ids));
-        }
+      DigiCollection<Flavor01, ::calo::common::DevStoragePolicy> digisF01HE;
+      DigiCollection<Flavor5, ::calo::common::DevStoragePolicy> digisF5HB;
+      DigiCollection<Flavor3, ::calo::common::DevStoragePolicy> digisF3HB;
+
+      void allocate(ConfigurationParameters const &config, cudaStream_t cudaStream) {
+        digisF01HE.data = cms::cuda::make_device_unique<uint16_t[]>(
+          config.maxChannelsF01HE*compute_stride<Flavor01>(config.nsamplesF01HE),
+          cudaStream
+        );
+        //cudaCheck(
+        //    cudaMalloc((void **)&digisF01HE.data,
+        //               config.maxChannelsF01HE * sizeof(uint16_t) * compute_stride<Flavor01>(config.nsamplesF01HE)));
+        digisF01HE.ids = cms::cuda::make_device_unique<uint32_t[]>(
+          config.maxChannelsF01HE,
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF01HE.ids, sizeof(uint32_t) * config.maxChannelsF01HE));
+
+        digisF5HB.data = cms::cuda::make_device_unique<uint16_t[]>(
+          config.maxChannelsF5HB * compute_stride<Flavor5>(config.nsamplesF5HB),
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF5HB.data,
+        //                     config.maxChannelsF5HB * sizeof(uint16_t) * compute_stride<Flavor5>(config.nsamplesF5HB)));
+        digisF5HB.ids = cms::cuda::make_device_unique<uint32_t[]>(
+          config.maxChannelsF5HB,
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF5HB.ids, sizeof(uint32_t) * config.maxChannelsF5HB));
+        digisF5HB.npresamples = cms::cuda::make_device_unique<uint8_t[]>(
+          config.maxChannelsF5HB,
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF5HB.npresamples, sizeof(uint8_t) * config.maxChannelsF5HB));
+
+        digisF3HB.data = cms::cuda::make_device_unique<uint16_t[]>(
+          config.maxChannelsF3HB * compute_stride<Flavor3>(config.nsamplesF3HB),
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF3HB.data,
+        //                     config.maxChannelsF3HB * sizeof(uint16_t) * compute_stride<Flavor3>(config.nsamplesF3HB)));
+        digisF3HB.ids = cms::cuda::make_device_unique<uint32_t[]>(
+          config.maxChannelsF3HB,
+          cudaStream
+        );
+        //cudaCheck(cudaMalloc((void **)&digisF3HB.ids, config.maxChannelsF3HB * sizeof(uint32_t)));
       }
     };
 
     struct InputDataGPU {
-      unsigned char *data = nullptr;
-      uint32_t *offsets = nullptr;
-      int *feds = nullptr;
-
-      void allocate() {
-        cudaCheck(cudaMalloc((void **)&data, sizeof(unsigned char) * nbytes_per_fed_max * utca_nfeds_max));
-        cudaCheck(cudaMalloc((void **)&offsets, sizeof(uint32_t) * utca_nfeds_max));
-        cudaCheck(cudaMalloc((void **)&feds, sizeof(int) * utca_nfeds_max));
-      }
-
-      void deallocate() {
-        if (data) {
-          cudaCheck(cudaFree(data));
-          cudaCheck(cudaFree(offsets));
-          cudaCheck(cudaFree(feds));
-        }
-      }
+      cms::cuda::device::unique_ptr<unsigned char[]> data;
+      cms::cuda::device::unique_ptr<uint32_t[]> offsets;
+      cms::cuda::device::unique_ptr<int[]> feds;
     };
 
     struct ConditionsProducts {
diff --git a/EventFilter/HcalRawToDigi/plugins/DecodeGPU.cu b/EventFilter/HcalRawToDigi/plugins/DecodeGPU.cu
index 1589ec6cb1661..5011b7b74fac3 100644
--- a/EventFilter/HcalRawToDigi/plugins/DecodeGPU.cu
+++ b/EventFilter/HcalRawToDigi/plugins/DecodeGPU.cu
@@ -568,38 +568,38 @@ namespace hcal {
                     uint32_t const nbytesTotal) {
       // transfer
       cudaCheck(cudaMemcpyAsync(
-          inputGPU.data, inputCPU.data.data(), nbytesTotal * sizeof(unsigned char), cudaMemcpyHostToDevice, cudaStream));
-      cudaCheck(cudaMemcpyAsync(inputGPU.offsets,
-                                inputCPU.offsets.data(),
+          inputGPU.data.get(), inputCPU.data.get(), nbytesTotal * sizeof(unsigned char), cudaMemcpyHostToDevice, cudaStream));
+      cudaCheck(cudaMemcpyAsync(inputGPU.offsets.get(),
+                                inputCPU.offsets.get(),
                                 nfedsWithData * sizeof(uint32_t),
                                 cudaMemcpyHostToDevice,
                                 cudaStream));
-      cudaCheck(cudaMemsetAsync(scratchGPU.pChannelsCounters, 0, sizeof(uint32_t) * numOutputCollections, cudaStream));
+      cudaCheck(cudaMemsetAsync(scratchGPU.pChannelsCounters.get(), 0, sizeof(uint32_t) * numOutputCollections, cudaStream));
       cudaCheck(cudaMemcpyAsync(
-          inputGPU.feds, inputCPU.feds.data(), nfedsWithData * sizeof(int), cudaMemcpyHostToDevice, cudaStream));
+          inputGPU.feds.get(), inputCPU.feds.get(), nfedsWithData * sizeof(int), cudaMemcpyHostToDevice, cudaStream));
 
       // 12 is the max number of modules per crate
-      kernel_rawdecode_test<32><<<nfedsWithData, 12 * 32, 0, cudaStream>>>(inputGPU.data,
-                                                                           inputGPU.offsets,
-                                                                           inputGPU.feds,
+      kernel_rawdecode_test<32><<<nfedsWithData, 12 * 32, 0, cudaStream>>>(inputGPU.data.get(),
+                                                                           inputGPU.offsets.get(),
+                                                                           inputGPU.feds.get(),
                                                                            conditions.eMappingProduct.eid2did,
                                                                            conditions.eMappingProduct.eid2tid,
-                                                                           outputGPU.digisF01HE.data,
-                                                                           outputGPU.digisF01HE.ids,
-                                                                           outputGPU.digisF5HB.data,
-                                                                           outputGPU.digisF5HB.ids,
-                                                                           outputGPU.digisF5HB.npresamples,
-                                                                           outputGPU.digisF3HB.data,
-                                                                           outputGPU.digisF3HB.ids,
-                                                                           scratchGPU.pChannelsCounters,
+                                                                           outputGPU.digisF01HE.data.get(),
+                                                                           outputGPU.digisF01HE.ids.get(),
+                                                                           outputGPU.digisF5HB.data.get(),
+                                                                           outputGPU.digisF5HB.ids.get(),
+                                                                           outputGPU.digisF5HB.npresamples.get(),
+                                                                           outputGPU.digisF3HB.data.get(),
+                                                                           outputGPU.digisF3HB.ids.get(),
+                                                                           scratchGPU.pChannelsCounters.get(),
                                                                            config.nsamplesF01HE,
                                                                            config.nsamplesF5HB,
                                                                            config.nsamplesF3HB,
                                                                            nbytesTotal);
       cudaCheck(cudaGetLastError());
 
-      cudaCheck(cudaMemcpyAsync(outputCPU.nchannels.data(),
-                                scratchGPU.pChannelsCounters,
+      cudaCheck(cudaMemcpyAsync(outputCPU.nchannels.get(),
+                                scratchGPU.pChannelsCounters.get(),
                                 sizeof(uint32_t) * numOutputCollections,
                                 cudaMemcpyDeviceToHost,
                                 cudaStream));
diff --git a/EventFilter/HcalRawToDigi/plugins/HcalCPUDigisProducer.cc b/EventFilter/HcalRawToDigi/plugins/HcalCPUDigisProducer.cc
index 8aad10228021c..a45d5d44adcd2 100644
--- a/EventFilter/HcalRawToDigi/plugins/HcalCPUDigisProducer.cc
+++ b/EventFilter/HcalRawToDigi/plugins/HcalCPUDigisProducer.cc
@@ -23,21 +23,21 @@ class HcalCPUDigisProducer : public edm::stream::EDProducer<edm::ExternalWork> {
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  using IProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef01> digisF01HETokenIn_;
-  using IProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef5> digisF5HBTokenIn_;
-  using IProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef3> digisF3HBTokenIn_;
 
   using OProductTypef01 =
-      hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   edm::EDPutTokenT<OProductTypef01> digisF01HETokenOut_;
   using OProductTypef5 =
-      hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   edm::EDPutTokenT<OProductTypef5> digisF5HBTokenOut_;
   using OProductTypef3 =
-      hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+      hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   edm::EDPutTokenT<OProductTypef3> digisF3HBTokenOut_;
 
   // needed to pass data from acquire to produce
@@ -89,92 +89,29 @@ void HcalCPUDigisProducer::acquire(edm::Event const& event,
   digisf5HB_.resize(f5HBDigis.size);
   digisf3HB_.resize(f3HBDigis.size);
 
-  /*
-    idsf01he.resize(f01HEDigis.ndigis);
-    dataf01he.resize(f01HEDigis.ndigis * f01HEDigis.stride);
-    idsf5hb.resize(f5HBDigis.ndigis);
-    npresamplesf5hb.resize(f5HBDigis.ndigis);
-    dataf5hb.resize(f5HBDigis.ndigis * f5HBDigis.stride);
-    stridef01he = f01HEDigis.stride;
-    stridef5hb = f5HBDigis.stride;
-    */
-
   auto lambdaToTransfer = [&ctx](auto& dest, auto* src) {
     using vector_type = typename std::remove_reference<decltype(dest)>::type;
     using type = typename vector_type::value_type;
+    using src_data_type = typename std::remove_pointer<decltype(src)>::type;
+    static_assert(std::is_same<src_data_type, type>::value && "Dest and Src data types do not match");
     cudaCheck(cudaMemcpyAsync(dest.data(), src, dest.size() * sizeof(type), cudaMemcpyDeviceToHost, ctx.stream()));
   };
 
-  lambdaToTransfer(digisf01HE_.data, f01HEDigis.data);
-  lambdaToTransfer(digisf01HE_.ids, f01HEDigis.ids);
-
-  lambdaToTransfer(digisf5HB_.data, f5HBDigis.data);
-  lambdaToTransfer(digisf5HB_.ids, f5HBDigis.ids);
-  lambdaToTransfer(digisf5HB_.npresamples, f5HBDigis.npresamples);
-
-  lambdaToTransfer(digisf3HB_.data, f3HBDigis.data);
-  lambdaToTransfer(digisf3HB_.ids, f3HBDigis.ids);
-
-  /*
-    // enqeue transfers
-    cudaCheck( cudaMemcpyAsync(digisf01.data.data(),
-                               f01HEDigis.data,
-                               dataf01HE.data.size() * sizeof(uint16_t),
-                               cudaMemcpyDeviceToHost,
-                               ctx.stream().id()) );
-    cudaCheck( cudaMemcpyAsync(dataf5hb.data(),
-                               f5HBDigis.data,
-                               dataf5hb.size() * sizeof(uint16_t),
-                               cudaMemcpyDeviceToHost,
-                               ctx.stream().id()) );
-    cudaCheck( cudaMemcpyAsync(idsf01he.data(),
-                               f01HEDigis.ids,
-                               idsf01he.size() * sizeof(uint32_t),
-                               cudaMemcpyDeviceToHost,
-                               ctx.stream().id()) );
-    cudaCheck( cudaMemcpyAsync(idsf5hb.data(),
-                               f5HBDigis.ids,
-                               idsf5hb.size() * sizeof(uint32_t),
-                               cudaMemcpyDeviceToHost,
-                               ctx.stream().id()) );
-    cudaCheck( cudaMemcpyAsync(npresamplesf5hb.data(),
-                               f5HBDigis.npresamples,
-                               npresamplesf5hb.size() * sizeof(uint8_t),
-                               cudaMemcpyDeviceToHost,
-                               ctx.stream.id()) );
-                               */
+  lambdaToTransfer(digisf01HE_.data, f01HEDigis.data.get());
+  lambdaToTransfer(digisf01HE_.ids, f01HEDigis.ids.get());
+
+  lambdaToTransfer(digisf5HB_.data, f5HBDigis.data.get());
+  lambdaToTransfer(digisf5HB_.ids, f5HBDigis.ids.get());
+  lambdaToTransfer(digisf5HB_.npresamples, f5HBDigis.npresamples.get());
+
+  lambdaToTransfer(digisf3HB_.data, f3HBDigis.data.get());
+  lambdaToTransfer(digisf3HB_.ids, f3HBDigis.ids.get());
 }
 
 void HcalCPUDigisProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
   event.emplace(digisF01HETokenOut_, std::move(digisf01HE_));
   event.emplace(digisF5HBTokenOut_, std::move(digisf5HB_));
   event.emplace(digisF3HBTokenOut_, std::move(digisf3HB_));
-
-  // output collections
-  /*
-    auto f01he = std::make_unique<edm::DataFrameContainer>(
-        stridef01he, HcalEndcap, idsf01he.size());
-    auto f5hb = std::make_unique<edm::DataFrameContainer>(
-        stridef5hb, HcalBarrel, idsf5hb.size());
-    
-    // cast constness away
-    // use pointers to buffers instead of move operator= semantics (or swap)
-    // cause we have different allocators in there...
-    auto *dataf01hetmp = const_cast<uint16_t*>(f01he->data().data());
-    auto *dataf5hbtmp = const_cast<uint16_t*>(f5hb->data().data());
-
-    auto *idsf01hetmp = const_cast<uint32_t*>(f01he->ids().data());
-    auto idsf5hbtmp = const_cast<uint32_t*>(f5hb->ids().data());
-
-    // copy data
-    std::memcpy(dataf01hetmp, dataf01he.data(), dataf01he.size() * sizeof(uint16_t));
-    std::memcpy(dataf5hbtmp, dataf5hb.data(), dataf5hb.size() * sizeof(uint16_t));
-    std::memcpy(idsf01hetmp, idsf01he.data(), idsf01he.size() * sizeof(uint32_t));
-    std::memcpy(idsf5hbtmp, idsf5hb.data(), idsf5hb.size() * sizeof(uint32_t));
-
-    event.put(digisF01HETokenOut_, std::move(f01he));
-    event.put(digisF5HBTokenOut_, std::move(f5hb));
-    */
 }
 
 DEFINE_FWK_MODULE(HcalCPUDigisProducer);
diff --git a/EventFilter/HcalRawToDigi/plugins/HcalDigisProducerGPU.cc b/EventFilter/HcalRawToDigi/plugins/HcalDigisProducerGPU.cc
index c7bb27b60fa12..69546a7a118bc 100644
--- a/EventFilter/HcalRawToDigi/plugins/HcalDigisProducerGPU.cc
+++ b/EventFilter/HcalRawToDigi/plugins/HcalDigisProducerGPU.cc
@@ -29,14 +29,14 @@ class HcalDigisProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 
   // type aliases
   using HostCollectionf01 =
-      hcal::DigiCollection<hcal::Flavor01, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
-  using DeviceCollectionf01 = hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>;
+      hcal::DigiCollection<hcal::Flavor01, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
+  using DeviceCollectionf01 = hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>;
   using HostCollectionf5 =
-      hcal::DigiCollection<hcal::Flavor5, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
-  using DeviceCollectionf5 = hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>;
+      hcal::DigiCollection<hcal::Flavor5, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
+  using DeviceCollectionf5 = hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>;
   using HostCollectionf3 =
-      hcal::DigiCollection<hcal::Flavor3, hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
-  using DeviceCollectionf3 = hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>;
+      hcal::DigiCollection<hcal::Flavor3, calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
+  using DeviceCollectionf3 = hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>;
 
   // output product tokens
   using ProductTypef01 = cms::cuda::Product<DeviceCollectionf01>;
@@ -48,16 +48,6 @@ class HcalDigisProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 
   cms::cuda::ContextState cudaState_;
 
-  /*
-    hcal::raw::ConfigurationParameters config_;
-    // FIXME move this to use raii
-    hcal::raw::InputDataCPU inputCPU_;
-    hcal::raw::InputDataGPU inputGPU_;
-    hcal::raw::OutputDataGPU outputGPU_;
-    hcal::raw::ScratchDataGPU scratchGPU_;
-    hcal::raw::OutputDataCPU outputCPU_;
-    */
-
   struct ConfigParameters {
     uint32_t maxChannelsF01HE, maxChannelsF5HB, maxChannelsF3HB, nsamplesF01HE, nsamplesF5HB, nsamplesF3HB;
   };
@@ -68,8 +58,7 @@ class HcalDigisProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
   HostCollectionf5 hf5_;
   HostCollectionf3 hf3_;
 
-  // device products
-  // NOTE: this module owns memory of the product on the device
+  // device products: product owns memory (i.e. not the module)
   DeviceCollectionf01 df01_;
   DeviceCollectionf5 df5_;
   DeviceCollectionf3 df3_;
@@ -107,27 +96,6 @@ HcalDigisProducerGPU::HcalDigisProducerGPU(const edm::ParameterSet& ps)
   config_.nsamplesF5HB = ps.getParameter<uint32_t>("nsamplesF5HB");
   config_.nsamplesF3HB = ps.getParameter<uint32_t>("nsamplesF3HB");
 
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    // allocate on the device
-    cudaCheck(cudaMalloc(
-        (void**)&df01_.data,
-        config_.maxChannelsF01HE * sizeof(uint16_t) * hcal::compute_stride<hcal::Flavor01>(config_.nsamplesF01HE)));
-    cudaCheck(cudaMalloc((void**)&df01_.ids, config_.maxChannelsF01HE * sizeof(uint32_t)));
-
-    cudaCheck(cudaMalloc(
-        (void**)&df5_.data,
-        config_.maxChannelsF5HB * sizeof(uint16_t) * hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB)));
-    cudaCheck(cudaMalloc((void**)&df5_.ids, config_.maxChannelsF5HB * sizeof(uint32_t)));
-    cudaCheck(cudaMalloc((void**)&df5_.npresamples, sizeof(uint8_t) * config_.maxChannelsF5HB));
-
-    cudaCheck(cudaMalloc(
-        (void**)&df3_.data,
-        config_.maxChannelsF3HB * sizeof(uint16_t) * hcal::compute_stride<hcal::Flavor3>(config_.nsamplesF3HB)));
-    cudaCheck(cudaMalloc((void**)&df3_.ids, config_.maxChannelsF3HB * sizeof(uint32_t)));
-  }
-
   // preallocate on the host
   hf01_.stride = hcal::compute_stride<hcal::Flavor01>(config_.nsamplesF01HE);
   hf5_.stride = hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB);
@@ -137,22 +105,7 @@ HcalDigisProducerGPU::HcalDigisProducerGPU(const edm::ParameterSet& ps)
   hf3_.reserve(config_.maxChannelsF3HB);
 }
 
-HcalDigisProducerGPU::~HcalDigisProducerGPU() {
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    // deallocate on the device
-    cudaCheck(cudaFree(df01_.data));
-    cudaCheck(cudaFree(df01_.ids));
-
-    cudaCheck(cudaFree(df5_.data));
-    cudaCheck(cudaFree(df5_.ids));
-    cudaCheck(cudaFree(df5_.npresamples));
-
-    cudaCheck(cudaFree(df3_.data));
-    cudaCheck(cudaFree(df3_.ids));
-  }
-}
+HcalDigisProducerGPU::~HcalDigisProducerGPU() {}
 
 void HcalDigisProducerGPU::acquire(edm::Event const& event,
                                    edm::EventSetup const& setup,
@@ -170,6 +123,43 @@ void HcalDigisProducerGPU::acquire(edm::Event const& event,
   event.getByToken(hbheDigiToken_, hbheDigis);
   event.getByToken(qie11DigiToken_, qie11Digis);
 
+  // flavor 0/1 get devie blobs
+  df01_.data = cms::cuda::make_device_unique<uint16_t[]>(
+    config_.maxChannelsF01HE * hcal::compute_stride<hcal::Flavor01>(
+      config_.nsamplesF01HE),
+    ctx.stream()
+  );
+  df01_.ids = cms::cuda::make_device_unique<uint32_t[]>(
+    config_.maxChannelsF01HE,
+    ctx.stream()
+  );
+
+  // flavor3 get device blobs
+  df3_.data  = cms::cuda::make_device_unique<uint16_t[]>(
+    config_.maxChannelsF3HB * hcal::compute_stride<hcal::Flavor3>(
+      config_.nsamplesF3HB),
+    ctx.stream()
+  );
+  df3_.ids = cms::cuda::make_device_unique<uint32_t[]>(
+    config_.maxChannelsF3HB,
+    ctx.stream()
+  );
+
+  // flavor5 get device blobs
+  df5_.data = cms::cuda::make_device_unique<uint16_t[]>(
+    config_.maxChannelsF5HB * hcal::compute_stride<hcal::Flavor5>(
+      config_.nsamplesF5HB),
+    ctx.stream()
+  );
+  df5_.ids = cms::cuda::make_device_unique<uint32_t[]>(
+    config_.maxChannelsF5HB,
+    ctx.stream()
+  );
+  df5_.npresamples = cms::cuda::make_device_unique<uint8_t[]>(
+    config_.maxChannelsF5HB,
+    ctx.stream()
+  );
+
   for (auto const& hbhe : *hbheDigis) {
     auto const id = hbhe.id().rawId();
     auto const presamples = hbhe.presamples();
@@ -218,18 +208,20 @@ void HcalDigisProducerGPU::acquire(edm::Event const& event,
   auto lambdaToTransfer = [&ctx](auto* dest, auto const& src) {
     using vector_type = typename std::remove_reference<decltype(src)>::type;
     using type = typename vector_type::value_type;
+    using dest_data_type = typename std::remove_pointer<decltype(dest)>::type;
+    static_assert(std::is_same<dest_data_type, type>::value && "Dest and Src data typesdo not match");
     cudaCheck(cudaMemcpyAsync(dest, src.data(), src.size() * sizeof(type), cudaMemcpyHostToDevice, ctx.stream()));
   };
 
-  lambdaToTransfer(df01_.data, hf01_.data);
-  lambdaToTransfer(df01_.ids, hf01_.ids);
+  lambdaToTransfer(df01_.data.get(), hf01_.data);
+  lambdaToTransfer(df01_.ids.get(), hf01_.ids);
 
-  lambdaToTransfer(df5_.data, hf5_.data);
-  lambdaToTransfer(df5_.ids, hf5_.ids);
-  lambdaToTransfer(df5_.npresamples, hf5_.npresamples);
+  lambdaToTransfer(df5_.data.get(), hf5_.data);
+  lambdaToTransfer(df5_.ids.get(), hf5_.ids);
+  lambdaToTransfer(df5_.npresamples.get(), hf5_.npresamples);
 
-  lambdaToTransfer(df3_.data, hf3_.data);
-  lambdaToTransfer(df3_.ids, hf3_.ids);
+  lambdaToTransfer(df3_.data.get(), hf3_.data);
+  lambdaToTransfer(df3_.ids.get(), hf3_.ids);
 }
 
 void HcalDigisProducerGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
@@ -242,39 +234,9 @@ void HcalDigisProducerGPU::produce(edm::Event& event, edm::EventSetup const& set
   df3_.stride = hcal::compute_stride<hcal::Flavor3>(config_.nsamplesF3HB);
   df3_.size = hf3_.ids.size();
 
-  ctx.emplace(event, digisF01HEToken_, df01_);
-  ctx.emplace(event, digisF5HBToken_, df5_);
-  ctx.emplace(event, digisF3HBToken_, df3_);
-
-  /*
-
-#ifdef HCAL_RAWDECODE_CPUDEBUG
-    printf("f01he channels = %u f5hb channesl = %u\n",
-        outputCPU_.nchannels[hcal::raw::OutputF01HE], 
-        outputCPU_.nchannels[hcal::raw::OutputF5HB]);
-#endif
-
-    // FIXME: use sizes of views directly for cuda mem cpy?
-    auto const nchannelsF01HE = outputCPU_.nchannels[hcal::raw::OutputF01HE];
-    auto const nchannelsF5HB = outputCPU_.nchannels[hcal::raw::OutputF5HB];
-    outputGPU_.digisF01HE.size = nchannelsF01HE;
-    outputGPU_.digisF5HB.size = nchannelsF5HB;
-    outputGPU_.digisF01HE.stride = 
-        hcal::compute_stride<hcal::Flavor01>(config_.nsamplesF01HE);
-    outputGPU_.digisF5HB.stride = 
-        hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB);
-
-    hcal::DigiCollection<hcal::Flavor01> digisF01HE{outputGPU_.idsF01HE,
-        outputGPU_.digisF01HE, nchannelsF01HE, 
-        hcal::compute_stride<hcal::Flavor01>(config_.nsamplesF01HE)};
-    hcal::DigiCollection<hcal::Flavor5> digisF5HB{outputGPU_.idsF5HB,
-        outputGPU_.digisF5HB, outputGPU_.npresamplesF5HB, nchannelsF5HB, 
-        hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB)};
-
-    ctx.emplace(event, digisF01HEToken_, std::move(outputGPU_.digisF01HE));
-    ctx.emplace(event, digisF5HBToken_, std::move(outputGPU_.digisF5HB));
-
-    */
+  ctx.emplace(event, digisF01HEToken_, std::move(df01_));
+  ctx.emplace(event, digisF5HBToken_, std::move(df5_));
+  ctx.emplace(event, digisF3HBToken_, std::move(df3_));
 }
 
 DEFINE_FWK_MODULE(HcalDigisProducerGPU);
diff --git a/EventFilter/HcalRawToDigi/plugins/HcalRawToDigiGPU.cc b/EventFilter/HcalRawToDigi/plugins/HcalRawToDigiGPU.cc
index 0e3a1a0d3b1e3..ab479a36202b0 100644
--- a/EventFilter/HcalRawToDigi/plugins/HcalRawToDigiGPU.cc
+++ b/EventFilter/HcalRawToDigi/plugins/HcalRawToDigiGPU.cc
@@ -12,6 +12,7 @@
 #include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
 #include "HeterogeneousCore/CUDAServices/interface/CUDAService.h"
 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
 
 #include "DeclsForKernels.h"
 #include "DecodeGPU.h"
@@ -29,11 +30,11 @@ class HcalRawToDigiGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 
 private:
   edm::EDGetTokenT<FEDRawDataCollection> rawDataToken_;
-  using ProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>>;
+  using ProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>>;
   edm::EDPutTokenT<ProductTypef01> digisF01HEToken_;
-  using ProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>>;
+  using ProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>;
   edm::EDPutTokenT<ProductTypef5> digisF5HBToken_;
-  using ProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>>;
+  using ProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>;
   edm::EDPutTokenT<ProductTypef3> digisF3HBToken_;
 
   cms::cuda::ContextState cudaState_;
@@ -41,11 +42,7 @@ class HcalRawToDigiGPU : public edm::stream::EDProducer<edm::ExternalWork> {
   std::vector<int> fedsToUnpack_;
 
   hcal::raw::ConfigurationParameters config_;
-  // FIXME move this to use raii
-  hcal::raw::InputDataCPU inputCPU_;
-  hcal::raw::InputDataGPU inputGPU_;
   hcal::raw::OutputDataGPU outputGPU_;
-  hcal::raw::ScratchDataGPU scratchGPU_;
   hcal::raw::OutputDataCPU outputCPU_;
 };
 
@@ -84,27 +81,9 @@ HcalRawToDigiGPU::HcalRawToDigiGPU(const edm::ParameterSet& ps)
   config_.nsamplesF01HE = ps.getParameter<uint32_t>("nsamplesF01HE");
   config_.nsamplesF5HB = ps.getParameter<uint32_t>("nsamplesF5HB");
   config_.nsamplesF3HB = ps.getParameter<uint32_t>("nsamplesF3HB");
-
-  // reserve memory and call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    inputCPU_.allocate();
-    outputCPU_.allocate();
-
-    inputGPU_.allocate();
-    outputGPU_.allocate(config_);
-    scratchGPU_.allocate(config_);
-  }
 }
 
 HcalRawToDigiGPU::~HcalRawToDigiGPU() {
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    inputGPU_.deallocate();
-    outputGPU_.deallocate(config_);
-    scratchGPU_.deallocate(config_);
-  }
 }
 
 void HcalRawToDigiGPU::acquire(edm::Event const& event,
@@ -125,6 +104,50 @@ void HcalRawToDigiGPU::acquire(edm::Event const& event,
   edm::Handle<FEDRawDataCollection> rawDataHandle;
   event.getByToken(rawDataToken_, rawDataHandle);
 
+  // scratch
+  hcal::raw::ScratchDataGPU scratchGPU = {
+    cms::cuda::make_device_unique<uint32_t[]>(
+      hcal::raw::numOutputCollections,
+      ctx.stream())
+  };
+
+  // input cpu data
+  hcal::raw::InputDataCPU inputCPU = {
+    cms::cuda::make_host_unique<unsigned char[]>(
+      hcal::raw::utca_nfeds_max * hcal::raw::nbytes_per_fed_max,
+      ctx.stream()),
+    cms::cuda::make_host_unique<uint32_t[]>(
+      hcal::raw::utca_nfeds_max,
+      ctx.stream()),
+    cms::cuda::make_host_unique<int[]>(
+      hcal::raw::utca_nfeds_max,
+      ctx.stream())
+  };
+
+  // input data gpu
+  hcal::raw::InputDataGPU inputGPU = {
+    cms::cuda::make_device_unique<unsigned char[]>(
+      hcal::raw::utca_nfeds_max * hcal::raw::nbytes_per_fed_max,
+      ctx.stream()),
+    cms::cuda::make_device_unique<uint32_t[]>(
+      hcal::raw::utca_nfeds_max,
+      ctx.stream()),
+    cms::cuda::make_device_unique<int[]>(
+      hcal::raw::utca_nfeds_max,
+      ctx.stream())
+  };
+
+  // output cpu
+  outputCPU_ = {
+    cms::cuda::make_host_unique<uint32_t[]>(
+      hcal::raw::numOutputCollections,
+      ctx.stream()
+    )
+  };
+
+  // output gpu
+  outputGPU_.allocate(config_, ctx.stream());
+
   // iterate over feds
   // TODO: another idea
   //   - loop over all feds to unpack and enqueue cuda memcpy
@@ -146,20 +169,20 @@ void HcalRawToDigiGPU::acquire(edm::Event const& event,
 #endif
 
     // copy raw data into plain buffer
-    std::memcpy(inputCPU_.data.data() + currentCummOffset, data.data(), nbytes);
+    std::memcpy(inputCPU.data.get() + currentCummOffset, data.data(), nbytes);
     // set the offset in bytes from the start
-    inputCPU_.offsets[counter] = currentCummOffset;
-    inputCPU_.feds[counter] = fed;
+    inputCPU.offsets[counter] = currentCummOffset;
+    inputCPU.feds[counter] = fed;
 
     // this is the current offset into the vector
     currentCummOffset += nbytes;
     ++counter;
   }
 
-  hcal::raw::entryPoint(inputCPU_,
-                        inputGPU_,
+  hcal::raw::entryPoint(inputCPU,
+                        inputGPU,
                         outputGPU_,
-                        scratchGPU_,
+                        scratchGPU,
                         outputCPU_,
                         conditions,
                         config_,
@@ -188,18 +211,12 @@ void HcalRawToDigiGPU::produce(edm::Event& event, edm::EventSetup const& setup)
   outputGPU_.digisF5HB.stride = hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB);
   outputGPU_.digisF3HB.stride = hcal::compute_stride<hcal::Flavor3>(config_.nsamplesF3HB);
 
-  /*
-    hcal::DigiCollection<hcal::Flavor01> digisF01HE{outputGPU_.idsF01HE,
-        outputGPU_.digisF01HE, nchannelsF01HE, 
-        hcal::compute_stride<hcal::Flavor01>(config_.nsamplesF01HE)};
-    hcal::DigiCollection<hcal::Flavor5> digisF5HB{outputGPU_.idsF5HB,
-        outputGPU_.digisF5HB, outputGPU_.npresamplesF5HB, nchannelsF5HB, 
-        hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB)};
-        */
-
   ctx.emplace(event, digisF01HEToken_, std::move(outputGPU_.digisF01HE));
   ctx.emplace(event, digisF5HBToken_, std::move(outputGPU_.digisF5HB));
   ctx.emplace(event, digisF3HBToken_, std::move(outputGPU_.digisF3HB));
+  
+  // reset ptrs that are carried as members
+  outputCPU_.nchannels.reset();
 }
 
 DEFINE_FWK_MODULE(HcalRawToDigiGPU);
diff --git a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
index febad835b00da..ffb3252193c03 100644
--- a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
+++ b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
@@ -13,7 +13,7 @@
 #include "DataFormats/Common/interface/Wrapper.h"
 #include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 
 #include "TStyle.h"
 
@@ -35,8 +35,8 @@ int main(int argc, char *argv[]) {
 
   gStyle->SetOptStat("ourme");
 
-  edm::Wrapper<ecal::UncalibratedRecHit<ecal::Tag::soa>> *wgpuEB = nullptr;
-  edm::Wrapper<ecal::UncalibratedRecHit<ecal::Tag::soa>> *wgpuEE = nullptr;
+  edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>> *wgpuEB = nullptr;
+  edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>> *wgpuEE = nullptr;
   edm::Wrapper<EBUncalibratedRecHitCollection> *wcpuEB = nullptr;
   edm::Wrapper<EEUncalibratedRecHitCollection> *wcpuEE = nullptr;
 
@@ -152,9 +152,9 @@ int main(int argc, char *argv[]) {
   std::cout << "validating file " << fileName << std::endl;
   TFile rf{fileName.c_str()};
   TTree *rt = (TTree *)rf.Get("Events");
-  rt->SetBranchAddress("ecalTagsoaecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_EcalUncalibRecHitsEB_RECO.",
+  rt->SetBranchAddress("calocommonCUDAHostAllocatorAliascalocommonVecStoragePolicyecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_EcalUncalibRecHitsEB_RECO.",
                        &wgpuEB);
-  rt->SetBranchAddress("ecalTagsoaecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_EcalUncalibRecHitsEE_RECO.",
+  rt->SetBranchAddress("calocommonCUDAHostAllocatorAliascalocommonVecStoragePolicyecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_EcalUncalibRecHitsEE_RECO.",
                        &wgpuEE);
   rt->SetBranchAddress("EcalUncalibratedRecHitsSorted_ecalMultiFitUncalibRecHit_EcalUncalibRecHitsEB_RECO.", &wcpuEB);
   rt->SetBranchAddress("EcalUncalibratedRecHitsSorted_ecalMultiFitUncalibRecHit_EcalUncalibRecHitsEE_RECO.", &wcpuEE);
diff --git a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
index 2203fd21f6ebc..42d1fceaf8b76 100644
--- a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
+++ b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
@@ -16,7 +16,7 @@
 #include "DataFormats/Common/interface/Wrapper.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
 
 int main(int argc, char *argv[]) {
   if (argc < 3) {
@@ -24,8 +24,8 @@ int main(int argc, char *argv[]) {
     exit(0);
   }
   // Set the GPU and CPU pointers for both EB and EE
-  edm::Wrapper<ecal::RecHit<ecal::Tag::soa>> *wgpuEB = nullptr;
-  edm::Wrapper<ecal::RecHit<ecal::Tag::soa>> *wgpuEE = nullptr;
+  edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>> *wgpuEB = nullptr;
+  edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>> *wgpuEE = nullptr;
   edm::Wrapper<EBRecHitCollection> *wcpuEB = nullptr;
   edm::Wrapper<EERecHitCollection> *wcpuEE = nullptr;
 
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h
new file mode 100644
index 0000000000000..127e76fe68336
--- /dev/null
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h
@@ -0,0 +1,39 @@
+#ifndef RecoLocalCalo_EcalRecAlgos_interfaceEcalMultifitParametersGPU_h
+#define RecoLocalCalo_EcalRecAlgos_interfaceEcalMultifitParametersGPU_h
+
+#include <array>
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#ifndef __CUDACC__
+#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
+#endif
+
+class EcalMultifitParametersGPU {
+public:
+    struct Product {
+        ~Product();
+        double *amplitudeFitParametersEB, *amplitudeFitParametersEE,
+               *timeFitParametersEB, *timeFitParametersEE;
+    };
+
+#ifndef __CUDACC__
+    EcalMultifitParametersGPU(edm::ParameterSet const&);
+
+    ~EcalMultifitParametersGPU() = default;
+
+    Product const& getProduct(cudaStream_t) const;
+
+    std::array<std::reference_wrapper<std::vector<double, cms::cuda::HostAllocator<double>> const>, 4> getValues() const {
+        return {{amplitudeFitParametersEB_, amplitudeFitParametersEE_, timeFitParametersEB_, timeFitParametersEE_}};
+    }
+
+private:
+    std::vector<double, cms::cuda::HostAllocator<double>> amplitudeFitParametersEB_, amplitudeFitParametersEE_, timeFitParametersEB_, timeFitParametersEE_;
+
+    cms::cuda::ESProduct<Product> product_;
+#endif
+};
+
+#endif // RecoLocalCalo_EcalRecAlgos_interfaceEcalMultifitParametersGPU_h
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h
new file mode 100644
index 0000000000000..04221fa11f006
--- /dev/null
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h
@@ -0,0 +1,43 @@
+#ifndef RecoLocalCalo_EcalRecAlgos_interfaceEcalRecHitParametersGPU_h
+#define RecoLocalCalo_EcalRecAlgos_interfaceEcalRecHitParametersGPU_h
+
+#include <array>
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#ifndef __CUDACC__
+#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
+#endif
+
+class EcalRecHitParametersGPU {
+public:
+    struct Product {
+        ~Product();
+        int *ChannelStatusToBeExcluded, *expanded_v_DB_reco_flags;
+        uint32_t *expanded_Sizes_v_DB_reco_flags, *expanded_flagbit_v_DB_reco_flags;
+    };
+
+#ifndef __CUDACC__
+    EcalRecHitParametersGPU(edm::ParameterSet const&);
+
+    ~EcalRecHitParametersGPU() = default;
+
+    Product const& getProduct(cudaStream_t) const;
+
+    using intvec = std::reference_wrapper<std::vector<int, cms::cuda::HostAllocator<int>> const>;
+    using uint32vec = std::reference_wrapper<std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> const>;
+    std::tuple<intvec, intvec, uint32vec, uint32vec> getValues() const {
+        return {ChannelStatusToBeExcluded_, expanded_v_DB_reco_flags_, expanded_Sizes_v_DB_reco_flags_, expanded_flagbit_v_DB_reco_flags_};
+    }
+
+private:
+    std::vector<int, cms::cuda::HostAllocator<int>> ChannelStatusToBeExcluded_;
+    std::vector<int, cms::cuda::HostAllocator<int>> expanded_v_DB_reco_flags_;
+    std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> expanded_Sizes_v_DB_reco_flags_, expanded_flagbit_v_DB_reco_flags_;
+
+    cms::cuda::ESProduct<Product> product_;
+#endif
+};
+
+#endif // RecoLocalCalo_EcalRecAlgos_interfaceEcalRecHitParametersGPU_h
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalMultifitParametersGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalMultifitParametersGPU.cc
new file mode 100644
index 0000000000000..9fe6d55e3cc1c
--- /dev/null
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalMultifitParametersGPU.cc
@@ -0,0 +1,73 @@
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h"
+
+#include "FWCore/Utilities/interface/typelookup.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+
+EcalMultifitParametersGPU::EcalMultifitParametersGPU(edm::ParameterSet const& ps) {
+    auto const& amplitudeFitParametersEB = ps.getParameter<std::vector<double>>(
+        "EBamplitudeFitParameters");
+    auto const& amplitudeFitParametersEE = ps.getParameter<std::vector<double>>(
+        "EEamplitudeFitParameters");
+    auto const& timeFitParametersEB = ps.getParameter<std::vector<double>>(
+        "EBtimeFitParameters");
+    auto const& timeFitParametersEE = ps.getParameter<std::vector<double>>(
+        "EEtimeFitParameters");
+
+    amplitudeFitParametersEB_.resize(amplitudeFitParametersEB.size());
+    amplitudeFitParametersEE_.resize(amplitudeFitParametersEE.size());
+    timeFitParametersEB_.resize(timeFitParametersEB.size());
+    timeFitParametersEE_.resize(timeFitParametersEE.size());
+
+    std::copy(amplitudeFitParametersEB.begin(), amplitudeFitParametersEB.end(),
+        amplitudeFitParametersEB_.begin());
+    std::copy(amplitudeFitParametersEE.begin(), amplitudeFitParametersEE.end(),
+        amplitudeFitParametersEE_.begin());
+    std::copy(timeFitParametersEB.begin(), timeFitParametersEB.end(),
+        timeFitParametersEB_.begin());
+    std::copy(timeFitParametersEE.begin(), timeFitParametersEE.end(),
+        timeFitParametersEE_.begin());
+}
+
+EcalMultifitParametersGPU::Product::~Product() {
+    cudaCheck(cudaFree(amplitudeFitParametersEB));
+    cudaCheck(cudaFree(amplitudeFitParametersEE));
+    cudaCheck(cudaFree(timeFitParametersEB));
+    cudaCheck(cudaFree(timeFitParametersEE));
+}
+
+EcalMultifitParametersGPU::Product const& EcalMultifitParametersGPU::getProduct(cudaStream_t cudaStream) const { 
+    auto const& product = 
+        product_.dataForCurrentDeviceAsync(cudaStream, [this](EcalMultifitParametersGPU::Product& product, cudaStream_t cudaStream) {
+            // malloc
+            cudaCheck(cudaMalloc((void**)&product.amplitudeFitParametersEB, this->amplitudeFitParametersEB_.size() * sizeof(double)));
+            cudaCheck(cudaMalloc((void**)&product.amplitudeFitParametersEE, this->amplitudeFitParametersEE_.size() * sizeof(double)));
+            cudaCheck(cudaMalloc((void**)&product.timeFitParametersEB, this->timeFitParametersEB_.size() * sizeof(double)));
+            cudaCheck(cudaMalloc((void**)&product.timeFitParametersEE, this->timeFitParametersEE_.size() * sizeof(double)));
+                                
+            // transfer
+            cudaCheck(cudaMemcpyAsync(product.amplitudeFitParametersEB,
+                this->amplitudeFitParametersEB_.data(),
+                this->amplitudeFitParametersEB_.size() * sizeof(double),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.amplitudeFitParametersEE,
+                this->amplitudeFitParametersEE_.data(),
+                this->amplitudeFitParametersEE_.size() * sizeof(double),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.timeFitParametersEB,
+                this->timeFitParametersEB_.data(),
+                this->timeFitParametersEB_.size() * sizeof(double),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.timeFitParametersEE,
+                this->timeFitParametersEE_.data(),
+                this->timeFitParametersEE_.size() * sizeof(double),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+
+        });
+    return product;
+}
+
+TYPELOOKUP_DATA_REG(EcalMultifitParametersGPU);
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalRecHitParametersGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalRecHitParametersGPU.cc
new file mode 100644
index 0000000000000..378d5c10d7dc4
--- /dev/null
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalRecHitParametersGPU.cc
@@ -0,0 +1,80 @@
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h"
+
+#include "FWCore/Utilities/interface/typelookup.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+#include "CommonTools/Utils/interface/StringToEnumValue.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitChannelStatusGPU.h"
+#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
+
+EcalRecHitParametersGPU::EcalRecHitParametersGPU(edm::ParameterSet const& ps) {
+    auto const& ChannelStatusToBeExcluded = StringToEnumValue<EcalChannelStatusCode::Code>(
+        ps.getParameter<std::vector<std::string>>("ChannelStatusToBeExcluded"));
+
+    ChannelStatusToBeExcluded_.resize(ChannelStatusToBeExcluded.size());
+    std::copy(ChannelStatusToBeExcluded.begin(), ChannelStatusToBeExcluded.end(),
+        ChannelStatusToBeExcluded_.begin());
+
+    //     https://github.com/cms-sw/cmssw/blob/266e21cfc9eb409b093e4cf064f4c0a24c6ac293/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitWorkerSimple.cc
+
+    // Traslate string representation of flagsMapDBReco into enum values
+    const edm::ParameterSet& p = ps.getParameter<edm::ParameterSet>("flagsMapDBReco");
+    std::vector<std::string> recoflagbitsStrings = p.getParameterNames();
+
+    for (unsigned int i = 0; i != recoflagbitsStrings.size(); ++i) {
+        EcalRecHit::Flags recoflagbit = (EcalRecHit::Flags)StringToEnumValue<EcalRecHit::Flags>(recoflagbitsStrings[i]);
+        std::vector<std::string> dbstatus_s = p.getParameter<std::vector<std::string>>(recoflagbitsStrings[i]);
+        //     std::vector<uint32_t> dbstatuses;
+        for (unsigned int j = 0; j != dbstatus_s.size(); ++j) {
+            EcalChannelStatusCode::Code dbstatus =
+                (EcalChannelStatusCode::Code)StringToEnumValue<EcalChannelStatusCode::Code>(dbstatus_s[j]);
+            expanded_v_DB_reco_flags_.push_back(dbstatus);
+        }
+
+        expanded_Sizes_v_DB_reco_flags_.push_back(dbstatus_s.size());
+        expanded_flagbit_v_DB_reco_flags_.push_back(recoflagbit);
+    }
+}
+
+EcalRecHitParametersGPU::Product::~Product() {
+    cudaCheck(cudaFree(ChannelStatusToBeExcluded));
+    cudaCheck(cudaFree(expanded_v_DB_reco_flags));
+    cudaCheck(cudaFree(expanded_Sizes_v_DB_reco_flags));
+    cudaCheck(cudaFree(expanded_flagbit_v_DB_reco_flags));
+}
+
+EcalRecHitParametersGPU::Product const& EcalRecHitParametersGPU::getProduct(cudaStream_t cudaStream) const { 
+    auto const& product = 
+        product_.dataForCurrentDeviceAsync(cudaStream, [this](EcalRecHitParametersGPU::Product& product, cudaStream_t cudaStream) {
+            // malloc
+            cudaCheck(cudaMalloc((void**)&product.ChannelStatusToBeExcluded, this->ChannelStatusToBeExcluded_.size() * sizeof(int)));
+            cudaCheck(cudaMalloc((void**)&product.expanded_v_DB_reco_flags, this->expanded_v_DB_reco_flags_.size() * sizeof(int)));
+            cudaCheck(cudaMalloc((void**)&product.expanded_Sizes_v_DB_reco_flags, this->expanded_Sizes_v_DB_reco_flags_.size() * sizeof(uint32_t)));
+            cudaCheck(cudaMalloc((void**)&product.expanded_flagbit_v_DB_reco_flags, this->expanded_flagbit_v_DB_reco_flags_.size() * sizeof(uint32_t)));
+                                
+            // transfer
+            cudaCheck(cudaMemcpyAsync(product.ChannelStatusToBeExcluded,
+                this->ChannelStatusToBeExcluded_.data(),
+                this->ChannelStatusToBeExcluded_.size() * sizeof(int),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.expanded_v_DB_reco_flags,
+                this->expanded_v_DB_reco_flags_.data(),
+                this->expanded_v_DB_reco_flags_.size() * sizeof(int),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.expanded_Sizes_v_DB_reco_flags,
+                this->expanded_Sizes_v_DB_reco_flags_.data(),
+                this->expanded_Sizes_v_DB_reco_flags_.size() * sizeof(uint32_t),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+            cudaCheck(cudaMemcpyAsync(product.expanded_flagbit_v_DB_reco_flags,
+                this->expanded_flagbit_v_DB_reco_flags_.data(),
+                this->expanded_flagbit_v_DB_reco_flags_.size() * sizeof(uint32_t),
+                cudaMemcpyHostToDevice,
+                cudaStream));
+
+        });
+    return product;
+}
+
+TYPELOOKUP_DATA_REG(EcalRecHitParametersGPU);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
index 36601a0fb9230..f5f7bded8cd11 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
+++ b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
@@ -27,7 +27,8 @@ namespace ecal {
                                                   uint16_t const* digis_in_ee,
                                                   uint32_t const* dids_ee,
                                                   SampleVector* amplitudes,
-                                                  SampleVector* amplitudesForMinimization,
+                                                  SampleVector* amplitudesForMinimizationEB,
+                                                  SampleVector* amplitudesForMinimizationEE,
                                                   SampleGainVector* gainsNoise,
                                                   float const* mean_x1,
                                                   float const* mean_x12,
@@ -38,11 +39,16 @@ namespace ecal {
                                                   bool* hasSwitchToGain6,
                                                   bool* hasSwitchToGain1,
                                                   bool* isSaturated,
-                                                  ::ecal::reco::StorageScalarType* energies,
-                                                  ::ecal::reco::StorageScalarType* chi2,
-                                                  ::ecal::reco::StorageScalarType* g_pedestal,
-                                                  uint32_t* dids_out,
-                                                  uint32_t* flags,
+                                                  ::ecal::reco::StorageScalarType* energiesEB,
+                                                  ::ecal::reco::StorageScalarType* energiesEE,
+                                                  ::ecal::reco::StorageScalarType* chi2EB,
+                                                  ::ecal::reco::StorageScalarType* chi2EE,
+                                                  ::ecal::reco::StorageScalarType* g_pedestalEB,
+                                                  ::ecal::reco::StorageScalarType* g_pedestalEE,
+                                                  uint32_t* dids_outEB,
+                                                  uint32_t* dids_outEE,
+                                                  uint32_t* flagsEB,
+                                                  uint32_t* flagsEE,
                                                   char* acState,
                                                   BXVectorType* bxs,
                                                   uint32_t const offsetForHashes,
@@ -65,6 +71,17 @@ namespace ecal {
       auto const* dids = ch >= offsetForInputs ? dids_ee : dids_eb;
       int const sample = threadIdx.x % nsamples;
 
+      // need to ref the right ptr
+      // macro is for clarity and safety
+#define ARRANGE(var) auto *var = ch >= offsetForInputs ? var##EE : var##EB
+      ARRANGE(amplitudesForMinimization);
+      ARRANGE(energies);
+      ARRANGE(chi2);
+      ARRANGE(g_pedestal);
+      ARRANGE(dids_out);
+      ARRANGE(flags);
+#undef ARRANGE
+
       if (ch < nchannels) {
         // array of 10 x channels per block
         // TODO: any other way of doing simple reduction
@@ -215,7 +232,7 @@ namespace ecal {
         //
         // initialization
         //
-        amplitudesForMinimization[ch](sample) = 0;
+        amplitudesForMinimization[inputCh](sample) = 0;
         bxs[ch](sample) = sample - 5;
 
         // select the thread for the max sample
@@ -225,11 +242,11 @@ namespace ecal {
           // initialization
           //
           acState[ch] = static_cast<char>(MinimizationState::NotFinished);
-          energies[ch] = 0;
-          chi2[ch] = 0;
-          g_pedestal[ch] = 0;
+          energies[inputCh] = 0;
+          chi2[inputCh] = 0;
+          g_pedestal[inputCh] = 0;
           uint32_t flag = 0;
-          dids_out[ch] = did.rawId();
+          dids_out[inputCh] = did.rawId();
 
           // start of this channel in shared mem
           int const chStart = threadIdx.x - sample_max;
@@ -247,8 +264,8 @@ namespace ecal {
           // likely false
           if (check_hasSwitchToGain0) {
             // assign for the case some sample having gainId == 0
-            //energies[ch] = amplitudes[ch][sample_max];
-            energies[ch] = amplitude;
+            //energies[inputCh] = amplitudes[ch][sample_max];
+            energies[inputCh] = amplitude;
 
             // check if samples before sample_max have true
             bool saturated_before_max = false;
@@ -258,14 +275,14 @@ namespace ecal {
 
             // if saturation is in the max sample and not in the first 5
             if (!saturated_before_max && shr_hasSwitchToGain0[threadMax])
-              energies[ch] = 49140;  // 4095 * 12
+              energies[inputCh] = 49140;  // 4095 * 12
                                      //---- AM FIXME : no pedestal subtraction???
                                      //It should be "(4095. - pedestal) * gainratio"
 
             // set state flag to terminate further processing of this channel
             acState[ch] = static_cast<char>(MinimizationState::Precomputed);
             flag |= 0x1 << EcalUncalibratedRecHit::kSaturated;
-            flags[ch] = flag;
+            flags[inputCh] = flag;
             return;
           }
 
@@ -279,12 +296,12 @@ namespace ecal {
               shr_hasSwitchToGain6[chStart] || shr_hasSwitchToGain1[chStart] || shr_isSaturated[chStart + 3];
 
           // pedestal is final unconditionally
-          g_pedestal[ch] = pedestal;
+          g_pedestal[inputCh] = pedestal;
           if (hasGainSwitch && gainSwitchUseMaxSample) {
             // thread for sample=0 will access the right guys
-            energies[ch] = max_amplitude / shape_value;
+            energies[inputCh] = max_amplitude / shape_value;
             acState[ch] = static_cast<char>(MinimizationState::Precomputed);
-            flags[ch] = flag;
+            flags[inputCh] = flag;
             return;
           }
 
@@ -293,12 +310,12 @@ namespace ecal {
           // general case here is that noisecov is a Zero matrix
           if (rmsForChecking == 0) {
             acState[ch] = static_cast<char>(MinimizationState::Precomputed);
-            flags[ch] = flag;
+            flags[inputCh] = flag;
             return;
           }
 
           // for the case when no shortcuts were taken
-          flags[ch] = flag;
+          flags[inputCh] = flag;
         }
       }
     }
@@ -485,21 +502,5 @@ namespace ecal {
         energies[ch] = values[threadIdx.x];
     }
 
-///
-/// Build an Ecal RecHit.
-/// TODO: Use SoA data structures on the host directly
-/// the reason for removing this from minimize kernel is to isolate the minimize +
-/// again, building an aos rec hit involves strides... -> bad memory access pattern
-///
-#ifdef RUN_BUILD_AOS_RECHIT
-    __global__ void kernel_build_rechit(
-        float const* energies, float const* chi2s, uint32_t* dids, EcalUncalibratedRecHit* rechits, int nchannels) {
-      int idx = threadIdx.x + blockDim.x * blockIdx.x;
-      if (idx < nchannels) {
-        rechits[idx] = EcalUncalibratedRecHit{dids[idx], energies[idx], 0, 0, chi2s[idx], 0};
-      }
-    }
-#endif
-
   }  // namespace multifit
 }  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
index 3e813b529a2ad..57b976b8b33d5 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
+++ b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
@@ -24,7 +24,8 @@ namespace ecal {
                                                   uint16_t const* digis_in_ee,
                                                   uint32_t const* dids_ee,
                                                   SampleVector* amplitudes,
-                                                  SampleVector* amplitudesForMinimization,
+                                                  SampleVector* amplitudesForMinimizationEB,
+                                                  SampleVector* amplitudesForMinimizationEE,
                                                   SampleGainVector* gainsNoise,
                                                   float const* mean_x1,
                                                   float const* mean_x12,
@@ -35,11 +36,16 @@ namespace ecal {
                                                   bool* hasSwitchToGain6,
                                                   bool* hasSwitchToGain1,
                                                   bool* isSaturated,
-                                                  ::ecal::reco::StorageScalarType* energies,
-                                                  ::ecal::reco::StorageScalarType* chi2,
-                                                  ::ecal::reco::StorageScalarType* pedestal,
-                                                  uint32_t* dids_out,
-                                                  uint32_t* flags,
+                                                  ::ecal::reco::StorageScalarType* energiesEB,
+                                                  ::ecal::reco::StorageScalarType* energiesEE,
+                                                  ::ecal::reco::StorageScalarType* chi2EB,
+                                                  ::ecal::reco::StorageScalarType* chi2EE,
+                                                  ::ecal::reco::StorageScalarType* pedestalEB,
+                                                  ::ecal::reco::StorageScalarType* pedestalEE,
+                                                  uint32_t* dids_outEB,
+                                                  uint32_t* dids_outEE,
+                                                  uint32_t* flagsEB,
+                                                  uint32_t* flagsEE,
                                                   char* acState,
                                                   BXVectorType* bxs,
                                                   uint32_t const offsetForHashes,
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
index 42c0b8aab85db..4996e4e6ce0a9 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
+++ b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
@@ -121,10 +121,13 @@ namespace ecal {
                                     EcalPulseCovariance const* __restrict__ pulse_covariance,
                                     BXVectorType* bxs,
                                     SampleVector const* __restrict__ samples,
-                                    SampleVector* amplitudes,
+                                    SampleVector* amplitudesEB,
+                                    SampleVector* amplitudesEE,
                                     PulseMatrixType const* __restrict__ pulse_matrix,
-                                    ::ecal::reco::StorageScalarType* chi2s,
-                                    ::ecal::reco::StorageScalarType* energies,
+                                    ::ecal::reco::StorageScalarType* chi2sEB,
+                                    ::ecal::reco::StorageScalarType* chi2sEE,
+                                    ::ecal::reco::StorageScalarType* energiesEB,
+                                    ::ecal::reco::StorageScalarType* energiesEE,
                                     char* acState,
                                     int nchannels,
                                     int max_iterations,
@@ -133,7 +136,7 @@ namespace ecal {
       // FIXME: ecal has 10 samples and 10 pulses....
       // but this needs to be properly treated and renamed everywhere
       constexpr auto NSAMPLES = SampleMatrix::RowsAtCompileTime;
-      constexpr auto NPULSES = SampleMatrix::RowsAtCompileTime;
+      constexpr auto NPULSES = SampleMatrix::ColsAtCompileTime;
       static_assert(NSAMPLES == NPULSES);
 
       using DataType = SampleVector::Scalar;
@@ -146,6 +149,14 @@ namespace ecal {
 
       // FIXME: remove eitehr idx or ch -> they are teh same thing
       int idx = threadIdx.x + blockDim.x * blockIdx.x;
+      
+      // ref the right ptr
+      #define ARRANGE(var) auto *var = idx >= offsetForInputs ? var##EE : var##EB
+      ARRANGE(amplitudes);
+      ARRANGE(chi2s);
+      ARRANGE(energies);
+      #undef ARRANGE
+
       auto const ch = idx;
       if (idx < nchannels) {
         if (static_cast<MinimizationState>(acState[idx]) == MinimizationState::Precomputed)
@@ -348,12 +359,12 @@ namespace ecal {
 
         // store to global output values
         // FIXME: amplitudes are used in global directly
-        chi2s[idx] = chi2;
-        energies[idx] = resultAmplitudes(5);
+        chi2s[inputCh] = chi2;
+        energies[inputCh] = resultAmplitudes(5);
 
 #pragma unroll
         for (int counter = 0; counter < NPULSES; counter++)
-          amplitudes[idx](counter) = resultAmplitudes(counter);
+          amplitudes[inputCh](counter) = resultAmplitudes(counter);
       }
     }
 
@@ -366,27 +377,30 @@ namespace ecal {
                                   ConfigurationParameters const& configParameters,
                                   cudaStream_t cudaStream) {
         using DataType = SampleVector::Scalar;
-        unsigned int totalChannels = eventInputGPU.ebDigis.ndigis + eventInputGPU.eeDigis.ndigis;
+        unsigned int totalChannels = eventInputGPU.ebDigis.size + eventInputGPU.eeDigis.size;
         //    unsigned int threads_min = conf.threads.x;
         // TODO: configure from python
         unsigned int threads_min = configParameters.kernelMinimizeThreads[0];
         unsigned int blocks_min = threads_min > totalChannels ? 1 : (totalChannels + threads_min - 1) / threads_min;
         uint32_t const offsetForHashes = conditions.offsetForHashes;
-        uint32_t const offsetForInputs = eventInputGPU.ebDigis.ndigis;
+        uint32_t const offsetForInputs = eventInputGPU.ebDigis.size;
         auto const nbytesShared =
             2 * threads_min * MapSymM<DataType, SampleVector::RowsAtCompileTime>::total * sizeof(DataType);
         kernel_minimize<<<blocks_min, threads_min, nbytesShared, cudaStream>>>(
-            eventInputGPU.ebDigis.ids,
-            eventInputGPU.eeDigis.ids,
-            scratch.noisecov,
+            eventInputGPU.ebDigis.ids.get(),
+            eventInputGPU.eeDigis.ids.get(),
+            (SampleMatrix*)scratch.noisecov.get(),
             conditions.pulseCovariances.values,
-            scratch.activeBXs,
-            scratch.samples,
-            (SampleVector*)eventOutputGPU.amplitudesAll,
-            scratch.pulse_matrix,
-            eventOutputGPU.chi2,
-            eventOutputGPU.amplitude,
-            scratch.acState,
+            (BXVectorType*)scratch.activeBXs.get(),
+            (SampleVector*)scratch.samples.get(),
+            (SampleVector*)eventOutputGPU.recHitsEB.amplitudesAll.get(),
+            (SampleVector*)eventOutputGPU.recHitsEE.amplitudesAll.get(),
+            (PulseMatrixType*)scratch.pulse_matrix.get(),
+            eventOutputGPU.recHitsEB.chi2.get(),
+            eventOutputGPU.recHitsEE.chi2.get(),
+            eventOutputGPU.recHitsEB.amplitude.get(),
+            eventOutputGPU.recHitsEE.amplitude.get(),
+            scratch.acState.get(),
             totalChannels,
             50,
             offsetForHashes,
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
index 1ea0fcc430882..ffba115f3e019 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
+++ b/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
@@ -7,8 +7,8 @@
 #include <cuda_runtime.h>
 
 #include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 #include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
 #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
 #include "CondFormats/EcalObjects/interface/EcalChannelStatusCode.h"
@@ -32,6 +32,7 @@
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h"
 
 #include "EigenMatrixTypes_gpu.h"
 
@@ -57,8 +58,8 @@ namespace ecal {
 
     //
     struct EventInputDataGPU {
-      ecal::DigisCollection const& ebDigis;
-      ecal::DigisCollection const& eeDigis;
+      ecal::DigisCollection<calo::common::DevStoragePolicy> const& ebDigis;
+      ecal::DigisCollection<calo::common::DevStoragePolicy> const& eeDigis;
     };
 
     // parameters have a fixed type
@@ -89,126 +90,141 @@ namespace ecal {
       std::array<uint32_t, 3> kernelMinimizeThreads;
 
       bool shouldRunTimingComputation;
+
+      uint32_t maxNumberHits;
     };
 
-    struct EventOutputDataGPU final : public ::ecal::UncalibratedRecHit<::ecal::Tag::ptr> {
-      void allocate(ConfigurationParameters const& configParameters, uint32_t size) {
-        cudaCheck(cudaMalloc((void**)&amplitudesAll, size * sizeof(SampleVector)));
-        cudaCheck(cudaMalloc((void**)&amplitude, size * sizeof(::ecal::reco::StorageScalarType)));
-        cudaCheck(cudaMalloc((void**)&chi2, size * sizeof(::ecal::reco::StorageScalarType)));
-        cudaCheck(cudaMalloc((void**)&pedestal, size * sizeof(::ecal::reco::StorageScalarType)));
+    struct EventOutputDataGPU {
+      UncalibratedRecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
+
+      void allocate(ConfigurationParameters const& configParameters, cudaStream_t cudaStream) {
+        auto const size = configParameters.maxNumberHits;
+        recHitsEB.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(size * EcalDataFrame::MAXSAMPLES, cudaStream);
+        recHitsEB.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEB.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEB.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
 
         if (configParameters.shouldRunTimingComputation) {
-          cudaCheck(cudaMalloc((void**)&jitter, size * sizeof(::ecal::reco::StorageScalarType)));
-          cudaCheck(cudaMalloc((void**)&jitterError, size * sizeof(::ecal::reco::StorageScalarType)));
+          recHitsEB.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+          recHitsEB.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
         }
 
-        cudaCheck(cudaMalloc((void**)&did, size * sizeof(uint32_t)));
-        cudaCheck(cudaMalloc((void**)&flags, size * sizeof(uint32_t)));
-      }
+        recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEB.flags = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        
+        recHitsEE.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(size * EcalDataFrame::MAXSAMPLES, cudaStream);
+        recHitsEE.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEE.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEE.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
 
-      void deallocate(ConfigurationParameters const& configParameters) {
-        cudaCheck(cudaFree(amplitudesAll));
-        cudaCheck(cudaFree(amplitude));
-        cudaCheck(cudaFree(chi2));
-        cudaCheck(cudaFree(pedestal));
         if (configParameters.shouldRunTimingComputation) {
-          cudaCheck(cudaFree(jitter));
-          cudaCheck(cudaFree(jitterError));
+          recHitsEE.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
+          recHitsEE.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
         }
-        cudaCheck(cudaFree(did));
-        cudaCheck(cudaFree(flags));
+
+        recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEE.flags = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
       }
     };
+    
+    template<typename EigenM>
+    constexpr auto getLength() -> uint32_t {
+      return EigenM::RowsAtCompileTime * EigenM::ColsAtCompileTime;
+    }
 
     struct EventDataForScratchGPU {
-      SampleVector* samples = nullptr;
-      SampleGainVector* gainsNoise = nullptr;
-
-      SampleMatrix* noisecov = nullptr;
-      PulseMatrixType* pulse_matrix = nullptr;
-      BXVectorType* activeBXs = nullptr;
-      char* acState = nullptr;
-
-      bool *hasSwitchToGain6 = nullptr, *hasSwitchToGain1 = nullptr, *isSaturated = nullptr;
-
-      SampleVector::Scalar *sample_values, *sample_value_errors;
-      bool* useless_sample_values;
-      SampleVector::Scalar* chi2sNullHypot;
-      SampleVector::Scalar* sum0sNullHypot;
-      SampleVector::Scalar* sumAAsNullHypot;
-      char* pedestal_nums;
-      SampleVector::Scalar *tMaxAlphaBetas, *tMaxErrorAlphaBetas;
-      SampleVector::Scalar *accTimeMax, *accTimeWgt;
-      SampleVector::Scalar *ampMaxAlphaBeta, *ampMaxError;
-      SampleVector::Scalar *timeMax, *timeError;
-      TimeComputationState* tcState;
-
-      void allocate(ConfigurationParameters const& configParameters, uint32_t size) {
-        cudaCheck(cudaMalloc((void**)&samples, size * sizeof(SampleVector)));
-        cudaCheck(cudaMalloc((void**)&gainsNoise, size * sizeof(SampleGainVector)));
-
-        cudaCheck(cudaMalloc((void**)&noisecov, size * sizeof(SampleMatrix)));
-        cudaCheck(cudaMalloc((void**)&pulse_matrix, size * sizeof(PulseMatrixType)));
-        cudaCheck(cudaMalloc((void**)&activeBXs, size * sizeof(BXVectorType)));
-        cudaCheck(cudaMalloc((void**)&acState, size * sizeof(char)));
-
-        cudaCheck(cudaMalloc((void**)&hasSwitchToGain6, size * sizeof(bool)));
-        cudaCheck(cudaMalloc((void**)&hasSwitchToGain1, size * sizeof(bool)));
-        cudaCheck(cudaMalloc((void**)&isSaturated, size * sizeof(bool)));
+      using SVT = SampleVector::Scalar;
+      using SGVT = SampleGainVector::Scalar;
+      using SMT = SampleMatrix::Scalar;
+      using PMT = PulseMatrixType::Scalar;
+      using BXVT = BXVectorType::Scalar;
+
+      cms::cuda::device::unique_ptr<SVT[]> samples;
+      cms::cuda::device::unique_ptr<SGVT[]> gainsNoise;
+
+      cms::cuda::device::unique_ptr<SMT[]> noisecov;
+      cms::cuda::device::unique_ptr<PMT[]> pulse_matrix;
+      cms::cuda::device::unique_ptr<BXVT[]> activeBXs;
+      cms::cuda::device::unique_ptr<char[]> acState;
+
+      cms::cuda::device::unique_ptr<bool[]> hasSwitchToGain6, hasSwitchToGain1, isSaturated;
+
+      cms::cuda::device::unique_ptr<SVT[]> sample_values, sample_value_errors;
+      cms::cuda::device::unique_ptr<bool[]> useless_sample_values;
+      cms::cuda::device::unique_ptr<SVT[]> chi2sNullHypot;
+      cms::cuda::device::unique_ptr<SVT[]> sum0sNullHypot;
+      cms::cuda::device::unique_ptr<SVT[]> sumAAsNullHypot;
+      cms::cuda::device::unique_ptr<char[]> pedestal_nums;
+      cms::cuda::device::unique_ptr<SVT[]> tMaxAlphaBetas, tMaxErrorAlphaBetas;
+      cms::cuda::device::unique_ptr<SVT[]> accTimeMax, accTimeWgt;
+      cms::cuda::device::unique_ptr<SVT[]> ampMaxAlphaBeta, ampMaxError;
+      cms::cuda::device::unique_ptr<SVT[]> timeMax, timeError;
+      cms::cuda::device::unique_ptr<TimeComputationState[]> tcState;
+
+      void allocate(ConfigurationParameters const& configParameters, cudaStream_t cudaStream) {
+        constexpr auto svlength = getLength<SampleVector>();
+        constexpr auto sgvlength = getLength<SampleGainVector>();
+        constexpr auto smlength = getLength<SampleMatrix>();
+        constexpr auto pmlength = getLength<PulseMatrixType>();
+        constexpr auto bxvlength = getLength<BXVectorType>();
+        auto const size = configParameters.maxNumberHits;
+
+#define MYMALLOC(var, size) var = cms::cuda::make_device_unique<decltype(var)::element_type[]>(size, cudaStream)
+        MYMALLOC(samples, size*svlength);
+        //cudaCheck(cudaMalloc((void**)&samples, size * sizeof(SampleVector)));
+        MYMALLOC(gainsNoise, size*sgvlength);
+        //cudaCheck(cudaMalloc((void**)&gainsNoise, size * sizeof(SampleGainVector)));
+
+        MYMALLOC(noisecov, size * smlength);
+        //cudaCheck(cudaMalloc((void**)&noisecov, size * sizeof(SampleMatrix)));
+        MYMALLOC(pulse_matrix, size * pmlength);
+        //cudaCheck(cudaMalloc((void**)&pulse_matrix, size * sizeof(PulseMatrixType)));
+        MYMALLOC(activeBXs, size*bxvlength);
+        //cudaCheck(cudaMalloc((void**)&activeBXs, size * sizeof(BXVectorType)));
+        MYMALLOC(acState, size);
+        //cudaCheck(cudaMalloc((void**)&acState, size * sizeof(char)));
+
+        MYMALLOC(hasSwitchToGain6, size);
+        //cudaCheck(cudaMalloc((void**)&hasSwitchToGain6, size * sizeof(bool)));
+        MYMALLOC(hasSwitchToGain1, size);
+        //cudaCheck(cudaMalloc((void**)&hasSwitchToGain1, size * sizeof(bool)));
+        MYMALLOC(isSaturated, size);
+        //cudaCheck(cudaMalloc((void**)&isSaturated, size * sizeof(bool)));
 
         if (configParameters.shouldRunTimingComputation) {
-          cudaCheck(cudaMalloc((void**)&sample_values, size * sizeof(SampleVector)));
-          cudaCheck(cudaMalloc((void**)&sample_value_errors, size * sizeof(SampleVector)));
-          cudaCheck(cudaMalloc((void**)&useless_sample_values, size * sizeof(bool) * EcalDataFrame::MAXSAMPLES));
-          cudaCheck(cudaMalloc((void**)&chi2sNullHypot, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&sum0sNullHypot, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&sumAAsNullHypot, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&pedestal_nums, size * sizeof(char)));
-
-          cudaCheck(cudaMalloc((void**)&tMaxAlphaBetas, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&tMaxErrorAlphaBetas, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&accTimeMax, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&accTimeWgt, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&ampMaxAlphaBeta, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&ampMaxError, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&timeMax, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&timeError, size * sizeof(SampleVector::Scalar)));
-          cudaCheck(cudaMalloc((void**)&tcState, size * sizeof(TimeComputationState)));
-        }
-      }
-
-      void deallocate(ConfigurationParameters const& configParameters) {
-        cudaCheck(cudaFree(samples));
-        cudaCheck(cudaFree(gainsNoise));
-
-        cudaCheck(cudaFree(noisecov));
-        cudaCheck(cudaFree(pulse_matrix));
-        cudaCheck(cudaFree(activeBXs));
-        cudaCheck(cudaFree(acState));
-
-        cudaCheck(cudaFree(hasSwitchToGain6));
-        cudaCheck(cudaFree(hasSwitchToGain1));
-        cudaCheck(cudaFree(isSaturated));
-
-        if (configParameters.shouldRunTimingComputation) {
-          cudaCheck(cudaFree(sample_values));
-          cudaCheck(cudaFree(sample_value_errors));
-          cudaCheck(cudaFree(useless_sample_values));
-          cudaCheck(cudaFree(chi2sNullHypot));
-          cudaCheck(cudaFree(sum0sNullHypot));
-          cudaCheck(cudaFree(sumAAsNullHypot));
-          cudaCheck(cudaFree(pedestal_nums));
-
-          cudaCheck(cudaFree(tMaxAlphaBetas));
-          cudaCheck(cudaFree(tMaxErrorAlphaBetas));
-          cudaCheck(cudaFree(accTimeMax));
-          cudaCheck(cudaFree(accTimeWgt));
-          cudaCheck(cudaFree(ampMaxAlphaBeta));
-          cudaCheck(cudaFree(ampMaxError));
-          cudaCheck(cudaFree(timeMax));
-          cudaCheck(cudaFree(timeError));
-          cudaCheck(cudaFree(tcState));
+          MYMALLOC(sample_values, size*svlength);
+          //cudaCheck(cudaMalloc((void**)&sample_values, size * sizeof(SampleVector)));
+          MYMALLOC(sample_value_errors, size*svlength);
+          //cudaCheck(cudaMalloc((void**)&sample_value_errors, size * sizeof(SampleVector)));
+          MYMALLOC(useless_sample_values, size*EcalDataFrame::MAXSAMPLES);
+          //cudaCheck(cudaMalloc((void**)&useless_sample_values, size * sizeof(bool) * EcalDataFrame::MAXSAMPLES));
+          MYMALLOC(chi2sNullHypot, size);
+          //cudaCheck(cudaMalloc((void**)&chi2sNullHypot, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(sum0sNullHypot, size);
+          //cudaCheck(cudaMalloc((void**)&sum0sNullHypot, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(sumAAsNullHypot, size);
+          //cudaCheck(cudaMalloc((void**)&sumAAsNullHypot, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(pedestal_nums, size);
+          //cudaCheck(cudaMalloc((void**)&pedestal_nums, size * sizeof(char)));
+
+          MYMALLOC(tMaxAlphaBetas, size);
+          //cudaCheck(cudaMalloc((void**)&tMaxAlphaBetas, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(tMaxErrorAlphaBetas, size);
+          //cudaCheck(cudaMalloc((void**)&tMaxErrorAlphaBetas, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(accTimeMax, size);
+          //cudaCheck(cudaMalloc((void**)&accTimeMax, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(accTimeWgt, size);
+          //cudaCheck(cudaMalloc((void**)&accTimeWgt, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(ampMaxAlphaBeta, size);
+          //cudaCheck(cudaMalloc((void**)&ampMaxAlphaBeta, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(ampMaxError, size);
+          //cudaCheck(cudaMalloc((void**)&ampMaxError, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(timeMax, size);
+          //cudaCheck(cudaMalloc((void**)&timeMax, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(timeError, size);
+          //cudaCheck(cudaMalloc((void**)&timeError, size * sizeof(SampleVector::Scalar)));
+          MYMALLOC(tcState, size);
+          //cudaCheck(cudaMalloc((void**)&tcState, size * sizeof(TimeComputationState)));
         }
       }
     };
@@ -225,6 +241,7 @@ namespace ecal {
       EcalSampleMask const& sampleMask;
       EcalTimeOffsetConstant const& timeOffsetConstant;
       uint32_t offsetForHashes;
+      EcalMultifitParametersGPU::Product const& multifitParameters;
     };
 
     //*/
@@ -276,40 +293,38 @@ namespace ecal {
       uint32_t expanded_v_DB_reco_flagsSize;
 
       uint32_t flagmask;
+      uint32_t maxNumberHits;
 
       //
       //       bool shouldRunTimingComputation;
     };
 
-    struct EventOutputDataGPU final : public ::ecal::RecHit<::ecal::Tag::ptr> {
-      void allocate(ConfigurationParameters const& configParameters, uint32_t size) {
-        //      void allocate(uint32_t size) {
-        //---- configParameters -> needed only to decide if to save the timing information or not
-
-        cudaCheck(cudaMalloc((void**)&energy, size * sizeof(::ecal::reco::StorageScalarType)));
-        cudaCheck(cudaMalloc((void**)&time, size * sizeof(::ecal::reco::StorageScalarType)));
-        cudaCheck(cudaMalloc((void**)&chi2, size * sizeof(::ecal::reco::StorageScalarType)));
-        cudaCheck(cudaMalloc((void**)&flagBits, size * sizeof(uint32_t)));
-        cudaCheck(cudaMalloc((void**)&extra, size * sizeof(uint32_t)));
-        cudaCheck(cudaMalloc((void**)&did, size * sizeof(uint32_t)));
-      }
+    struct EventOutputDataGPU {
+      RecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
 
-      void deallocate(ConfigurationParameters const& configParameters) {
-        //     void deallocate() {
+      void allocate(ConfigurationParameters const& configParameters, cudaStream_t cudaStream) {
+        //      void allocate(uint32_t size) {
         //---- configParameters -> needed only to decide if to save the timing information or not
-
-        cudaCheck(cudaFree(energy));
-        cudaCheck(cudaFree(time));
-        cudaCheck(cudaFree(chi2));
-        cudaCheck(cudaFree(flagBits));
-        cudaCheck(cudaFree(extra));
-        cudaCheck(cudaFree(did));
+        auto const size = configParameters.maxNumberHits;
+        recHitsEB.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEB.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEB.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEB.flagBits = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEB.extra = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+
+        recHitsEE.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEE.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEE.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(size, cudaStream);
+        recHitsEE.flagBits = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEE.extra = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
+        recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
       }
     };
 
     struct EventInputDataGPU {
-      ecal::UncalibratedRecHit<ecal::Tag::ptr> const& ebUncalibRecHits;
-      ecal::UncalibratedRecHit<ecal::Tag::ptr> const& eeUncalibRecHits;
+      ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& ebUncalibRecHits;
+      ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& eeUncalibRecHits;
     };
 
     // const refs products to conditions
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
index 8e1b4d399e0c7..10a063dca084e 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
@@ -17,7 +17,7 @@
 
 #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
 
 class EcalCPURecHitProducer : public edm::stream::EDProducer<edm::ExternalWork> {
 public:
@@ -30,10 +30,12 @@ class EcalCPURecHitProducer : public edm::stream::EDProducer<edm::ExternalWork>
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  edm::EDGetTokenT<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>> recHitsInEBToken_, recHitsInEEToken_;
-  edm::EDPutTokenT<ecal::RecHit<ecal::Tag::soa>> recHitsOutEBToken_, recHitsOutEEToken_;
+  using InputProduct = cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>;
+  edm::EDGetTokenT<InputProduct> recHitsInEBToken_, recHitsInEEToken_;
+  using OutputProduct = ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
+  edm::EDPutTokenT<OutputProduct> recHitsOutEBToken_, recHitsOutEEToken_;
 
-  ecal::RecHit<ecal::Tag::soa> recHitsEB_, recHitsEE_;
+  OutputProduct recHitsEB_, recHitsEE_;
   bool containsTimingInformation_;
 };
 
@@ -50,12 +52,12 @@ void EcalCPURecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& con
 }
 
 EcalCPURecHitProducer::EcalCPURecHitProducer(const edm::ParameterSet& ps)
-    : recHitsInEBToken_{consumes<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>>(
+    : recHitsInEBToken_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("recHitsInLabelEB"))},
-      recHitsInEEToken_{consumes<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>>(
+      recHitsInEEToken_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("recHitsInLabelEE"))},
-      recHitsOutEBToken_{produces<ecal::RecHit<ecal::Tag::soa>>(ps.getParameter<std::string>("recHitsOutLabelEB"))},
-      recHitsOutEEToken_{produces<ecal::RecHit<ecal::Tag::soa>>(ps.getParameter<std::string>("recHitsOutLabelEE"))},
+      recHitsOutEBToken_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEB"))},
+      recHitsOutEEToken_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEE"))},
       containsTimingInformation_{ps.getParameter<bool>("containsTimingInformation")} {}
 
 void EcalCPURecHitProducer::acquire(edm::Event const& event,
@@ -77,12 +79,12 @@ void EcalCPURecHitProducer::acquire(edm::Event const& event,
 
   // enqeue transfers
   cudaCheck(cudaMemcpyAsync(recHitsEB_.did.data(),
-                            ebRecHits.did,
+                            ebRecHits.did.get(),
                             recHitsEB_.did.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
   cudaCheck(cudaMemcpyAsync(recHitsEE_.did.data(),
-                            eeRecHits.did,
+                            eeRecHits.did.get(),
                             recHitsEE_.did.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
@@ -91,45 +93,45 @@ void EcalCPURecHitProducer::acquire(edm::Event const& event,
   //
 
   cudaCheck(cudaMemcpyAsync(recHitsEB_.energy.data(),
-                            ebRecHits.energy,
+                            ebRecHits.energy.get(),
                             recHitsEB_.energy.size() * sizeof(::ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
   cudaCheck(cudaMemcpyAsync(recHitsEE_.energy.data(),
-                            eeRecHits.energy,
+                            eeRecHits.energy.get(),
                             recHitsEE_.energy.size() * sizeof(::ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
 
   cudaCheck(cudaMemcpyAsync(recHitsEB_.chi2.data(),
-                            ebRecHits.chi2,
+                            ebRecHits.chi2.get(),
                             recHitsEB_.chi2.size() * sizeof(::ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
   cudaCheck(cudaMemcpyAsync(recHitsEE_.chi2.data(),
-                            eeRecHits.chi2,
+                            eeRecHits.chi2.get(),
                             recHitsEE_.chi2.size() * sizeof(::ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
 
   cudaCheck(cudaMemcpyAsync(recHitsEB_.extra.data(),
-                            ebRecHits.extra,
+                            ebRecHits.extra.get(),
                             recHitsEB_.extra.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
   cudaCheck(cudaMemcpyAsync(recHitsEE_.extra.data(),
-                            eeRecHits.extra,
+                            eeRecHits.extra.get(),
                             recHitsEE_.extra.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
 
   cudaCheck(cudaMemcpyAsync(recHitsEB_.flagBits.data(),
-                            ebRecHits.flagBits,
+                            ebRecHits.flagBits.get(),
                             recHitsEB_.flagBits.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
   cudaCheck(cudaMemcpyAsync(recHitsEE_.flagBits.data(),
-                            eeRecHits.flagBits,
+                            eeRecHits.flagBits.get(),
                             recHitsEE_.flagBits.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
                             ctx.stream()));
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
index 95ccee87c726a..04c8fb9bf3614 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
@@ -16,7 +16,7 @@
 
 #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 
 class EcalCPUUncalibRecHitProducer : public edm::stream::EDProducer<edm::ExternalWork> {
 public:
@@ -29,10 +29,12 @@ class EcalCPUUncalibRecHitProducer : public edm::stream::EDProducer<edm::Externa
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  edm::EDGetTokenT<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>> recHitsInEBToken_, recHitsInEEToken_;
-  edm::EDPutTokenT<ecal::UncalibratedRecHit<ecal::Tag::soa>> recHitsOutEBToken_, recHitsOutEEToken_;
+  using InputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
+  edm::EDGetTokenT<InputProduct> recHitsInEBToken_, recHitsInEEToken_;
+  using OutputProduct = ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
+  edm::EDPutTokenT<OutputProduct> recHitsOutEBToken_, recHitsOutEEToken_;
 
-  ecal::UncalibratedRecHit<ecal::Tag::soa> recHitsEB_, recHitsEE_;
+  OutputProduct recHitsEB_, recHitsEE_;
   bool containsTimingInformation_;
 };
 
@@ -50,14 +52,14 @@ void EcalCPUUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptio
 }
 
 EcalCPUUncalibRecHitProducer::EcalCPUUncalibRecHitProducer(const edm::ParameterSet& ps)
-    : recHitsInEBToken_{consumes<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+    : recHitsInEBToken_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("recHitsInLabelEB"))},
-      recHitsInEEToken_{consumes<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+      recHitsInEEToken_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("recHitsInLabelEE"))},
       recHitsOutEBToken_{
-          produces<ecal::UncalibratedRecHit<ecal::Tag::soa>>(ps.getParameter<std::string>("recHitsOutLabelEB"))},
+          produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEB"))},
       recHitsOutEEToken_{
-          produces<ecal::UncalibratedRecHit<ecal::Tag::soa>>(ps.getParameter<std::string>("recHitsOutLabelEE"))},
+          produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEE"))},
       containsTimingInformation_{ps.getParameter<bool>("containsTimingInformation")} {}
 
 EcalCPUUncalibRecHitProducer::~EcalCPUUncalibRecHitProducer() {}
@@ -79,41 +81,43 @@ void EcalCPUUncalibRecHitProducer::acquire(edm::Event const& event,
   auto lambdaToTransfer = [&ctx](auto& dest, auto* src) {
     using vector_type = typename std::remove_reference<decltype(dest)>::type;
     using type = typename vector_type::value_type;
+    using src_type = typename std::remove_pointer<decltype(src)>::type;
+    static_assert(std::is_same<src_type, type>::value && "dst and src data types do not match");
     cudaCheck(cudaMemcpyAsync(dest.data(), src, dest.size() * sizeof(type), cudaMemcpyDeviceToHost, ctx.stream()));
   };
 
   // enqeue transfers
-  lambdaToTransfer(recHitsEB_.did, ebRecHits.did);
-  lambdaToTransfer(recHitsEE_.did, eeRecHits.did);
+  lambdaToTransfer(recHitsEB_.did, ebRecHits.did.get());
+  lambdaToTransfer(recHitsEE_.did, eeRecHits.did.get());
 
-  lambdaToTransfer(recHitsEB_.amplitudesAll, ebRecHits.amplitudesAll);
-  lambdaToTransfer(recHitsEE_.amplitudesAll, eeRecHits.amplitudesAll);
+  lambdaToTransfer(recHitsEB_.amplitudesAll, ebRecHits.amplitudesAll.get());
+  lambdaToTransfer(recHitsEE_.amplitudesAll, eeRecHits.amplitudesAll.get());
 
-  lambdaToTransfer(recHitsEB_.amplitude, ebRecHits.amplitude);
-  lambdaToTransfer(recHitsEE_.amplitude, eeRecHits.amplitude);
+  lambdaToTransfer(recHitsEB_.amplitude, ebRecHits.amplitude.get());
+  lambdaToTransfer(recHitsEE_.amplitude, eeRecHits.amplitude.get());
 
-  lambdaToTransfer(recHitsEB_.chi2, ebRecHits.chi2);
-  lambdaToTransfer(recHitsEE_.chi2, eeRecHits.chi2);
+  lambdaToTransfer(recHitsEB_.chi2, ebRecHits.chi2.get());
+  lambdaToTransfer(recHitsEE_.chi2, eeRecHits.chi2.get());
 
-  lambdaToTransfer(recHitsEB_.pedestal, ebRecHits.pedestal);
-  lambdaToTransfer(recHitsEE_.pedestal, eeRecHits.pedestal);
+  lambdaToTransfer(recHitsEB_.pedestal, ebRecHits.pedestal.get());
+  lambdaToTransfer(recHitsEE_.pedestal, eeRecHits.pedestal.get());
 
-  lambdaToTransfer(recHitsEB_.flags, ebRecHits.flags);
-  lambdaToTransfer(recHitsEE_.flags, eeRecHits.flags);
+  lambdaToTransfer(recHitsEB_.flags, ebRecHits.flags.get());
+  lambdaToTransfer(recHitsEE_.flags, eeRecHits.flags.get());
 
   if (containsTimingInformation_) {
-    lambdaToTransfer(recHitsEB_.jitter, ebRecHits.jitter);
-    lambdaToTransfer(recHitsEE_.jitter, eeRecHits.jitter);
+    lambdaToTransfer(recHitsEB_.jitter, ebRecHits.jitter.get());
+    lambdaToTransfer(recHitsEE_.jitter, eeRecHits.jitter.get());
 
-    lambdaToTransfer(recHitsEB_.jitterError, ebRecHits.jitterError);
-    lambdaToTransfer(recHitsEE_.jitterError, eeRecHits.jitterError);
+    lambdaToTransfer(recHitsEB_.jitterError, ebRecHits.jitterError.get());
+    lambdaToTransfer(recHitsEE_.jitterError, eeRecHits.jitterError.get());
   }
 }
 
 void EcalCPUUncalibRecHitProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
   // tmp vectors
-  auto recHitsOutEB = std::make_unique<ecal::UncalibratedRecHit<ecal::Tag::soa>>(std::move(recHitsEB_));
-  auto recHitsOutEE = std::make_unique<ecal::UncalibratedRecHit<ecal::Tag::soa>>(std::move(recHitsEE_));
+  auto recHitsOutEB = std::make_unique<OutputProduct>(std::move(recHitsEB_));
+  auto recHitsOutEE = std::make_unique<OutputProduct>(std::move(recHitsEE_));
 
   // put into event
   event.put(recHitsOutEBToken_, std::move(recHitsOutEB));
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc
new file mode 100644
index 0000000000000..070cadcc3e71a
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc
@@ -0,0 +1,73 @@
+#include <array>
+#include <iostream>
+#include <tuple>
+#include <utility>
+
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ESProductHost.h"
+#include "FWCore/Framework/interface/ESTransientHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ReusableObjectHolder.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h"
+#include "EcalMultifitParametersGPURecord.h"
+
+#include "FWCore/Framework/interface/SourceFactory.h"
+
+class EcalMultifitParametersGPUESProducer
+        : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
+public:
+    EcalMultifitParametersGPUESProducer(edm::ParameterSet const&);
+    ~EcalMultifitParametersGPUESProducer() override = default;
+
+    static void fillDescriptions(edm::ConfigurationDescriptions&);
+    std::unique_ptr<EcalMultifitParametersGPU> produce(EcalMultifitParametersGPURecord const&);
+
+protected:
+    void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
+                        const edm::IOVSyncValue&,
+                        edm::ValidityInterval&) override;
+
+private:
+    edm::ParameterSet const& pset_;
+};
+
+EcalMultifitParametersGPUESProducer::EcalMultifitParametersGPUESProducer(
+        edm::ParameterSet const& pset) : pset_{pset}
+{
+    setWhatProduced(this);
+    findingRecord<EcalMultifitParametersGPURecord>();
+}
+
+void EcalMultifitParametersGPUESProducer::setIntervalFor(
+        const edm::eventsetup::EventSetupRecordKey& iKey,
+        const edm::IOVSyncValue& iTime,
+        edm::ValidityInterval& oInterval) {
+    oInterval = edm::ValidityInterval(
+        edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
+}
+
+void EcalMultifitParametersGPUESProducer::fillDescriptions(
+        edm::ConfigurationDescriptions& desc) {
+    edm::ParameterSetDescription d;
+    d.add<std::vector<int>>("pulseOffsets", {-3, -2, -1, 0, 1, 2, 3, 4});
+    d.add<std::vector<double>>("EBtimeFitParameters",
+        {-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01});
+    d.add<std::vector<double>>("EEtimeFitParameters",
+        {-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01});
+    d.add<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652});
+    d.add<std::vector<double>>("EEamplitudeFitParameters", {1.890, 1.400});
+    desc.addWithDefaultLabel(d);
+}
+
+std::unique_ptr<EcalMultifitParametersGPU> EcalMultifitParametersGPUESProducer::produce(
+        EcalMultifitParametersGPURecord const&) {
+    return std::make_unique<EcalMultifitParametersGPU>(pset_);
+}
+
+DEFINE_FWK_EVENTSETUP_SOURCE(EcalMultifitParametersGPUESProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.cc
new file mode 100644
index 0000000000000..435fe16f92b57
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.cc
@@ -0,0 +1,4 @@
+#include "EcalMultifitParametersGPURecord.h"
+
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+EVENTSETUP_RECORD_REG(EcalMultifitParametersGPURecord);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.h
new file mode 100644
index 0000000000000..4fe73467f9a3b
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPURecord.h
@@ -0,0 +1,7 @@
+#ifndef EcalMultifitParametersGPURecord_h
+#define EcalMultifitParametersGPURecord_h
+
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+class EcalMultifitParametersGPURecord : public edm::eventsetup::EventSetupRecordImplementation<EcalMultifitParametersGPURecord> {};
+
+#endif
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
index d816414aa71a0..23f7bf092caee 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
@@ -1,7 +1,7 @@
 #include <cuda.h>
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 
 #include "EcalRecHitBuilderKernels.h"
 #include "KernelHelpers.h"
@@ -118,12 +118,18 @@ namespace ecal {
         uint32_t const* flags_eb,
         uint32_t const* flags_ee,
         // output
-        uint32_t* did,
-        ::ecal::reco::StorageScalarType* energy,  // in energy [GeV]
-        ::ecal::reco::StorageScalarType* time,
-        ::ecal::reco::StorageScalarType* chi2,
-        uint32_t* flagBits,
-        uint32_t* extra,
+        uint32_t* didEB,
+        uint32_t* didEE,
+        ::ecal::reco::StorageScalarType* energyEB,  // in energy [GeV]
+        ::ecal::reco::StorageScalarType* energyEE,  // in energy [GeV]
+        ::ecal::reco::StorageScalarType* timeEB,
+        ::ecal::reco::StorageScalarType* timeEE,
+        ::ecal::reco::StorageScalarType* chi2EB,
+        ::ecal::reco::StorageScalarType* chi2EE,
+        uint32_t* flagBitsEB,
+        uint32_t* flagBitsEE,
+        uint32_t* extraEB,
+        uint32_t* extraEE,
         // other
         int const nchannels,
         uint32_t const nChannelsBarrel,
@@ -143,6 +149,15 @@ namespace ecal {
 
         uint32_t const* didCh = isEndcap ? did_ee : did_eb;
 
+        // arrange to access the right ptrs
+#define ARRANGE(var) auto *var = isEndcap ? var##EE : var##EB
+        ARRANGE(did);
+        ARRANGE(energy);
+        ARRANGE(chi2);
+        ARRANGE(flagBits);
+        ARRANGE(extra);
+#undef ARRANGE
+
         // only two values, EB or EE
         // AM : FIXME : why not using "isBarrel" ?    isBarrel ? adc2gev[0] : adc2gev[1]
         float adc2gev_to_use = isEndcap ? adc2gev[1]   // ee
@@ -159,7 +174,7 @@ namespace ecal {
         uint32_t const* flags_in = isEndcap ? flags_ee : flags_eb;
 
         // simple copy
-        did[ch] = didCh[inputCh];
+        did[inputCh] = didCh[inputCh];
 
         auto const did_to_use = DetId{didCh[inputCh]};
 
@@ -280,17 +295,17 @@ namespace ecal {
         // Default energy? Not to be updated if "ChannelStatusToBeExcluded"
         // Exploited later by the module "EcalRecHitConvertGPU2CPUFormat"
         //
-        energy[ch] = -1;  //---- AM: default, un-physical, ok
+        energy[inputCh] = -1;  //---- AM: default, un-physical, ok
 
         // truncate the chi2
         if (chi2_in[inputCh] > 64)
-          chi2[ch] = 64;
+          chi2[inputCh] = 64;
         else
-          chi2[ch] = chi2_in[inputCh];
+          chi2[inputCh] = chi2_in[inputCh];
 
         // default values for the flags
-        flagBits[ch] = 0;
-        extra[ch] = 0;
+        flagBits[inputCh] = 0;
+        extra[inputCh] = 0;
 
         static const int chStatusMask = 0x1f;
         // ChannelStatusToBeExcluded is a "int" then I put "dbstatus" to be the same
@@ -345,7 +360,7 @@ namespace ecal {
           flagbit_counter += 1;
         }
 
-        flagBits[ch] = temporary_flagBits;
+        flagBits[inputCh] = temporary_flagBits;
 
         if ((flagmask & temporary_flagBits) && killDeadChannels) {
           // skip this channel
@@ -357,7 +372,7 @@ namespace ecal {
         //
 
         //         energy[ch] = amplitude[inputCh] * adc2gev_to_use * intercalib_to_use ;
-        energy[ch] = amplitude[inputCh] * adc2gev_to_use * intercalib_to_use * lasercalib;
+        energy[inputCh] = amplitude[inputCh] * adc2gev_to_use * intercalib_to_use * lasercalib;
 
         // Time is not saved so far, FIXME
         //         time[ch] = time_in[inputCh];
@@ -372,7 +387,7 @@ namespace ecal {
         uint32_t width;
         uint32_t value;
 
-        float chi2_temp = chi2[ch];
+        float chi2_temp = chi2[inputCh];
         if (chi2_temp > 64)
           chi2_temp = 64;
         // use 7 bits
@@ -440,7 +455,7 @@ namespace ecal {
         //
         // now finally set "extra[ch]"
         //
-        extra[ch] = value;
+        extra[inputCh] = value;
 
         //
         // additional flags setting
@@ -452,14 +467,14 @@ namespace ecal {
         bool good = true;
 
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kLeadingEdgeRecovered))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kLeadingEdgeRecovered));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kLeadingEdgeRecovered));
           good = false;
         }
 
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kSaturated))) {
           // leading edge recovery failed - still keep the information
           // about the saturation and do not flag as dead
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
           good = false;
         }
 
@@ -476,34 +491,34 @@ namespace ecal {
         //
 
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kSaturated))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
           good = false;
         }
 
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kOutOfTime))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kOutOfTime));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kOutOfTime));
           good = false;
         }
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kPoorReco))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorReco));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorReco));
           good = false;
         }
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kHasSwitchToGain6))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain6));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain6));
         }
         if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kHasSwitchToGain1))) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain1));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain1));
         }
 
         if (good) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kGood));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kGood));
         }
 
         if (isBarrel && (lasercalib < EBLaserMIN || lasercalib > EBLaserMAX)) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorCalib));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorCalib));
         }
         if (!isBarrel && (lasercalib < EELaserMIN || lasercalib > EELaserMAX)) {
-          flagBits[ch] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorCalib));
+          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorCalib));
         }
 
         // recover, killing, and other stuff
@@ -549,7 +564,7 @@ namespace ecal {
               }
               // kill all the other cases
               else {
-                energy[ch] = 0.;  // Need to set also the flags ...
+                energy[inputCh] = 0.;  // Need to set also the flags ...
               }
             }
           }
@@ -568,7 +583,7 @@ namespace ecal {
               }
               // kill all the other cases
               else {
-                energy[ch] = 0.;  // Need to set also the flags ...
+                energy[inputCh] = 0.;  // Need to set also the flags ...
               }
             }
           }
@@ -645,23 +660,29 @@ namespace ecal {
           // time, used for time dependent corrections
           event_time,
           // input
-          eventInputGPU.ebUncalibRecHits.did,
-          eventInputGPU.eeUncalibRecHits.did,
-          eventInputGPU.ebUncalibRecHits.amplitude,
-          eventInputGPU.eeUncalibRecHits.amplitude,
-          eventInputGPU.ebUncalibRecHits.jitter,
-          eventInputGPU.eeUncalibRecHits.jitter,
-          eventInputGPU.ebUncalibRecHits.chi2,
-          eventInputGPU.eeUncalibRecHits.chi2,
-          eventInputGPU.ebUncalibRecHits.flags,
-          eventInputGPU.eeUncalibRecHits.flags,
+          eventInputGPU.ebUncalibRecHits.did.get(),
+          eventInputGPU.eeUncalibRecHits.did.get(),
+          eventInputGPU.ebUncalibRecHits.amplitude.get(),
+          eventInputGPU.eeUncalibRecHits.amplitude.get(),
+          eventInputGPU.ebUncalibRecHits.jitter.get(),
+          eventInputGPU.eeUncalibRecHits.jitter.get(),
+          eventInputGPU.ebUncalibRecHits.chi2.get(),
+          eventInputGPU.eeUncalibRecHits.chi2.get(),
+          eventInputGPU.ebUncalibRecHits.flags.get(),
+          eventInputGPU.eeUncalibRecHits.flags.get(),
           // output
-          eventOutputGPU.did,
-          eventOutputGPU.energy,
-          eventOutputGPU.time,
-          eventOutputGPU.chi2,
-          eventOutputGPU.flagBits,
-          eventOutputGPU.extra,
+          eventOutputGPU.recHitsEB.did.get(),
+          eventOutputGPU.recHitsEE.did.get(),
+          eventOutputGPU.recHitsEB.energy.get(),
+          eventOutputGPU.recHitsEE.energy.get(),
+          eventOutputGPU.recHitsEB.time.get(),
+          eventOutputGPU.recHitsEE.time.get(),
+          eventOutputGPU.recHitsEB.chi2.get(),
+          eventOutputGPU.recHitsEE.chi2.get(),
+          eventOutputGPU.recHitsEB.flagBits.get(),
+          eventOutputGPU.recHitsEE.flagBits.get(),
+          eventOutputGPU.recHitsEB.extra.get(),
+          eventOutputGPU.recHitsEE.extra.get(),
           // other
           nchannels,
           nChannelsBarrel,
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
index 831c602a24e61..42014ae87642f 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
@@ -5,8 +5,8 @@
 // Builder of ECAL RecHits on GPU
 //
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 #include "DataFormats/Provenance/interface/Timestamp.h"
 
 #include "Common.h"
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
index 5766fa0ffcb85..62d6c140bc13e 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
@@ -1,6 +1,6 @@
 #include <iostream>
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
@@ -19,12 +19,12 @@ class EcalRecHitConvertGPU2CPUFormat : public edm::stream::EDProducer<> {
   static void fillDescriptions(edm::ConfigurationDescriptions&);
 
 private:
-  using GPURecHitType = ecal::RecHit<ecal::Tag::soa>;
+  using InputProduct = ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  const edm::EDGetTokenT<ecal::SoARecHitCollection> recHitsGPUEB_;
-  const edm::EDGetTokenT<ecal::SoARecHitCollection> recHitsGPUEE_;
+  const edm::EDGetTokenT<InputProduct> recHitsGPUEB_;
+  const edm::EDGetTokenT<InputProduct> recHitsGPUEE_;
 
   const std::string recHitsLabelCPUEB_, recHitsLabelCPUEE_;
 };
@@ -42,8 +42,8 @@ void EcalRecHitConvertGPU2CPUFormat::fillDescriptions(edm::ConfigurationDescript
 }
 
 EcalRecHitConvertGPU2CPUFormat::EcalRecHitConvertGPU2CPUFormat(const edm::ParameterSet& ps)
-    : recHitsGPUEB_{consumes<ecal::SoARecHitCollection>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEB"))},
-      recHitsGPUEE_{consumes<ecal::SoARecHitCollection>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEE"))},
+    : recHitsGPUEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEB"))},
+      recHitsGPUEE_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEE"))},
       recHitsLabelCPUEB_{ps.getParameter<std::string>("recHitsLabelCPUEB")},
       recHitsLabelCPUEE_{ps.getParameter<std::string>("recHitsLabelCPUEE")} {
   produces<EBRecHitCollection>(recHitsLabelCPUEB_);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc
new file mode 100644
index 0000000000000..f87fae5a16d39
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc
@@ -0,0 +1,82 @@
+#include <array>
+#include <iostream>
+#include <tuple>
+#include <utility>
+
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ESProductHost.h"
+#include "FWCore/Framework/interface/ESTransientHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ReusableObjectHolder.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h"
+#include "EcalRecHitParametersGPURecord.h"
+
+#include "FWCore/Framework/interface/SourceFactory.h"
+
+class EcalRecHitParametersGPUESProducer
+        : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
+public:
+    EcalRecHitParametersGPUESProducer(edm::ParameterSet const&);
+    ~EcalRecHitParametersGPUESProducer() override = default;
+
+    static void fillDescriptions(edm::ConfigurationDescriptions&);
+    std::unique_ptr<EcalRecHitParametersGPU> produce(EcalRecHitParametersGPURecord const&);
+
+protected:
+    void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
+                        const edm::IOVSyncValue&,
+                        edm::ValidityInterval&) override;
+
+private:
+    edm::ParameterSet const& pset_;
+};
+
+EcalRecHitParametersGPUESProducer::EcalRecHitParametersGPUESProducer(
+        edm::ParameterSet const& pset) : pset_{pset}
+{
+    setWhatProduced(this);
+    findingRecord<EcalRecHitParametersGPURecord>();
+}
+
+void EcalRecHitParametersGPUESProducer::setIntervalFor(
+        const edm::eventsetup::EventSetupRecordKey& iKey,
+        const edm::IOVSyncValue& iTime,
+        edm::ValidityInterval& oInterval) {
+    oInterval = edm::ValidityInterval(
+        edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
+}
+
+void EcalRecHitParametersGPUESProducer::fillDescriptions(
+        edm::ConfigurationDescriptions& desc) {
+    edm::ParameterSetDescription d;
+
+    // ## db statuses to be exluded from reconstruction (some will be recovered)
+    edm::ParameterSetDescription desc_ChannelStatusToBeExcluded;
+    desc_ChannelStatusToBeExcluded.add<std::string>("kDAC");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kNoisy");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kNNoisy");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG6");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG1");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG0");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kNonRespondingIsolated");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kDeadVFE");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kDeadFE");
+    desc_ChannelStatusToBeExcluded.add<std::string>("kNoDataNoTP");
+    std::vector<edm::ParameterSet> default_ChannelStatusToBeExcluded(1);
+    d.addVPSet("ChannelStatusToBeExcluded", desc_ChannelStatusToBeExcluded, default_ChannelStatusToBeExcluded);
+
+    desc.addWithDefaultLabel(d);
+}
+
+std::unique_ptr<EcalRecHitParametersGPU> EcalRecHitParametersGPUESProducer::produce(
+        EcalRecHitParametersGPURecord const&) {
+    return std::make_unique<EcalRecHitParametersGPU>(pset_);
+}
+
+DEFINE_FWK_EVENTSETUP_SOURCE(EcalRecHitParametersGPUESProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.cc
new file mode 100644
index 0000000000000..0425103a73268
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.cc
@@ -0,0 +1,4 @@
+#include "EcalRecHitParametersGPURecord.h"
+
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+EVENTSETUP_RECORD_REG(EcalRecHitParametersGPURecord);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.h
new file mode 100644
index 0000000000000..124fea64eefbc
--- /dev/null
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPURecord.h
@@ -0,0 +1,7 @@
+#ifndef EcalRecHitParametersGPURecord_h
+#define EcalRecHitParametersGPURecord_h
+
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+class EcalRecHitParametersGPURecord : public edm::eventsetup::EventSetupRecordImplementation<EcalRecHitParametersGPURecord> {};
+
+#endif
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
index c13d00a530feb..8c5589f719b70 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
@@ -1,5 +1,5 @@
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit_soa.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 #include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
 #include "CommonTools/Utils/interface/StringToEnumValue.h"
 #include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
@@ -26,8 +26,10 @@
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalLinearCorrectionsGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitADCToGeVConstantGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitChannelStatusGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitParametersGPU.h"
 
 #include "EcalRecHitBuilderKernels.h"
+#include "EcalRecHitParametersGPURecord.h"
 
 class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 public:
@@ -36,7 +38,6 @@ class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork>
   static void fillDescriptions(edm::ConfigurationDescriptions&);
 
 private:
-  using RecHitType = ecal::RecHit<ecal::Tag::soa>;
   void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
@@ -45,8 +46,9 @@ class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork>
   uint32_t neb_, nee_;  // extremely important, in particular neb_
 
   // gpu input
-  edm::EDGetTokenT<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>> uncalibRecHitsInEBToken_;
-  edm::EDGetTokenT<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>> uncalibRecHitsInEEToken_;
+  using InputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
+  edm::EDGetTokenT<InputProduct> uncalibRecHitsInEBToken_;
+  edm::EDGetTokenT<InputProduct> uncalibRecHitsInEEToken_;
 
   // event data
   ecal::rechit::EventOutputDataGPU eventOutputDataGPU_;
@@ -54,11 +56,11 @@ class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork>
   cms::cuda::ContextState cudaState_;
 
   // gpu output
-  edm::EDPutTokenT<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>> recHitsTokenEB_, recHitsTokenEE_;
+  using OutputProduct = cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>;
+  edm::EDPutTokenT<OutputProduct> recHitsTokenEB_, recHitsTokenEE_;
 
   // configuration parameters
   ecal::rechit::ConfigurationParameters configParameters_;
-  uint32_t maxNumberHits_;
 
   // conditions handles
   edm::ESHandle<EcalRechitADCToGeVConstantGPU> ADCToGeVConstantHandle_;
@@ -69,6 +71,7 @@ class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork>
   edm::ESHandle<EcalLaserAPDPNRatiosRefGPU> LaserAPDPNRatiosRefHandle_;
   edm::ESHandle<EcalLaserAlphasGPU> LaserAlphasHandle_;
   edm::ESHandle<EcalLinearCorrectionsGPU> LinearCorrectionsHandle_;
+  edm::ESHandle<EcalRecHitParametersGPU> recHitParametersHandle_;
 
   // configuration
   std::vector<int> v_chstatus_;
@@ -106,37 +109,20 @@ void EcalRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptions& con
   desc.add<double>("EELaserMAX", 30.0);
 
   desc.add<uint32_t>("maxNumberHits", 20000);
-
-  // ## db statuses to be exluded from reconstruction (some will be recovered)
-  edm::ParameterSetDescription desc_ChannelStatusToBeExcluded;
-  desc_ChannelStatusToBeExcluded.add<std::string>("kDAC");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kNoisy");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kNNoisy");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG6");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG1");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kFixedG0");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kNonRespondingIsolated");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kDeadVFE");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kDeadFE");
-  desc_ChannelStatusToBeExcluded.add<std::string>("kNoDataNoTP");
-
-  std::vector<edm::ParameterSet> default_ChannelStatusToBeExcluded(1);
-
-  desc.addVPSet("ChannelStatusToBeExcluded", desc_ChannelStatusToBeExcluded, default_ChannelStatusToBeExcluded);
 }
 
 EcalRecHitProducerGPU::EcalRecHitProducerGPU(const edm::ParameterSet& ps) {
   //---- input
-  uncalibRecHitsInEBToken_ = consumes<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+  uncalibRecHitsInEBToken_ = consumes<InputProduct>(
       ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEB"));
-  uncalibRecHitsInEEToken_ = consumes<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+  uncalibRecHitsInEEToken_ = consumes<InputProduct>(
       ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEE"));
 
   //---- output
   recHitsTokenEB_ =
-      produces<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>>(ps.getParameter<std::string>("recHitsLabelEB"));
+      produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"));
   recHitsTokenEE_ =
-      produces<cms::cuda::Product<ecal::RecHit<ecal::Tag::ptr>>>(ps.getParameter<std::string>("recHitsLabelEE"));
+      produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEE"));
 
   //---- db statuses to be exluded from reconstruction
   v_chstatus_ = StringToEnumValue<EcalChannelStatusCode::Code>(
@@ -151,80 +137,7 @@ EcalRecHitProducerGPU::EcalRecHitProducerGPU(const edm::ParameterSet& ps) {
   configParameters_.EELaserMAX = ps.getParameter<double>("EELaserMAX");
 
   // max number of digis to allocate for
-  maxNumberHits_ = ps.getParameter<uint32_t>("maxNumberHits");
-
-  // allocate event output data
-  eventOutputDataGPU_.allocate(configParameters_, maxNumberHits_);
-
-  configParameters_.ChannelStatusToBeExcludedSize = v_chstatus_.size();
-
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    cudaCheck(cudaMalloc((void**)&configParameters_.ChannelStatusToBeExcluded, sizeof(int) * v_chstatus_.size()));
-    cudaCheck(cudaMemcpy(configParameters_.ChannelStatusToBeExcluded,
-                         v_chstatus_.data(),
-                         v_chstatus_.size() * sizeof(int),
-                         cudaMemcpyHostToDevice));
-  }
-
-  //
-  //     https://github.com/cms-sw/cmssw/blob/266e21cfc9eb409b093e4cf064f4c0a24c6ac293/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitWorkerSimple.cc
-  //
-
-  // Traslate string representation of flagsMapDBReco into enum values
-  const edm::ParameterSet& p = ps.getParameter<edm::ParameterSet>("flagsMapDBReco");
-  std::vector<std::string> recoflagbitsStrings = p.getParameterNames();
-  //   v_DB_reco_flags_.resize(32);
-
-  for (unsigned int i = 0; i != recoflagbitsStrings.size(); ++i) {
-    EcalRecHit::Flags recoflagbit = (EcalRecHit::Flags)StringToEnumValue<EcalRecHit::Flags>(recoflagbitsStrings[i]);
-    std::vector<std::string> dbstatus_s = p.getParameter<std::vector<std::string>>(recoflagbitsStrings[i]);
-    //     std::vector<uint32_t> dbstatuses;
-    for (unsigned int j = 0; j != dbstatus_s.size(); ++j) {
-      EcalChannelStatusCode::Code dbstatus =
-          (EcalChannelStatusCode::Code)StringToEnumValue<EcalChannelStatusCode::Code>(dbstatus_s[j]);
-      //       dbstatuses.push_back(dbstatus);
-      expanded_v_DB_reco_flags_.push_back(dbstatus);
-    }
-
-    expanded_Sizes_v_DB_reco_flags_.push_back(dbstatus_s.size());
-    expanded_flagbit_v_DB_reco_flags_.push_back(recoflagbit);
-
-    //     v_DB_reco_flags_[recoflagbit] = dbstatuses;
-  }
-
-  // call CUDA API functions only if CUDA is available
-  if (cs and cs->enabled()) {
-    // actual values
-    cudaCheck(cudaMalloc((void**)&configParameters_.expanded_v_DB_reco_flags,
-                         sizeof(int) * expanded_v_DB_reco_flags_.size()));
-
-    cudaCheck(cudaMemcpy(configParameters_.expanded_v_DB_reco_flags,
-                         expanded_v_DB_reco_flags_.data(),
-                         expanded_v_DB_reco_flags_.size() * sizeof(int),
-                         cudaMemcpyHostToDevice));
-
-    // sizes
-    cudaCheck(cudaMalloc((void**)&configParameters_.expanded_Sizes_v_DB_reco_flags,
-                         sizeof(uint32_t) * expanded_Sizes_v_DB_reco_flags_.size()));
-
-    cudaCheck(cudaMemcpy(configParameters_.expanded_Sizes_v_DB_reco_flags,
-                         expanded_Sizes_v_DB_reco_flags_.data(),
-                         expanded_Sizes_v_DB_reco_flags_.size() * sizeof(uint32_t),
-                         cudaMemcpyHostToDevice));
-
-    // keys
-    cudaCheck(cudaMalloc((void**)&configParameters_.expanded_flagbit_v_DB_reco_flags,
-                         sizeof(uint32_t) * expanded_flagbit_v_DB_reco_flags_.size()));
-
-    cudaCheck(cudaMemcpy(configParameters_.expanded_flagbit_v_DB_reco_flags,
-                         expanded_flagbit_v_DB_reco_flags_.data(),
-                         expanded_flagbit_v_DB_reco_flags_.size() * sizeof(uint32_t),
-                         cudaMemcpyHostToDevice));
-  }
-
-  configParameters_.expanded_v_DB_reco_flagsSize = expanded_flagbit_v_DB_reco_flags_.size();
+  configParameters_.maxNumberHits = ps.getParameter<uint32_t>("maxNumberHits");
 
   flagmask_ = 0;
   flagmask_ |= 0x1 << EcalRecHit::kNeighboursRecovered;
@@ -246,21 +159,7 @@ EcalRecHitProducerGPU::EcalRecHitProducerGPU(const edm::ParameterSet& ps) {
   configParameters_.recoverEEFE = ps.getParameter<bool>("recoverEEFE");
 }
 
-EcalRecHitProducerGPU::~EcalRecHitProducerGPU() {
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    // free event ouput data
-    eventOutputDataGPU_.deallocate(configParameters_);
-
-    // FIXME AM: do I need to do this?
-    //           Or can I do it as part of "deallocate" ?
-    cudaCheck(cudaFree(configParameters_.ChannelStatusToBeExcluded));
-
-    cudaCheck(cudaFree(configParameters_.expanded_v_DB_reco_flags));
-    cudaCheck(cudaFree(configParameters_.expanded_Sizes_v_DB_reco_flags));
-    cudaCheck(cudaFree(configParameters_.expanded_flagbit_v_DB_reco_flags));
-  }
-}
+EcalRecHitProducerGPU::~EcalRecHitProducerGPU() {}
 
 void EcalRecHitProducerGPU::acquire(edm::Event const& event,
                                     edm::EventSetup const& setup,
@@ -280,7 +179,7 @@ void EcalRecHitProducerGPU::acquire(edm::Event const& event,
   nee_ = eeUncalibRecHits.size;
   // std::cout << " [EcalRecHitProducerGPU::acquire]  neb_:nee_ = " << neb_ << " : " << nee_ << std::endl;
 
-  if ((neb_ + nee_) > maxNumberHits_) {
+  if ((neb_ + nee_) > configParameters_.maxNumberHits) {
     edm::LogError("EcalRecHitProducerGPU") << "max number of channels exceeded. See options 'maxNumberHits' ";
   }
 
@@ -300,6 +199,7 @@ void EcalRecHitProducerGPU::acquire(edm::Event const& event,
   setup.get<EcalLaserAPDPNRatiosRefRcd>().get(LaserAPDPNRatiosRefHandle_);
   setup.get<EcalLaserAlphasRcd>().get(LaserAlphasHandle_);
   setup.get<EcalLinearCorrectionsRcd>().get(LinearCorrectionsHandle_);
+  setup.get<EcalRecHitParametersGPURecord>().get(recHitParametersHandle_);
 
   auto const& ADCToGeVConstantProduct = ADCToGeVConstantHandle_->getProduct(ctx.stream());
   auto const& IntercalibConstantsProduct = IntercalibConstantsHandle_->getProduct(ctx.stream());
@@ -309,6 +209,15 @@ void EcalRecHitProducerGPU::acquire(edm::Event const& event,
   auto const& LaserAPDPNRatiosRefProduct = LaserAPDPNRatiosRefHandle_->getProduct(ctx.stream());
   auto const& LaserAlphasProduct = LaserAlphasHandle_->getProduct(ctx.stream());
   auto const& LinearCorrectionsProduct = LinearCorrectionsHandle_->getProduct(ctx.stream());
+  auto const& recHitParametersProduct = recHitParametersHandle_->getProduct(ctx.stream());
+
+  // set config ptrs : this is done to avoid changing things downstream
+  configParameters_.ChannelStatusToBeExcluded = recHitParametersProduct.ChannelStatusToBeExcluded;
+  configParameters_.ChannelStatusToBeExcludedSize = std::get<0>(recHitParametersHandle_->getValues()).get().size();
+  configParameters_.expanded_v_DB_reco_flags = recHitParametersProduct.expanded_v_DB_reco_flags;
+  configParameters_.expanded_Sizes_v_DB_reco_flags = recHitParametersProduct.expanded_Sizes_v_DB_reco_flags;
+  configParameters_.expanded_flagbit_v_DB_reco_flags = recHitParametersProduct.expanded_flagbit_v_DB_reco_flags;
+  configParameters_.expanded_v_DB_reco_flagsSize = std::get<3>(recHitParametersHandle_->getValues()).get().size();
 
   // bundle up conditions
   ecal::rechit::ConditionsProducts conditions{ADCToGeVConstantProduct,
@@ -322,6 +231,9 @@ void EcalRecHitProducerGPU::acquire(edm::Event const& event,
                                               //
                                               IntercalibConstantsHandle_->getOffset()};
 
+  // dev mem
+  eventOutputDataGPU_.allocate(configParameters_, ctx.stream());
+
   //
   // schedule algorithms
   //
@@ -344,26 +256,12 @@ void EcalRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup const& se
   //DurationMeasurer<std::chrono::milliseconds> timer{std::string{"produce duration"}};
   cms::cuda::ScopedContextProduce ctx{cudaState_};
 
-  // copy construct output collections
-  // note, output collections do not own device memory!
-  ecal::RecHit<ecal::Tag::ptr> ebRecHits{eventOutputDataGPU_};
-  ecal::RecHit<ecal::Tag::ptr> eeRecHits{eventOutputDataGPU_};
-
-  // set the size of eb and ee
-  ebRecHits.size = neb_;
-  eeRecHits.size = nee_;
-
-  // shift ptrs for ee
-  eeRecHits.energy += neb_;
-  eeRecHits.chi2 += neb_;
-  eeRecHits.did += neb_;
-  eeRecHits.time += neb_;
-  eeRecHits.extra += neb_;
-  eeRecHits.flagBits += neb_;
+  eventOutputDataGPU_.recHitsEB.size = neb_;
+  eventOutputDataGPU_.recHitsEE.size = nee_;
 
   // put into the event
-  ctx.emplace(event, recHitsTokenEB_, std::move(ebRecHits));
-  ctx.emplace(event, recHitsTokenEE_, std::move(eeRecHits));
+  ctx.emplace(event, recHitsTokenEB_, std::move(eventOutputDataGPU_.recHitsEB));
+  ctx.emplace(event, recHitsTokenEE_, std::move(eventOutputDataGPU_.recHitsEE));
 }
 
 DEFINE_FWK_MODULE(EcalRecHitProducerGPU);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc
index 69c6b7a67831c..18f20b19d3e37 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc
@@ -1,6 +1,6 @@
 #include <iostream>
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
 #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
 #include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
@@ -19,12 +19,12 @@ class EcalUncalibRecHitConvertGPU2CPUFormat : public edm::stream::EDProducer<> {
   static void fillDescriptions(edm::ConfigurationDescriptions&);
 
 private:
-  using GPURecHitType = ecal::UncalibratedRecHit<ecal::Tag::soa>;
+  using InputProduct = ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  const edm::EDGetTokenT<ecal::SoAUncalibratedRecHitCollection> recHitsGPUEB_;
-  const edm::EDGetTokenT<ecal::SoAUncalibratedRecHitCollection> recHitsGPUEE_;
+  const edm::EDGetTokenT<InputProduct> recHitsGPUEB_;
+  const edm::EDGetTokenT<InputProduct> recHitsGPUEE_;
 
   const std::string recHitsLabelCPUEB_, recHitsLabelCPUEE_;
 };
@@ -43,10 +43,10 @@ void EcalUncalibRecHitConvertGPU2CPUFormat::fillDescriptions(edm::ConfigurationD
 }
 
 EcalUncalibRecHitConvertGPU2CPUFormat::EcalUncalibRecHitConvertGPU2CPUFormat(const edm::ParameterSet& ps)
-    : recHitsGPUEB_{consumes<ecal::SoAUncalibratedRecHitCollection>(
+    : recHitsGPUEB_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("recHitsLabelGPUEB"))},
       recHitsGPUEE_{
-          consumes<ecal::SoAUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEE"))},
+          consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEE"))},
       recHitsLabelCPUEB_{ps.getParameter<std::string>("recHitsLabelCPUEB")},
       recHitsLabelCPUEE_{ps.getParameter<std::string>("recHitsLabelCPUEE")} {
   produces<EBUncalibratedRecHitCollection>(recHitsLabelCPUEB_);
@@ -56,7 +56,7 @@ EcalUncalibRecHitConvertGPU2CPUFormat::EcalUncalibRecHitConvertGPU2CPUFormat(con
 EcalUncalibRecHitConvertGPU2CPUFormat::~EcalUncalibRecHitConvertGPU2CPUFormat() {}
 
 void EcalUncalibRecHitConvertGPU2CPUFormat::produce(edm::Event& event, edm::EventSetup const& setup) {
-  edm::Handle<ecal::SoAUncalibratedRecHitCollection> hRecHitsGPUEB, hRecHitsGPUEE;
+  edm::Handle<InputProduct> hRecHitsGPUEB, hRecHitsGPUEE;
   event.getByToken(recHitsGPUEB_, hRecHitsGPUEB);
   event.getByToken(recHitsGPUEE_, hRecHitsGPUEE);
 
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgo_gpu_new.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgo_gpu_new.cu
index e79a5dff85d9f..b0aed9cfd5b47 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgo_gpu_new.cu
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgo_gpu_new.cu
@@ -40,8 +40,8 @@ namespace ecal {
       bool const gainSwitchUseMaxSampleEE = false;
 
       uint32_t const offsetForHashes = conditions.offsetForHashes;
-      uint32_t const offsetForInputs = eventInputGPU.ebDigis.ndigis;
-      unsigned int totalChannels = eventInputGPU.ebDigis.ndigis + eventInputGPU.eeDigis.ndigis;
+      uint32_t const offsetForInputs = eventInputGPU.ebDigis.size;
+      unsigned int totalChannels = eventInputGPU.ebDigis.size + eventInputGPU.eeDigis.size;
 
       //
       // 1d preparation kernel
@@ -53,29 +53,35 @@ namespace ecal {
                          (sizeof(bool) + sizeof(bool) + sizeof(bool) + sizeof(bool) + sizeof(char) + sizeof(bool));
       kernel_prep_1d_and_initialize<<<blocks_1d, threads_1d, shared_bytes, cudaStream>>>(
           conditions.pulseShapes.values,
-          eventInputGPU.ebDigis.data,
-          eventInputGPU.ebDigis.ids,
-          eventInputGPU.eeDigis.data,
-          eventInputGPU.eeDigis.ids,
-          scratch.samples,
-          (SampleVector*)eventOutputGPU.amplitudesAll,
-          scratch.gainsNoise,
+          eventInputGPU.ebDigis.data.get(),
+          eventInputGPU.ebDigis.ids.get(),
+          eventInputGPU.eeDigis.data.get(),
+          eventInputGPU.eeDigis.ids.get(),
+          (SampleVector*)scratch.samples.get(),
+          (SampleVector*)eventOutputGPU.recHitsEB.amplitudesAll.get(),
+          (SampleVector*)eventOutputGPU.recHitsEE.amplitudesAll.get(),
+          (SampleGainVector*)scratch.gainsNoise.get(),
           conditions.pedestals.mean_x1,
           conditions.pedestals.mean_x12,
           conditions.pedestals.rms_x12,
           conditions.pedestals.mean_x6,
           conditions.gainRatios.gain6Over1,
           conditions.gainRatios.gain12Over6,
-          scratch.hasSwitchToGain6,
-          scratch.hasSwitchToGain1,
-          scratch.isSaturated,
-          eventOutputGPU.amplitude,
-          eventOutputGPU.chi2,
-          eventOutputGPU.pedestal,
-          eventOutputGPU.did,
-          eventOutputGPU.flags,
-          scratch.acState,
-          scratch.activeBXs,
+          scratch.hasSwitchToGain6.get(),
+          scratch.hasSwitchToGain1.get(),
+          scratch.isSaturated.get(),
+          eventOutputGPU.recHitsEB.amplitude.get(),
+          eventOutputGPU.recHitsEE.amplitude.get(),
+          eventOutputGPU.recHitsEB.chi2.get(),
+          eventOutputGPU.recHitsEE.chi2.get(),
+          eventOutputGPU.recHitsEB.pedestal.get(),
+          eventOutputGPU.recHitsEE.pedestal.get(),
+          eventOutputGPU.recHitsEB.did.get(),
+          eventOutputGPU.recHitsEE.did.get(),
+          eventOutputGPU.recHitsEB.flags.get(),
+          eventOutputGPU.recHitsEE.flags.get(),
+          scratch.acState.get(),
+          (BXVectorType*)scratch.activeBXs.get(),
           offsetForHashes,
           offsetForInputs,
           gainSwitchUseMaxSampleEB,
@@ -88,9 +94,9 @@ namespace ecal {
       //
       int blocks_2d = totalChannels;
       dim3 threads_2d{10, 10};
-      kernel_prep_2d<<<blocks_2d, threads_2d, 0, cudaStream>>>(scratch.gainsNoise,
-                                                               eventInputGPU.ebDigis.ids,
-                                                               eventInputGPU.eeDigis.ids,
+      kernel_prep_2d<<<blocks_2d, threads_2d, 0, cudaStream>>>((SampleGainVector*)scratch.gainsNoise.get(),
+                                                               eventInputGPU.ebDigis.ids.get(),
+                                                               eventInputGPU.eeDigis.ids.get(),
                                                                conditions.pedestals.rms_x12,
                                                                conditions.pedestals.rms_x6,
                                                                conditions.pedestals.rms_x1,
@@ -102,12 +108,12 @@ namespace ecal {
                                                                conditions.samplesCorrelation.EEG12SamplesCorrelation,
                                                                conditions.samplesCorrelation.EEG6SamplesCorrelation,
                                                                conditions.samplesCorrelation.EEG1SamplesCorrelation,
-                                                               scratch.noisecov,
-                                                               scratch.pulse_matrix,
+                                                               (SampleMatrix*)scratch.noisecov.get(),
+                                                               (PulseMatrixType*)scratch.pulse_matrix.get(),
                                                                conditions.pulseShapes.values,
-                                                               scratch.hasSwitchToGain6,
-                                                               scratch.hasSwitchToGain1,
-                                                               scratch.isSaturated,
+                                                               scratch.hasSwitchToGain6.get(),
+                                                               scratch.hasSwitchToGain1.get(),
+                                                               scratch.isSaturated.get(),
                                                                offsetForHashes,
                                                                offsetForInputs);
       cudaCheck(cudaGetLastError());
@@ -124,10 +130,10 @@ namespace ecal {
         unsigned int blocks_time_init = blocks_1d;
         int sharedBytesInit = 2 * threads_time_init * sizeof(SampleVector::Scalar);
         kernel_time_computation_init<<<blocks_time_init, threads_time_init, sharedBytesInit, cudaStream>>>(
-            eventInputGPU.ebDigis.data,
-            eventInputGPU.ebDigis.ids,
-            eventInputGPU.eeDigis.data,
-            eventInputGPU.eeDigis.ids,
+            eventInputGPU.ebDigis.data.get(),
+            eventInputGPU.ebDigis.ids.get(),
+            eventInputGPU.eeDigis.data.get(),
+            eventInputGPU.eeDigis.ids.get(),
             conditions.pedestals.rms_x12,
             conditions.pedestals.rms_x6,
             conditions.pedestals.rms_x1,
@@ -136,11 +142,11 @@ namespace ecal {
             conditions.pedestals.mean_x1,
             conditions.gainRatios.gain12Over6,
             conditions.gainRatios.gain6Over1,
-            scratch.sample_values,
-            scratch.sample_value_errors,
-            scratch.ampMaxError,
-            scratch.useless_sample_values,
-            scratch.pedestal_nums,
+            scratch.sample_values.get(),
+            scratch.sample_value_errors.get(),
+            scratch.ampMaxError.get(),
+            scratch.useless_sample_values.get(),
+            scratch.pedestal_nums.get(),
             offsetForHashes,
             offsetForInputs,
             conditions.sampleMask.getEcalSampleMaskRecordEB(),
@@ -156,15 +162,15 @@ namespace ecal {
         // therefore we need to create threads/blocks only for that
         unsigned int const threadsFixMGPA = threads_1d;
         unsigned int const blocksFixMGPA =
-            threadsFixMGPA > 10 * eventInputGPU.ebDigis.ndigis
+            threadsFixMGPA > 10 * eventInputGPU.ebDigis.size
                 ? 1
-                : (10 * eventInputGPU.ebDigis.ndigis + threadsFixMGPA - 1) / threadsFixMGPA;
+                : (10 * eventInputGPU.ebDigis.size + threadsFixMGPA - 1) / threadsFixMGPA;
         kernel_time_compute_fixMGPAslew<<<blocksFixMGPA, threadsFixMGPA, 0, cudaStream>>>(
-            eventInputGPU.ebDigis.data,
-            eventInputGPU.eeDigis.data,
-            scratch.sample_values,
-            scratch.sample_value_errors,
-            scratch.useless_sample_values,
+            eventInputGPU.ebDigis.data.get(),
+            eventInputGPU.eeDigis.data.get(),
+            scratch.sample_values.get(),
+            scratch.sample_value_errors.get(),
+            scratch.useless_sample_values.get(),
             conditions.sampleMask.getEcalSampleMaskRecordEB(),
             totalChannels,
             offsetForInputs);
@@ -177,12 +183,12 @@ namespace ecal {
         auto const threads_nullhypot = threads_1d;
         auto const blocks_nullhypot = blocks_1d;
         kernel_time_compute_nullhypot<<<blocks_nullhypot, threads_nullhypot, sharedBytes, cudaStream>>>(
-            scratch.sample_values,
-            scratch.sample_value_errors,
-            scratch.useless_sample_values,
-            scratch.chi2sNullHypot,
-            scratch.sum0sNullHypot,
-            scratch.sumAAsNullHypot,
+            scratch.sample_values.get(),
+            scratch.sample_value_errors.get(),
+            scratch.useless_sample_values.get(),
+            scratch.chi2sNullHypot.get(),
+            scratch.sum0sNullHypot.get(),
+            scratch.sumAAsNullHypot.get(),
             totalChannels);
         cudaCheck(cudaGetLastError());
 
@@ -193,23 +199,23 @@ namespace ecal {
                                             : (totalChannels * 45 + threads_makeratio - 1) / threads_makeratio;
         int sharedBytesMakeRatio = 5 * threads_makeratio * sizeof(SampleVector::Scalar);
         kernel_time_compute_makeratio<<<blocks_makeratio, threads_makeratio, sharedBytesMakeRatio, cudaStream>>>(
-            scratch.sample_values,
-            scratch.sample_value_errors,
-            eventInputGPU.ebDigis.ids,
-            eventInputGPU.eeDigis.ids,
-            scratch.useless_sample_values,
-            scratch.pedestal_nums,
+            scratch.sample_values.get(),
+            scratch.sample_value_errors.get(),
+            eventInputGPU.ebDigis.ids.get(),
+            eventInputGPU.eeDigis.ids.get(),
+            scratch.useless_sample_values.get(),
+            scratch.pedestal_nums.get(),
             configParameters.amplitudeFitParametersEB,
             configParameters.amplitudeFitParametersEE,
             configParameters.timeFitParametersEB,
             configParameters.timeFitParametersEE,
-            scratch.sumAAsNullHypot,
-            scratch.sum0sNullHypot,
-            scratch.tMaxAlphaBetas,
-            scratch.tMaxErrorAlphaBetas,
-            scratch.accTimeMax,
-            scratch.accTimeWgt,
-            scratch.tcState,
+            scratch.sumAAsNullHypot.get(),
+            scratch.sum0sNullHypot.get(),
+            scratch.tMaxAlphaBetas.get(),
+            scratch.tMaxErrorAlphaBetas.get(),
+            scratch.accTimeMax.get(),
+            scratch.accTimeWgt.get(),
+            scratch.tcState.get(),
             configParameters.timeFitParametersSizeEB,
             configParameters.timeFitParametersSizeEE,
             configParameters.timeFitLimitsFirstEB,
@@ -229,25 +235,25 @@ namespace ecal {
         kernel_time_compute_findamplchi2_and_finish<<<blocks_findamplchi2,
                                                       threads_findamplchi2,
                                                       sharedBytesFindAmplChi2,
-                                                      cudaStream>>>(scratch.sample_values,
-                                                                    scratch.sample_value_errors,
-                                                                    eventInputGPU.ebDigis.ids,
-                                                                    eventInputGPU.eeDigis.ids,
-                                                                    scratch.useless_sample_values,
-                                                                    scratch.tMaxAlphaBetas,
-                                                                    scratch.tMaxErrorAlphaBetas,
-                                                                    scratch.accTimeMax,
-                                                                    scratch.accTimeWgt,
+                                                      cudaStream>>>(scratch.sample_values.get(),
+                                                                    scratch.sample_value_errors.get(),
+                                                                    eventInputGPU.ebDigis.ids.get(),
+                                                                    eventInputGPU.eeDigis.ids.get(),
+                                                                    scratch.useless_sample_values.get(),
+                                                                    scratch.tMaxAlphaBetas.get(),
+                                                                    scratch.tMaxErrorAlphaBetas.get(),
+                                                                    scratch.accTimeMax.get(),
+                                                                    scratch.accTimeWgt.get(),
                                                                     configParameters.amplitudeFitParametersEB,
                                                                     configParameters.amplitudeFitParametersEE,
-                                                                    scratch.sumAAsNullHypot,
-                                                                    scratch.sum0sNullHypot,
-                                                                    scratch.chi2sNullHypot,
-                                                                    scratch.tcState,
-                                                                    scratch.ampMaxAlphaBeta,
-                                                                    scratch.ampMaxError,
-                                                                    scratch.timeMax,
-                                                                    scratch.timeError,
+                                                                    scratch.sumAAsNullHypot.get(),
+                                                                    scratch.sum0sNullHypot.get(),
+                                                                    scratch.chi2sNullHypot.get(),
+                                                                    scratch.tcState.get(),
+                                                                    scratch.ampMaxAlphaBeta.get(),
+                                                                    scratch.ampMaxError.get(),
+                                                                    scratch.timeMax.get(),
+                                                                    scratch.timeError.get(),
                                                                     totalChannels,
                                                                     offsetForInputs);
         cudaCheck(cudaGetLastError());
@@ -259,22 +265,26 @@ namespace ecal {
         auto const blocks_timecorr =
             threads_timecorr > totalChannels ? 1 : (totalChannels + threads_timecorr - 1) / threads_timecorr;
         kernel_time_correction_and_finalize<<<blocks_timecorr, threads_timecorr, 0, cudaStream>>>(
-            eventOutputGPU.amplitude,
-            eventInputGPU.ebDigis.data,
-            eventInputGPU.ebDigis.ids,
-            eventInputGPU.eeDigis.data,
-            eventInputGPU.eeDigis.ids,
+            eventOutputGPU.recHitsEB.amplitude.get(),
+            eventOutputGPU.recHitsEE.amplitude.get(),
+            eventInputGPU.ebDigis.data.get(),
+            eventInputGPU.ebDigis.ids.get(),
+            eventInputGPU.eeDigis.data.get(),
+            eventInputGPU.eeDigis.ids.get(),
             conditions.timeBiasCorrections.EBTimeCorrAmplitudeBins,
             conditions.timeBiasCorrections.EETimeCorrAmplitudeBins,
             conditions.timeBiasCorrections.EBTimeCorrShiftBins,
             conditions.timeBiasCorrections.EETimeCorrShiftBins,
-            scratch.timeMax,
-            scratch.timeError,
+            scratch.timeMax.get(),
+            scratch.timeError.get(),
             conditions.pedestals.rms_x12,
             conditions.timeCalibConstants.values,
-            eventOutputGPU.jitter,
-            eventOutputGPU.jitterError,
-            eventOutputGPU.flags,
+            eventOutputGPU.recHitsEB.jitter.get(),
+            eventOutputGPU.recHitsEE.jitter.get(),
+            eventOutputGPU.recHitsEB.jitterError.get(),
+            eventOutputGPU.recHitsEE.jitterError.get(),
+            eventOutputGPU.recHitsEB.flags.get(),
+            eventOutputGPU.recHitsEE.flags.get(),
             conditions.timeBiasCorrections.EBTimeCorrAmplitudeBinsSize,
             conditions.timeBiasCorrections.EETimeCorrAmplitudeBinsSize,
             configParameters.timeConstantTermEB,
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
index 5bd54787ee155..71dc26bb98090 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
@@ -1,6 +1,6 @@
 #include <iostream>
 
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit_soa.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
 #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
 #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
 #include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
@@ -26,10 +26,12 @@
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalMultifitParametersGPU.h"
 
 #include "Common.h"
 #include "DeclsForKernels.h"
 #include "EcalUncalibRecHitMultiFitAlgo_gpu_new.h"
+#include "EcalMultifitParametersGPURecord.h"
 
 class EcalUncalibRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
 public:
@@ -38,13 +40,14 @@ class EcalUncalibRecHitProducerGPU : public edm::stream::EDProducer<edm::Externa
   static void fillDescriptions(edm::ConfigurationDescriptions&);
 
 private:
-  using RecHitType = ecal::UncalibratedRecHit<ecal::Tag::soa>;
   void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  edm::EDGetTokenT<cms::cuda::Product<ecal::DigisCollection>> digisTokenEB_, digisTokenEE_;
-  edm::EDPutTokenT<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>> recHitsTokenEB_, recHitsTokenEE_;
+  using InputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
+  edm::EDGetTokenT<InputProduct> digisTokenEB_, digisTokenEE_;
+  using OutputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
+  edm::EDPutTokenT<OutputProduct> recHitsTokenEB_, recHitsTokenEE_;
 
   // conditions handles
   edm::ESHandle<EcalPedestalsGPU> pedestalsHandle_;
@@ -56,17 +59,16 @@ class EcalUncalibRecHitProducerGPU : public edm::stream::EDProducer<edm::Externa
   edm::ESHandle<EcalTimeCalibConstantsGPU> timeCalibConstantsHandle_;
   edm::ESHandle<EcalSampleMask> sampleMaskHandle_;
   edm::ESHandle<EcalTimeOffsetConstant> timeOffsetConstantHandle_;
+  edm::ESHandle<EcalMultifitParametersGPU> multifitParametersHandle_;
 
   // configuration parameters
   ecal::multifit::ConfigurationParameters configParameters_;
 
   // event data
   ecal::multifit::EventOutputDataGPU eventOutputDataGPU_;
-  ecal::multifit::EventDataForScratchGPU eventDataForScratchGPU_;
 
   cms::cuda::ContextState cudaState_;
 
-  uint32_t maxNumberHits_;
   uint32_t neb_, nee_;
 };
 
@@ -79,26 +81,6 @@ void EcalUncalibRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptio
   desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
   desc.add<std::string>("recHitsLabelEE", "EcalUncalibRecHitsEE");
 
-  desc.add<std::vector<double>>("EBtimeFitParameters",
-                                {-2.015452e+00,
-                                 3.130702e+00,
-                                 -1.234730e+01,
-                                 4.188921e+01,
-                                 -8.283944e+01,
-                                 9.101147e+01,
-                                 -5.035761e+01,
-                                 1.105621e+01});
-  desc.add<std::vector<double>>("EEtimeFitParameters",
-                                {-2.390548e+00,
-                                 3.553628e+00,
-                                 -1.762341e+01,
-                                 6.767538e+01,
-                                 -1.332130e+02,
-                                 1.407432e+02,
-                                 -7.541106e+01,
-                                 1.620277e+01});
-  desc.add<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652});
-  desc.add<std::vector<double>>("EEamplitudeFitParameters", {1.890, 1.400});
   desc.add<double>("EBtimeFitLimits_Lower", 0.2);
   desc.add<double>("EBtimeFitLimits_Upper", 1.4);
   desc.add<double>("EEtimeFitLimits_Lower", 0.2);
@@ -126,18 +108,14 @@ void EcalUncalibRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptio
 }
 
 EcalUncalibRecHitProducerGPU::EcalUncalibRecHitProducerGPU(const edm::ParameterSet& ps)
-    : digisTokenEB_{consumes<cms::cuda::Product<ecal::DigisCollection>>(
+    : digisTokenEB_{consumes<InputProduct>(
           ps.getParameter<edm::InputTag>("digisLabelEB"))},
       digisTokenEE_{
-          consumes<cms::cuda::Product<ecal::DigisCollection>>(ps.getParameter<edm::InputTag>("digisLabelEE"))},
-      recHitsTokenEB_{produces<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+          consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEE"))},
+      recHitsTokenEB_{produces<OutputProduct>(
           ps.getParameter<std::string>("recHitsLabelEB"))},
-      recHitsTokenEE_{produces<cms::cuda::Product<ecal::UncalibratedRecHit<ecal::Tag::ptr>>>(
+      recHitsTokenEE_{produces<OutputProduct>(
           ps.getParameter<std::string>("recHitsLabelEE"))} {
-  auto EBamplitudeFitParameters = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
-  auto EEamplitudeFitParameters = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
-  auto EBtimeFitParameters = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
-  auto EEtimeFitParameters = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
   std::pair<double, double> EBtimeFitLimits, EEtimeFitLimits;
   EBtimeFitLimits.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
   EBtimeFitLimits.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
@@ -161,7 +139,7 @@ EcalUncalibRecHitProducerGPU::EcalUncalibRecHitProducerGPU(const edm::ParameterS
   auto amplitudeThreshEE = ps.getParameter<double>("amplitudeThresholdEE");
 
   // max number of digis to allocate for
-  maxNumberHits_ = ps.getParameter<uint32_t>("maxNumberHits");
+  configParameters_.maxNumberHits = ps.getParameter<uint32_t>("maxNumberHits");
 
   // switch to run timing computation kernels
   configParameters_.shouldRunTimingComputation = ps.getParameter<bool>("shouldRunTimingComputation");
@@ -178,39 +156,11 @@ EcalUncalibRecHitProducerGPU::EcalUncalibRecHitProducerGPU(const edm::ParameterS
   // use sync copying
   //
 
-  // amplitude fit parameters copying
-  cudaCheck(cudaMalloc((void**)&configParameters_.amplitudeFitParametersEB,
-                       sizeof(ecal::multifit::ConfigurationParameters::type) * EBamplitudeFitParameters.size()));
-  cudaCheck(cudaMemcpy(configParameters_.amplitudeFitParametersEB,
-                       EBamplitudeFitParameters.data(),
-                       EBamplitudeFitParameters.size() * sizeof(ecal::multifit::ConfigurationParameters::type),
-                       cudaMemcpyHostToDevice));
-  cudaCheck(cudaMalloc((void**)&configParameters_.amplitudeFitParametersEE,
-                       sizeof(ecal::multifit::ConfigurationParameters::type) * EEamplitudeFitParameters.size()));
-  cudaCheck(cudaMemcpy(configParameters_.amplitudeFitParametersEE,
-                       EEamplitudeFitParameters.data(),
-                       EEamplitudeFitParameters.size() * sizeof(ecal::multifit::ConfigurationParameters::type),
-                       cudaMemcpyHostToDevice));
-
   // time fit parameters and limits
-  configParameters_.timeFitParametersSizeEB = EBtimeFitParameters.size();
-  configParameters_.timeFitParametersSizeEE = EEtimeFitParameters.size();
   configParameters_.timeFitLimitsFirstEB = EBtimeFitLimits.first;
   configParameters_.timeFitLimitsSecondEB = EBtimeFitLimits.second;
   configParameters_.timeFitLimitsFirstEE = EEtimeFitLimits.first;
   configParameters_.timeFitLimitsSecondEE = EEtimeFitLimits.second;
-  cudaCheck(cudaMalloc((void**)&configParameters_.timeFitParametersEB,
-                       sizeof(ecal::multifit::ConfigurationParameters::type) * EBtimeFitParameters.size()));
-  cudaCheck(cudaMemcpy(configParameters_.timeFitParametersEB,
-                       EBtimeFitParameters.data(),
-                       EBtimeFitParameters.size() * sizeof(ecal::multifit::ConfigurationParameters::type),
-                       cudaMemcpyHostToDevice));
-  cudaCheck(cudaMalloc((void**)&configParameters_.timeFitParametersEE,
-                       sizeof(ecal::multifit::ConfigurationParameters::type) * EEtimeFitParameters.size()));
-  cudaCheck(cudaMemcpy(configParameters_.timeFitParametersEE,
-                       EEtimeFitParameters.data(),
-                       EEtimeFitParameters.size() * sizeof(ecal::multifit::ConfigurationParameters::type),
-                       cudaMemcpyHostToDevice));
 
   // time constant terms
   configParameters_.timeConstantTermEB = EBtimeConstantTerm;
@@ -233,33 +183,9 @@ EcalUncalibRecHitProducerGPU::EcalUncalibRecHitProducerGPU(const edm::ParameterS
   configParameters_.outOfTimeThreshG12mEE = outOfTimeThreshG12mEE;
   configParameters_.outOfTimeThreshG61mEB = outOfTimeThreshG61mEB;
   configParameters_.outOfTimeThreshG61mEE = outOfTimeThreshG61mEE;
-
-  // allocate event output data
-  eventOutputDataGPU_.allocate(configParameters_, maxNumberHits_);
-
-  // allocate scratch data for gpu
-  eventDataForScratchGPU_.allocate(configParameters_, maxNumberHits_);
 }
 
-EcalUncalibRecHitProducerGPU::~EcalUncalibRecHitProducerGPU() {
-  //
-  // assume single device for now
-  //
-
-  if (configParameters_.amplitudeFitParametersEB) {
-    // configuration parameters
-    cudaCheck(cudaFree(configParameters_.amplitudeFitParametersEB));
-    cudaCheck(cudaFree(configParameters_.amplitudeFitParametersEE));
-    cudaCheck(cudaFree(configParameters_.timeFitParametersEB));
-    cudaCheck(cudaFree(configParameters_.timeFitParametersEE));
-
-    // free event ouput data
-    eventOutputDataGPU_.deallocate(configParameters_);
-
-    // free event scratch data
-    eventDataForScratchGPU_.deallocate(configParameters_);
-  }
-}
+EcalUncalibRecHitProducerGPU::~EcalUncalibRecHitProducerGPU() {}
 
 void EcalUncalibRecHitProducerGPU::acquire(edm::Event const& event,
                                            edm::EventSetup const& setup,
@@ -275,10 +201,10 @@ void EcalUncalibRecHitProducerGPU::acquire(edm::Event const& event,
   auto const& ebDigis = ctx.get(ebDigisProduct);
   auto const& eeDigis = ctx.get(eeDigisProduct);
   ecal::multifit::EventInputDataGPU inputDataGPU{ebDigis, eeDigis};
-  neb_ = ebDigis.ndigis;
-  nee_ = eeDigis.ndigis;
+  neb_ = ebDigis.size;
+  nee_ = eeDigis.size;
 
-  if ((neb_ + nee_) > maxNumberHits_) {
+  if ((neb_ + nee_) > configParameters_.maxNumberHits) {
     edm::LogError("EcalUncalibRecHitProducerGPU") << "max number of channels exceeded. See options 'maxNumberHits' ";
   }
 
@@ -292,6 +218,7 @@ void EcalUncalibRecHitProducerGPU::acquire(edm::Event const& event,
   setup.get<EcalTimeCalibConstantsRcd>().get(timeCalibConstantsHandle_);
   setup.get<EcalSampleMaskRcd>().get(sampleMaskHandle_);
   setup.get<EcalTimeOffsetConstantRcd>().get(timeOffsetConstantHandle_);
+  setup.get<EcalMultifitParametersGPURecord>().get(multifitParametersHandle_);
 
   auto const& pedProduct = pedestalsHandle_->getProduct(ctx.stream());
   auto const& gainsProduct = gainRatiosHandle_->getProduct(ctx.stream());
@@ -300,6 +227,15 @@ void EcalUncalibRecHitProducerGPU::acquire(edm::Event const& event,
   auto const& samplesCorrelationProduct = samplesCorrelationHandle_->getProduct(ctx.stream());
   auto const& timeBiasCorrectionsProduct = timeBiasCorrectionsHandle_->getProduct(ctx.stream());
   auto const& timeCalibConstantsProduct = timeCalibConstantsHandle_->getProduct(ctx.stream());
+  auto const& multifitParametersProduct = multifitParametersHandle_->getProduct(ctx.stream());
+
+  // assign ptrs/values: this is done not to change how things look downstream
+  configParameters_.amplitudeFitParametersEB = multifitParametersProduct.amplitudeFitParametersEB;
+  configParameters_.amplitudeFitParametersEE = multifitParametersProduct.amplitudeFitParametersEE;
+  configParameters_.timeFitParametersEB = multifitParametersProduct.timeFitParametersEB;
+  configParameters_.timeFitParametersEE = multifitParametersProduct.timeFitParametersEE;
+  configParameters_.timeFitParametersSizeEB = multifitParametersHandle_->getValues()[2].get().size();
+  configParameters_.timeFitParametersSizeEE = multifitParametersHandle_->getValues()[3].get().size();
 
   // bundle up conditions
   ecal::multifit::ConditionsProducts conditions{pedProduct,
@@ -311,42 +247,34 @@ void EcalUncalibRecHitProducerGPU::acquire(edm::Event const& event,
                                                 timeCalibConstantsProduct,
                                                 *sampleMaskHandle_,
                                                 *timeOffsetConstantHandle_,
-                                                timeCalibConstantsHandle_->getOffset()};
+                                                timeCalibConstantsHandle_->getOffset(),
+                                                multifitParametersProduct};
+  
+  // dev mem
+  eventOutputDataGPU_.allocate(configParameters_, ctx.stream());
+  
+  // scratch mem
+  ecal::multifit::EventDataForScratchGPU eventDataForScratchGPU;
+  eventDataForScratchGPU.allocate(configParameters_, ctx.stream());
 
   //
   // schedule algorithms
   //
   ecal::multifit::entryPoint(
-      inputDataGPU, eventOutputDataGPU_, eventDataForScratchGPU_, conditions, configParameters_, ctx.stream());
+      inputDataGPU, eventOutputDataGPU_, eventDataForScratchGPU, conditions, configParameters_, ctx.stream());
 }
 
 void EcalUncalibRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
   //DurationMeasurer<std::chrono::milliseconds> timer{std::string{"produce duration"}};
   cms::cuda::ScopedContextProduce ctx{cudaState_};
 
-  // copy construct output collections
-  // note, output collections do not own device memory!
-  ecal::UncalibratedRecHit<ecal::Tag::ptr> ebRecHits{eventOutputDataGPU_}, eeRecHits{eventOutputDataGPU_};
-
   // set the size of eb and ee
-  ebRecHits.size = neb_;
-  eeRecHits.size = nee_;
-
-  // shift ptrs for ee
-  eeRecHits.amplitudesAll += neb_ * EcalDataFrame::MAXSAMPLES;
-  eeRecHits.amplitude += neb_;
-  eeRecHits.chi2 += neb_;
-  eeRecHits.pedestal += neb_;
-  eeRecHits.did += neb_;
-  eeRecHits.flags += neb_;
-  if (configParameters_.shouldRunTimingComputation) {
-    eeRecHits.jitter += neb_;
-    eeRecHits.jitterError += neb_;
-  }
+  eventOutputDataGPU_.recHitsEB.size = neb_;
+  eventOutputDataGPU_.recHitsEE.size = nee_;
 
   // put into the event
-  ctx.emplace(event, recHitsTokenEB_, std::move(ebRecHits));
-  ctx.emplace(event, recHitsTokenEE_, std::move(eeRecHits));
+  ctx.emplace(event, recHitsTokenEB_, std::move(eventOutputDataGPU_.recHitsEB));
+  ctx.emplace(event, recHitsTokenEE_, std::move(eventOutputDataGPU_.recHitsEE));
 }
 
 DEFINE_FWK_MODULE(EcalUncalibRecHitProducerGPU);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu
index ddb9334826f40..1728b887bc289 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu
+++ b/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu
@@ -987,7 +987,8 @@ namespace ecal {
     //#define DEBUG_TIME_CORRECTION
     __global__ void kernel_time_correction_and_finalize(
         //        SampleVector::Scalar const* g_amplitude,
-        ::ecal::reco::StorageScalarType const* g_amplitude,
+        ::ecal::reco::StorageScalarType const* g_amplitudeEB,
+        ::ecal::reco::StorageScalarType const* g_amplitudeEE,
         uint16_t const* digis_eb,
         uint32_t const* dids_eb,
         uint16_t const* digis_ee,
@@ -1000,9 +1001,12 @@ namespace ecal {
         SampleVector::Scalar const* g_timeError,
         float const* g_rms_x12,
         float const* timeCalibConstant,
-        float* g_jitter,
-        float* g_jitterError,
-        uint32_t* flags,
+        float* g_jitterEB,
+        float* g_jitterEE,
+        float* g_jitterErrorEB,
+        float* g_jitterErrorEE,
+        uint32_t* flagsEB,
+        uint32_t* flagsEE,
         const int amplitudeBinsSizeEB,
         const int amplitudeBinsSizeEE,
         ConfigurationParameters::type const timeConstantTermEB,
@@ -1039,6 +1043,14 @@ namespace ecal {
       if (gtx >= nchannels)
         return;
 
+      // need to ref the right ptrs
+      #define ARRANGE(var) auto *var = gtx >= offsetForInputs ? var##EE : var##EB
+      ARRANGE(g_amplitude);
+      ARRANGE(g_jitter);
+      ARRANGE(g_jitterError);
+      ARRANGE(flags);
+#undef ARRANGE
+
       const auto did = DetId{dids[inputGtx]};
       const auto isBarrel = did.subdetId() == EcalBarrel;
       const auto hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did.rawId())
@@ -1056,10 +1068,10 @@ namespace ecal {
       const auto outOfTimeThreshG61m = isBarrel ? outOfTimeThreshG61mEB : outOfTimeThreshG61mEE;
 
       // load some
-      const auto amplitude = g_amplitude[gtx];
+      const auto amplitude = g_amplitude[inputGtx];
       const auto rms_x12 = g_rms_x12[hashedId];
       const auto timeCalibConst = timeCalibConstant[hashedId];
-
+ 
       int myBin = -1;
       for (int bin = 0; bin < amplitudeBinsSize; bin++) {
         if (amplitude > amplitudeBins[bin])
@@ -1099,8 +1111,8 @@ namespace ecal {
 #endif
 
       // store back to  global
-      g_jitter[gtx] = jitter;
-      g_jitterError[gtx] = jitterError;
+      g_jitter[inputGtx] = jitter;
+      g_jitterError[inputGtx] = jitterError;
 
       // set the flag
       // TODO: replace with something more efficient (if required),
@@ -1123,7 +1135,7 @@ namespace ecal {
         const auto nterm = timeNconst * rms_x12 / amplitude;
         const auto sigmat = std::sqrt(nterm * nterm + timeConstantTerm * timeConstantTerm);
         if (correctedTime > sigmat * threshP || correctedTime < -sigmat * threshM)
-          flags[gtx] |= 0x1 << EcalUncalibratedRecHit::kOutOfTime;
+          flags[inputGtx] |= 0x1 << EcalUncalibratedRecHit::kOutOfTime;
       }
     }
 
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
index 68500ddfe70d2..a9b1c69678abd 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
+++ b/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
@@ -138,7 +138,8 @@ namespace ecal {
     //#define DEBUG_TIME_CORRECTION
     __global__ void kernel_time_correction_and_finalize(
         //        SampleVector::Scalar const* g_amplitude,
-        ::ecal::reco::StorageScalarType const* g_amplitude,
+        ::ecal::reco::StorageScalarType const* g_amplitudeEB,
+        ::ecal::reco::StorageScalarType const* g_amplitudeEE,
         uint16_t const* digis_eb,
         uint32_t const* dids_eb,
         uint16_t const* digis_ee,
@@ -151,9 +152,12 @@ namespace ecal {
         SampleVector::Scalar const* g_timeError,
         float const* g_rms_x12,
         float const* timeCalibConstant,
-        ::ecal::reco::StorageScalarType* g_jitter,
-        ::ecal::reco::StorageScalarType* g_jitterError,
-        uint32_t* flags,
+        ::ecal::reco::StorageScalarType* g_jitterEB,
+        ::ecal::reco::StorageScalarType* g_jitterEE,
+        ::ecal::reco::StorageScalarType* g_jitterErrorEB,
+        ::ecal::reco::StorageScalarType* g_jitterErrorEE,
+        uint32_t* flagsEB,
+        uint32_t* flagsEE,
         int const amplitudeBinsSizeEB,
         int const amplitudeBinsSizeEE,
         ConfigurationParameters::type const timeConstantTermEB,
diff --git a/RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h b/RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h
new file mode 100644
index 0000000000000..2481a80711d33
--- /dev/null
+++ b/RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h
@@ -0,0 +1,39 @@
+#ifndef RecoLocalCalo_HcalRecAlgos_interface_HcalMahiPulseOffsetsGPU_h
+#define RecoLocalCalo_HcalRecAlgos_interface_HcalMahiPulseOffsetsGPU_h
+
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#ifndef __CUDACC__
+#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
+#endif
+
+class HcalMahiPulseOffsetsGPU {
+public:
+  struct Product {
+    ~Product();
+    int* values;
+  };
+
+#ifndef __CUDACC__
+  // rearrange reco params
+  HcalMahiPulseOffsetsGPU(edm::ParameterSet const&);
+
+  // will trigger deallocation of Product thru ~Product
+  ~HcalMahiPulseOffsetsGPU() = default;
+
+  std::vector<int, cms::cuda::HostAllocator<int>> const& getValues() const {
+      return values_;
+  }
+
+  // get device pointers
+  Product const& getProduct(cudaStream_t) const;
+
+private:
+  std::vector<int, cms::cuda::HostAllocator<int>> values_;
+
+  cms::cuda::ESProduct<Product> product_;
+#endif
+};
+
+#endif
diff --git a/RecoLocalCalo/HcalRecAlgos/src/HcalMahiPulseOffsetsGPU.cc b/RecoLocalCalo/HcalRecAlgos/src/HcalMahiPulseOffsetsGPU.cc
new file mode 100644
index 0000000000000..3f5cdbe5f15ca
--- /dev/null
+++ b/RecoLocalCalo/HcalRecAlgos/src/HcalMahiPulseOffsetsGPU.cc
@@ -0,0 +1,36 @@
+#include "RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h"
+
+#include "FWCore/Utilities/interface/typelookup.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
+
+// FIXME: add proper getters to conditions
+HcalMahiPulseOffsetsGPU::HcalMahiPulseOffsetsGPU(edm::ParameterSet const& ps) 
+{
+    auto const& values = ps.getParameter<std::vector<int>>("pulseOffsets");
+    values_.resize(values.size());
+    std::copy(values.begin(), values.end(), values_.begin());
+}
+
+HcalMahiPulseOffsetsGPU::Product::~Product() {
+  // deallocation
+  cudaCheck(cudaFree(values));
+}
+
+HcalMahiPulseOffsetsGPU::Product const& HcalMahiPulseOffsetsGPU::getProduct(cudaStream_t cudaStream) const {
+  auto const& product =
+      product_.dataForCurrentDeviceAsync(cudaStream, [this](HcalMahiPulseOffsetsGPU::Product& product, cudaStream_t cudaStream) {
+        // malloc
+        cudaCheck(cudaMalloc((void**)&product.values, this->values_.size() * sizeof(int)));
+
+        // transfer
+        cudaCheck(cudaMemcpyAsync(product.values,
+                                  this->values_.data(),
+                                  this->values_.size() * sizeof(int),
+                                  cudaMemcpyHostToDevice,
+                                  cudaStream));
+      });
+
+  return product;
+}
+
+TYPELOOKUP_DATA_REG(HcalMahiPulseOffsetsGPU);
diff --git a/RecoLocalCalo/HcalRecProducers/BuildFile.xml b/RecoLocalCalo/HcalRecProducers/BuildFile.xml
index 7375c85d61a54..524c2d64dd5d7 100644
--- a/RecoLocalCalo/HcalRecProducers/BuildFile.xml
+++ b/RecoLocalCalo/HcalRecProducers/BuildFile.xml
@@ -1,7 +1,7 @@
 <use name="boost"/>
 <use name="cuda"/>
 <use name="CUDADataFormats/Common" />
-<use name="CUDADataFormats/HcalCommon"/>
+<use name="CUDADataFormats/CaloCommon"/>
 <use name="CUDADataFormats/HcalDigi"/>
 <use name="CUDADataFormats/HcalRecHitSoA"/>
 <use name="CalibCalorimetry/HcalAlgos"/>
diff --git a/RecoLocalCalo/HcalRecProducers/bin/makeHcalRecHitGpuValidationPlots.cpp b/RecoLocalCalo/HcalRecProducers/bin/makeHcalRecHitGpuValidationPlots.cpp
index 5ef7861f43232..fe6aabf928aca 100644
--- a/RecoLocalCalo/HcalRecProducers/bin/makeHcalRecHitGpuValidationPlots.cpp
+++ b/RecoLocalCalo/HcalRecProducers/bin/makeHcalRecHitGpuValidationPlots.cpp
@@ -30,7 +30,7 @@ int main(int argc, char* argv[]) {
   // branches to use
   edm::Wrapper<HBHERecHitCollection>* wcpu = nullptr;
   edm::Wrapper<HBHERecHitCollection>* wgpu = nullptr;
-  //    edm::Wrapper<hcal::RecHitCollection<hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>> *wgpu=nullptr;
+  //    edm::Wrapper<hcal::RecHitCollection<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>> *wgpu=nullptr;
 
   // prep output
   TFile rfout{outFileName.c_str(), "recreate"};
@@ -61,7 +61,7 @@ int main(int argc, char* argv[]) {
   // prep input
   TFile rfin{inFileName.c_str()};
   TTree* rt = (TTree*)rfin.Get("Events");
-  rt->SetBranchAddress("HBHERecHitsSorted_hcalCPURecHitsProducer_recHitsLegacyLabelOut_RECO.", &wgpu);
+  rt->SetBranchAddress("HBHERecHitsSorted_hcalCPURecHitsProducer_recHitsLegacyHBHE_RECO.", &wgpu);
   //    rt->SetBranchAddress("hcalCUDAHostAllocatorAliashcalcommonVecStoragePolicyhcalRecHitCollection_hcalCPURecHitsProducer_recHitsM0LabelOut_RECO.", &wgpu);
   rt->SetBranchAddress("HBHERecHitsSorted_hbheprereco__RECO.", &wcpu);
 
diff --git a/RecoLocalCalo/HcalRecProducers/src/DeclsForKernels.h b/RecoLocalCalo/HcalRecProducers/src/DeclsForKernels.h
index 42f1992bcf119..1486e27557285 100644
--- a/RecoLocalCalo/HcalRecProducers/src/DeclsForKernels.h
+++ b/RecoLocalCalo/HcalRecProducers/src/DeclsForKernels.h
@@ -24,6 +24,10 @@
 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSiPMCharacteristicsGPU.h"
 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSiPMParametersGPU.h"
 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalTimeCorrsGPU.h"
+#include "RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h"
+
+#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/host_unique_ptr.h"
 
 namespace hcal {
   namespace mahi {
@@ -46,6 +50,8 @@ namespace hcal {
       HcalTopology const* topology;
       HcalDDDRecConstants const* recConstants;
       uint32_t offsetForHashes;
+      HcalMahiPulseOffsetsGPU::Product const& pulseOffsets;
+      std::vector<int, cms::cuda::HostAllocator<int>> const& pulseOffsetsHost;
     };
 
     struct ConfigParameters {
@@ -62,7 +68,8 @@ namespace hcal {
       float ts4Thresh;
 
       std::vector<int> pulseOffsets;
-      int* pulseOffsetsDevice = nullptr;
+      // FIXME remove pulseOffsets - they come from esproduce now
+      //int* pulseOffsetsDevice = nullptr;
 
       std::array<uint32_t, 3> kernelMinimizeThreads;
 
@@ -75,59 +82,32 @@ namespace hcal {
     };
 
     struct OutputDataGPU {
-      RecHitCollection<common::ViewStoragePolicy> recHits;
-
-      void allocate(ConfigParameters const& config) {
-        cudaCheck(cudaMalloc((void**)&recHits.energy, config.maxChannels * sizeof(float)));
-        cudaCheck(cudaMalloc((void**)&recHits.chi2, config.maxChannels * sizeof(float)));
-        cudaCheck(cudaMalloc((void**)&recHits.energyM0, config.maxChannels * sizeof(float)));
-        cudaCheck(cudaMalloc((void**)&recHits.timeM0, config.maxChannels * sizeof(float)));
-        cudaCheck(cudaMalloc((void**)&recHits.did, config.maxChannels * sizeof(uint32_t)));
-      }
-
-      void deallocate(ConfigParameters const& config) {
-        cudaCheck(cudaFree(recHits.energy));
-        cudaCheck(cudaFree(recHits.chi2));
-        cudaCheck(cudaFree(recHits.energyM0));
-        cudaCheck(cudaFree(recHits.timeM0));
-        cudaCheck(cudaFree(recHits.did));
+      RecHitCollection<::calo::common::DevStoragePolicy> recHits;
+
+      void allocate(ConfigParameters const& config, cudaStream_t cudaStream) {
+        recHits.energy = cms::cuda::make_device_unique<float[]>(
+          config.maxChannels, cudaStream);
+        recHits.chi2 = cms::cuda::make_device_unique<float[]>(
+          config.maxChannels, cudaStream);
+        recHits.energyM0 = cms::cuda::make_device_unique<float[]>(
+          config.maxChannels, cudaStream);
+        recHits.timeM0 = cms::cuda::make_device_unique<float[]>(
+          config.maxChannels, cudaStream);
+        recHits.did = cms::cuda::make_device_unique<uint32_t[]>(
+          config.maxChannels, cudaStream);
       }
     };
 
     struct ScratchDataGPU {
-      float *amplitudes = nullptr, *noiseTerms = nullptr;
-      float *pulseMatrices = nullptr, *pulseMatricesM = nullptr, *pulseMatricesP = nullptr;
-      int8_t* soiSamples = nullptr;
-
-      // TODO: properly allocate for NSAMPLES VS NPULSES
-      void allocate(ConfigParameters const& config) {
-        cudaCheck(cudaMalloc((void**)&amplitudes, sizeof(float) * config.maxChannels * config.maxTimeSamples));
-        cudaCheck(cudaMalloc((void**)&noiseTerms, sizeof(float) * config.maxChannels * config.maxTimeSamples));
-        cudaCheck(cudaMalloc((void**)&pulseMatrices,
-                             sizeof(float) * config.maxChannels * config.maxTimeSamples * config.maxTimeSamples));
-        cudaCheck(cudaMalloc((void**)&pulseMatricesM,
-                             sizeof(float) * config.maxChannels * config.maxTimeSamples * config.maxTimeSamples));
-        cudaCheck(cudaMalloc((void**)&pulseMatricesP,
-                             sizeof(float) * config.maxChannels * config.maxTimeSamples * config.maxTimeSamples));
-        cudaCheck(cudaMalloc((void**)&soiSamples, sizeof(int8_t) * config.maxChannels));
-      }
-
-      void deallocate(ConfigParameters const& config) {
-        if (amplitudes) {
-          cudaCheck(cudaFree(amplitudes));
-          cudaCheck(cudaFree(noiseTerms));
-          cudaCheck(cudaFree(pulseMatrices));
-          cudaCheck(cudaFree(pulseMatricesM));
-          cudaCheck(cudaFree(pulseMatricesP));
-          cudaCheck(cudaFree(soiSamples));
-        }
-      }
+      cms::cuda::device::unique_ptr<float[]> amplitudes, noiseTerms,
+          pulseMatrices, pulseMatricesM, pulseMatricesP;
+      cms::cuda::device::unique_ptr<int8_t[]> soiSamples;
     };
 
     struct InputDataGPU {
-      DigiCollection<Flavor01, common::ViewStoragePolicy> const& f01HEDigis;
-      DigiCollection<Flavor5, common::ViewStoragePolicy> const& f5HBDigis;
-      DigiCollection<Flavor3, common::ViewStoragePolicy> const& f3HBDigis;
+      DigiCollection<Flavor01, ::calo::common::DevStoragePolicy> const& f01HEDigis;
+      DigiCollection<Flavor5, ::calo::common::DevStoragePolicy> const& f5HBDigis;
+      DigiCollection<Flavor3, ::calo::common::DevStoragePolicy> const& f3HBDigis;
     };
 
   }  // namespace mahi
diff --git a/RecoLocalCalo/HcalRecProducers/src/HBHERecHitProducerGPU.cc b/RecoLocalCalo/HcalRecProducers/src/HBHERecHitProducerGPU.cc
index c78200badce57..e0294d68f0edd 100644
--- a/RecoLocalCalo/HcalRecProducers/src/HBHERecHitProducerGPU.cc
+++ b/RecoLocalCalo/HcalRecProducers/src/HBHERecHitProducerGPU.cc
@@ -37,6 +37,9 @@
 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSiPMParametersGPU.h"
 #include "RecoLocalCalo/HcalRecAlgos/interface/HcalTimeCorrsGPU.h"
 
+#include "RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h"
+#include "HcalMahiPulseOffsetsGPURecord.h"
+
 #include "MahiGPU.h"
 
 class HBHERecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
@@ -49,22 +52,21 @@ class HBHERecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork>
   void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
-  using IProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor01, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef01> digisTokenF01HE_;
 
-  using IProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef5> digisTokenF5HB_;
 
-  using IProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, hcal::common::ViewStoragePolicy>>;
+  using IProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductTypef3> digisTokenF3HB_;
 
-  using RecHitType = hcal::RecHitCollection<hcal::common::ViewStoragePolicy>;
+  using RecHitType = hcal::RecHitCollection<calo::common::DevStoragePolicy>;
   using OProductType = cms::cuda::Product<RecHitType>;
   edm::EDPutTokenT<OProductType> rechitsM0Token_;
 
   hcal::mahi::ConfigParameters configParameters_;
   hcal::mahi::OutputDataGPU outputGPU_;
-  hcal::mahi::ScratchDataGPU scratchGPU_;
   cms::cuda::ContextState cudaState_;
 };
 
@@ -75,7 +77,6 @@ HBHERecHitProducerGPU::HBHERecHitProducerGPU(edm::ParameterSet const& ps)
       rechitsM0Token_{produces<OProductType>(ps.getParameter<std::string>("recHitsLabelM0HBHE"))} {
   configParameters_.maxChannels = ps.getParameter<uint32_t>("maxChannels");
   configParameters_.maxTimeSamples = ps.getParameter<uint32_t>("maxTimeSamples");
-  configParameters_.pulseOffsets = ps.getParameter<std::vector<int>>("pulseOffsets");
   configParameters_.kprep1dChannelsPerBlock = ps.getParameter<uint32_t>("kprep1dChannelsPerBlock");
   configParameters_.sipmQTSShift = ps.getParameter<int>("sipmQTSShift");
   configParameters_.sipmQNTStoSum = ps.getParameter<int>("sipmQNTStoSum");
@@ -100,39 +101,14 @@ HBHERecHitProducerGPU::HBHERecHitProducerGPU(edm::ParameterSet const& ps)
   configParameters_.kernelMinimizeThreads[0] = threadsMinimize[0];
   configParameters_.kernelMinimizeThreads[1] = threadsMinimize[1];
   configParameters_.kernelMinimizeThreads[2] = threadsMinimize[2];
-
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    outputGPU_.allocate(configParameters_);
-    scratchGPU_.allocate(configParameters_);
-
-    // FIXME: use default device and default stream
-    cudaCheck(
-        cudaMalloc((void**)&configParameters_.pulseOffsetsDevice, sizeof(int) * configParameters_.pulseOffsets.size()));
-    cudaCheck(cudaMemcpy(configParameters_.pulseOffsetsDevice,
-                         configParameters_.pulseOffsets.data(),
-                         configParameters_.pulseOffsets.size() * sizeof(int),
-                         cudaMemcpyHostToDevice));
-  }
 }
 
-HBHERecHitProducerGPU::~HBHERecHitProducerGPU() {
-  // call CUDA API functions only if CUDA is available
-  edm::Service<CUDAService> cs;
-  if (cs and cs->enabled()) {
-    outputGPU_.deallocate(configParameters_);
-    scratchGPU_.deallocate(configParameters_);
-
-    cudaCheck(cudaFree(configParameters_.pulseOffsetsDevice));
-  }
-}
+HBHERecHitProducerGPU::~HBHERecHitProducerGPU() {}
 
 void HBHERecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptions& cdesc) {
   edm::ParameterSetDescription desc;
   desc.add<uint32_t>("maxChannels", 10000u);
   desc.add<uint32_t>("maxTimeSamples", 10);
-  desc.add<std::vector<int>>("pulseOffsets", {-3, -2, -1, 0, 1, 2, 3, 4});
   desc.add<uint32_t>("kprep1dChannelsPerBlock", 32);
   desc.add<edm::InputTag>("digisLabelF01HE", edm::InputTag{"hcalRawToDigiGPU", "f01HEDigisGPU"});
   desc.add<edm::InputTag>("digisLabelF5HB", edm::InputTag{"hcalRawToDigiGPU", "f5HBDigisGPU"});
@@ -239,6 +215,10 @@ void HBHERecHitProducerGPU::acquire(edm::Event const& event,
   setup.get<HcalSiPMCharacteristicsRcd>().get(sipmCharacteristicsHandle);
   auto const& sipmCharacteristicsProduct = sipmCharacteristicsHandle->getProduct(ctx.stream());
 
+  edm::ESHandle<HcalMahiPulseOffsetsGPU> pulseOffsetsHandle;
+  setup.get<HcalMahiPulseOffsetsGPURecord>().get(pulseOffsetsHandle);
+  auto const& pulseOffsetsProduct = pulseOffsetsHandle->getProduct(ctx.stream());
+
   // bundle up conditions
   hcal::mahi::ConditionsProducts conditions{gainWidthsProduct,
                                             gainsProduct,
@@ -256,9 +236,35 @@ void HBHERecHitProducerGPU::acquire(edm::Event const& event,
                                             effectivePedestalsProduct,
                                             topologyHandle.product(),
                                             recConstantsHandle.product(),
-                                            pedestalsHandle->offsetForHashes()};
-
-  hcal::mahi::entryPoint(inputGPU, outputGPU_, conditions, scratchGPU_, configParameters_, ctx.stream());
+                                            pedestalsHandle->offsetForHashes(),
+                                            pulseOffsetsProduct,
+                                            pulseOffsetsHandle->getValues()};
+
+  // scratch mem on device
+  hcal::mahi::ScratchDataGPU scratchGPU = {
+    cms::cuda::make_device_unique<float[]>(
+      configParameters_.maxChannels * configParameters_.maxTimeSamples,
+      ctx.stream()
+    ),
+    cms::cuda::make_device_unique<float[]>(
+      configParameters_.maxChannels * configParameters_.maxTimeSamples, ctx.stream()),
+    cms::cuda::make_device_unique<float[]>(
+      configParameters_.maxChannels*configParameters_.maxTimeSamples*configParameters_.maxTimeSamples, 
+      ctx.stream()),
+    cms::cuda::make_device_unique<float[]>(
+      configParameters_.maxChannels*configParameters_.maxTimeSamples*configParameters_.maxTimeSamples, 
+      ctx.stream()),
+    cms::cuda::make_device_unique<float[]>(
+      configParameters_.maxChannels*configParameters_.maxTimeSamples*configParameters_.maxTimeSamples, 
+      ctx.stream()),
+    cms::cuda::make_device_unique<int8_t[]>(
+      configParameters_.maxChannels, ctx.stream()),
+  };
+
+  // output dev mem
+  outputGPU_.allocate(configParameters_, ctx.stream());
+
+  hcal::mahi::entryPoint(inputGPU, outputGPU_, conditions, scratchGPU, configParameters_, ctx.stream());
 
 #ifdef HCAL_MAHI_CPUDEBUG
   auto end = std::chrono::high_resolution_clock::now();
diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalCPURecHitsProducer.cc b/RecoLocalCalo/HcalRecProducers/src/HcalCPURecHitsProducer.cc
index db934710f6108..714ec8b7de5af 100644
--- a/RecoLocalCalo/HcalRecProducers/src/HcalCPURecHitsProducer.cc
+++ b/RecoLocalCalo/HcalRecProducers/src/HcalCPURecHitsProducer.cc
@@ -23,9 +23,9 @@ class HcalCPURecHitsProducer : public edm::stream::EDProducer<edm::ExternalWork>
   void produce(edm::Event&, edm::EventSetup const&) override;
 
 private:
-  using IProductType = cms::cuda::Product<hcal::RecHitCollection<hcal::common::ViewStoragePolicy>>;
+  using IProductType = cms::cuda::Product<hcal::RecHitCollection<calo::common::DevStoragePolicy>>;
   edm::EDGetTokenT<IProductType> recHitsM0TokenIn_;
-  using OProductType = hcal::RecHitCollection<hcal::common::VecStoragePolicy<hcal::CUDAHostAllocatorAlias>>;
+  using OProductType = hcal::RecHitCollection<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
   edm::EDPutTokenT<OProductType> recHitsM0TokenOut_;
   edm::EDPutTokenT<HBHERecHitCollection> recHitsLegacyTokenOut_;
 
@@ -67,15 +67,17 @@ void HcalCPURecHitsProducer::acquire(edm::Event const& event,
 
   auto lambdaToTransfer = [&ctx](auto& dest, auto* src) {
     using vector_type = typename std::remove_reference<decltype(dest)>::type;
+    using src_data_type = typename std::remove_pointer<decltype(src)>::type;
     using type = typename vector_type::value_type;
+    static_assert(std::is_same<src_data_type, type>::value && "Dest and Src data types do not match");
     cudaCheck(cudaMemcpyAsync(dest.data(), src, dest.size() * sizeof(type), cudaMemcpyDeviceToHost, ctx.stream()));
   };
 
-  lambdaToTransfer(tmpRecHits_.energy, recHits.energy);
-  lambdaToTransfer(tmpRecHits_.chi2, recHits.chi2);
-  lambdaToTransfer(tmpRecHits_.energyM0, recHits.energyM0);
-  lambdaToTransfer(tmpRecHits_.timeM0, recHits.timeM0);
-  lambdaToTransfer(tmpRecHits_.did, recHits.did);
+  lambdaToTransfer(tmpRecHits_.energy, recHits.energy.get());
+  lambdaToTransfer(tmpRecHits_.chi2, recHits.chi2.get());
+  lambdaToTransfer(tmpRecHits_.energyM0, recHits.energyM0.get());
+  lambdaToTransfer(tmpRecHits_.timeM0, recHits.timeM0.get());
+  lambdaToTransfer(tmpRecHits_.did, recHits.did.get());
 }
 
 void HcalCPURecHitsProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPUESProducer.cc b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPUESProducer.cc
new file mode 100644
index 0000000000000..9500f62ea869f
--- /dev/null
+++ b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPUESProducer.cc
@@ -0,0 +1,67 @@
+#include <array>
+#include <iostream>
+#include <tuple>
+#include <utility>
+
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ESProductHost.h"
+#include "FWCore/Framework/interface/ESTransientHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/ReusableObjectHolder.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+#include "RecoLocalCalo/HcalRecAlgos/interface/HcalMahiPulseOffsetsGPU.h"
+#include "HcalMahiPulseOffsetsGPURecord.h"
+
+#include "FWCore/Framework/interface/SourceFactory.h"
+
+class HcalMahiPulseOffsetsGPUESProducer 
+        : public edm::ESProducer, public edm::EventSetupRecordIntervalFinder {
+public:
+    HcalMahiPulseOffsetsGPUESProducer(edm::ParameterSet const&);
+    ~HcalMahiPulseOffsetsGPUESProducer() override = default;
+
+    static void fillDescriptions(edm::ConfigurationDescriptions&);
+    std::unique_ptr<HcalMahiPulseOffsetsGPU> produce(HcalMahiPulseOffsetsGPURecord const&);
+
+protected:
+    void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
+                        const edm::IOVSyncValue&,
+                        edm::ValidityInterval&) override;
+
+private:
+    edm::ParameterSet const& pset_;
+};
+
+HcalMahiPulseOffsetsGPUESProducer::HcalMahiPulseOffsetsGPUESProducer(
+        edm::ParameterSet const& pset) : pset_{pset}
+{
+    setWhatProduced(this);
+    findingRecord<HcalMahiPulseOffsetsGPURecord>();
+}
+
+void HcalMahiPulseOffsetsGPUESProducer::setIntervalFor(
+        const edm::eventsetup::EventSetupRecordKey& iKey,
+        const edm::IOVSyncValue& iTime,
+        edm::ValidityInterval& oInterval) {
+    oInterval = edm::ValidityInterval(
+        edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());
+}
+
+void HcalMahiPulseOffsetsGPUESProducer::fillDescriptions(
+        edm::ConfigurationDescriptions& desc) {
+    edm::ParameterSetDescription d;
+    d.add<std::vector<int>>("pulseOffsets", {-3, -2, -1, 0, 1, 2, 3, 4});
+    desc.addWithDefaultLabel(d);
+}
+
+std::unique_ptr<HcalMahiPulseOffsetsGPU> HcalMahiPulseOffsetsGPUESProducer::produce(
+        HcalMahiPulseOffsetsGPURecord const&) {
+    return std::make_unique<HcalMahiPulseOffsetsGPU>(pset_);
+}
+
+DEFINE_FWK_EVENTSETUP_SOURCE(HcalMahiPulseOffsetsGPUESProducer);
diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.cc b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.cc
new file mode 100644
index 0000000000000..e59e802411c9b
--- /dev/null
+++ b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.cc
@@ -0,0 +1,4 @@
+#include "HcalMahiPulseOffsetsGPURecord.h"
+
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+EVENTSETUP_RECORD_REG(HcalMahiPulseOffsetsGPURecord);
diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.h b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.h
new file mode 100644
index 0000000000000..ea6683606ca72
--- /dev/null
+++ b/RecoLocalCalo/HcalRecProducers/src/HcalMahiPulseOffsetsGPURecord.h
@@ -0,0 +1,7 @@
+#ifndef HcalMahiPulseOffsetsGPURecord_h
+#define HcalMahiPulseOffsetsGPURecord_h
+
+#include "FWCore/Framework/interface/EventSetupRecordImplementation.h"
+class HcalMahiPulseOffsetsGPURecord : public edm::eventsetup::EventSetupRecordImplementation<HcalMahiPulseOffsetsGPURecord> {};
+
+#endif
diff --git a/RecoLocalCalo/HcalRecProducers/src/MahiGPU.cu b/RecoLocalCalo/HcalRecProducers/src/MahiGPU.cu
index 72df5d89815a2..05ddb83ae540a 100644
--- a/RecoLocalCalo/HcalRecProducers/src/MahiGPU.cu
+++ b/RecoLocalCalo/HcalRecProducers/src/MahiGPU.cu
@@ -1675,26 +1675,26 @@ namespace hcal {
       int nbytesShared =
           ((2 * f01nsamples + 2) * sizeof(float) + sizeof(uint64_t)) * configParameters.kprep1dChannelsPerBlock;
       kernel_prep1d_sameNumberOfSamples<<<blocks, threadsPerBlock, nbytesShared, cudaStream>>>(
-          scratch.amplitudes,
-          scratch.noiseTerms,
-          outputGPU.recHits.energy,
-          outputGPU.recHits.chi2,
-          inputGPU.f01HEDigis.data,
-          inputGPU.f5HBDigis.data,
-          inputGPU.f3HBDigis.data,
-          inputGPU.f01HEDigis.ids,
-          inputGPU.f5HBDigis.ids,
-          inputGPU.f3HBDigis.ids,
+          scratch.amplitudes.get(),
+          scratch.noiseTerms.get(),
+          outputGPU.recHits.energy.get(),
+          outputGPU.recHits.chi2.get(),
+          inputGPU.f01HEDigis.data.get(),
+          inputGPU.f5HBDigis.data.get(),
+          inputGPU.f3HBDigis.data.get(),
+          inputGPU.f01HEDigis.ids.get(),
+          inputGPU.f5HBDigis.ids.get(),
+          inputGPU.f3HBDigis.ids.get(),
           inputGPU.f01HEDigis.stride,
           inputGPU.f5HBDigis.stride,
           inputGPU.f3HBDigis.stride,
           inputGPU.f01HEDigis.size,
           inputGPU.f5HBDigis.size,
-          inputGPU.f5HBDigis.npresamples,
-          scratch.soiSamples,
-          outputGPU.recHits.energyM0,
-          outputGPU.recHits.timeM0,
-          outputGPU.recHits.did,
+          inputGPU.f5HBDigis.npresamples.get(),
+          scratch.soiSamples.get(),
+          outputGPU.recHits.energyM0.get(),
+          outputGPU.recHits.timeM0.get(),
+          outputGPU.recHits.did.get(),
           totalChannels,
           conditions.recoParams.param1,
           conditions.recoParams.param2,
@@ -1734,8 +1734,8 @@ namespace hcal {
 
       // 1024 is the max threads per block for gtx1080
       // FIXME: take this from cuda service or something like that
-      uint32_t const channelsPerBlock = 1024 / (f01nsamples * configParameters.pulseOffsets.size());
-      dim3 threadsPerBlock2{f01nsamples, static_cast<uint32_t>(configParameters.pulseOffsets.size()), channelsPerBlock};
+      uint32_t const channelsPerBlock = 1024 / (f01nsamples * conditions.pulseOffsetsHost.size());
+      dim3 threadsPerBlock2{f01nsamples, static_cast<uint32_t>(conditions.pulseOffsetsHost.size()), channelsPerBlock};
       int blocks2 =
           threadsPerBlock2.z > totalChannels ? 1 : (totalChannels + threadsPerBlock2.z - 1) / threadsPerBlock2.z;
 
@@ -1746,18 +1746,18 @@ namespace hcal {
 #endif
 
       kernel_prep_pulseMatrices_sameNumberOfSamples<<<blocks2, threadsPerBlock2, 0, cudaStream>>>(
-          scratch.pulseMatrices,
-          scratch.pulseMatricesM,
-          scratch.pulseMatricesP,
-          configParameters.pulseOffsetsDevice,
-          scratch.amplitudes,
-          inputGPU.f01HEDigis.ids,
-          inputGPU.f5HBDigis.ids,
-          inputGPU.f3HBDigis.ids,
+          scratch.pulseMatrices.get(),
+          scratch.pulseMatricesM.get(),
+          scratch.pulseMatricesP.get(),
+          conditions.pulseOffsets.values,
+          scratch.amplitudes.get(),
+          inputGPU.f01HEDigis.ids.get(),
+          inputGPU.f5HBDigis.ids.get(),
+          inputGPU.f3HBDigis.ids.get(),
           inputGPU.f01HEDigis.size,
           inputGPU.f5HBDigis.size,
           totalChannels,
-          scratch.soiSamples,
+          scratch.soiSamples.get(),
           conditions.recoParams.ids,
           conditions.recoParams.acc25nsVec,
           conditions.recoParams.diff25nsItvlVec,
@@ -1786,27 +1786,27 @@ namespace hcal {
           configParameters.tmaxTimeSlew);
       cudaCheck(cudaGetLastError());
 
-      if (f01nsamples == 8 && configParameters.pulseOffsets.size() == 8u) {
+      if (f01nsamples == 8 && conditions.pulseOffsetsHost.size() == 8u) {
         // FIXME: provide constants from configuration
         uint32_t threadsPerBlock = configParameters.kernelMinimizeThreads[0];
         uint32_t blocks = threadsPerBlock > totalChannels ? 1 : (totalChannels + threadsPerBlock - 1) / threadsPerBlock;
         auto const nbytesShared = 2 * threadsPerBlock * MapSymM<float, 8>::total * sizeof(float);
         kernel_minimize<8, 8><<<blocks, threadsPerBlock, nbytesShared, cudaStream>>>(
-            outputGPU.recHits.energy,
-            outputGPU.recHits.chi2,
-            scratch.amplitudes,
-            scratch.pulseMatrices,
-            scratch.pulseMatricesM,
-            scratch.pulseMatricesP,
-            configParameters.pulseOffsetsDevice,
-            scratch.noiseTerms,
-            scratch.soiSamples,
+            outputGPU.recHits.energy.get(),
+            outputGPU.recHits.chi2.get(),
+            scratch.amplitudes.get(),
+            scratch.pulseMatrices.get(),
+            scratch.pulseMatricesM.get(),
+            scratch.pulseMatricesP.get(),
+            conditions.pulseOffsets.values,
+            scratch.noiseTerms.get(),
+            scratch.soiSamples.get(),
             conditions.pedestalWidths.values,
             conditions.effectivePedestalWidths.values,
             configParameters.useEffectivePedestals,
-            inputGPU.f01HEDigis.ids,
-            inputGPU.f5HBDigis.ids,
-            inputGPU.f3HBDigis.ids,
+            inputGPU.f01HEDigis.ids.get(),
+            inputGPU.f5HBDigis.ids.get(),
+            inputGPU.f3HBDigis.ids.get(),
             conditions.gains.values,
             conditions.respCorrs.values,
             inputGPU.f01HEDigis.size,
@@ -1827,7 +1827,7 @@ namespace hcal {
       } else {
         throw cms::Exception("Invalid MahiGPU configuration")
             << "Currently support only 8 pulses and 8 time samples and provided: " << f01nsamples << " samples and "
-            << configParameters.pulseOffsets.size() << " pulses" << std::endl;
+            << conditions.pulseOffsetsHost.size() << " pulses" << std::endl;
       }
     }