From 393d985658be940542a7248d2acea2b3ea6aafd3 Mon Sep 17 00:00:00 2001
From: Thomas Reis <thomas.reis@cern.ch>
Date: Mon, 19 Jan 2026 23:27:17 +0100
Subject: [PATCH] Remove ECAL CUDA modules and data formats.

---
 CUDADataFormats/CaloCommon/BuildFile.xml      |    6 -
 CUDADataFormats/CaloCommon/interface/Common.h |   68 -
 CUDADataFormats/EcalDigi/BuildFile.xml        |    7 -
 .../EcalDigi/interface/DigisCollection.h      |   24 -
 CUDADataFormats/EcalRecHitSoA/BuildFile.xml   |   11 -
 .../EcalRecHitSoA/interface/EcalRecHit.h      |   45 -
 .../interface/EcalUncalibratedRecHit.h        |   45 -
 CondFormats/EcalObjects/BuildFile.xml         |    8 +-
 .../EcalObjects/interface/EcalGainRatiosGPU.h |   45 -
 .../interface/EcalIntercalibConstantsGPU.h    |   44 -
 .../interface/EcalLaserAPDPNRatiosGPU.h       |   54 -
 .../interface/EcalLaserAPDPNRatiosRefGPU.h    |   44 -
 .../interface/EcalLaserAlphasGPU.h            |   44 -
 .../interface/EcalLinearCorrectionsGPU.h      |   54 -
 .../interface/EcalMultifitParametersGPU.h     |   45 -
 .../EcalObjects/interface/EcalPedestalsGPU.h  |   52 -
 .../interface/EcalPulseCovariancesGPU.h       |   40 -
 .../interface/EcalPulseShapesGPU.h            |   40 -
 .../interface/EcalRecHitParametersGPU.h       |   57 -
 .../interface/EcalRechitADCToGeVConstantGPU.h |   43 -
 .../interface/EcalRechitChannelStatusGPU.h    |   43 -
 .../interface/EcalSamplesCorrelationGPU.h     |   49 -
 .../interface/EcalTimeBiasCorrectionsGPU.h    |   49 -
 .../interface/EcalTimeCalibConstantsGPU.h     |   44 -
 .../interface/ElectronicsMappingGPU.h         |   48 -
 .../EcalObjects/src/EcalGainRatiosGPU.cc      |   38 -
 .../src/EcalIntercalibConstantsGPU.cc         |   25 -
 .../src/EcalLaserAPDPNRatiosGPU.cc            |   61 -
 .../src/EcalLaserAPDPNRatiosRefGPU.cc         |   25 -
 .../EcalObjects/src/EcalLaserAlphasGPU.cc     |   25 -
 .../src/EcalLinearCorrectionsGPU.cc           |   59 -
 .../src/EcalMultifitParametersGPU.cc          |   40 -
 .../EcalObjects/src/EcalPedestalsGPU.cc       |   59 -
 .../src/EcalPulseCovariancesGPU.cc            |   42 -
 .../EcalObjects/src/EcalPulseShapesGPU.cc     |   42 -
 .../src/EcalRecHitParametersGPU.cc            |   46 -
 .../src/EcalRechitADCToGeVConstantGPU.cc      |   25 -
 .../src/EcalRechitChannelStatusGPU.cc         |   33 -
 .../src/EcalSamplesCorrelationGPU.cc          |   66 -
 .../src/EcalTimeBiasCorrectionsGPU.cc         |   53 -
 .../src/EcalTimeCalibConstantsGPU.cc          |   26 -
 .../EcalObjects/src/ElectronicsMappingGPU.cc  |   47 -
 .../EcalRawToDigi/plugins/BuildFile.xml       |   12 +-
 .../EcalRawToDigi/plugins/DeclsForKernels.h   |   66 -
 .../plugins/EcalCPUDigisProducer.cc           |  242 ----
 .../plugins/EcalRawESProducersGPUDefs.cc      |    9 -
 .../EcalRawToDigi/plugins/EcalRawToDigiGPU.cc |  169 ---
 .../EcalRawToDigi/plugins/UnpackGPU.cu        |  459 -------
 EventFilter/EcalRawToDigi/plugins/UnpackGPU.h |   23 -
 RecoLocalCalo/EcalRecAlgos/bin/BuildFile.xml  |   17 -
 ...eEcalMultifitResultsGpuValidationPlots.cpp |  564 --------
 .../bin/makeEcalRechitValidationPlots.cpp     |  864 -------------
 RecoLocalCalo/EcalRecProducers/BuildFile.xml  |    3 +-
 .../AmplitudeComputationCommonKernels.cu      |  487 -------
 .../AmplitudeComputationCommonKernels.h       |  103 --
 .../plugins/AmplitudeComputationKernels.cu    |  305 -----
 .../plugins/AmplitudeComputationKernels.h     |   28 -
 .../EcalRecProducers/plugins/BuildFile.xml    |   12 +-
 .../plugins/DeclsForKernels.h                 |  324 -----
 .../plugins/DeclsForKernelsPhase2.h           |   28 -
 .../plugins/EcalCPURecHitProducer.cc          |  168 ---
 .../plugins/EcalCPUUncalibRecHitProducer.cc   |  131 --
 .../plugins/EcalESProducersGPUDefs.cc         |   88 --
 .../EcalMultifitParametersGPUESProducer.cc    |   82 --
 .../plugins/EcalPhase2DigiToGPUProducer.cc    |   91 --
 .../plugins/EcalRecHitBuilderKernels.cu       |  674 ----------
 .../plugins/EcalRecHitBuilderKernels.h        |   92 --
 .../plugins/EcalRecHitConvertGPU2CPUFormat.cc |   96 --
 .../EcalRecHitParametersGPUESProducer.cc      |  111 --
 .../plugins/EcalRecHitProducerGPU.cc          |  243 ----
 .../EcalUncalibRecHitConvertGPU2CPUFormat.cc  |  101 --
 .../EcalUncalibRecHitMultiFitAlgoGPU.cu       |  304 -----
 .../EcalUncalibRecHitMultiFitAlgoGPU.h        |   23 -
 .../EcalUncalibRecHitPhase2WeightsAlgoGPU.cu  |   33 -
 .../EcalUncalibRecHitPhase2WeightsAlgoGPU.h   |   19 -
 .../EcalUncalibRecHitPhase2WeightsKernels.cu  |   65 -
 .../EcalUncalibRecHitPhase2WeightsKernels.h   |   20 -
 ...alUncalibRecHitPhase2WeightsProducerGPU.cc |  106 --
 .../plugins/EcalUncalibRecHitProducerGPU.cc   |  264 ----
 .../plugins/TimeComputationKernels.cu         | 1133 -----------------
 .../plugins/TimeComputationKernels.h          |  185 ---
 .../python/ecalRecHitGPU_cfi.py               |   72 --
 .../python/ecalUncalibRecHitPhase2GPU_cfi.py  |    2 -
 .../test/ecalRawDecodingAndMultifit.py        |  144 ---
 .../test/testEcalRechitProducer_cfg.py        |  281 ----
 ...alUncalibRecHitPhase2WeightsProducerGPU.py |  141 --
 ...cHitPhase2WeightsProducerGPU_harvesting.py |   95 --
 .../test/testEcalUncalibRechitProducer_cfg.py |  202 ---
 88 files changed, 6 insertions(+), 10396 deletions(-)
 delete mode 100644 CUDADataFormats/CaloCommon/BuildFile.xml
 delete mode 100644 CUDADataFormats/CaloCommon/interface/Common.h
 delete mode 100644 CUDADataFormats/EcalDigi/BuildFile.xml
 delete mode 100644 CUDADataFormats/EcalDigi/interface/DigisCollection.h
 delete mode 100644 CUDADataFormats/EcalRecHitSoA/BuildFile.xml
 delete mode 100644 CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h
 delete mode 100644 CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalPedestalsGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h
 delete mode 100644 CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h
 delete mode 100644 CondFormats/EcalObjects/src/EcalGainRatiosGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalIntercalibConstantsGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosRefGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalLaserAlphasGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalLinearCorrectionsGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalMultifitParametersGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalPedestalsGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalPulseCovariancesGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalPulseShapesGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalRecHitParametersGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalRechitADCToGeVConstantGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalRechitChannelStatusGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalSamplesCorrelationGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalTimeBiasCorrectionsGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/EcalTimeCalibConstantsGPU.cc
 delete mode 100644 CondFormats/EcalObjects/src/ElectronicsMappingGPU.cc
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/EcalRawESProducersGPUDefs.cc
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu
 delete mode 100644 EventFilter/EcalRawToDigi/plugins/UnpackGPU.h
 delete mode 100644 RecoLocalCalo/EcalRecAlgos/bin/BuildFile.xml
 delete mode 100644 RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
 delete mode 100644 RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernelsPhase2.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalESProducersGPUDefs.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalPhase2DigiToGPUProducer.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsProducerGPU.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu
 delete mode 100644 RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
 delete mode 100644 RecoLocalCalo/EcalRecProducers/python/ecalRecHitGPU_cfi.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHitPhase2GPU_cfi.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/test/ecalRawDecodingAndMultifit.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/test/testEcalRechitProducer_cfg.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU_harvesting.py
 delete mode 100644 RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRechitProducer_cfg.py

diff --git a/CUDADataFormats/CaloCommon/BuildFile.xml b/CUDADataFormats/CaloCommon/BuildFile.xml
deleted file mode 100644
index 9f9d23d5c1f84..0000000000000
--- a/CUDADataFormats/CaloCommon/BuildFile.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<use name="HeterogeneousCore/CUDAUtilities"/>
-<use name="DataFormats/Common"/>
-
-<export>
-  <lib   name="1"/>
-</export>
diff --git a/CUDADataFormats/CaloCommon/interface/Common.h b/CUDADataFormats/CaloCommon/interface/Common.h
deleted file mode 100644
index 1be760ec917df..0000000000000
--- a/CUDADataFormats/CaloCommon/interface/Common.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#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 calo {
-  namespace common {
-
-    // FIXME: not able to get enums to work with genreflex
-    namespace tags {
-
-      struct Vec {};
-      struct Ptr {};
-      struct DevPtr {};
-
-    }  // namespace tags
-
-    template <typename tag>
-    struct AddSize {};
-
-    template <>
-    struct AddSize<tags::Ptr> {
-      uint32_t size;
-    };
-
-    template <>
-    struct AddSize<tags::DevPtr> {
-      uint32_t size;
-    };
-
-    struct ViewStoragePolicy {
-      using TagType = tags::Ptr;
-
-      template <typename T>
-      struct StorageSelector {
-        using type = T*;
-      };
-    };
-
-    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;
-
-      template <typename T>
-      struct StorageSelector {
-        using type = std::vector<T, Allocator<T>>;
-      };
-    };
-
-    template <typename T>
-    using CUDAHostAllocatorAlias = cms::cuda::HostAllocator<T>;
-
-  }  // namespace common
-}  // namespace calo
-
-#endif  // CUDADataFormats_CaloCommon_interface_Common_h
diff --git a/CUDADataFormats/EcalDigi/BuildFile.xml b/CUDADataFormats/EcalDigi/BuildFile.xml
deleted file mode 100644
index b479a9f9db1ec..0000000000000
--- a/CUDADataFormats/EcalDigi/BuildFile.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<use name="CUDADataFormats/Common"/>
-<use name="CUDADataFormats/CaloCommon"/>
-<use name="DataFormats/Common"/>
-
-<export>
-  <lib   name="1"/>
-</export>
diff --git a/CUDADataFormats/EcalDigi/interface/DigisCollection.h b/CUDADataFormats/EcalDigi/interface/DigisCollection.h
deleted file mode 100644
index f471dbfb9fac8..0000000000000
--- a/CUDADataFormats/EcalDigi/interface/DigisCollection.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef CUDADataFormats_EcalDigi_interface_DigisCollection_h
-#define CUDADataFormats_EcalDigi_interface_DigisCollection_h
-
-#include "CUDADataFormats/CaloCommon/interface/Common.h"
-
-namespace ecal {
-
-  template <typename StoragePolicy>
-  struct DigisCollection : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
-    DigisCollection() = default;
-    DigisCollection(DigisCollection const &) = default;
-    DigisCollection &operator=(DigisCollection const &) = default;
-
-    DigisCollection(DigisCollection &&) = default;
-    DigisCollection &operator=(DigisCollection &&) = default;
-
-    // stride is statically known
-    typename StoragePolicy::template StorageSelector<uint32_t>::type ids;
-    typename StoragePolicy::template StorageSelector<uint16_t>::type data;
-  };
-
-}  // namespace ecal
-
-#endif  // CUDADataFormats_EcalDigi_interface_DigisCollection_h
diff --git a/CUDADataFormats/EcalRecHitSoA/BuildFile.xml b/CUDADataFormats/EcalRecHitSoA/BuildFile.xml
deleted file mode 100644
index 6d67c5d5f6220..0000000000000
--- a/CUDADataFormats/EcalRecHitSoA/BuildFile.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<use name="cuda"/>
-<use name="CUDADataFormats/Common"/>
-<use name="CUDADataFormats/CaloCommon"/>
-<use name="DataFormats/Common"/>
-<use name="DataFormats/EcalDigi"/>
-<use name="DataFormats/EcalRecHit"/>
-<use name="HeterogeneousCore/CUDAUtilities"/>
-
-<export>
-  <lib   name="1"/>
-</export>
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h
deleted file mode 100644
index 3e312218a112f..0000000000000
--- a/CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h
-#define CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h
-
-#include <array>
-#include <vector>
-
-#include "CUDADataFormats/CaloCommon/interface/Common.h"
-#include "DataFormats/EcalRecHit/interface/RecoTypes.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.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  // CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h
diff --git a/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h b/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h
deleted file mode 100644
index a48850e68858f..0000000000000
--- a/CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
-#define CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
-
-#include "CUDADataFormats/CaloCommon/interface/Common.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalRecHit/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 amplitudeError;
-    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);
-      amplitudeError.resize(size);
-      pedestal.resize(size);
-      chi2.resize(size);
-      did.resize(size);
-      flags.resize(size);
-      jitter.resize(size);
-      jitterError.resize(size);
-    }
-  };
-
-}  // namespace ecal
-
-#endif  // CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
diff --git a/CondFormats/EcalObjects/BuildFile.xml b/CondFormats/EcalObjects/BuildFile.xml
index 61c5c69126a5e..7ddf77d34e558 100644
--- a/CondFormats/EcalObjects/BuildFile.xml
+++ b/CondFormats/EcalObjects/BuildFile.xml
@@ -5,17 +5,11 @@
 <use name="DataFormats/Math"/>
 <use name="DataFormats/Portable"/>
 <use name="DataFormats/SoATemplate"/>
-<use name="HeterogeneousCore/CUDACore"/>
-<use name="HeterogeneousCore/CUDAUtilities"/>
 <use name="boost"/>
 <use name="boost_serialization"/>
 <use name="rootmath"/>
 <use name="clhep"/>
-<iftool name="cuda">
-  <use name="cuda"/>
-<else/>
-  <flags SKIP_FILES="%GPU.cc"/>
-</iftool>
+<use name="eigen"/>
 <use name="HeterogeneousCore/AlpakaInterface"/>
 <flags ALPAKA_BACKENDS="!serial"/>
 <export>
diff --git a/CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h b/CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h
deleted file mode 100644
index 27a4236acd6e1..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalGainRatiosGPU_h
-#define CondFormats_EcalObjects_interface_EcalGainRatiosGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalGainRatiosGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> gain12Over6;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> gain6Over1;
-  };
-
-#ifndef __CUDACC__
-
-  // rearrange pedestals
-  EcalGainRatiosGPU(EcalGainRatios const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalGainRatiosGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalGainRatiosGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<float, cms::cuda::HostAllocator<float>> gain12Over6_;
-  std::vector<float, cms::cuda::HostAllocator<float>> gain6Over1_;
-
-  cms::cuda::ESProduct<Product> product_;
-
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalGainRatiosGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h b/CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h
deleted file mode 100644
index 35c172a2920af..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalIntercalibConstantsGPU_h
-#define CondFormats_EcalObjects_interface_EcalIntercalibConstantsGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalIntercalibConstantsGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> values;
-  };
-
-#ifndef __CUDACC__
-  //
-  EcalIntercalibConstantsGPU(EcalIntercalibConstants const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalIntercalibConstantsGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  // TODO: do this centrally
-  // get offset for hashes. equals number of barrel items
-  uint32_t getOffset() const { return offset_; }
-
-  //
-  static std::string name() { return std::string{"ecalIntercalibConstantsGPU"}; }
-
-private:
-  std::vector<float, cms::cuda::HostAllocator<float>> values_;
-  uint32_t offset_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalIntercalibConstantsGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h b/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h
deleted file mode 100644
index f68c405470556..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosGPU_h
-#define CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatios.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalLaserAPDPNRatiosGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p1;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p2;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p3;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t1;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t2;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t3;
-  };
-
-#ifndef __CUDACC__
-
-  //
-  EcalLaserAPDPNRatiosGPU(EcalLaserAPDPNRatios const &);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalLaserAPDPNRatiosGPU() = default;
-
-  // get device pointers
-  Product const &getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalLaserAPDPNRatiosGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<float, cms::cuda::HostAllocator<float>> p1_;
-  std::vector<float, cms::cuda::HostAllocator<float>> p2_;
-  std::vector<float, cms::cuda::HostAllocator<float>> p3_;
-
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t1_;
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t2_;
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t3_;
-
-  cms::cuda::ESProduct<Product> product_;
-
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h b/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h
deleted file mode 100644
index 2b9514a081c14..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosRefGPU_h
-#define CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosRefGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRef.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalLaserAPDPNRatiosRefGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> values;
-  };
-
-#ifndef __CUDACC__
-  //
-  EcalLaserAPDPNRatiosRefGPU(EcalLaserAPDPNRatiosRef const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalLaserAPDPNRatiosRefGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  // TODO: do this centrally
-  // get offset for hashes. equals number of barrel items
-  uint32_t getOffset() const { return offset_; }
-  uint32_t offset_;
-
-  //
-  static std::string name() { return std::string{"ecalLaserAPDPNRatiosRefGPU"}; }
-
-private:
-  std::vector<float, cms::cuda::HostAllocator<float>> values_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalLaserAPDPNRatiosRefGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h b/CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h
deleted file mode 100644
index 50599a6afb43f..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalLaserAlphasGPU_h
-#define CondFormats_EcalObjects_interface_EcalLaserAlphasGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalLaserAlphas.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalLaserAlphasGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> values;
-  };
-
-#ifndef __CUDACC__
-  //
-  EcalLaserAlphasGPU(EcalLaserAlphas const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalLaserAlphasGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  // TODO: do this centrally
-  // get offset for hashes. equals number of barrel items
-  uint32_t getOffset() const { return offset_; }
-
-  //
-  static std::string name() { return std::string{"ecalLaserAlphasGPU"}; }
-
-private:
-  std::vector<float, cms::cuda::HostAllocator<float>> values_;
-  uint32_t offset_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalLaserAlphasGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h b/CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h
deleted file mode 100644
index 8513224071f9d..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalLinearCorrectionsGPU_h
-#define CondFormats_EcalObjects_interface_EcalLinearCorrectionsGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalLinearCorrections.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalLinearCorrectionsGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p1;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p2;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> p3;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t1;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t2;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<edm::TimeValue_t[]>> t3;
-  };
-
-#ifndef __CUDACC__
-
-  //
-  EcalLinearCorrectionsGPU(EcalLinearCorrections const &);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalLinearCorrectionsGPU() = default;
-
-  // get device pointers
-  Product const &getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalLinearCorrectionsGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<float, cms::cuda::HostAllocator<float>> p1_;
-  std::vector<float, cms::cuda::HostAllocator<float>> p2_;
-  std::vector<float, cms::cuda::HostAllocator<float>> p3_;
-
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t1_;
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t2_;
-  std::vector<edm::TimeValue_t, cms::cuda::HostAllocator<edm::TimeValue_t>> t3_;
-
-  cms::cuda::ESProduct<Product> product_;
-
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalLinearCorrectionsGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h b/CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h
deleted file mode 100644
index 51b59a2d46dc8..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalMultifitParametersGPU_h
-#define CondFormats_EcalObjects_interface_EcalMultifitParametersGPU_h
-
-#include <array>
-
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalMultifitParametersGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> amplitudeFitParametersEB;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> amplitudeFitParametersEE;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> timeFitParametersEB;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> timeFitParametersEE;
-  };
-
-#ifndef __CUDACC__
-  EcalMultifitParametersGPU(std::vector<double> const& amplitudeEB,
-                            std::vector<double> const& amplitudeEE,
-                            std::vector<double> const& timeEB,
-                            std::vector<double> const& timeEE);
-
-  ~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  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalMultifitParametersGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalPedestalsGPU.h b/CondFormats/EcalObjects/interface/EcalPedestalsGPU.h
deleted file mode 100644
index 80bc2d3a3fb80..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalPedestalsGPU.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalPedestalsGPU_h
-#define CondFormats_EcalObjects_interface_EcalPedestalsGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalPedestals.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalPedestalsGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> mean_x12;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> mean_x6;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> mean_x1;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> rms_x12;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> rms_x6;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> rms_x1;
-  };
-
-#ifndef __CUDACC__
-
-  // rearrange pedestals
-  EcalPedestalsGPU(EcalPedestals const &);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalPedestalsGPU() = default;
-
-  // get device pointers
-  Product const &getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalPedestalsGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<float, cms::cuda::HostAllocator<float>> mean_x12_;
-  std::vector<float, cms::cuda::HostAllocator<float>> rms_x12_;
-  std::vector<float, cms::cuda::HostAllocator<float>> mean_x6_;
-  std::vector<float, cms::cuda::HostAllocator<float>> rms_x6_;
-  std::vector<float, cms::cuda::HostAllocator<float>> mean_x1_;
-  std::vector<float, cms::cuda::HostAllocator<float>> rms_x1_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalPedestalsGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h b/CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h
deleted file mode 100644
index 56207d8cb4ab3..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalPulseCovariancesGPU_h
-#define CondFormats_EcalObjects_interface_EcalPulseCovariancesGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariances.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalPulseCovariancesGPU {
-public:
-  struct Product {
-    ~Product();
-    EcalPulseCovariance* values = nullptr;
-  };
-
-#ifndef __CUDACC__
-  // rearrange pedestals
-  EcalPulseCovariancesGPU(EcalPulseCovariances const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalPulseCovariancesGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalPulseCovariancesGPU"}; }
-
-private:
-  // reuse original vectors (although with default allocator)
-  std::vector<EcalPulseCovariance> const& valuesEB_;
-  std::vector<EcalPulseCovariance> const& valuesEE_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalPulseCovariancesGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h b/CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h
deleted file mode 100644
index 0caf954409b18..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalPulseShapesGPU_h
-#define CondFormats_EcalObjects_interface_EcalPulseShapesGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalPulseShapes.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalPulseShapesGPU {
-public:
-  struct Product {
-    ~Product();
-    EcalPulseShape* values = nullptr;
-  };
-
-#ifndef __CUDACC__
-  // rearrange pedestals
-  EcalPulseShapesGPU(EcalPulseShapes const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalPulseShapesGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalPulseShapesGPU"}; }
-
-private:
-  // reuse original vectors (although with default allocator)
-  std::vector<EcalPulseShape> const& valuesEB_;
-  std::vector<EcalPulseShape> const& valuesEE_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalPulseShapesGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h b/CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h
deleted file mode 100644
index 513b1206f3e93..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalRecHitParametersGPU_h
-#define CondFormats_EcalObjects_interface_EcalRecHitParametersGPU_h
-
-#include <array>
-
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalRecHitParametersGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<int[]>> channelStatusToBeExcluded;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<int[]>> expanded_v_DB_reco_flags;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<uint32_t[]>> expanded_Sizes_v_DB_reco_flags;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<uint32_t[]>> expanded_flagbit_v_DB_reco_flags;
-  };
-
-#ifndef __CUDACC__
-  struct DBStatus {
-    DBStatus(int flag, std::vector<uint32_t> status) : recoflagbit{flag}, dbstatus(std::move(status)) {}
-    int recoflagbit;                 //must be a EcalRecHit::Flags
-    std::vector<uint32_t> dbstatus;  //must contain EcalChannelStatusCode::Code
-  };
-
-  /// channelStatusToBeExcluded must contain EcalChannelStatusCode::Code
-  EcalRecHitParametersGPU(std::vector<int> const& channelStatusToBeExcluded,
-                          std::vector<DBStatus> const& flagsMapDBReco);
-
-  ~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  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalRecHitParametersGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h b/CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h
deleted file mode 100644
index a4f2dc1e555b5..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalRechitADCToGeVConstantGPU_h
-#define CondFormats_EcalObjects_interface_EcalRechitADCToGeVConstantGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalRechitADCToGeVConstantGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> adc2gev;
-  };
-
-#ifndef __CUDACC__
-
-  //
-  EcalRechitADCToGeVConstantGPU(EcalADCToGeVConstant const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalRechitADCToGeVConstantGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalRechitADCToGeVConstantGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<float, cms::cuda::HostAllocator<float>> adc2gev_;
-
-  cms::cuda::ESProduct<Product> product_;
-
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalRechitADCToGeVConstantGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h b/CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h
deleted file mode 100644
index 93e0f6a8dd7c0..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalRechitChannelStatusGPU_h
-#define CondFormats_EcalObjects_interface_EcalRechitChannelStatusGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalRechitChannelStatusGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<uint16_t[]>> status;
-  };
-
-#ifndef __CUDACC__
-
-  //
-  EcalRechitChannelStatusGPU(EcalChannelStatus const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalRechitChannelStatusGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalRechitChannelStatusGPU"}; }
-
-private:
-  // in the future, we need to arrange so to avoid this copy on the host
-  // store eb first then ee
-  std::vector<uint16_t, cms::cuda::HostAllocator<uint16_t>> status_;
-
-  cms::cuda::ESProduct<Product> product_;
-
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalRechitChannelStatusGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h b/CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h
deleted file mode 100644
index dd6d48b16a6fa..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalSamplesCorrelationGPU_h
-#define CondFormats_EcalObjects_interface_EcalSamplesCorrelationGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelation.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalSamplesCorrelationGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EBG12SamplesCorrelation;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EBG6SamplesCorrelation;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EBG1SamplesCorrelation;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EEG12SamplesCorrelation;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EEG6SamplesCorrelation;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<double[]>> EEG1SamplesCorrelation;
-  };
-
-#ifndef __CUDACC__
-  // rearrange pedestals
-  EcalSamplesCorrelationGPU(EcalSamplesCorrelation const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalSamplesCorrelationGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalSamplesCorrelationGPU"}; }
-
-private:
-  std::vector<double, cms::cuda::HostAllocator<double>> EBG12SamplesCorrelation_;
-  std::vector<double, cms::cuda::HostAllocator<double>> EBG6SamplesCorrelation_;
-  std::vector<double, cms::cuda::HostAllocator<double>> EBG1SamplesCorrelation_;
-  std::vector<double, cms::cuda::HostAllocator<double>> EEG12SamplesCorrelation_;
-  std::vector<double, cms::cuda::HostAllocator<double>> EEG6SamplesCorrelation_;
-  std::vector<double, cms::cuda::HostAllocator<double>> EEG1SamplesCorrelation_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalSamplesCorrelationGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h b/CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h
deleted file mode 100644
index 086decb53f01b..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalTimeBiasCorrectionsGPU_h
-#define CondFormats_EcalObjects_interface_EcalTimeBiasCorrectionsGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrections.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalTimeBiasCorrectionsGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> ebTimeCorrAmplitudeBins;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> ebTimeCorrShiftBins;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> eeTimeCorrAmplitudeBins;
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> eeTimeCorrShiftBins;
-    int ebTimeCorrAmplitudeBinsSize, eeTimeCorrAmplitudeBinsSize;
-  };
-
-  // rearrange pedestals
-  EcalTimeBiasCorrectionsGPU(EcalTimeBiasCorrections const&);
-
-#ifndef __CUDACC__
-
-  // will call dealloation for Product thru ~Product
-  ~EcalTimeBiasCorrectionsGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  //
-  static std::string name() { return std::string{"ecalTimeBiasCorrectionsGPU"}; }
-#endif  // __CUDACC__
-
-private:
-  std::vector<float, cms::cuda::HostAllocator<float>> ebTimeCorrAmplitudeBins_;
-  std::vector<float, cms::cuda::HostAllocator<float>> ebTimeCorrShiftBins_;
-  std::vector<float, cms::cuda::HostAllocator<float>> eeTimeCorrAmplitudeBins_;
-  std::vector<float, cms::cuda::HostAllocator<float>> eeTimeCorrShiftBins_;
-
-#ifndef __CUDACC__
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalTimeBiasCorrectionsGPU_h
diff --git a/CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h b/CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h
deleted file mode 100644
index 410e7699bdf7b..0000000000000
--- a/CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_EcalTimeCalibConstantsGPU_h
-#define CondFormats_EcalObjects_interface_EcalTimeCalibConstantsGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-class EcalTimeCalibConstantsGPU {
-public:
-  struct Product {
-    edm::propagate_const_array<cms::cuda::device::unique_ptr<float[]>> values;
-  };
-
-#ifndef __CUDACC__
-  // rearrange pedestals
-  EcalTimeCalibConstantsGPU(EcalTimeCalibConstants const&);
-
-  // will call dealloation for Product thru ~Product
-  ~EcalTimeCalibConstantsGPU() = default;
-
-  // get device pointers
-  Product const& getProduct(cudaStream_t) const;
-
-  // TODO: do this centrally
-  // get offset for hashes. equals number of barrel items
-  uint32_t getOffset() const { return offset_; }
-
-  //
-  static std::string name() { return std::string{"ecalTimeCalibConstantsGPU"}; }
-
-private:
-  std::vector<float, cms::cuda::HostAllocator<float>> values_;
-  uint32_t offset_;
-
-  cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-};
-
-#endif  // CondFormats_EcalObjects_interface_EcalTimeCalibConstantsGPU_h
diff --git a/CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h b/CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h
deleted file mode 100644
index 4c0cb30222bb9..0000000000000
--- a/CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef CondFormats_EcalObjects_interface_ElectronicsMappingGPU_h
-#define CondFormats_EcalObjects_interface_ElectronicsMappingGPU_h
-
-#include "CondFormats/EcalObjects/interface/EcalMappingElectronics.h"
-#include "FWCore/Utilities/interface/propagate_const_array.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/device_unique_ptr.h"
-
-#ifndef __CUDACC__
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDACore/interface/ESProduct.h"
-#endif  // __CUDACC__
-
-namespace ecal {
-  namespace raw {
-
-    class ElectronicsMappingGPU {
-    public:
-      struct Product {
-        edm::propagate_const_array<cms::cuda::device::unique_ptr<uint32_t[]>> eid2did;
-      };
-
-#ifndef __CUDACC__
-
-      // rearrange pedestals
-      ElectronicsMappingGPU(EcalMappingElectronics const&);
-
-      // will call dealloation for Product thru ~Product
-      ~ElectronicsMappingGPU() = default;
-
-      // get device pointers
-      Product const& getProduct(cudaStream_t) const;
-
-      //
-      static std::string name() { return std::string{"ecalElectronicsMappingGPU"}; }
-
-    private:
-      // in the future, we need to arrange so to avoid this copy on the host
-      // store eb first then ee
-      std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> eid2did_;
-
-      cms::cuda::ESProduct<Product> product_;
-#endif  // __CUDACC__
-    };
-
-  }  // namespace raw
-}  // namespace ecal
-
-#endif  // CondFormats_EcalObjects_interface_ElectronicsMappingGPU_h
diff --git a/CondFormats/EcalObjects/src/EcalGainRatiosGPU.cc b/CondFormats/EcalObjects/src/EcalGainRatiosGPU.cc
deleted file mode 100644
index 9e509430c4276..0000000000000
--- a/CondFormats/EcalObjects/src/EcalGainRatiosGPU.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalGainRatiosGPU::EcalGainRatiosGPU(EcalGainRatios const& values)
-    : gain12Over6_(values.size()), gain6Over1_(values.size()) {
-  // fill in eb
-  auto const& barrelValues = values.barrelItems();
-  for (unsigned int i = 0; i < barrelValues.size(); i++) {
-    gain12Over6_[i] = barrelValues[i].gain12Over6();
-    gain6Over1_[i] = barrelValues[i].gain6Over1();
-  }
-
-  // fill in ee
-  auto const& endcapValues = values.endcapItems();
-  auto const offset = barrelValues.size();
-  for (unsigned int i = 0; i < endcapValues.size(); i++) {
-    gain12Over6_[offset + i] = endcapValues[i].gain12Over6();
-    gain6Over1_[offset + i] = endcapValues[i].gain6Over1();
-  }
-}
-
-EcalGainRatiosGPU::Product const& EcalGainRatiosGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalGainRatiosGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.gain12Over6 = cms::cuda::make_device_unique<float[]>(gain12Over6_.size(), cudaStream);
-        product.gain6Over1 = cms::cuda::make_device_unique<float[]>(gain6Over1_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.gain12Over6, gain12Over6_, cudaStream);
-        cms::cuda::copyAsync(product.gain6Over1, gain6Over1_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalGainRatiosGPU);
diff --git a/CondFormats/EcalObjects/src/EcalIntercalibConstantsGPU.cc b/CondFormats/EcalObjects/src/EcalIntercalibConstantsGPU.cc
deleted file mode 100644
index d85b1e1eb7420..0000000000000
--- a/CondFormats/EcalObjects/src/EcalIntercalibConstantsGPU.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalIntercalibConstantsGPU::EcalIntercalibConstantsGPU(EcalIntercalibConstants const& values) {
-  values_.reserve(values.size());
-  values_.insert(values_.end(), values.barrelItems().begin(), values.barrelItems().end());
-  values_.insert(values_.end(), values.endcapItems().begin(), values.endcapItems().end());
-  offset_ = values.barrelItems().size();
-}
-
-EcalIntercalibConstantsGPU::Product const& EcalIntercalibConstantsGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalIntercalibConstantsGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.values = cms::cuda::make_device_unique<float[]>(values_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.values, values_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalIntercalibConstantsGPU);
diff --git a/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosGPU.cc b/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosGPU.cc
deleted file mode 100644
index 3a74f029ec185..0000000000000
--- a/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosGPU.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalLaserAPDPNRatiosGPU::EcalLaserAPDPNRatiosGPU(EcalLaserAPDPNRatios const& values)
-    : p1_(values.getLaserMap().size()),
-      p2_(values.getLaserMap().size()),
-      p3_(values.getLaserMap().size()),
-      t1_(values.getTimeMap().size()),
-      t2_(values.getTimeMap().size()),
-      t3_(values.getTimeMap().size()) {
-  // fill in eb
-  //     auto const& barrelValues = values.barrelItems();
-  for (unsigned int i = 0; i < values.getLaserMap().barrelItems().size(); i++) {
-    p1_[i] = values.getLaserMap().barrelItems()[i].p1;
-    p2_[i] = values.getLaserMap().barrelItems()[i].p2;
-    p3_[i] = values.getLaserMap().barrelItems()[i].p3;
-  }
-
-  // fill in ee
-  //     auto const& endcapValues = values.endcapItems();
-  auto const offset_laser = values.getLaserMap().barrelItems().size();
-  for (unsigned int i = 0; i < values.getLaserMap().endcapItems().size(); i++) {
-    p1_[offset_laser + i] = values.getLaserMap().endcapItems()[i].p1;
-    p2_[offset_laser + i] = values.getLaserMap().endcapItems()[i].p2;
-    p3_[offset_laser + i] = values.getLaserMap().endcapItems()[i].p3;
-  }
-
-  //   Time is a simple std::vector
-  //       typedef std::vector<EcalLaserTimeStamp> EcalLaserTimeStampMap;
-  for (unsigned int i = 0; i < values.getTimeMap().size(); i++) {
-    t1_[i] = values.getTimeMap()[i].t1.value();
-    t2_[i] = values.getTimeMap()[i].t2.value();
-    t3_[i] = values.getTimeMap()[i].t3.value();
-  }
-}
-
-EcalLaserAPDPNRatiosGPU::Product const& EcalLaserAPDPNRatiosGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalLaserAPDPNRatiosGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.p1 = cms::cuda::make_device_unique<float[]>(p1_.size(), cudaStream);
-        product.p2 = cms::cuda::make_device_unique<float[]>(p2_.size(), cudaStream);
-        product.p3 = cms::cuda::make_device_unique<float[]>(p3_.size(), cudaStream);
-        product.t1 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t1_.size(), cudaStream);
-        product.t2 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t2_.size(), cudaStream);
-        product.t3 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t3_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.p1, p1_, cudaStream);
-        cms::cuda::copyAsync(product.p2, p2_, cudaStream);
-        cms::cuda::copyAsync(product.p3, p3_, cudaStream);
-        cms::cuda::copyAsync(product.t1, t1_, cudaStream);
-        cms::cuda::copyAsync(product.t2, t2_, cudaStream);
-        cms::cuda::copyAsync(product.t3, t3_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalLaserAPDPNRatiosGPU);
diff --git a/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosRefGPU.cc b/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosRefGPU.cc
deleted file mode 100644
index 7cc7117ba48de..0000000000000
--- a/CondFormats/EcalObjects/src/EcalLaserAPDPNRatiosRefGPU.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalLaserAPDPNRatiosRefGPU::EcalLaserAPDPNRatiosRefGPU(EcalLaserAPDPNRatiosRef const& values) {
-  values_.reserve(values.size());
-  values_.insert(values_.end(), values.barrelItems().begin(), values.barrelItems().end());
-  values_.insert(values_.end(), values.endcapItems().begin(), values.endcapItems().end());
-  offset_ = values.barrelItems().size();
-}
-
-EcalLaserAPDPNRatiosRefGPU::Product const& EcalLaserAPDPNRatiosRefGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalLaserAPDPNRatiosRefGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.values = cms::cuda::make_device_unique<float[]>(values_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.values, values_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalLaserAPDPNRatiosRefGPU);
diff --git a/CondFormats/EcalObjects/src/EcalLaserAlphasGPU.cc b/CondFormats/EcalObjects/src/EcalLaserAlphasGPU.cc
deleted file mode 100644
index 538c0438829bc..0000000000000
--- a/CondFormats/EcalObjects/src/EcalLaserAlphasGPU.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalLaserAlphasGPU::EcalLaserAlphasGPU(EcalLaserAlphas const& values) {
-  values_.reserve(values.size());
-  values_.insert(values_.end(), values.barrelItems().begin(), values.barrelItems().end());
-  values_.insert(values_.end(), values.endcapItems().begin(), values.endcapItems().end());
-  offset_ = values.barrelItems().size();
-}
-
-EcalLaserAlphasGPU::Product const& EcalLaserAlphasGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalLaserAlphasGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.values = cms::cuda::make_device_unique<float[]>(values_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.values, values_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalLaserAlphasGPU);
diff --git a/CondFormats/EcalObjects/src/EcalLinearCorrectionsGPU.cc b/CondFormats/EcalObjects/src/EcalLinearCorrectionsGPU.cc
deleted file mode 100644
index b6b706d6b18e8..0000000000000
--- a/CondFormats/EcalObjects/src/EcalLinearCorrectionsGPU.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalLinearCorrectionsGPU::EcalLinearCorrectionsGPU(EcalLinearCorrections const& values)
-    : p1_(values.getValueMap().size()),
-      p2_(values.getValueMap().size()),
-      p3_(values.getValueMap().size()),
-      t1_(values.getTimeMap().size()),
-      t2_(values.getTimeMap().size()),
-      t3_(values.getTimeMap().size()) {
-  // fill in eb
-  for (unsigned int i = 0; i < values.getValueMap().barrelItems().size(); i++) {
-    p1_[i] = values.getValueMap().barrelItems()[i].p1;
-    p2_[i] = values.getValueMap().barrelItems()[i].p2;
-    p3_[i] = values.getValueMap().barrelItems()[i].p3;
-  }
-
-  // fill in ee
-  auto const offset_laser = values.getValueMap().barrelItems().size();
-  for (unsigned int i = 0; i < values.getValueMap().endcapItems().size(); i++) {
-    p1_[offset_laser + i] = values.getValueMap().endcapItems()[i].p1;
-    p2_[offset_laser + i] = values.getValueMap().endcapItems()[i].p2;
-    p3_[offset_laser + i] = values.getValueMap().endcapItems()[i].p3;
-  }
-
-  //   Time is a simple std::vector
-  //       typedef std::vector<EcalLaserTimeStamp> EcalLaserTimeStampMap;
-  for (unsigned int i = 0; i < values.getTimeMap().size(); i++) {
-    t1_[i] = values.getTimeMap()[i].t1.value();
-    t2_[i] = values.getTimeMap()[i].t2.value();
-    t3_[i] = values.getTimeMap()[i].t3.value();
-  }
-}
-
-EcalLinearCorrectionsGPU::Product const& EcalLinearCorrectionsGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalLinearCorrectionsGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.p1 = cms::cuda::make_device_unique<float[]>(p1_.size(), cudaStream);
-        product.p2 = cms::cuda::make_device_unique<float[]>(p2_.size(), cudaStream);
-        product.p3 = cms::cuda::make_device_unique<float[]>(p3_.size(), cudaStream);
-        product.t1 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t1_.size(), cudaStream);
-        product.t2 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t2_.size(), cudaStream);
-        product.t3 = cms::cuda::make_device_unique<edm::TimeValue_t[]>(t3_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.p1, p1_, cudaStream);
-        cms::cuda::copyAsync(product.p2, p2_, cudaStream);
-        cms::cuda::copyAsync(product.p3, p3_, cudaStream);
-        cms::cuda::copyAsync(product.t1, t1_, cudaStream);
-        cms::cuda::copyAsync(product.t2, t2_, cudaStream);
-        cms::cuda::copyAsync(product.t3, t3_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalLinearCorrectionsGPU);
diff --git a/CondFormats/EcalObjects/src/EcalMultifitParametersGPU.cc b/CondFormats/EcalObjects/src/EcalMultifitParametersGPU.cc
deleted file mode 100644
index 69e4f273d75ab..0000000000000
--- a/CondFormats/EcalObjects/src/EcalMultifitParametersGPU.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalMultifitParametersGPU::EcalMultifitParametersGPU(std::vector<double> const& amplitudeFitParametersEB,
-                                                     std::vector<double> const& amplitudeFitParametersEE,
-                                                     std::vector<double> const& timeFitParametersEB,
-                                                     std::vector<double> const& timeFitParametersEE) {
-  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 const& EcalMultifitParametersGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalMultifitParametersGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.amplitudeFitParametersEB =
-            cms::cuda::make_device_unique<double[]>(amplitudeFitParametersEB_.size(), cudaStream);
-        product.amplitudeFitParametersEE =
-            cms::cuda::make_device_unique<double[]>(amplitudeFitParametersEE_.size(), cudaStream);
-        product.timeFitParametersEB = cms::cuda::make_device_unique<double[]>(timeFitParametersEB_.size(), cudaStream);
-        product.timeFitParametersEE = cms::cuda::make_device_unique<double[]>(timeFitParametersEE_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.amplitudeFitParametersEB, amplitudeFitParametersEB_, cudaStream);
-        cms::cuda::copyAsync(product.amplitudeFitParametersEE, amplitudeFitParametersEE_, cudaStream);
-        cms::cuda::copyAsync(product.timeFitParametersEB, timeFitParametersEB_, cudaStream);
-        cms::cuda::copyAsync(product.timeFitParametersEE, timeFitParametersEE_, cudaStream);
-      });
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalMultifitParametersGPU);
diff --git a/CondFormats/EcalObjects/src/EcalPedestalsGPU.cc b/CondFormats/EcalObjects/src/EcalPedestalsGPU.cc
deleted file mode 100644
index 2528dab1665fb..0000000000000
--- a/CondFormats/EcalObjects/src/EcalPedestalsGPU.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalPedestalsGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalPedestalsGPU::EcalPedestalsGPU(EcalPedestals const& pedestals)
-    : mean_x12_(pedestals.size()),
-      rms_x12_(pedestals.size()),
-      mean_x6_(pedestals.size()),
-      rms_x6_(pedestals.size()),
-      mean_x1_(pedestals.size()),
-      rms_x1_(pedestals.size()) {
-  // fill in eb
-  auto const& barrelValues = pedestals.barrelItems();
-  for (unsigned int i = 0; i < barrelValues.size(); i++) {
-    mean_x12_[i] = barrelValues[i].mean_x12;
-    rms_x12_[i] = barrelValues[i].rms_x12;
-    mean_x6_[i] = barrelValues[i].mean_x6;
-    rms_x6_[i] = barrelValues[i].rms_x6;
-    mean_x1_[i] = barrelValues[i].mean_x1;
-    rms_x1_[i] = barrelValues[i].rms_x1;
-  }
-
-  // fill in ee
-  auto const& endcapValues = pedestals.endcapItems();
-  auto const offset = barrelValues.size();
-  for (unsigned int i = 0; i < endcapValues.size(); i++) {
-    mean_x12_[offset + i] = endcapValues[i].mean_x12;
-    rms_x12_[offset + i] = endcapValues[i].rms_x12;
-    mean_x6_[offset + i] = endcapValues[i].mean_x6;
-    rms_x6_[offset + i] = endcapValues[i].rms_x6;
-    mean_x1_[offset + i] = endcapValues[i].mean_x1;
-    rms_x1_[offset + i] = endcapValues[i].rms_x1;
-  }
-}
-
-EcalPedestalsGPU::Product const& EcalPedestalsGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPedestalsGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.mean_x12 = cms::cuda::make_device_unique<float[]>(mean_x12_.size(), cudaStream);
-        product.mean_x6 = cms::cuda::make_device_unique<float[]>(mean_x6_.size(), cudaStream);
-        product.mean_x1 = cms::cuda::make_device_unique<float[]>(mean_x1_.size(), cudaStream);
-        product.rms_x12 = cms::cuda::make_device_unique<float[]>(rms_x12_.size(), cudaStream);
-        product.rms_x6 = cms::cuda::make_device_unique<float[]>(rms_x6_.size(), cudaStream);
-        product.rms_x1 = cms::cuda::make_device_unique<float[]>(rms_x1_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.mean_x12, mean_x12_, cudaStream);
-        cms::cuda::copyAsync(product.mean_x6, mean_x6_, cudaStream);
-        cms::cuda::copyAsync(product.mean_x1, mean_x1_, cudaStream);
-        cms::cuda::copyAsync(product.rms_x12, rms_x12_, cudaStream);
-        cms::cuda::copyAsync(product.rms_x6, rms_x6_, cudaStream);
-        cms::cuda::copyAsync(product.rms_x1, rms_x1_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalPedestalsGPU);
diff --git a/CondFormats/EcalObjects/src/EcalPulseCovariancesGPU.cc b/CondFormats/EcalObjects/src/EcalPulseCovariancesGPU.cc
deleted file mode 100644
index 05586080bff6a..0000000000000
--- a/CondFormats/EcalObjects/src/EcalPulseCovariancesGPU.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-EcalPulseCovariancesGPU::EcalPulseCovariancesGPU(EcalPulseCovariances const& values)
-    : valuesEB_{values.barrelItems()}, valuesEE_{values.endcapItems()} {}
-
-EcalPulseCovariancesGPU::Product::~Product() {
-  // deallocation
-  cudaCheck(cudaFree(values));
-}
-
-EcalPulseCovariancesGPU::Product const& EcalPulseCovariancesGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPulseCovariancesGPU::Product& product, cudaStream_t cudaStream) {
-        // malloc
-        cudaCheck(cudaMalloc((void**)&product.values,
-                             (this->valuesEE_.size() + this->valuesEB_.size()) * sizeof(EcalPulseCovariance)));
-
-        // offset in terms of sizeof(EcalPulseCovariance)
-        uint32_t offset = this->valuesEB_.size();
-
-        // transfer eb
-        cudaCheck(cudaMemcpyAsync(product.values,
-                                  this->valuesEB_.data(),
-                                  this->valuesEB_.size() * sizeof(EcalPulseCovariance),
-                                  cudaMemcpyHostToDevice,
-                                  cudaStream));
-
-        // transfer ee starting at values + offset
-        cudaCheck(cudaMemcpyAsync(product.values + offset,
-                                  this->valuesEE_.data(),
-                                  this->valuesEE_.size() * sizeof(EcalPulseCovariance),
-                                  cudaMemcpyHostToDevice,
-                                  cudaStream));
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalPulseCovariancesGPU);
diff --git a/CondFormats/EcalObjects/src/EcalPulseShapesGPU.cc b/CondFormats/EcalObjects/src/EcalPulseShapesGPU.cc
deleted file mode 100644
index 96b492f3ad335..0000000000000
--- a/CondFormats/EcalObjects/src/EcalPulseShapesGPU.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-EcalPulseShapesGPU::EcalPulseShapesGPU(EcalPulseShapes const& values)
-    : valuesEB_{values.barrelItems()}, valuesEE_{values.endcapItems()} {}
-
-EcalPulseShapesGPU::Product::~Product() {
-  // deallocation
-  cudaCheck(cudaFree(values));
-}
-
-EcalPulseShapesGPU::Product const& EcalPulseShapesGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPulseShapesGPU::Product& product, cudaStream_t cudaStream) {
-        // malloc
-        cudaCheck(cudaMalloc((void**)&product.values,
-                             (this->valuesEE_.size() + this->valuesEB_.size()) * sizeof(EcalPulseShape)));
-
-        // offset in terms of sizeof(EcalPulseShape) - plain c array
-        uint32_t offset = this->valuesEB_.size();
-
-        // transfer eb
-        cudaCheck(cudaMemcpyAsync(product.values,
-                                  this->valuesEB_.data(),
-                                  this->valuesEB_.size() * sizeof(EcalPulseShape),
-                                  cudaMemcpyHostToDevice,
-                                  cudaStream));
-
-        // transfer ee starting at values + offset
-        cudaCheck(cudaMemcpyAsync(product.values + offset,
-                                  this->valuesEE_.data(),
-                                  this->valuesEE_.size() * sizeof(EcalPulseShape),
-                                  cudaMemcpyHostToDevice,
-                                  cudaStream));
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalPulseShapesGPU);
diff --git a/CondFormats/EcalObjects/src/EcalRecHitParametersGPU.cc b/CondFormats/EcalObjects/src/EcalRecHitParametersGPU.cc
deleted file mode 100644
index 4398d249624a7..0000000000000
--- a/CondFormats/EcalObjects/src/EcalRecHitParametersGPU.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
-
-EcalRecHitParametersGPU::EcalRecHitParametersGPU(std::vector<int> const& channelStatusToBeExcluded,
-                                                 std::vector<DBStatus> const& flagsMapDBReco) {
-  channelStatusToBeExcluded_.resize(channelStatusToBeExcluded.size());
-  std::copy(channelStatusToBeExcluded.begin(), channelStatusToBeExcluded.end(), channelStatusToBeExcluded_.begin());
-
-  for (auto const& flagInfo : flagsMapDBReco) {
-    EcalRecHit::Flags recoflagbit = static_cast<EcalRecHit::Flags>(flagInfo.recoflagbit);
-    for (auto v : flagInfo.dbstatus) {
-      EcalChannelStatusCode::Code dbstatus = static_cast<EcalChannelStatusCode::Code>(v);
-      expanded_v_DB_reco_flags_.push_back(dbstatus);
-    }
-
-    expanded_Sizes_v_DB_reco_flags_.push_back(flagInfo.dbstatus.size());
-    expanded_flagbit_v_DB_reco_flags_.push_back(recoflagbit);
-  }
-}
-
-EcalRecHitParametersGPU::Product const& EcalRecHitParametersGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalRecHitParametersGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.channelStatusToBeExcluded =
-            cms::cuda::make_device_unique<int[]>(channelStatusToBeExcluded_.size(), cudaStream);
-        product.expanded_v_DB_reco_flags =
-            cms::cuda::make_device_unique<int[]>(expanded_v_DB_reco_flags_.size(), cudaStream);
-        product.expanded_Sizes_v_DB_reco_flags =
-            cms::cuda::make_device_unique<uint32_t[]>(expanded_Sizes_v_DB_reco_flags_.size(), cudaStream);
-        product.expanded_flagbit_v_DB_reco_flags =
-            cms::cuda::make_device_unique<uint32_t[]>(expanded_flagbit_v_DB_reco_flags_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.channelStatusToBeExcluded, channelStatusToBeExcluded_, cudaStream);
-        cms::cuda::copyAsync(product.expanded_v_DB_reco_flags, expanded_v_DB_reco_flags_, cudaStream);
-        cms::cuda::copyAsync(product.expanded_Sizes_v_DB_reco_flags, expanded_Sizes_v_DB_reco_flags_, cudaStream);
-        cms::cuda::copyAsync(product.expanded_flagbit_v_DB_reco_flags, expanded_flagbit_v_DB_reco_flags_, cudaStream);
-      });
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalRecHitParametersGPU);
diff --git a/CondFormats/EcalObjects/src/EcalRechitADCToGeVConstantGPU.cc b/CondFormats/EcalObjects/src/EcalRechitADCToGeVConstantGPU.cc
deleted file mode 100644
index a71266d1615dc..0000000000000
--- a/CondFormats/EcalObjects/src/EcalRechitADCToGeVConstantGPU.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalRechitADCToGeVConstantGPU::EcalRechitADCToGeVConstantGPU(EcalADCToGeVConstant const& values)
-    : adc2gev_(2)  // size is 2, one form EB and one for EE
-{
-  adc2gev_[0] = values.getEBValue();
-  adc2gev_[1] = values.getEEValue();
-}
-
-EcalRechitADCToGeVConstantGPU::Product const& EcalRechitADCToGeVConstantGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalRechitADCToGeVConstantGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.adc2gev = cms::cuda::make_device_unique<float[]>(adc2gev_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.adc2gev, adc2gev_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalRechitADCToGeVConstantGPU);
diff --git a/CondFormats/EcalObjects/src/EcalRechitChannelStatusGPU.cc b/CondFormats/EcalObjects/src/EcalRechitChannelStatusGPU.cc
deleted file mode 100644
index 2a0740828f6cf..0000000000000
--- a/CondFormats/EcalObjects/src/EcalRechitChannelStatusGPU.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalRechitChannelStatusGPU::EcalRechitChannelStatusGPU(EcalChannelStatus const& values) : status_(values.size()) {
-  // fill in eb
-  auto const& barrelValues = values.barrelItems();
-  for (unsigned int i = 0; i < barrelValues.size(); i++) {
-    status_[i] = barrelValues[i].getEncodedStatusCode();
-  }
-
-  // fill in ee
-  auto const& endcapValues = values.endcapItems();
-  auto const offset = barrelValues.size();
-  for (unsigned int i = 0; i < endcapValues.size(); i++) {
-    status_[offset + i] = endcapValues[i].getEncodedStatusCode();
-  }
-}
-
-EcalRechitChannelStatusGPU::Product const& EcalRechitChannelStatusGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalRechitChannelStatusGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.status = cms::cuda::make_device_unique<uint16_t[]>(status_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.status, status_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalRechitChannelStatusGPU);
diff --git a/CondFormats/EcalObjects/src/EcalSamplesCorrelationGPU.cc b/CondFormats/EcalObjects/src/EcalSamplesCorrelationGPU.cc
deleted file mode 100644
index 9e355045149ea..0000000000000
--- a/CondFormats/EcalObjects/src/EcalSamplesCorrelationGPU.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalSamplesCorrelationGPU::EcalSamplesCorrelationGPU(EcalSamplesCorrelation const& values) {
-  EBG12SamplesCorrelation_.reserve(values.EBG12SamplesCorrelation.size());
-  for (const auto& EBG12SamplesCorrelation : values.EBG12SamplesCorrelation) {
-    EBG12SamplesCorrelation_.emplace_back(EBG12SamplesCorrelation);
-  }
-
-  EBG6SamplesCorrelation_.reserve(values.EBG6SamplesCorrelation.size());
-  for (const auto& EBG6SamplesCorrelation : values.EBG6SamplesCorrelation) {
-    EBG6SamplesCorrelation_.emplace_back(EBG6SamplesCorrelation);
-  }
-
-  EBG1SamplesCorrelation_.reserve(values.EBG1SamplesCorrelation.size());
-  for (const auto& EBG1SamplesCorrelation : values.EBG1SamplesCorrelation) {
-    EBG1SamplesCorrelation_.emplace_back(EBG1SamplesCorrelation);
-  }
-
-  EEG12SamplesCorrelation_.reserve(values.EEG12SamplesCorrelation.size());
-  for (const auto& EEG12SamplesCorrelation : values.EEG12SamplesCorrelation) {
-    EEG12SamplesCorrelation_.emplace_back(EEG12SamplesCorrelation);
-  }
-
-  EEG6SamplesCorrelation_.reserve(values.EEG6SamplesCorrelation.size());
-  for (const auto& EEG6SamplesCorrelation : values.EEG6SamplesCorrelation) {
-    EEG6SamplesCorrelation_.emplace_back(EEG6SamplesCorrelation);
-  }
-
-  EEG1SamplesCorrelation_.reserve(values.EEG1SamplesCorrelation.size());
-  for (const auto& EEG1SamplesCorrelation : values.EEG1SamplesCorrelation) {
-    EEG1SamplesCorrelation_.emplace_back(EEG1SamplesCorrelation);
-  }
-}
-
-EcalSamplesCorrelationGPU::Product const& EcalSamplesCorrelationGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalSamplesCorrelationGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.EBG12SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EBG12SamplesCorrelation_.size(), cudaStream);
-        product.EBG6SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EBG6SamplesCorrelation_.size(), cudaStream);
-        product.EBG1SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EBG1SamplesCorrelation_.size(), cudaStream);
-        product.EEG12SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EEG12SamplesCorrelation_.size(), cudaStream);
-        product.EEG6SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EEG6SamplesCorrelation_.size(), cudaStream);
-        product.EEG1SamplesCorrelation =
-            cms::cuda::make_device_unique<double[]>(EEG1SamplesCorrelation_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.EBG12SamplesCorrelation, EBG12SamplesCorrelation_, cudaStream);
-        cms::cuda::copyAsync(product.EBG6SamplesCorrelation, EBG6SamplesCorrelation_, cudaStream);
-        cms::cuda::copyAsync(product.EBG1SamplesCorrelation, EBG1SamplesCorrelation_, cudaStream);
-        cms::cuda::copyAsync(product.EEG12SamplesCorrelation, EEG12SamplesCorrelation_, cudaStream);
-        cms::cuda::copyAsync(product.EEG6SamplesCorrelation, EEG6SamplesCorrelation_, cudaStream);
-        cms::cuda::copyAsync(product.EEG1SamplesCorrelation, EEG1SamplesCorrelation_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalSamplesCorrelationGPU);
diff --git a/CondFormats/EcalObjects/src/EcalTimeBiasCorrectionsGPU.cc b/CondFormats/EcalObjects/src/EcalTimeBiasCorrectionsGPU.cc
deleted file mode 100644
index 268a22f7182f5..0000000000000
--- a/CondFormats/EcalObjects/src/EcalTimeBiasCorrectionsGPU.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalTimeBiasCorrectionsGPU::EcalTimeBiasCorrectionsGPU(EcalTimeBiasCorrections const& values) {
-  ebTimeCorrAmplitudeBins_.reserve(values.EBTimeCorrAmplitudeBins.size());
-  for (const auto& ebTimeCorrAmplitudeBin : values.EBTimeCorrAmplitudeBins) {
-    ebTimeCorrAmplitudeBins_.emplace_back(ebTimeCorrAmplitudeBin);
-  }
-
-  ebTimeCorrShiftBins_.reserve(values.EBTimeCorrAmplitudeBins.size());
-  for (const auto& ebTimeCorrShiftBin : values.EBTimeCorrShiftBins) {
-    ebTimeCorrShiftBins_.emplace_back(ebTimeCorrShiftBin);
-  }
-
-  eeTimeCorrAmplitudeBins_.reserve(values.EETimeCorrAmplitudeBins.size());
-  for (const auto& eeTimeCorrAmplitudeBin : values.EETimeCorrAmplitudeBins) {
-    eeTimeCorrAmplitudeBins_.emplace_back(eeTimeCorrAmplitudeBin);
-  }
-
-  eeTimeCorrShiftBins_.reserve(values.EETimeCorrAmplitudeBins.size());
-  for (const auto& eeTimeCorrShiftBin : values.EETimeCorrShiftBins) {
-    eeTimeCorrShiftBins_.emplace_back(eeTimeCorrShiftBin);
-  }
-}
-
-EcalTimeBiasCorrectionsGPU::Product const& EcalTimeBiasCorrectionsGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalTimeBiasCorrectionsGPU::Product& product, cudaStream_t cudaStream) {
-        // to get the size of vectors later on
-        // should be removed and host conditions' objects used directly
-        product.ebTimeCorrAmplitudeBinsSize = this->ebTimeCorrAmplitudeBins_.size();
-        product.eeTimeCorrAmplitudeBinsSize = this->eeTimeCorrAmplitudeBins_.size();
-
-        // allocate
-        product.ebTimeCorrAmplitudeBins =
-            cms::cuda::make_device_unique<float[]>(ebTimeCorrAmplitudeBins_.size(), cudaStream);
-        product.ebTimeCorrShiftBins = cms::cuda::make_device_unique<float[]>(ebTimeCorrShiftBins_.size(), cudaStream);
-        product.eeTimeCorrAmplitudeBins =
-            cms::cuda::make_device_unique<float[]>(eeTimeCorrAmplitudeBins_.size(), cudaStream);
-        product.eeTimeCorrShiftBins = cms::cuda::make_device_unique<float[]>(eeTimeCorrShiftBins_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.ebTimeCorrAmplitudeBins, ebTimeCorrAmplitudeBins_, cudaStream);
-        cms::cuda::copyAsync(product.ebTimeCorrShiftBins, ebTimeCorrShiftBins_, cudaStream);
-        cms::cuda::copyAsync(product.eeTimeCorrAmplitudeBins, eeTimeCorrAmplitudeBins_, cudaStream);
-        cms::cuda::copyAsync(product.eeTimeCorrShiftBins, eeTimeCorrShiftBins_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalTimeBiasCorrectionsGPU);
diff --git a/CondFormats/EcalObjects/src/EcalTimeCalibConstantsGPU.cc b/CondFormats/EcalObjects/src/EcalTimeCalibConstantsGPU.cc
deleted file mode 100644
index 80537fa9f07c8..0000000000000
--- a/CondFormats/EcalObjects/src/EcalTimeCalibConstantsGPU.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-EcalTimeCalibConstantsGPU::EcalTimeCalibConstantsGPU(EcalTimeCalibConstants const& values) {
-  values_.reserve(values.size());
-  for (size_t i = 0; i < values.size(); ++i) {
-    values_.emplace_back(values[i]);
-  }
-  offset_ = values.barrelItems().size();
-}
-
-EcalTimeCalibConstantsGPU::Product const& EcalTimeCalibConstantsGPU::getProduct(cudaStream_t cudaStream) const {
-  auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalTimeCalibConstantsGPU::Product& product, cudaStream_t cudaStream) {
-        // allocate
-        product.values = cms::cuda::make_device_unique<float[]>(values_.size(), cudaStream);
-        // transfer
-        cms::cuda::copyAsync(product.values, values_, cudaStream);
-      });
-
-  return product;
-}
-
-TYPELOOKUP_DATA_REG(EcalTimeCalibConstantsGPU);
diff --git a/CondFormats/EcalObjects/src/ElectronicsMappingGPU.cc b/CondFormats/EcalObjects/src/ElectronicsMappingGPU.cc
deleted file mode 100644
index 343441e5d059a..0000000000000
--- a/CondFormats/EcalObjects/src/ElectronicsMappingGPU.cc
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h"
-
-#include "FWCore/Utilities/interface/typelookup.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/copyAsync.h"
-
-#include "DataFormats/EcalDetId/interface/EcalElectronicsId.h"
-
-namespace ecal {
-  namespace raw {
-
-    // TODO: 0x3FFFFF * 4B ~= 16MB
-    // tmp solution for linear mapping of eid -> did
-    ElectronicsMappingGPU::ElectronicsMappingGPU(EcalMappingElectronics const& mapping) : eid2did_(0x3FFFFF) {
-      // fill in eb
-      // TODO: EB vector is actually empty
-      auto const& barrelValues = mapping.barrelItems();
-      for (unsigned int i = 0; i < barrelValues.size(); i++) {
-        EcalElectronicsId eid{barrelValues[i].electronicsid};
-        EBDetId did{EBDetId::unhashIndex(i)};
-        eid2did_[eid.linearIndex()] = did.rawId();
-      }
-
-      // fill in ee
-      auto const& endcapValues = mapping.endcapItems();
-      for (unsigned int i = 0; i < endcapValues.size(); i++) {
-        EcalElectronicsId eid{endcapValues[i].electronicsid};
-        EEDetId did{EEDetId::unhashIndex(i)};
-        eid2did_[eid.linearIndex()] = did.rawId();
-      }
-    }
-
-    ElectronicsMappingGPU::Product const& ElectronicsMappingGPU::getProduct(cudaStream_t cudaStream) const {
-      auto const& product = product_.dataForCurrentDeviceAsync(
-          cudaStream, [this](ElectronicsMappingGPU::Product& product, cudaStream_t cudaStream) {
-            // allocate
-            product.eid2did = cms::cuda::make_device_unique<uint32_t[]>(eid2did_.size(), cudaStream);
-            // transfer
-            cms::cuda::copyAsync(product.eid2did, eid2did_, cudaStream);
-          });
-
-      return product;
-    }
-
-  }  // namespace raw
-}  // namespace ecal
-
-TYPELOOKUP_DATA_REG(ecal::raw::ElectronicsMappingGPU);
diff --git a/EventFilter/EcalRawToDigi/plugins/BuildFile.xml b/EventFilter/EcalRawToDigi/plugins/BuildFile.xml
index 96962e9b142ce..a5e629e02e46a 100644
--- a/EventFilter/EcalRawToDigi/plugins/BuildFile.xml
+++ b/EventFilter/EcalRawToDigi/plugins/BuildFile.xml
@@ -7,16 +7,8 @@
 <use name="FWCore/Framework"/>
 <use name="FWCore/Utilities"/>
 <use name="FWStorage/StorageFactory"/>
-<iftool name="cuda-gcc-support">
-  <use name="cuda"/>
-  <set name="cuda_src" value="*.cu"/>
-<else/>
-  <set name="cuda_src" value=""/>
-</iftool>
-<library file="*.cc ${cuda_src}" name="EventFilterEcalRawToDigiPlugins">
-  <use name="CUDADataFormats/EcalDigi" />
-  <use name="HeterogeneousCore/CUDACore"/>
-  <use name="HeterogeneousCore/CUDAUtilities"/>
+
+<library file="*.cc" name="EventFilterEcalRawToDigiPlugins">
   <flags EDM_PLUGIN="1"/>
 </library>
 
diff --git a/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h b/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
deleted file mode 100644
index 6873173704e40..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/DeclsForKernels.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef EventFilter_EcalRawToDigi_plugins_DeclsForKernels_h
-#define EventFilter_EcalRawToDigi_plugins_DeclsForKernels_h
-
-#include <vector>
-
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-#include "CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "EventFilter/EcalRawToDigi/interface/DCCRawDataDefinitions.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"
-
-namespace ecal {
-  namespace raw {
-
-    struct InputDataCPU {
-      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 {
-      uint32_t maxChannelsEE;
-      uint32_t maxChannelsEB;
-    };
-
-    struct OutputDataCPU {
-      // [0] - eb, [1] - ee
-      cms::cuda::host::unique_ptr<uint32_t[]> nchannels;
-    };
-
-    struct OutputDataGPU {
-      DigisCollection<::calo::common::DevStoragePolicy> digisEB, digisEE;
-
-      void allocate(ConfigurationParameters const &config, cudaStream_t cudaStream) {
-        digisEB.data =
-            cms::cuda::make_device_unique<uint16_t[]>(config.maxChannelsEB * EcalDataFrame::MAXSAMPLES, cudaStream);
-        digisEE.data =
-            cms::cuda::make_device_unique<uint16_t[]>(config.maxChannelsEE * EcalDataFrame::MAXSAMPLES, cudaStream);
-        digisEB.ids = cms::cuda::make_device_unique<uint32_t[]>(config.maxChannelsEB, cudaStream);
-        digisEE.ids = cms::cuda::make_device_unique<uint32_t[]>(config.maxChannelsEE, cudaStream);
-      }
-    };
-
-    struct ScratchDataGPU {
-      // [0] = EB
-      // [1] = EE
-      cms::cuda::device::unique_ptr<uint32_t[]> pChannelsCounter;
-    };
-
-    struct InputDataGPU {
-      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 {
-      ElectronicsMappingGPU::Product const &eMappingProduct;
-    };
-
-  }  // namespace raw
-}  // namespace ecal
-
-#endif  // EventFilter_EcalRawToDigi_plugins_DeclsForKernels_h
diff --git a/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc b/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
deleted file mode 100644
index 827ad7f568bc0..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/EcalCPUDigisProducer.cc
+++ /dev/null
@@ -1,242 +0,0 @@
-#include <iostream>
-#include <utility>
-
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-#include "CondFormats/DataRecord/interface/EcalMappingElectronicsRcd.h"
-#include "CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h"
-#include "DataFormats/EcalDetId/interface/EcalDetIdCollections.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/EcalRawData/interface/EcalRawDataCollections.h"
-#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-#include "DeclsForKernels.h"
-#include "UnpackGPU.h"
-
-class EcalCPUDigisProducer : public edm::stream::EDProducer<edm::ExternalWork> {
-public:
-  explicit EcalCPUDigisProducer(edm::ParameterSet const& ps);
-  ~EcalCPUDigisProducer() override = default;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-  template <typename ProductType, typename... ARGS>
-  edm::EDPutTokenT<ProductType> dummyProduces(ARGS&&... args) {
-    return (produceDummyIntegrityCollections_) ? produces<ProductType>(std::forward<ARGS>(args)...)
-                                               : edm::EDPutTokenT<ProductType>{};
-  }
-
-private:
-  // input digi collections in GPU-friendly format
-  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_;
-  edm::EDPutTokenT<EEDigiCollection> digisOutEEToken_;
-
-  // whether to produce dummy integrity collections
-  bool produceDummyIntegrityCollections_;
-
-  // dummy producer collections
-  edm::EDPutTokenT<EBSrFlagCollection> ebSrFlagToken_;
-  edm::EDPutTokenT<EESrFlagCollection> eeSrFlagToken_;
-
-  // dummy ECAL raw data collection
-  edm::EDPutTokenT<EcalRawDataCollection> ecalRawDataToken_;
-
-  // dummy integrity for xtal data
-  edm::EDPutTokenT<EBDetIdCollection> ebIntegrityGainErrorsToken_;
-  edm::EDPutTokenT<EBDetIdCollection> ebIntegrityGainSwitchErrorsToken_;
-  edm::EDPutTokenT<EBDetIdCollection> ebIntegrityChIdErrorsToken_;
-
-  // dummy integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
-  edm::EDPutTokenT<EEDetIdCollection> eeIntegrityGainErrorsToken_;
-  edm::EDPutTokenT<EEDetIdCollection> eeIntegrityGainSwitchErrorsToken_;
-  edm::EDPutTokenT<EEDetIdCollection> eeIntegrityChIdErrorsToken_;
-
-  // dummy integrity errors
-  edm::EDPutTokenT<EcalElectronicsIdCollection> integrityTTIdErrorsToken_;
-  edm::EDPutTokenT<EcalElectronicsIdCollection> integrityZSXtalIdErrorsToken_;
-  edm::EDPutTokenT<EcalElectronicsIdCollection> integrityBlockSizeErrorsToken_;
-
-  edm::EDPutTokenT<EcalPnDiodeDigiCollection> pnDiodeDigisToken_;
-
-  // dummy TCC collections
-  edm::EDPutTokenT<EcalTrigPrimDigiCollection> ecalTriggerPrimitivesToken_;
-  edm::EDPutTokenT<EcalPSInputDigiCollection> ecalPseudoStripInputsToken_;
-
-  // dummy mem integrity collections
-  edm::EDPutTokenT<EcalElectronicsIdCollection> ecalIntegrityMemTtIdErrorsToken_;
-  edm::EDPutTokenT<EcalElectronicsIdCollection> ecalIntegrityMemBlockSizeErrorsToken_;
-  edm::EDPutTokenT<EcalElectronicsIdCollection> ecalIntegrityMemChIdErrorsToken_;
-  edm::EDPutTokenT<EcalElectronicsIdCollection> ecalIntegrityMemGainErrorsToken_;
-
-  // FIXME better way to pass pointers from acquire to produce?
-  std::vector<uint32_t, cms::cuda::HostAllocator<uint32_t>> idsebtmp, idseetmp;
-  std::vector<uint16_t, cms::cuda::HostAllocator<uint16_t>> dataebtmp, dataeetmp;
-};
-
-void EcalCPUDigisProducer::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("digisInLabelEB", edm::InputTag{"ecalRawToDigiGPU", "ebDigis"});
-  desc.add<edm::InputTag>("digisInLabelEE", edm::InputTag{"ecalRawToDigiGPU", "eeDigis"});
-  desc.add<std::string>("digisOutLabelEB", "ebDigis");
-  desc.add<std::string>("digisOutLabelEE", "eeDigis");
-
-  desc.add<bool>("produceDummyIntegrityCollections", false);
-
-  std::string label = "ecalCPUDigisProducer";
-  confDesc.add(label, desc);
-}
-
-EcalCPUDigisProducer::EcalCPUDigisProducer(const edm::ParameterSet& ps)
-    :  // input digi collections in GPU-friendly format
-      digisInEBToken_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisInLabelEB"))},
-      digisInEEToken_{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"))},
-
-      // whether to produce dummy integrity collections
-      produceDummyIntegrityCollections_{ps.getParameter<bool>("produceDummyIntegrityCollections")},
-
-      // dummy collections
-      ebSrFlagToken_{dummyProduces<EBSrFlagCollection>()},
-      eeSrFlagToken_{dummyProduces<EESrFlagCollection>()},
-
-      // dummy ECAL raw data collection
-      ecalRawDataToken_{dummyProduces<EcalRawDataCollection>()},
-
-      // dummy integrity for xtal data
-      ebIntegrityGainErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityGainErrors")},
-      ebIntegrityGainSwitchErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityGainSwitchErrors")},
-      ebIntegrityChIdErrorsToken_{dummyProduces<EBDetIdCollection>("EcalIntegrityChIdErrors")},
-
-      // dummy integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
-      eeIntegrityGainErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityGainErrors")},
-      eeIntegrityGainSwitchErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityGainSwitchErrors")},
-      eeIntegrityChIdErrorsToken_{dummyProduces<EEDetIdCollection>("EcalIntegrityChIdErrors")},
-
-      // dummy integrity errors
-      integrityTTIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityTTIdErrors")},
-      integrityZSXtalIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityZSXtalIdErrors")},
-      integrityBlockSizeErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityBlockSizeErrors")},
-
-      //
-      pnDiodeDigisToken_{dummyProduces<EcalPnDiodeDigiCollection>()},
-
-      // dummy TCC collections
-      ecalTriggerPrimitivesToken_{dummyProduces<EcalTrigPrimDigiCollection>("EcalTriggerPrimitives")},
-      ecalPseudoStripInputsToken_{dummyProduces<EcalPSInputDigiCollection>("EcalPseudoStripInputs")},
-
-      // dummy mem integrity collections
-      ecalIntegrityMemTtIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemTtIdErrors")},
-      ecalIntegrityMemBlockSizeErrorsToken_{
-          dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemBlockSizeErrors")},
-      ecalIntegrityMemChIdErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemChIdErrors")},
-      ecalIntegrityMemGainErrorsToken_{dummyProduces<EcalElectronicsIdCollection>("EcalIntegrityMemGainErrors")}
-
-// constructor body
-{}
-
-void EcalCPUDigisProducer::acquire(edm::Event const& event,
-                                   edm::EventSetup const& setup,
-                                   edm::WaitingTaskWithArenaHolder taskHolder) {
-  // retrieve data/ctx
-  auto const& ebdigisProduct = event.get(digisInEBToken_);
-  auto const& eedigisProduct = event.get(digisInEEToken_);
-  cms::cuda::ScopedContextAcquire ctx{ebdigisProduct, std::move(taskHolder)};
-  auto const& ebdigis = ctx.get(ebdigisProduct);
-  auto const& eedigis = ctx.get(eedigisProduct);
-
-  // resize tmp buffers
-  dataebtmp.resize(ebdigis.size * EcalDataFrame::MAXSAMPLES);
-  dataeetmp.resize(eedigis.size * EcalDataFrame::MAXSAMPLES);
-  idsebtmp.resize(ebdigis.size);
-  idseetmp.resize(eedigis.size);
-
-  // enqeue transfers
-  cudaCheck(cudaMemcpyAsync(
-      dataebtmp.data(), ebdigis.data.get(), dataebtmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(
-      dataeetmp.data(), eedigis.data.get(), dataeetmp.size() * sizeof(uint16_t), cudaMemcpyDeviceToHost, ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(
-      idsebtmp.data(), ebdigis.ids.get(), idsebtmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(
-      idseetmp.data(), eedigis.ids.get(), idseetmp.size() * sizeof(uint32_t), cudaMemcpyDeviceToHost, ctx.stream()));
-}
-
-void EcalCPUDigisProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
-  // output collections
-  auto digisEB = std::make_unique<EBDigiCollection>();
-  auto digisEE = std::make_unique<EEDigiCollection>();
-  digisEB->resize(idsebtmp.size());
-  digisEE->resize(idseetmp.size());
-
-  // cast constness away
-  // use pointers to buffers instead of move operator= semantics
-  // cause we have different allocators in there...
-  auto* dataEB = const_cast<uint16_t*>(digisEB->data().data());
-  auto* dataEE = const_cast<uint16_t*>(digisEE->data().data());
-  auto* idsEB = const_cast<uint32_t*>(digisEB->ids().data());
-  auto* idsEE = const_cast<uint32_t*>(digisEE->ids().data());
-
-  // copy data
-  std::memcpy(dataEB, dataebtmp.data(), dataebtmp.size() * sizeof(uint16_t));
-  std::memcpy(dataEE, dataeetmp.data(), dataeetmp.size() * sizeof(uint16_t));
-  std::memcpy(idsEB, idsebtmp.data(), idsebtmp.size() * sizeof(uint32_t));
-  std::memcpy(idsEE, idseetmp.data(), idseetmp.size() * sizeof(uint32_t));
-
-  digisEB->sort();
-  digisEE->sort();
-
-  event.put(digisOutEBToken_, std::move(digisEB));
-  event.put(digisOutEEToken_, std::move(digisEE));
-
-  if (produceDummyIntegrityCollections_) {
-    // dummy collections
-    event.emplace(ebSrFlagToken_);
-    event.emplace(eeSrFlagToken_);
-    // dummy ECAL raw data collection
-    event.emplace(ecalRawDataToken_);
-    // dummy integrity for xtal data
-    event.emplace(ebIntegrityGainErrorsToken_);
-    event.emplace(ebIntegrityGainSwitchErrorsToken_);
-    event.emplace(ebIntegrityChIdErrorsToken_);
-    // dummy integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
-    event.emplace(eeIntegrityGainErrorsToken_);
-    event.emplace(eeIntegrityGainSwitchErrorsToken_);
-    event.emplace(eeIntegrityChIdErrorsToken_);
-    // dummy integrity errors
-    event.emplace(integrityTTIdErrorsToken_);
-    event.emplace(integrityZSXtalIdErrorsToken_);
-    event.emplace(integrityBlockSizeErrorsToken_);
-    //
-    event.emplace(pnDiodeDigisToken_);
-    // dummy TCC collections
-    event.emplace(ecalTriggerPrimitivesToken_);
-    event.emplace(ecalPseudoStripInputsToken_);
-    // dummy mem integrity collections
-    event.emplace(ecalIntegrityMemTtIdErrorsToken_);
-    event.emplace(ecalIntegrityMemBlockSizeErrorsToken_);
-    event.emplace(ecalIntegrityMemChIdErrorsToken_);
-    event.emplace(ecalIntegrityMemGainErrorsToken_);
-  }
-}
-
-DEFINE_FWK_MODULE(EcalCPUDigisProducer);
diff --git a/EventFilter/EcalRawToDigi/plugins/EcalRawESProducersGPUDefs.cc b/EventFilter/EcalRawToDigi/plugins/EcalRawESProducersGPUDefs.cc
deleted file mode 100644
index b2569a57ee575..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/EcalRawESProducersGPUDefs.cc
+++ /dev/null
@@ -1,9 +0,0 @@
-#include "CondFormats/DataRecord/interface/EcalMappingElectronicsRcd.h"
-#include "CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h"
-
-using EcalElectronicsMappingGPUESProducer =
-    ConvertingESProducerT<EcalMappingElectronicsRcd, ecal::raw::ElectronicsMappingGPU, EcalMappingElectronics>;
-
-DEFINE_FWK_EVENTSETUP_MODULE(EcalElectronicsMappingGPUESProducer);
diff --git a/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc b/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
deleted file mode 100644
index 8b710aaa0f5d2..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/EcalRawToDigiGPU.cc
+++ /dev/null
@@ -1,169 +0,0 @@
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-#include "CondFormats/DataRecord/interface/EcalMappingElectronicsRcd.h"
-#include "CondFormats/EcalObjects/interface/ElectronicsMappingGPU.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/Utilities/interface/ESGetToken.h"
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-#include "DeclsForKernels.h"
-#include "UnpackGPU.h"
-
-class EcalRawToDigiGPU : public edm::stream::EDProducer<edm::ExternalWork> {
-public:
-  explicit EcalRawToDigiGPU(edm::ParameterSet const& ps);
-  ~EcalRawToDigiGPU() override = default;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  edm::EDGetTokenT<FEDRawDataCollection> rawDataToken_;
-  using OutputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
-  edm::EDPutTokenT<OutputProduct> digisEBToken_, digisEEToken_;
-  edm::ESGetToken<ecal::raw::ElectronicsMappingGPU, EcalMappingElectronicsRcd> eMappingToken_;
-
-  cms::cuda::ContextState cudaState_;
-
-  std::vector<int> fedsToUnpack_;
-
-  ecal::raw::ConfigurationParameters config_;
-  ecal::raw::OutputDataGPU outputGPU_;
-  ecal::raw::OutputDataCPU outputCPU_;
-};
-
-void EcalRawToDigiGPU::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
-  std::vector<int> feds(54);
-  for (uint32_t i = 0; i < 54; ++i)
-    feds[i] = i + 601;
-  desc.add<std::vector<int>>("FEDs", feds);
-  desc.add<uint32_t>("maxChannelsEB", 61200);
-  desc.add<uint32_t>("maxChannelsEE", 14648);
-  desc.add<std::string>("digisLabelEB", "ebDigis");
-  desc.add<std::string>("digisLabelEE", "eeDigis");
-
-  std::string label = "ecalRawToDigiGPU";
-  confDesc.add(label, desc);
-}
-
-EcalRawToDigiGPU::EcalRawToDigiGPU(const edm::ParameterSet& ps)
-    : rawDataToken_{consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("InputLabel"))},
-      digisEBToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEB"))},
-      digisEEToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEE"))},
-      eMappingToken_{esConsumes<ecal::raw::ElectronicsMappingGPU, EcalMappingElectronicsRcd>()},
-      fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
-  config_.maxChannelsEB = ps.getParameter<uint32_t>("maxChannelsEB");
-  config_.maxChannelsEE = ps.getParameter<uint32_t>("maxChannelsEE");
-}
-
-void EcalRawToDigiGPU::acquire(edm::Event const& event,
-                               edm::EventSetup const& setup,
-                               edm::WaitingTaskWithArenaHolder holder) {
-  // raii
-  cms::cuda::ScopedContextAcquire ctx{event.streamID(), std::move(holder), cudaState_};
-
-  // conditions
-  edm::ESHandle<ecal::raw::ElectronicsMappingGPU> eMappingHandle = setup.getHandle(eMappingToken_);
-  auto const& eMappingProduct = eMappingHandle->getProduct(ctx.stream());
-
-  // bundle up conditions
-  ecal::raw::ConditionsProducts conditions{eMappingProduct};
-
-  // event data
-  edm::Handle<FEDRawDataCollection> rawDataHandle;
-  event.getByToken(rawDataToken_, rawDataHandle);
-
-  // scratch
-  ecal::raw::ScratchDataGPU scratchGPU = {cms::cuda::make_device_unique<uint32_t[]>(2, ctx.stream())};
-
-  // make a first iteration over the FEDs to compute the total buffer size
-  uint32_t size = 0;
-  uint32_t feds = 0;
-  for (auto const& fed : fedsToUnpack_) {
-    auto const& data = rawDataHandle->FEDData(fed);
-    auto const nbytes = data.size();
-
-    // skip empty FEDs
-    if (nbytes < globalFieds::EMPTYEVENTSIZE)
-      continue;
-
-    size += nbytes;
-    ++feds;
-  }
-
-  // input cpu data
-  ecal::raw::InputDataCPU inputCPU = {cms::cuda::make_host_unique<unsigned char[]>(size, ctx.stream()),
-                                      cms::cuda::make_host_unique<uint32_t[]>(feds, ctx.stream()),
-                                      cms::cuda::make_host_unique<int[]>(feds, ctx.stream())};
-
-  // input data gpu
-  ecal::raw::InputDataGPU inputGPU = {cms::cuda::make_device_unique<unsigned char[]>(size, ctx.stream()),
-                                      cms::cuda::make_device_unique<uint32_t[]>(feds, ctx.stream()),
-                                      cms::cuda::make_device_unique<int[]>(feds, ctx.stream())};
-
-  // output cpu
-  outputCPU_ = {cms::cuda::make_host_unique<uint32_t[]>(2, ctx.stream())};
-  // initialize the number of channels
-  outputCPU_.nchannels[0] = 0;
-  outputCPU_.nchannels[1] = 0;
-
-  // output gpu
-  outputGPU_.allocate(config_, ctx.stream());
-
-  // iterate over FEDs to fill the cpu buffer
-  uint32_t currentCummOffset = 0;
-  uint32_t counter = 0;
-  for (auto const& fed : fedsToUnpack_) {
-    auto const& data = rawDataHandle->FEDData(fed);
-    auto const nbytes = data.size();
-
-    // skip empty FEDs
-    if (nbytes < globalFieds::EMPTYEVENTSIZE)
-      continue;
-
-    // copy raw data into plain buffer
-    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;
-
-    // this is the current offset into the vector
-    currentCummOffset += nbytes;
-    ++counter;
-  }
-  assert(currentCummOffset == size);
-  assert(counter == feds);
-
-  // unpack if at least one FED has data
-  if (counter > 0) {
-    ecal::raw::entryPoint(
-        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
-  outputGPU_.digisEB.size = outputCPU_.nchannels[0];
-  outputGPU_.digisEE.size = outputCPU_.nchannels[1];
-
-  ctx.emplace(event, digisEBToken_, std::move(outputGPU_.digisEB));
-  ctx.emplace(event, digisEEToken_, std::move(outputGPU_.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
deleted file mode 100644
index 2ba5c508c588b..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/UnpackGPU.cu
+++ /dev/null
@@ -1,459 +0,0 @@
-#include "EventFilter/EcalRawToDigi/interface/ElectronicsIdGPU.h"
-#include "EventFilter/EcalRawToDigi/interface/DCCRawDataDefinitions.h"
-
-#include "UnpackGPU.h"
-
-namespace ecal {
-  namespace raw {
-
-    __forceinline__ __device__ void print_raw_buffer(uint8_t const* const buffer,
-                                                     uint32_t const nbytes,
-                                                     uint32_t const nbytes_per_row = 20) {
-      for (uint32_t i = 0; i < nbytes; i++) {
-        if (i % nbytes_per_row == 0 && i > 0)
-          printf("\n");
-        printf("%02X ", buffer[i]);
-      }
-    }
-
-    __forceinline__ __device__ void print_first3bits(uint64_t const* buffer, uint32_t size) {
-      for (uint32_t i = 0; i < size; ++i) {
-        uint8_t const b61 = (buffer[i] >> 61) & 0x1;
-        uint8_t const b62 = (buffer[i] >> 62) & 0x1;
-        uint8_t const b63 = (buffer[i] >> 63) & 0x1;
-        printf("[word: %u] %u%u%u\n", i, b63, b62, b61);
-      }
-    }
-
-    __forceinline__ __device__ bool is_barrel(uint8_t dccid) {
-      return dccid >= ElectronicsIdGPU::MIN_DCCID_EBM && dccid <= ElectronicsIdGPU::MAX_DCCID_EBP;
-    }
-
-    __forceinline__ __device__ uint8_t fed2dcc(int fed) { return static_cast<uint8_t>(fed - 600); }
-
-    __forceinline__ __device__ int zside_for_eb(ElectronicsIdGPU const& eid) {
-      int dcc = eid.dccId();
-      return ((dcc >= ElectronicsIdGPU::MIN_DCCID_EBM && dcc <= ElectronicsIdGPU::MAX_DCCID_EBM)) ? -1 : 1;
-    }
-
-    __forceinline__ __device__ uint8_t find_next_tower_block(uint64_t const*& current_tower_block,
-                                                             uint64_t const* trailer,
-                                                             uint32_t const bx,
-                                                             uint32_t const lv1) {
-      const auto* next_tower_block = current_tower_block + 1;  // move forward to skip the broken header
-
-      // expected LV1, BX, #TS
-      const uint64_t lv1local = ((lv1 - 1) & TOWER_L1_MASK);
-      const uint64_t bxlocal = (bx != 3564) ? bx : 0;
-      // The CPU unpacker also checks the # time samples expected in the header
-      // but those are currently not available here
-
-      // construct tower header and mask
-      const uint64_t sign = 0xC0000000C0000000 + (lv1local << TOWER_L1_B) + (bxlocal << TOWER_BX_B);
-      const uint64_t mask =
-          0xC0001000D0000000 + (uint64_t(TOWER_L1_MASK) << TOWER_L1_B) + (uint64_t(TOWER_BX_MASK) << TOWER_BX_B);
-
-      while (next_tower_block < trailer) {
-        if ((*next_tower_block & mask) == sign) {
-          current_tower_block = next_tower_block;
-          return uint8_t(*next_tower_block & TOWER_ID_MASK);
-        } else {
-          ++next_tower_block;
-        }
-      }
-      return TOWER_ID_MASK;  // return the maximum value
-    }
-
-    __forceinline__ __device__ bool is_synced_towerblock(uint16_t const dccbx,
-                                                         uint16_t const bx,
-                                                         uint16_t const dccl1,
-                                                         uint16_t const l1) {
-      bool const bxsync = (bx == 0 && dccbx == 3564) || (bx == dccbx && dccbx != 3564);
-      bool const l1sync = (l1 == ((dccl1 - 1) & 0xfff));
-      return bxsync && l1sync;
-    }
-
-    __forceinline__ __device__ bool right_tower_for_eb(int tower) {
-      // for EB, two types of tower (LVRB top/bottom)
-      if ((tower > 12 && tower < 21) || (tower > 28 && tower < 37) || (tower > 44 && tower < 53) ||
-          (tower > 60 && tower < 69))
-        return true;
-      else
-        return false;
-    }
-
-    __forceinline__ __device__ uint32_t compute_ebdetid(ElectronicsIdGPU const& eid) {
-      // as in Geometry/EcalMaping/.../EcalElectronicsMapping
-      auto const dcc = eid.dccId();
-      auto const tower = eid.towerId();
-      auto const strip = eid.stripId();
-      auto const xtal = eid.xtalId();
-
-      int smid = 0;
-      int iphi = 0;
-      bool EBPlus = (zside_for_eb(eid) > 0);
-      bool EBMinus = !EBPlus;
-
-      if (zside_for_eb(eid) < 0) {
-        smid = dcc + 19 - ElectronicsIdGPU::DCCID_PHI0_EBM;
-        iphi = (smid - 19) * ElectronicsIdGPU::kCrystalsInPhi;
-        iphi += 5 * ((tower - 1) % ElectronicsIdGPU::kTowersInPhi);
-      } else {
-        smid = dcc + 1 - ElectronicsIdGPU::DCCID_PHI0_EBP;
-        iphi = (smid - 1) * ElectronicsIdGPU::kCrystalsInPhi;
-        iphi += 5 * (ElectronicsIdGPU::kTowersInPhi - ((tower - 1) % ElectronicsIdGPU::kTowersInPhi) - 1);
-      }
-
-      bool RightTower = right_tower_for_eb(tower);
-      int ieta = 5 * ((tower - 1) / ElectronicsIdGPU::kTowersInPhi) + 1;
-      if (RightTower) {
-        ieta += (strip - 1);
-        if (strip % 2 == 1) {
-          if (EBMinus)
-            iphi += (xtal - 1) + 1;
-          else
-            iphi += (4 - (xtal - 1)) + 1;
-        } else {
-          if (EBMinus)
-            iphi += (4 - (xtal - 1)) + 1;
-          else
-            iphi += (xtal - 1) + 1;
-        }
-      } else {
-        ieta += 4 - (strip - 1);
-        if (strip % 2 == 1) {
-          if (EBMinus)
-            iphi += (4 - (xtal - 1)) + 1;
-          else
-            iphi += (xtal - 1) + 1;
-        } else {
-          if (EBMinus)
-            iphi += (xtal - 1) + 1;
-          else
-            iphi += (4 - (xtal - 1)) + 1;
-        }
-      }
-
-      if (zside_for_eb(eid) < 0)
-        ieta = -ieta;
-
-      DetId did{DetId::Ecal, EcalBarrel};
-      return did.rawId() | ((ieta > 0) ? (0x10000 | (ieta << 9)) : ((-ieta) << 9)) | (iphi & 0x1FF);
-    }
-
-    __forceinline__ __device__ int adc(uint16_t sample) { return sample & 0xfff; }
-
-    __forceinline__ __device__ int gainId(uint16_t sample) { return (sample >> 12) & 0x3; }
-
-    template <int NTHREADS>
-    __global__ void kernel_unpack_test(unsigned char const* __restrict__ data,
-                                       uint32_t const* __restrict__ offsets,
-                                       int const* __restrict__ feds,
-                                       uint16_t* samplesEB,
-                                       uint16_t* samplesEE,
-                                       uint32_t* idsEB,
-                                       uint32_t* idsEE,
-                                       uint32_t* pChannelsCounterEBEE,
-                                       uint32_t const* eid2did,
-                                       uint32_t const nbytesTotal) {
-      // indices
-      auto const ifed = blockIdx.x;
-
-      // offset in bytes
-      auto const offset = offsets[ifed];
-      // fed id
-      auto const fed = feds[ifed];
-      auto const isBarrel = is_barrel(static_cast<uint8_t>(fed - 600));
-      // size
-      auto const size = ifed == gridDim.x - 1 ? nbytesTotal - offset : offsets[ifed + 1] - offset;
-      auto* samples = isBarrel ? samplesEB : samplesEE;
-      auto* ids = isBarrel ? idsEB : idsEE;
-      auto* pChannelsCounter = isBarrel ? &pChannelsCounterEBEE[0] : &pChannelsCounterEBEE[1];
-
-      // offset to the right raw buffer
-      uint64_t const* buffer = reinterpret_cast<uint64_t const*>(data + offset);
-
-      // dump first 3 bits for each 64-bit word
-      //print_first3bits(buffer, size / 8);
-
-      //
-      // fed header
-      //
-      auto const fed_header = buffer[0];
-      uint32_t bx = (fed_header >> H_BX_B) & H_BX_MASK;
-      uint32_t lv1 = (fed_header >> H_L1_B) & H_L1_MASK;
-      uint32_t triggerType = (fed_header >> H_TTYPE_B) & H_TTYPE_MASK;
-
-      // determine the number of FE channels from the trigger type
-      uint32_t numbChannels(0);
-      if (triggerType == PHYSICTRIGGER) {
-        numbChannels = NUMB_FE;
-      } else if (triggerType == CALIBRATIONTRIGGER) {
-        numbChannels = NUMB_FE + 2;  // FE + 2 MEM blocks
-      } else {
-        // unsupported trigger type
-        return;
-      }
-
-      // 9 for fed + dcc header
-      // 36 for 4 EE TCC blocks or 18 for 1 EB TCC block
-      // 6 for SR block size
-
-      // dcc header w2
-      auto const w2 = buffer[2];
-      uint8_t const fov = (w2 >> H_FOV_B) & H_FOV_MASK;
-
-      // make a list of channels with data from DCC header channels status
-      // this could be done for each block instead of each thread since it defined per FED
-      uint8_t exp_ttids[NUMB_FE + 2];  // FE + 2 MEM blocks
-      uint8_t ch = 1;
-      uint8_t nCh = 0;
-      for (uint8_t i = 4; i < 9; ++i) {           // data words with channel status info
-        for (uint8_t j = 0; j < 14; ++j, ++ch) {  // channel status fields in one data word
-          const uint8_t shift = j * 4;            //each channel has 4 bits
-          const int chStatus = (buffer[i] >> shift) & H_CHSTATUS_MASK;
-          const bool regular = (chStatus == CH_DISABLED || chStatus == CH_SUPPRESS);
-          const bool problematic =
-              (chStatus == CH_TIMEOUT || chStatus == CH_HEADERERR || chStatus == CH_LINKERR ||
-               chStatus == CH_LENGTHERR || chStatus == CH_IFIFOFULL || chStatus == CH_L1AIFIFOFULL);
-          if (!(regular || problematic)) {
-            exp_ttids[nCh] = ch;
-            ++nCh;
-          }
-        }
-      }
-
-      //
-      // print Tower block headers
-      //
-      uint8_t ntccblockwords = isBarrel ? 18 : 36;
-      auto const* tower_blocks_start = buffer + 9 + ntccblockwords + 6;
-      auto const* trailer = buffer + (size / 8 - 1);
-      auto const* current_tower_block = tower_blocks_start;
-      uint8_t iCh = 0;
-      uint8_t next_tower_id = exp_ttids[iCh];
-      while (current_tower_block < trailer && iCh < numbChannels) {
-        auto const w = *current_tower_block;
-        uint8_t ttid = w & TOWER_ID_MASK;
-        uint16_t bxlocal = (w >> TOWER_BX_B) & TOWER_BX_MASK;
-        uint16_t lv1local = (w >> TOWER_L1_B) & TOWER_L1_MASK;
-        uint16_t block_length = (w >> TOWER_LENGTH_B) & TOWER_LENGTH_MASK;
-
-        // fast forward to the next good tower id (in case of recovery from an earlier header corruption)
-        while (exp_ttids[iCh] < next_tower_id) {
-          ++iCh;
-        }
-        ++iCh;
-
-        // check if the tower id in the tower header is the one expected
-        // if not try to find the next good header, point the current_tower_block to it, and extract its tower id
-        // or break if there is none
-        if (ttid != next_tower_id) {
-          next_tower_id = find_next_tower_block(current_tower_block, trailer, bx, lv1);
-          if (next_tower_id < TOWER_ID_MASK) {
-            continue;
-          } else {
-            break;
-          }
-        }
-
-        // prepare for the next iteration
-        next_tower_id = exp_ttids[iCh];
-
-        uint16_t const dccbx = bx & 0xfff;
-        uint16_t const dccl1 = lv1 & 0xfff;
-        // fov>=1 is required to support simulated data for which bx==bxlocal==0
-        if (fov >= 1 && !is_synced_towerblock(dccbx, bxlocal, dccl1, lv1local)) {
-          current_tower_block += block_length;
-          continue;
-        }
-
-        // go through all the channels
-        // get the next channel coordinates
-        uint32_t nchannels = (block_length - 1) / 3;
-
-        bool bad_block = false;
-        __shared__ uint32_t ch_with_bad_block;
-        // 1 threads per channel in this block
-        for (uint32_t ich = 0; ich < nchannels; ich += NTHREADS) {
-          auto const i_to_access = ich + threadIdx.x;
-          if (i_to_access == 0) {
-            ch_with_bad_block = std::numeric_limits<uint32_t>::max();
-          }
-
-          // make sure the shared memory is initialised for all threads
-          __syncthreads();
-
-          uint64_t wdata;
-          uint8_t stripid;
-          uint8_t xtalid;
-
-          // threads must be inside the range (no break here because of __syncthreads() afterwards)
-          if (i_to_access < nchannels && i_to_access < ch_with_bad_block) {
-            // inc the channel's counter and get the pos where to store
-            wdata = current_tower_block[1 + i_to_access * 3];
-            stripid = wdata & 0x7;
-            xtalid = (wdata >> 4) & 0x7;
-
-            // check if the stripid and xtalid are in the allowed range and if not skip the rest of the block
-            if (stripid < ElectronicsIdGPU::MIN_STRIPID || stripid > ElectronicsIdGPU::MAX_STRIPID ||
-                xtalid < ElectronicsIdGPU::MIN_XTALID || xtalid > ElectronicsIdGPU::MAX_XTALID) {
-              bad_block = true;
-            }
-            if (i_to_access > 0) {
-              // check if the stripid has increased or that the xtalid has increased from the previous data word. If not something is wrong and the rest of the block is skipped.
-              auto const prev_i_to_access = i_to_access - 1;
-              auto const prevwdata = current_tower_block[1 + prev_i_to_access * 3];
-              uint8_t const laststripid = prevwdata & 0x7;
-              uint8_t const lastxtalid = (prevwdata >> 4) & 0x7;
-              if ((stripid == laststripid && xtalid <= lastxtalid) || (stripid < laststripid)) {
-                bad_block = true;
-              }
-            }
-          }
-
-          // check if this thread has the lowest bad block
-          if (bad_block && i_to_access < ch_with_bad_block) {
-            atomicMin(&ch_with_bad_block, i_to_access);
-          }
-
-          // make sure that all threads that have to have set the ch_with_bad_block shared memory
-          __syncthreads();
-
-          // threads outside of the range or bad block detected in this thread or one working on a lower block -> stop this loop iteration here
-          if (i_to_access >= nchannels || i_to_access >= ch_with_bad_block) {
-            continue;
-          }
-
-          ElectronicsIdGPU eid{fed2dcc(fed), ttid, stripid, xtalid};
-          auto const didraw = isBarrel ? compute_ebdetid(eid) : eid2did[eid.linearIndex()];
-          // FIXME: what kind of channels are these guys
-          if (didraw == 0)
-            continue;
-
-          // get samples
-          uint16_t sampleValues[10];
-          sampleValues[0] = (wdata >> 16) & 0x3fff;
-          sampleValues[1] = (wdata >> 32) & 0x3fff;
-          sampleValues[2] = (wdata >> 48) & 0x3fff;
-          auto const wdata1 = current_tower_block[2 + i_to_access * 3];
-          sampleValues[3] = wdata1 & 0x3fff;
-          sampleValues[4] = (wdata1 >> 16) & 0x3fff;
-          sampleValues[5] = (wdata1 >> 32) & 0x3fff;
-          sampleValues[6] = (wdata1 >> 48) & 0x3fff;
-          auto const wdata2 = current_tower_block[3 + i_to_access * 3];
-          sampleValues[7] = wdata2 & 0x3fff;
-          sampleValues[8] = (wdata2 >> 16) & 0x3fff;
-          sampleValues[9] = (wdata2 >> 32) & 0x3fff;
-
-          // check gain
-          bool isSaturation = true;
-          short firstGainZeroSampID{-1}, firstGainZeroSampADC{-1};
-          for (uint32_t si = 0; si < 10; si++) {
-            if (gainId(sampleValues[si]) == 0) {
-              firstGainZeroSampID = si;
-              firstGainZeroSampADC = adc(sampleValues[si]);
-              break;
-            }
-          }
-          if (firstGainZeroSampID != -1) {
-            unsigned int plateauEnd = std::min(10u, (unsigned int)(firstGainZeroSampID + 5));
-            for (unsigned int s = firstGainZeroSampID; s < plateauEnd; s++) {
-              if (gainId(sampleValues[s]) == 0 && adc(sampleValues[s]) == firstGainZeroSampADC) {
-                ;
-              } else {
-                isSaturation = false;
-                break;
-              }  //it's not saturation
-            }
-            // get rid of channels which are stuck in gain0
-            if (firstGainZeroSampID < 3) {
-              isSaturation = false;
-            }
-            if (!isSaturation)
-              continue;
-          } else {  // there is no zero gainId sample
-            // gain switch check
-            short numGain = 1;
-            bool gainSwitchError = false;
-            for (unsigned int si = 1; si < 10; si++) {
-              if ((gainId(sampleValues[si - 1]) > gainId(sampleValues[si])) && numGain < 5)
-                gainSwitchError = true;
-              if (gainId(sampleValues[si - 1]) == gainId(sampleValues[si]))
-                numGain++;
-              else
-                numGain = 1;
-            }
-            if (gainSwitchError)
-              continue;
-          }
-
-          auto const pos = atomicAdd(pChannelsCounter, 1);
-
-          // store to global
-          ids[pos] = didraw;
-          samples[pos * 10] = sampleValues[0];
-          samples[pos * 10 + 1] = sampleValues[1];
-          samples[pos * 10 + 2] = sampleValues[2];
-          samples[pos * 10 + 3] = sampleValues[3];
-          samples[pos * 10 + 4] = sampleValues[4];
-          samples[pos * 10 + 5] = sampleValues[5];
-          samples[pos * 10 + 6] = sampleValues[6];
-          samples[pos * 10 + 7] = sampleValues[7];
-          samples[pos * 10 + 8] = sampleValues[8];
-          samples[pos * 10 + 9] = sampleValues[9];
-        }
-
-        current_tower_block += block_length;
-      }
-    }
-
-    void entryPoint(InputDataCPU const& inputCPU,
-                    InputDataGPU& inputGPU,
-                    OutputDataGPU& outputGPU,
-                    ScratchDataGPU& scratchGPU,
-                    OutputDataCPU& outputCPU,
-                    ConditionsProducts const& conditions,
-                    cudaStream_t cudaStream,
-                    uint32_t const nfedsWithData,
-                    uint32_t const nbytesTotal) {
-      // transfer
-      cudaCheck(cudaMemcpyAsync(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.get(),
-                                0,
-                                sizeof(uint32_t) * 2,  // EB + EE
-                                cudaStream));
-      cudaCheck(cudaMemcpyAsync(
-          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.get(),
-                                scratchGPU.pChannelsCounter.get(),
-                                sizeof(uint32_t) * 2,
-                                cudaMemcpyDeviceToHost,
-                                cudaStream));
-    }
-
-  }  // namespace raw
-}  // namespace ecal
diff --git a/EventFilter/EcalRawToDigi/plugins/UnpackGPU.h b/EventFilter/EcalRawToDigi/plugins/UnpackGPU.h
deleted file mode 100644
index d98906e7e24a7..0000000000000
--- a/EventFilter/EcalRawToDigi/plugins/UnpackGPU.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef EventFilter_EcalRawToDigi_plugins_UnpackGPU_h
-#define EventFilter_EcalRawToDigi_plugins_UnpackGPU_h
-
-#include "DeclsForKernels.h"
-
-namespace ecal {
-  namespace raw {
-
-    // FIXME: bundle up uint32_t values
-    void entryPoint(InputDataCPU const&,
-                    InputDataGPU&,
-                    OutputDataGPU&,
-                    ScratchDataGPU&,
-                    OutputDataCPU&,
-                    ConditionsProducts const&,
-                    cudaStream_t,
-                    uint32_t const,
-                    uint32_t const);
-
-  }  // namespace raw
-}  // namespace ecal
-
-#endif  // EventFilter_EcalRawToDigi_plugins_UnpackGPU_h
diff --git a/RecoLocalCalo/EcalRecAlgos/bin/BuildFile.xml b/RecoLocalCalo/EcalRecAlgos/bin/BuildFile.xml
deleted file mode 100644
index 4c98171091b84..0000000000000
--- a/RecoLocalCalo/EcalRecAlgos/bin/BuildFile.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<bin name="makeEcalMultifitResultsGpuValidationPlots" file="makeEcalMultifitResultsGpuValidationPlots.cpp">
-    <use name="root"/>
-    <use name="rootgraphics"/>
-    <use name="CUDADataFormats/EcalRecHitSoA"/>
-    <use name="DataFormats/Common"/>
-    <use name="DataFormats/EcalRecHit"/>
-</bin>
-
-<bin name="makeEcalRechitValidationPlots" file="makeEcalRechitValidationPlots.cpp">
-  <use name="root"/>
-  <use name="rootgraphics"/>
-  <use name="CUDADataFormats/EcalRecHitSoA"/>
-  <use name="DataFormats/Common"/>
-  <use name="DataFormats/EcalRecHit"/>
-</bin>
-
-
diff --git a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
deleted file mode 100644
index f010e3afdbb18..0000000000000
--- a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalMultifitResultsGpuValidationPlots.cpp
+++ /dev/null
@@ -1,564 +0,0 @@
-#include <iomanip>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <TCanvas.h>
-#include <TFile.h>
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TTree.h>
-#include <TPaveStats.h>
-
-#include "DataFormats/Common/interface/Wrapper.h"
-#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-
-#include "TStyle.h"
-
-void setAxis(TH2D *histo) {
-  histo->GetXaxis()->SetTitle("cpu");
-  histo->GetYaxis()->SetTitle("gpu");
-}
-
-void setAxisDelta(TH2D *histo) {
-  histo->GetXaxis()->SetTitle("cpu");
-  histo->GetYaxis()->SetTitle("#Delta gpu-cpu");
-}
-
-int main(int argc, char *argv[]) {
-  if (argc < 3) {
-    std::cout << "run with: ./validateGPU <path to input file> <output file>\n";
-    exit(0);
-  }
-
-  gStyle->SetOptStat("ourme");
-
-  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;
-
-  std::string fileName = argv[1];
-  std::string outFileName = argv[2];
-
-  // output
-  TFile rfout{outFileName.c_str(), "recreate"};
-
-  int nbins_count = 200;
-  float last_count = 5000.;
-  int nbins_count_delta = 201;
-
-  int nbins = 300;
-  float last = 3000.;
-
-  //     int nbins_chi2 = 1000;
-  //     float last_chi2 = 1000.;
-  int nbins_chi2 = 1000;
-  float last_chi2 = 200.;
-
-  int nbins_flags = 100;
-  float last_flags = 100.;
-  float delta_flags = 20;
-
-  int nbins_delta = 201;  // use an odd number to center around 0
-  float delta = 0.2;
-
-  // RecHits plots for EB and EE on both GPU and CPU
-  auto hRechitsEBGPU = new TH1D("RechitsEBGPU", "RechitsEBGPU; No. of Rechits", nbins_count, 0, last_count);
-  auto hRechitsEBCPU = new TH1D("RechitsEBCPU", "RechitsEBCPU; No. of Rechits", nbins_count, 0, last_count);
-  auto hRechitsEEGPU = new TH1D("RechitsEEGPU", "RechitsEEGPU; No. of Rechits", nbins_count, 0, last_count);
-  auto hRechitsEECPU = new TH1D("RechitsEECPU", "RechitsEECPU; No. of Rechits", nbins_count, 0, last_count);
-  auto hRechitsEBGPUCPUratio = new TH1D("RechitsEBGPU/CPUratio", "RechitsEBGPU/CPUratio; GPU/CPU", 50, 0.9, 1.1);
-  auto hRechitsEEGPUCPUratio = new TH1D("RechitsEEGPU/CPUratio", "RechitsEEGPU/CPUratio; GPU/CPU", 50, 0.9, 1.1);
-
-  auto hSOIAmplitudesEBGPU = new TH1D("hSOIAmplitudesEBGPU", "hSOIAmplitudesEBGPU", nbins, 0, last);
-  auto hSOIAmplitudesEEGPU = new TH1D("hSOIAmplitudesEEGPU", "hSOIAmplitudesEEGPU", nbins, 0, last);
-  auto hSOIAmplitudesEBCPU = new TH1D("hSOIAmplitudesEBCPU", "hSOIAmplitudesEBCPU", nbins, 0, last);
-  auto hSOIAmplitudesEECPU = new TH1D("hSOIAmplitudesEECPU", "hSOIAmplitudesEECPU", nbins, 0, last);
-  auto hSOIAmplitudesEBGPUCPUratio =
-      new TH1D("SOIAmplitudesEBGPU/CPUratio", "SOIAmplitudesEBGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-  auto hSOIAmplitudesEEGPUCPUratio =
-      new TH1D("SOIAmplitudesEEGPU/CPUratio", "SOIAmplitudesEEGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-
-  auto hChi2EBGPU = new TH1D("hChi2EBGPU", "hChi2EBGPU", nbins_chi2, 0, last_chi2);
-  auto hChi2EEGPU = new TH1D("hChi2EEGPU", "hChi2EEGPU", nbins_chi2, 0, last_chi2);
-  auto hChi2EBCPU = new TH1D("hChi2EBCPU", "hChi2EBCPU", nbins_chi2, 0, last_chi2);
-  auto hChi2EECPU = new TH1D("hChi2EECPU", "hChi2EECPU", nbins_chi2, 0, last_chi2);
-  auto hChi2EBGPUCPUratio = new TH1D("Chi2EBGPU/CPUratio", "Chi2EBGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-  auto hChi2EEGPUCPUratio = new TH1D("Chi2EEGPU/CPUratio", "Chi2EEGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-
-  auto hFlagsEBGPU = new TH1D("hFlagsEBGPU", "hFlagsEBGPU", nbins_flags, 0, last_flags);
-  auto hFlagsEEGPU = new TH1D("hFlagsEEGPU", "hFlagsEEGPU", nbins_flags, 0, last_flags);
-  auto hFlagsEBCPU = new TH1D("hFlagsEBCPU", "hFlagsEBCPU", nbins_flags, 0, last_flags);
-  auto hFlagsEECPU = new TH1D("hFlagsEECPU", "hFlagsEECPU", nbins_flags, 0, last_flags);
-  auto hFlagsEBGPUCPUratio = new TH1D("FlagsEBGPU/CPUratio", "FlagsEBGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-  auto hFlagsEEGPUCPUratio = new TH1D("FlagsEEGPU/CPUratio", "FlagsEEGPU/CPUratio; GPU/CPU", 200, 0.9, 1.1);
-
-  auto hSOIAmplitudesEBGPUvsCPU =
-      new TH2D("hSOIAmplitudesEBGPUvsCPU", "hSOIAmplitudesEBGPUvsCPU", nbins, 0, last, nbins, 0, last);
-  setAxis(hSOIAmplitudesEBGPUvsCPU);
-  auto hSOIAmplitudesEEGPUvsCPU =
-      new TH2D("hSOIAmplitudesEEGPUvsCPU", "hSOIAmplitudesEEGPUvsCPU", nbins, 0, last, nbins, 0, last);
-  setAxis(hSOIAmplitudesEEGPUvsCPU);
-  auto hSOIAmplitudesEBdeltavsCPU =
-      new TH2D("hSOIAmplitudesEBdeltavsCPU", "hSOIAmplitudesEBdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-  setAxisDelta(hSOIAmplitudesEBdeltavsCPU);
-  auto hSOIAmplitudesEEdeltavsCPU =
-      new TH2D("hSOIAmplitudesEEdeltavsCPU", "hSOIAmplitudesEEdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-  setAxisDelta(hSOIAmplitudesEEdeltavsCPU);
-
-  auto hChi2EBGPUvsCPU =
-      new TH2D("hChi2EBGPUvsCPU", "hChi2EBGPUvsCPU", nbins_chi2, 0, last_chi2, nbins_chi2, 0, last_chi2);
-  setAxis(hChi2EBGPUvsCPU);
-  auto hChi2EEGPUvsCPU =
-      new TH2D("hChi2EEGPUvsCPU", "hChi2EEGPUvsCPU", nbins_chi2, 0, last_chi2, nbins_chi2, 0, last_chi2);
-  setAxis(hChi2EEGPUvsCPU);
-  auto hChi2EBdeltavsCPU =
-      new TH2D("hChi2EBdeltavsCPU", "hChi2EBdeltavsCPU", nbins_chi2, 0, last_chi2, nbins_delta, -delta, delta);
-  setAxisDelta(hChi2EBdeltavsCPU);
-  auto hChi2EEdeltavsCPU =
-      new TH2D("hChi2EEdeltavsCPU", "hChi2EEdeltavsCPU", nbins_chi2, 0, last_chi2, nbins_delta, -delta, delta);
-  setAxisDelta(hChi2EEdeltavsCPU);
-
-  auto hFlagsEBGPUvsCPU =
-      new TH2D("hFlagsEBGPUvsCPU", "hFlagsEBGPUvsCPU", nbins_flags, 0, last_flags, nbins_flags, 0, last_flags);
-  setAxis(hFlagsEBGPUvsCPU);
-  auto hFlagsEEGPUvsCPU =
-      new TH2D("hFlagsEEGPUvsCPU", "hFlagsEEGPUvsCPU", nbins_flags, 0, last_flags, nbins_flags, 0, last_flags);
-  setAxis(hFlagsEEGPUvsCPU);
-  auto hFlagsEBdeltavsCPU = new TH2D(
-      "hFlagsEBdeltavsCPU", "hFlagsEBdeltavsCPU", nbins_flags, 0, last_flags, nbins_delta, -delta_flags, delta_flags);
-  setAxisDelta(hFlagsEBdeltavsCPU);
-  auto hFlagsEEdeltavsCPU = new TH2D(
-      "hFlagsEEdeltavsCPU", "hFlagsEEdeltavsCPU", nbins_flags, 0, last_flags, nbins_delta, -delta_flags, delta_flags);
-  setAxisDelta(hFlagsEEdeltavsCPU);
-
-  auto hRechitsEBGPUvsCPU = new TH2D(
-      "RechitsEBGPUvsCPU", "RechitsEBGPUvsCPU; CPU; GPU", last_count, 0, last_count, last_count, 0, last_count);
-  setAxis(hRechitsEBGPUvsCPU);
-  auto hRechitsEEGPUvsCPU = new TH2D(
-      "RechitsEEGPUvsCPU", "RechitsEEGPUvsCPU; CPU; GPU", last_count, 0, last_count, last_count, 0, last_count);
-  setAxis(hRechitsEEGPUvsCPU);
-  auto hRechitsEBdeltavsCPU = new TH2D(
-      "RechitsEBdeltavsCPU", "RechitsEBdeltavsCPU", nbins_count, 0, last_count, nbins_count_delta, -delta, delta);
-  setAxisDelta(hRechitsEBdeltavsCPU);
-  auto hRechitsEEdeltavsCPU = new TH2D(
-      "RechitsEEdeltavsCPU", "RechitsEEdeltavsCPU", nbins_count, 0, last_count, nbins_count_delta, -delta, delta);
-  setAxisDelta(hRechitsEEdeltavsCPU);
-
-  // input
-  std::cout << "validating file " << fileName << std::endl;
-  TFile rf{fileName.c_str()};
-  TTree *rt = (TTree *)rf.Get("Events");
-  rt->SetBranchAddress(
-      "calocommonCUDAHostAllocatorAliascalocommonVecStoragePolicyecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_"
-      "EcalUncalibRecHitsEB_RECO.",
-      &wgpuEB);
-  rt->SetBranchAddress(
-      "calocommonCUDAHostAllocatorAliascalocommonVecStoragePolicyecalUncalibratedRecHit_ecalCPUUncalibRecHitProducer_"
-      "EcalUncalibRecHitsEE_RECO.",
-      &wgpuEE);
-  rt->SetBranchAddress("EcalUncalibratedRecHitsSorted_ecalMultiFitUncalibRecHit_EcalUncalibRecHitsEB_RECO.", &wcpuEB);
-  rt->SetBranchAddress("EcalUncalibratedRecHitsSorted_ecalMultiFitUncalibRecHit_EcalUncalibRecHitsEE_RECO.", &wcpuEE);
-
-  constexpr float eps_diff = 1e-3;
-
-  // accumulate
-  auto const nentries = rt->GetEntries();
-  std::cout << "#events to validate over: " << nentries << std::endl;
-  for (int ie = 0; ie < nentries; ++ie) {
-    rt->GetEntry(ie);
-
-    const char *ordinal[] = {"th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"};
-    auto cpu_eb_size = wcpuEB->bareProduct().size();
-    auto cpu_ee_size = wcpuEE->bareProduct().size();
-    auto gpu_eb_size = wgpuEB->bareProduct().amplitude.size();
-    auto gpu_ee_size = wgpuEE->bareProduct().amplitude.size();
-
-    float eb_ratio = (float)gpu_eb_size / cpu_eb_size;
-    float ee_ratio = (float)gpu_ee_size / cpu_ee_size;
-
-    // Filling up the histograms on events sizes for EB and EE on both GPU and CPU
-    hRechitsEBGPU->Fill(gpu_eb_size);
-    hRechitsEBCPU->Fill(cpu_eb_size);
-    hRechitsEEGPU->Fill(gpu_ee_size);
-    hRechitsEECPU->Fill(cpu_ee_size);
-    hRechitsEBGPUvsCPU->Fill(cpu_eb_size, gpu_eb_size);
-    hRechitsEEGPUvsCPU->Fill(cpu_ee_size, gpu_ee_size);
-    hRechitsEBGPUCPUratio->Fill(eb_ratio);
-    hRechitsEEGPUCPUratio->Fill(ee_ratio);
-    hRechitsEBdeltavsCPU->Fill(cpu_eb_size, gpu_eb_size - cpu_eb_size);
-    hRechitsEEdeltavsCPU->Fill(cpu_ee_size, gpu_ee_size - cpu_ee_size);
-
-    if (cpu_eb_size != gpu_eb_size or cpu_ee_size != gpu_ee_size) {
-      std::cerr << ie << ordinal[ie % 10] << " entry:\n"
-                << "  EB size: " << std::setw(4) << cpu_eb_size << " (cpu) vs " << std::setw(4) << gpu_eb_size
-                << " (gpu)\n"
-                << "  EE size: " << std::setw(4) << cpu_ee_size << " (cpu) vs " << std::setw(4) << gpu_ee_size
-                << " (gpu)" << std::endl;
-      continue;
-    }
-
-    assert(wgpuEB->bareProduct().amplitude.size() == wcpuEB->bareProduct().size());
-    assert(wgpuEE->bareProduct().amplitude.size() == wcpuEE->bareProduct().size());
-    auto const neb = wcpuEB->bareProduct().size();
-    auto const nee = wcpuEE->bareProduct().size();
-
-    for (uint32_t i = 0; i < neb; ++i) {
-      auto const did_gpu = wgpuEB->bareProduct().did[i];
-      auto const soi_amp_gpu = wgpuEB->bareProduct().amplitude[i];
-      auto const cpu_iter = wcpuEB->bareProduct().find(DetId{did_gpu});
-      if (cpu_iter == wcpuEB->bareProduct().end()) {
-        std::cerr << ie << ordinal[ie % 10] << " entry\n"
-                  << "  Did not find a DetId " << did_gpu << " in a CPU collection\n";
-        continue;
-      }
-      auto const soi_amp_cpu = cpu_iter->amplitude();
-      auto const chi2_gpu = wgpuEB->bareProduct().chi2[i];
-      auto const chi2_cpu = cpu_iter->chi2();
-
-      auto const flags_gpu = wgpuEB->bareProduct().flags[i];
-      auto const flags_cpu = cpu_iter->flags();
-
-      hSOIAmplitudesEBGPU->Fill(soi_amp_gpu);
-      hSOIAmplitudesEBCPU->Fill(soi_amp_cpu);
-      hSOIAmplitudesEBGPUvsCPU->Fill(soi_amp_cpu, soi_amp_gpu);
-      hSOIAmplitudesEBdeltavsCPU->Fill(soi_amp_cpu, soi_amp_gpu - soi_amp_cpu);
-      if (soi_amp_cpu > 0)
-        hSOIAmplitudesEBGPUCPUratio->Fill((float)soi_amp_gpu / soi_amp_cpu);
-
-      hChi2EBGPU->Fill(chi2_gpu);
-      hChi2EBCPU->Fill(chi2_cpu);
-      hChi2EBGPUvsCPU->Fill(chi2_cpu, chi2_gpu);
-      hChi2EBdeltavsCPU->Fill(chi2_cpu, chi2_gpu - chi2_cpu);
-      if (chi2_cpu > 0)
-        hChi2EBGPUCPUratio->Fill((float)chi2_gpu / chi2_cpu);
-
-      if (std::abs(chi2_gpu / chi2_cpu - 1) > 0.05 || std::abs(soi_amp_gpu / soi_amp_cpu - 1) > 0.05) {
-        std::cout << " ---- EB  " << std::endl;
-        std::cout << " eventid = " << ie << " xtal = " << i << std::endl;
-        std::cout << " chi2_gpu    = " << chi2_gpu << " chi2_cpu =    " << chi2_cpu << std::endl;
-        std::cout << " soi_amp_gpu = " << soi_amp_gpu << " soi_amp_cpu = " << soi_amp_cpu << std::endl;
-        std::cout << " flags_gpu   = " << flags_gpu << " flags_cpu =   " << flags_cpu << std::endl;
-      }
-
-      hFlagsEBGPU->Fill(flags_gpu);
-      hFlagsEBCPU->Fill(flags_cpu);
-      hFlagsEBGPUvsCPU->Fill(flags_cpu, flags_gpu);
-      hFlagsEBdeltavsCPU->Fill(flags_cpu, flags_gpu - flags_cpu);
-      if (flags_cpu > 0)
-        hFlagsEBGPUCPUratio->Fill((float)flags_gpu / flags_cpu);
-
-      if (flags_cpu != flags_gpu) {
-        std::cout << "    >>  No! Different flag cpu:gpu = " << flags_cpu << " : " << flags_gpu;
-        std::cout << std::endl;
-      }
-
-      if ((std::abs(soi_amp_gpu - soi_amp_cpu) >= eps_diff) or (std::abs(chi2_gpu - chi2_cpu) >= eps_diff) or
-          std::isnan(chi2_gpu) or (flags_cpu != flags_gpu)) {
-        printf("EB eventid = %d chid = %d amp_gpu = %f amp_cpu %f chi2_gpu = %f chi2_cpu = %f\n",
-               ie,
-               i,
-               soi_amp_gpu,
-               soi_amp_cpu,
-               chi2_gpu,
-               chi2_cpu);
-        if (std::isnan(chi2_gpu))
-          printf("*** nan ***\n");
-      }
-    }
-
-    for (uint32_t i = 0; i < nee; ++i) {
-      auto const did_gpu = wgpuEE->bareProduct().did[i];
-      auto const soi_amp_gpu = wgpuEE->bareProduct().amplitude[i];
-      auto const cpu_iter = wcpuEE->bareProduct().find(DetId{did_gpu});
-      if (cpu_iter == wcpuEE->bareProduct().end()) {
-        std::cerr << ie << ordinal[ie % 10] << " entry\n"
-                  << "  did not find a DetId " << did_gpu << " in a CPU collection\n";
-        continue;
-      }
-      auto const soi_amp_cpu = cpu_iter->amplitude();
-      auto const chi2_gpu = wgpuEE->bareProduct().chi2[i];
-      auto const chi2_cpu = cpu_iter->chi2();
-
-      auto const flags_gpu = wgpuEE->bareProduct().flags[i];
-      auto const flags_cpu = cpu_iter->flags();
-
-      hSOIAmplitudesEEGPU->Fill(soi_amp_gpu);
-      hSOIAmplitudesEECPU->Fill(soi_amp_cpu);
-      hSOIAmplitudesEEGPUvsCPU->Fill(soi_amp_cpu, soi_amp_gpu);
-      hSOIAmplitudesEEdeltavsCPU->Fill(soi_amp_cpu, soi_amp_gpu - soi_amp_cpu);
-      if (soi_amp_cpu > 0)
-        hSOIAmplitudesEEGPUCPUratio->Fill((float)soi_amp_gpu / soi_amp_cpu);
-
-      hChi2EEGPU->Fill(chi2_gpu);
-      hChi2EECPU->Fill(chi2_cpu);
-      hChi2EEGPUvsCPU->Fill(chi2_cpu, chi2_gpu);
-      hChi2EEdeltavsCPU->Fill(chi2_cpu, chi2_gpu - chi2_cpu);
-      if (chi2_cpu > 0)
-        hChi2EEGPUCPUratio->Fill((float)chi2_gpu / chi2_cpu);
-
-      if (std::abs(chi2_gpu / chi2_cpu - 1) > 0.05 || std::abs(soi_amp_gpu / soi_amp_cpu - 1) > 0.05) {
-        std::cout << " ---- EE  " << std::endl;
-        std::cout << " eventid = " << ie << " xtal = " << i << std::endl;
-        std::cout << " chi2_gpu    = " << chi2_gpu << " chi2_cpu =    " << chi2_cpu << std::endl;
-        std::cout << " soi_amp_gpu = " << soi_amp_gpu << " soi_amp_cpu = " << soi_amp_cpu << std::endl;
-        std::cout << " flags_gpu   = " << flags_gpu << " flags_cpu =   " << flags_cpu << std::endl;
-      }
-
-      hFlagsEEGPU->Fill(flags_gpu);
-      hFlagsEECPU->Fill(flags_cpu);
-      hFlagsEEGPUvsCPU->Fill(flags_cpu, flags_gpu);
-      hFlagsEEdeltavsCPU->Fill(flags_cpu, flags_gpu - flags_cpu);
-      if (flags_cpu > 0)
-        hFlagsEEGPUCPUratio->Fill((float)flags_gpu / flags_cpu);
-
-      if (flags_cpu != flags_gpu) {
-        std::cout << "    >>  No! Different flag cpu:gpu = " << flags_cpu << " : " << flags_gpu;
-        std::cout << std::endl;
-      }
-
-      if ((std::abs(soi_amp_gpu - soi_amp_cpu) >= eps_diff) or (std::abs(chi2_gpu - chi2_cpu) >= eps_diff) or
-          std::isnan(chi2_gpu) or (flags_cpu != flags_gpu)) {
-        printf("EE eventid = %d chid = %d amp_gpu = %f amp_cpu %f chi2_gpu = %f chi2_cpu = %f\n",
-               ie,
-               static_cast<int>(neb + i),
-               soi_amp_gpu,
-               soi_amp_cpu,
-               chi2_gpu,
-               chi2_cpu);
-        if (std::isnan(chi2_gpu))
-          printf("*** nan ***\n");
-      }
-    }
-  }
-
-  {
-    TCanvas c("plots", "plots", 1750, 860);
-    c.Divide(3, 2);
-
-    c.cd(1);
-    {
-      gPad->SetLogy();
-      hSOIAmplitudesEBCPU->SetLineColor(kBlack);
-      hSOIAmplitudesEBCPU->SetLineWidth(1.);
-      hSOIAmplitudesEBCPU->Draw("");
-      hSOIAmplitudesEBGPU->SetLineColor(kBlue);
-      hSOIAmplitudesEBGPU->SetLineWidth(1.);
-      hSOIAmplitudesEBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hSOIAmplitudesEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(4);
-    {
-      gPad->SetLogy();
-      hSOIAmplitudesEECPU->SetLineColor(kBlack);
-      hSOIAmplitudesEECPU->SetLineWidth(1.);
-      hSOIAmplitudesEECPU->Draw("");
-      hSOIAmplitudesEEGPU->SetLineColor(kBlue);
-      hSOIAmplitudesEEGPU->SetLineWidth(1.);
-      hSOIAmplitudesEEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hSOIAmplitudesEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(2);
-    gPad->SetGrid();
-    hSOIAmplitudesEBGPUvsCPU->Draw("COLZ");
-
-    c.cd(5);
-    gPad->SetGrid();
-    hSOIAmplitudesEEGPUvsCPU->Draw("COLZ");
-
-    c.cd(3);
-
-    hSOIAmplitudesEBGPUCPUratio->Draw("");
-
-    c.cd(6);
-
-    hSOIAmplitudesEEGPUCPUratio->Draw("");
-
-    c.SaveAs("ecal-amplitudes.root");
-    c.SaveAs("ecal-amplitudes.png");
-
-    // chi2
-
-    c.cd(1);
-    {
-      gPad->SetLogy();
-      hChi2EBCPU->SetLineColor(kBlack);
-      hChi2EBCPU->SetLineWidth(1.);
-      hChi2EBCPU->Draw("");
-      hChi2EBGPU->SetLineColor(kBlue);
-      hChi2EBGPU->SetLineWidth(1.);
-      hChi2EBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hChi2EBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(4);
-    {
-      gPad->SetLogy();
-      hChi2EECPU->SetLineColor(kBlack);
-      hChi2EECPU->SetLineWidth(1.);
-      hChi2EECPU->Draw("");
-      hChi2EEGPU->SetLineColor(kBlue);
-      hChi2EEGPU->SetLineWidth(1.);
-      hChi2EEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hChi2EEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(2);
-    gPad->SetGrid();
-    hChi2EBGPUvsCPU->Draw("COLZ");
-
-    c.cd(5);
-    gPad->SetGrid();
-    hChi2EEGPUvsCPU->Draw("COLZ");
-
-    c.cd(3);
-
-    hChi2EBGPUCPUratio->Draw("");
-
-    c.cd(6);
-
-    hChi2EEGPUCPUratio->Draw("");
-
-    c.SaveAs("ecal-chi2.root");
-    c.SaveAs("ecal-chi2.png");
-
-    // flags
-
-    c.cd(1);
-    {
-      gPad->SetLogy();
-      hFlagsEBCPU->SetLineColor(kBlack);
-      hFlagsEBCPU->SetLineWidth(1.);
-      hFlagsEBCPU->Draw("");
-      hFlagsEBGPU->SetLineColor(kBlue);
-      hFlagsEBGPU->SetLineWidth(1.);
-      hFlagsEBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hFlagsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(4);
-    {
-      gPad->SetLogy();
-      hFlagsEECPU->SetLineColor(kBlack);
-      hFlagsEECPU->SetLineWidth(1.);
-      hFlagsEECPU->Draw("");
-      hFlagsEEGPU->SetLineColor(kBlue);
-      hFlagsEEGPU->SetLineWidth(1.);
-      hFlagsEEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hFlagsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-
-    c.cd(2);
-    gPad->SetGrid();
-    hFlagsEBGPUvsCPU->Draw("COLZ");
-
-    c.cd(5);
-    gPad->SetGrid();
-    hFlagsEEGPUvsCPU->Draw("COLZ");
-
-    c.cd(3);
-    hFlagsEBGPUCPUratio->Draw("");
-
-    c.cd(6);
-    hFlagsEEGPUCPUratio->Draw("");
-
-    c.SaveAs("ecal-flags.root");
-    c.SaveAs("ecal-flags.png");
-
-    TCanvas cRechits("Rechits", "Rechits", 1750, 860);
-    cRechits.Divide(3, 2);
-
-    // Plotting the sizes of GPU vs CPU for each event of EB
-    cRechits.cd(1);
-    {
-      gPad->SetLogy();
-      hRechitsEBCPU->SetLineColor(kRed);
-      hRechitsEBCPU->SetLineWidth(2);
-      hRechitsEBCPU->Draw("");
-      hRechitsEBGPU->SetLineColor(kBlue);
-      hRechitsEBGPU->SetLineWidth(2);
-      hRechitsEBGPU->Draw("sames");
-      cRechits.Update();
-      auto stats = (TPaveStats *)hRechitsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechits.cd(4);
-    {
-      gPad->SetLogy();
-      hRechitsEECPU->SetLineColor(kRed);
-      hRechitsEECPU->SetLineWidth(2);
-      hRechitsEECPU->Draw("");
-      hRechitsEEGPU->SetLineColor(kBlue);
-      hRechitsEEGPU->SetLineWidth(2);
-      hRechitsEEGPU->Draw("sames");
-      cRechits.Update();
-      auto stats = (TPaveStats *)hRechitsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechits.cd(2);
-    { hRechitsEBGPUvsCPU->Draw("COLZ"); }
-    cRechits.cd(5);
-    { hRechitsEEGPUvsCPU->Draw("COLZ"); }
-    cRechits.cd(3);
-    {
-      gPad->SetLogy();
-      hRechitsEBGPUCPUratio->Draw("");
-    }
-    cRechits.cd(6);
-    {
-      gPad->SetLogy();
-      hRechitsEEGPUCPUratio->Draw("");
-    }
-    cRechits.SaveAs("ecal-rechits.root");
-    cRechits.SaveAs("ecal-rechits.png");
-  }
-
-  rf.Close();
-  rfout.Write();
-  rfout.Close();
-
-  return 0;
-}
diff --git a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp b/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
deleted file mode 100644
index 42d1fceaf8b76..0000000000000
--- a/RecoLocalCalo/EcalRecAlgos/bin/makeEcalRechitValidationPlots.cpp
+++ /dev/null
@@ -1,864 +0,0 @@
-#include <iomanip>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <fstream>
-
-#include <TCanvas.h>
-#include <TStyle.h>
-#include <TPad.h>
-#include <TFile.h>
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TTree.h>
-#include <TPaveStats.h>
-
-#include "DataFormats/Common/interface/Wrapper.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-
-int main(int argc, char *argv[]) {
-  if (argc < 3) {
-    std::cout << "run with: ./makeEcalRechitValidationPlots <path to input file> <output file>\n";
-    exit(0);
-  }
-  // Set the GPU and CPU pointers for both EB and EE
-  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;
-
-  std::string fileName = argv[1];     // The input file containing the data to be validated (i.e. result.root)
-  std::string outFileName = argv[2];  //The output file in which the validation results will be saved (i.e. output.root)
-
-  //output
-  TFile rfout{outFileName.c_str(), "recreate"};
-
-  int nbins = 200;
-  int last = 5000.;
-
-  int nbins_energy = 300;
-  float last_energy = 2.;
-
-  int nbins_chi2 = 200;
-  float last_chi2 = 100.;
-
-  int nbins_flag = 40;
-  //   int nbins_flag = 1000;
-  int last_flag = 1500;
-  //   int nbins_flag = 40;
-  //   int last_flag = 10000;
-
-  int nbins_extra = 200;
-  int last_extra = 200;
-
-  int nbins_delta = 201;  // use an odd number to center around 0
-  float delta = 0.2;
-
-  // RecHits plots for EB and EE on both GPU and CPU
-  auto hRechitsEBGPU = new TH1D("RechitsEBGPU", "RechitsEBGPU; No. of Rechits. No Filter GPU", nbins, 0, last);
-  auto hRechitsEBCPU = new TH1D("RechitsEBCPU", "RechitsEBCPU; No. of Rechits. No Filter GPU", nbins, 0, last);
-  auto hRechitsEEGPU = new TH1D("RechitsEEGPU", "RechitsEEGPU; No. of Rechits. No Filter GPU", nbins, 0, last);
-  auto hRechitsEECPU = new TH1D("RechitsEECPU", "RechitsEECPU; No. of Rechits. No Filter GPU", nbins, 0, last);
-  auto hRechitsEBGPUvsCPU =
-      new TH2D("RechitsEBGPUvsCPU", "RechitsEBGPUvsCPU; CPU; GPU. No Filter GPU", last, 0, last, last, 0, last);
-  auto hRechitsEEGPUvsCPU =
-      new TH2D("RechitsEEGPUvsCPU", "RechitsEEGPUvsCPU; CPU; GPU. No Filter GPU", last, 0, last, last, 0, last);
-  auto hRechitsEBGPUCPUratio =
-      new TH1D("RechitsEBGPU/CPUratio", "RechitsEBGPU/CPUratio; GPU/CPU. No Filter GPU", 200, 0.95, 1.05);
-  auto hRechitsEEGPUCPUratio =
-      new TH1D("RechitsEEGPU/CPUratio", "RechitsEEGPU/CPUratio; GPU/CPU. No Filter GPU", 200, 0.95, 1.05);
-  auto hRechitsEBdeltavsCPU =
-      new TH2D("RechitsEBdeltavsCPU", "RechitsEBdeltavsCPU. No Filter GPU", nbins, 0, last, nbins_delta, -delta, delta);
-  auto hRechitsEEdeltavsCPU =
-      new TH2D("RechitsEEdeltavsCPU", "RechitsEEdeltavsCPU. No Filter GPU", nbins, 0, last, nbins_delta, -delta, delta);
-
-  // RecHits plots for EB and EE on both GPU and CPU
-  auto hSelectedRechitsEBGPU = new TH1D("RechitsEBGPU", "RechitsEBGPU; No. of Rechits", nbins, 0, last);
-  auto hSelectedRechitsEBCPU = new TH1D("RechitsEBCPU", "RechitsEBCPU; No. of Rechits", nbins, 0, last);
-  auto hSelectedRechitsEEGPU = new TH1D("RechitsEEGPU", "RechitsEEGPU; No. of Rechits", nbins, 0, last);
-  auto hSelectedRechitsEECPU = new TH1D("RechitsEECPU", "RechitsEECPU; No. of Rechits", nbins, 0, last);
-  auto hSelectedRechitsEBGPUvsCPU =
-      new TH2D("RechitsEBGPUvsCPU", "RechitsEBGPUvsCPU; CPU; GPU", last, 0, last, last, 0, last);
-  auto hSelectedRechitsEEGPUvsCPU =
-      new TH2D("RechitsEEGPUvsCPU", "RechitsEEGPUvsCPU; CPU; GPU", last, 0, last, last, 0, last);
-  auto hSelectedRechitsEBGPUCPUratio =
-      new TH1D("RechitsEBGPU/CPUratio", "RechitsEBGPU/CPUratio; GPU/CPU", 200, 0.95, 1.05);
-  auto hSelectedRechitsEEGPUCPUratio =
-      new TH1D("RechitsEEGPU/CPUratio", "RechitsEEGPU/CPUratio; GPU/CPU", 200, 0.95, 1.05);
-  auto hSelectedRechitsEBdeltavsCPU =
-      new TH2D("RechitsEBdeltavsCPU", "RechitsEBdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-  auto hSelectedRechitsEEdeltavsCPU =
-      new TH2D("RechitsEEdeltavsCPU", "RechitsEEdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-
-  // RecHits plots for EB and EE on both GPU and CPU
-  auto hPositiveRechitsEBGPU = new TH1D("RechitsEBGPU", "RechitsEBGPU; No. of Rechits", nbins, 0, last);
-  auto hPositiveRechitsEBCPU = new TH1D("RechitsEBCPU", "RechitsEBCPU; No. of Rechits", nbins, 0, last);
-  auto hPositiveRechitsEEGPU = new TH1D("RechitsEEGPU", "RechitsEEGPU; No. of Rechits", nbins, 0, last);
-  auto hPositiveRechitsEECPU = new TH1D("RechitsEECPU", "RechitsEECPU; No. of Rechits", nbins, 0, last);
-  auto hPositiveRechitsEBGPUvsCPU =
-      new TH2D("RechitsEBGPUvsCPU", "RechitsEBGPUvsCPU; CPU; GPU", last, 0, last, last, 0, last);
-  auto hPositiveRechitsEEGPUvsCPU =
-      new TH2D("RechitsEEGPUvsCPU", "RechitsEEGPUvsCPU; CPU; GPU", last, 0, last, last, 0, last);
-  auto hPositiveRechitsEBGPUCPUratio =
-      new TH1D("RechitsEBGPU/CPUratio", "RechitsEBGPU/CPUratio; GPU/CPU", 200, 0.95, 1.05);
-  auto hPositiveRechitsEEGPUCPUratio =
-      new TH1D("RechitsEEGPU/CPUratio", "RechitsEEGPU/CPUratio; GPU/CPU", 200, 0.95, 1.05);
-  auto hPositiveRechitsEBdeltavsCPU =
-      new TH2D("RechitsEBdeltavsCPU", "RechitsEBdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-  auto hPositiveRechitsEEdeltavsCPU =
-      new TH2D("RechitsEEdeltavsCPU", "RechitsEEdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-
-  // Energies plots for EB and EE on both GPU and CPU
-  auto hEnergiesEBGPU = new TH1D("EnergiesEBGPU", "EnergiesEBGPU; Energy [GeV]", nbins_energy, 0, last_energy);
-  auto hEnergiesEEGPU = new TH1D("EnergiesEEGPU", "EnergiesEEGPU; Energy [GeV]", nbins_energy, 0, last_energy);
-  auto hEnergiesEBCPU = new TH1D("EnergiesEBCPU", "EnergiesEBCPU; Energy [GeV]", nbins_energy, 0, last_energy);
-  auto hEnergiesEECPU = new TH1D("EnergiesEECPU", "EnergiesEECPU; Energy [GeV]", nbins_energy, 0, last_energy);
-  auto hEnergiesEBGPUvsCPU = new TH2D(
-      "EnergiesEBGPUvsCPU", "EnergiesEBGPUvsCPU; CPU; GPU", nbins_energy, 0, last_energy, nbins_energy, 0, last_energy);
-  auto hEnergiesEEGPUvsCPU = new TH2D(
-      "EnergiesEEGPUvsCPU", "EnergiesEEGPUvsCPU; CPU; GPU", nbins_energy, 0, last_energy, nbins_energy, 0, last_energy);
-  auto hEnergiesEBGPUCPUratio = new TH1D("EnergiesEBGPU/CPUratio", "EnergiesEBGPU/CPUratio; GPU/CPU", 100, 0.8, 1.2);
-  auto hEnergiesEEGPUCPUratio = new TH1D("EnergiesEEGPU/CPUratio", "EnergiesEEGPU/CPUratio; GPU/CPU", 100, 0.8, 1.2);
-  auto hEnergiesEBdeltavsCPU =
-      new TH2D("EnergiesEBdeltavsCPU", "EnergiesEBdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-  auto hEnergiesEEdeltavsCPU =
-      new TH2D("EnergiesEEdeltavsCPU", "EnergiesEEdeltavsCPU", nbins, 0, last, nbins_delta, -delta, delta);
-
-  // Chi2 plots for EB and EE on both GPU and CPU
-  auto hChi2EBGPU = new TH1D("Chi2EBGPU", "Chi2EBGPU; Ch^{2}", nbins_chi2, 0, last_chi2);
-  auto hChi2EEGPU = new TH1D("Chi2EEGPU", "Chi2EEGPU; Ch^{2}", nbins_chi2, 0, last_chi2);
-  auto hChi2EBCPU = new TH1D("Chi2EBCPU", "Chi2EBCPU; Ch^{2}", nbins_chi2, 0, last_chi2);
-  auto hChi2EECPU = new TH1D("Chi2EECPU", "Chi2EECPU; Ch^{2}", nbins_chi2, 0, last_chi2);
-  auto hChi2EBGPUvsCPU = new TH2D("Chi2EBGPUvsCPU", "Chi2EBGPUvsCPU; CPU; GPU", nbins_chi2, 0, 100, nbins_chi2, 0, 100);
-  auto hChi2EEGPUvsCPU = new TH2D("Chi2EEGPUvsCPU", "Chi2EEGPUvsCPU; CPU; GPU", nbins_chi2, 0, 100, nbins_chi2, 0, 100);
-  auto hChi2EBGPUCPUratio = new TH1D("Chi2EBGPU/CPUratio", "Chi2EBGPU/CPUratio; GPU/CPU", 100, 0.8, 1.2);
-  auto hChi2EEGPUCPUratio = new TH1D("Chi2EEGPU/CPUratio", "Chi2EEGPU/CPUratio; GPU/CPU", 100, 0.8, 1.2);
-  auto hChi2EBdeltavsCPU =
-      new TH2D("Chi2EBdeltavsCPU", "Chi2EBdeltavsCPU", nbins_chi2, 0, last_chi2, nbins_delta, -delta, delta);
-  auto hChi2EEdeltavsCPU =
-      new TH2D("Chi2EEdeltavsCPU", "Chi2EEdeltavsCPU", nbins_chi2, 0, last_chi2, nbins_delta, -delta, delta);
-
-  // Flags plots for EB and EE on both GPU and CPU
-  auto hFlagsEBGPU = new TH1D("FlagsEBGPU", "FlagsEBGPU; Flags", nbins_flag, -10, last_flag);
-  auto hFlagsEBCPU = new TH1D("FlagsEBCPU", "FlagsEBCPU; Flags", nbins_flag, -10, last_flag);
-  auto hFlagsEEGPU = new TH1D("FlagsEEGPU", "FlagsEEGPU; Flags", nbins_flag, -10, last_flag);
-  auto hFlagsEECPU = new TH1D("FlagsEECPU", "FlagsEECPU; Flags", nbins_flag, -10, last_flag);
-  auto hFlagsEBGPUvsCPU =
-      new TH2D("FlagsEBGPUvsCPU", "FlagsEBGPUvsCPU; CPU; GPU", nbins_flag, -10, last_flag, nbins_flag, -10, last_flag);
-  auto hFlagsEEGPUvsCPU =
-      new TH2D("FlagsEEGPUvsCPU", "FlagsEEGPUvsCPU; CPU; GPU", nbins_flag, -10, last_flag, nbins_flag, -10, last_flag);
-  auto hFlagsEBGPUCPUratio = new TH1D("FlagsEBGPU/CPUratio", "FlagsEBGPU/CPUratio; GPU/CPU", 50, -5, 10);
-  auto hFlagsEEGPUCPUratio = new TH1D("FlagsEEGPU/CPUratio", "FlagsEEGPU/CPUratio; GPU/CPU", 50, -5, 10);
-  auto hFlagsEBdeltavsCPU =
-      new TH2D("FlagsEBdeltavsCPU", "FlagsEBdeltavsCPU", nbins_flag, -10, last_flag, nbins_delta, -delta, delta);
-  auto hFlagsEEdeltavsCPU =
-      new TH2D("FlagsEEdeltavsCPU", "FlagsEEdeltavsCPU", nbins_flag, -10, last_flag, nbins_delta, -delta, delta);
-
-  // Extras plots for EB and EE on both GPU and CPU
-  auto hExtrasEBGPU = new TH1D("ExtrasEBGPU", "ExtrasEBGPU; No. of Extras", nbins_extra, 0, last_extra);
-  auto hExtrasEBCPU = new TH1D("ExtrasEBCPU", "ExtrasEBCPU; No. of Extras", nbins_extra, 0, last_extra);
-  auto hExtrasEEGPU = new TH1D("ExtrasEEGPU", "ExtrasEEGPU; No. of Extras", nbins_extra, 0, last_extra);
-  auto hExtrasEECPU = new TH1D("ExtrasEECPU", "ExtrasEECPU; No. of Extras", nbins_extra, 0, last_extra);
-  auto hExtrasEBGPUvsCPU = new TH2D(
-      "ExtrasEBGPUvsCPU", "ExtrasEBGPUvsCPU; CPU; GPU", nbins_extra, 0, last_extra, nbins_extra, 0, last_extra);
-  auto hExtrasEEGPUvsCPU = new TH2D(
-      "ExtrasEEGPUvsCPU", "ExtrasEEGPUvsCPU; CPU; GPU", nbins_extra, 0, last_extra, nbins_extra, 0, last_extra);
-  auto hExtrasEBGPUCPUratio = new TH1D("ExtrasEBGPU/CPUratio", "ExtrasEBGPU/CPUratio; GPU/CPU", 50, 0.0, 2.0);
-  auto hExtrasEEGPUCPUratio = new TH1D("ExtrasEEGPU/CPUratio", "ExtrasEEGPU/CPUratio; GPU/CPU", 50, 0.0, 2.0);
-  auto hExtrasEBdeltavsCPU =
-      new TH2D("ExtrasEBdeltavsCPU", "ExtrasEBdeltavsCPU", nbins_extra, 0, last_extra, nbins_delta, -delta, delta);
-  auto hExtrasEEdeltavsCPU =
-      new TH2D("ExtrasEEdeltavsCPU", "ExtrasEEdeltavsCPU", nbins_extra, 0, last_extra, nbins_delta, -delta, delta);
-
-  // input file setup for tree
-  std::cout << "validating file " << fileName << std::endl;
-  TFile rf{fileName.c_str()};
-  TTree *rt = (TTree *)rf.Get("Events");
-
-  // Allocating the appropriate data to their respective pointers
-  rt->SetBranchAddress("ecalTagsoaecalRecHit_ecalCPURecHitProducer_EcalRecHitsEB_RECO.", &wgpuEB);
-  rt->SetBranchAddress("ecalTagsoaecalRecHit_ecalCPURecHitProducer_EcalRecHitsEE_RECO.", &wgpuEE);
-  rt->SetBranchAddress("EcalRecHitsSorted_ecalRecHit_EcalRecHitsEB_RECO.", &wcpuEB);
-  rt->SetBranchAddress("EcalRecHitsSorted_ecalRecHit_EcalRecHitsEE_RECO.", &wcpuEE);
-
-  // constexpr float eps_diff = 1e-3;
-
-  // accumulate sizes for events and sizes of each event on both GPU and CPU
-  //   auto const nentries = rt->GetEntries();
-  int nentries = rt->GetEntries();
-
-  //---- AM: tests
-  if (nentries > 1000) {
-    nentries = 1000;
-  }
-  //   nentries = 1;
-
-  std::cout << "#events to validate over: " << nentries << std::endl;
-  for (int ie = 0; ie < nentries; ++ie) {
-    rt->GetEntry(ie);
-
-    //     const char* ordinal[] = { "th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th" };
-    auto cpu_eb_size = wcpuEB->bareProduct().size();
-    auto cpu_ee_size = wcpuEE->bareProduct().size();
-    auto gpu_eb_size = wgpuEB->bareProduct().energy.size();
-    auto gpu_ee_size = wgpuEE->bareProduct().energy.size();
-    float eb_ratio = (float)gpu_eb_size / cpu_eb_size;
-    float ee_ratio = (float)gpu_ee_size / cpu_ee_size;
-
-    // Filling up the histograms on events sizes for EB and EE on both GPU and CPU
-    hRechitsEBGPU->Fill(gpu_eb_size);
-    hRechitsEBCPU->Fill(cpu_eb_size);
-    hRechitsEEGPU->Fill(gpu_ee_size);
-    hRechitsEECPU->Fill(cpu_ee_size);
-    hRechitsEBGPUvsCPU->Fill(cpu_eb_size, gpu_eb_size);
-    hRechitsEEGPUvsCPU->Fill(cpu_ee_size, gpu_ee_size);
-    hRechitsEBGPUCPUratio->Fill(eb_ratio);
-    hRechitsEEGPUCPUratio->Fill(ee_ratio);
-    hRechitsEBdeltavsCPU->Fill(cpu_eb_size, gpu_eb_size - cpu_eb_size);
-    hRechitsEEdeltavsCPU->Fill(cpu_ee_size, gpu_ee_size - cpu_ee_size);
-
-    /*    
-     *    // condition that sizes on GPU and CPU should be the same for EB or EE
-     *       if (cpu_eb_size != gpu_eb_size or cpu_ee_size != gpu_ee_size) {
-     *         std::cerr << ie << ordinal[ie % 10] << " entry:\n"
-     *                   << "  EB size: " << std::setw(4) << cpu_eb_size << " (cpu) vs " << std::setw(4) << gpu_eb_size << " (gpu)\n"
-     *                   << "  EE size: " << std::setw(4) << cpu_ee_size << " (cpu) vs " << std::setw(4) << gpu_ee_size << " (gpu)" << std::endl;
-     *                  
-     *         continue;
-  }
-  assert(wgpuEB->bareProduct().energy.size() == wcpuEB->bareProduct().size());
-  assert(wgpuEE->bareProduct().energy.size() == wcpuEE->bareProduct().size()); 
-  auto const neb = wcpuEB->bareProduct().size(); //like cpu_eb_size but set to constant
-  auto const nee = wcpuEE->bareProduct().size(); //like cpu_ee_size but set to constant
-  */
-
-    uint selected_gpu_eb_size = 0;
-    uint selected_gpu_ee_size = 0;
-
-    uint positive_gpu_eb_size = 0;
-    uint positive_gpu_ee_size = 0;
-
-    // EB:
-    for (uint32_t i = 0; i < gpu_eb_size; ++i) {
-      auto const did_gpu = wgpuEB->bareProduct().did[i];  // set the did for the current RecHit
-      // Set the variables for GPU
-      auto const enr_gpu = wgpuEB->bareProduct().energy[i];
-      auto const chi2_gpu = wgpuEB->bareProduct().chi2[i];
-      auto const flag_gpu = wgpuEB->bareProduct().flagBits[i];
-      auto const extra_gpu = wgpuEB->bareProduct().extra[i];
-
-      // you have "-1" if the crystal is not selected
-      if (enr_gpu >= 0) {
-        selected_gpu_eb_size++;
-
-        if (enr_gpu > 0) {
-          positive_gpu_eb_size++;
-        }
-
-        // find the Rechit on CPU reflecting the same did
-        auto const cpu_iter = wcpuEB->bareProduct().find(DetId{did_gpu});
-        if (cpu_iter == wcpuEB->bareProduct().end()) {
-          //           std::cerr << ie << ordinal[ie % 10] << " entry\n"
-          //                   << "  Did not find a DetId " << did_gpu_eb
-          //                 << " in a CPU collection\n";
-          std::cerr << "  Did not find a DetId " << did_gpu << " in a CPU collection\n";
-          continue;
-        }
-        // Set the variables for CPU
-        auto const enr_cpu = cpu_iter->energy();
-        auto const chi2_cpu = cpu_iter->chi2();
-        //         auto const flag_cpu = cpu_iter->flagBits();
-        auto const flag_cpu = 1;
-        //         auto const extra_cpu = cpu_iter->extra();
-        auto const extra_cpu = 1;
-        //       auto const flag_cpu = cpu_iter->flagBits() ? cpu_iter->flagBits():-1;
-        //       auto const extra_cpu = cpu_iter->extra() ? cpu_iter->extra():-1;
-
-        // AM: TEST
-        //       if (extra_cpu != 10) continue;
-
-        // Fill the energy and Chi2 histograms for GPU and CPU and their comparisons with delta
-        hEnergiesEBGPU->Fill(enr_gpu);
-        hEnergiesEBCPU->Fill(enr_cpu);
-        //       std::cout<<"EB CPU Energy:\t"<<enr_cpu<<std::endl;
-        hEnergiesEBGPUvsCPU->Fill(enr_cpu, enr_gpu);
-        hEnergiesEBGPUCPUratio->Fill(enr_gpu / enr_cpu);
-        hEnergiesEBdeltavsCPU->Fill(enr_cpu, enr_gpu - enr_cpu);
-
-        hChi2EBGPU->Fill(chi2_gpu);
-        hChi2EBCPU->Fill(chi2_cpu);
-        hChi2EBGPUvsCPU->Fill(chi2_cpu, chi2_gpu);
-        hChi2EBGPUCPUratio->Fill(chi2_gpu / chi2_cpu);
-        hChi2EBdeltavsCPU->Fill(chi2_cpu, chi2_gpu - chi2_cpu);
-
-        hFlagsEBGPU->Fill(flag_gpu);
-        hFlagsEBCPU->Fill(flag_cpu);
-        hFlagsEBGPUvsCPU->Fill(flag_cpu, flag_gpu);
-        hFlagsEBGPUCPUratio->Fill(flag_cpu ? flag_gpu / flag_cpu : -1);
-        hFlagsEBdeltavsCPU->Fill(flag_cpu, flag_gpu - flag_cpu);
-
-        hExtrasEBGPU->Fill(extra_gpu);
-        hExtrasEBCPU->Fill(extra_cpu);
-        hExtrasEBGPUvsCPU->Fill(extra_cpu, extra_gpu);
-        hExtrasEBGPUCPUratio->Fill(extra_cpu ? extra_gpu / extra_cpu : -1);
-        hExtrasEBdeltavsCPU->Fill(extra_cpu, extra_gpu - extra_cpu);
-
-        // Check if abs difference between GPU and CPU values for energy and Chi2 are smaller than eps, if not print message
-        // if ((std::abs(enr_gpu - enr_cpu) >= eps_diff) or
-        //      (std::abs(chi2_gpu - chi2_cpu) >= eps_diff) or std::isnan(chi2_gpu))
-        //  {
-        //      printf("EB eventid = %d chid = %d energy_gpu = %f energy_cpu %f chi2_gpu = %f chi2_cpu = %f\n",
-        //          ie, i, enr_gpu, enr_cpu, chi2_gpu, chi2_cpu);
-        //      if (std::isnan(chi2_gpu))
-        //        printf("*** nan ***\n");
-        //  }
-      }
-    }
-
-    // EE:
-    for (uint32_t i = 0; i < gpu_ee_size; ++i) {
-      auto const did_gpu = wgpuEE->bareProduct().did[i];  // set the did for the current RecHit
-      // Set the variables for GPU
-      auto const enr_gpu = wgpuEE->bareProduct().energy[i];
-      auto const chi2_gpu = wgpuEE->bareProduct().chi2[i];
-      auto const flag_gpu = wgpuEE->bareProduct().flagBits[i];
-      auto const extra_gpu = wgpuEE->bareProduct().extra[i];
-
-      // you have "-1" if the crystal is not selected
-      if (enr_gpu >= 0) {
-        selected_gpu_ee_size++;
-
-        if (enr_gpu > 0) {
-          positive_gpu_ee_size++;
-        }
-
-        // find the Rechit on CPU reflecting the same did
-        auto const cpu_iter = wcpuEE->bareProduct().find(DetId{did_gpu});
-        if (cpu_iter == wcpuEE->bareProduct().end()) {
-          //    std::cerr << ie << ordinal[ie % 10] << " entry\n"
-          //            << "  Did not find a DetId " << did_gpu
-          //          << " in a CPU collection\n";
-          std::cerr << "  Did not find a DetId " << did_gpu << " in a CPU collection\n";
-          continue;
-        }
-        // Set the variables for CPU
-        auto const enr_cpu = cpu_iter->energy();
-        auto const chi2_cpu = cpu_iter->chi2();
-        //         auto const flag_cpu = cpu_iter->flagBits();
-        auto const flag_cpu = 1;
-        //         auto const extra_cpu = cpu_iter->extra();
-        auto const extra_cpu = 1;
-        //       auto const flag_cpu = cpu_iter->flagBits()?cpu_iter->flagBits():-1;
-        //       auto const extra_cpu = cpu_iter->extra()?cpu_iter->extra():-1;
-
-        // AM: TEST
-        //       if (extra_cpu != 10) continue;
-
-        // Fill the energy and Chi2 histograms for GPU and CPU and their comparisons with delta
-        hEnergiesEEGPU->Fill(enr_gpu);
-        hEnergiesEECPU->Fill(enr_cpu);
-        hEnergiesEEGPUvsCPU->Fill(enr_cpu, enr_gpu);
-        hEnergiesEEGPUCPUratio->Fill(enr_gpu / enr_cpu);
-        hEnergiesEEdeltavsCPU->Fill(enr_cpu, enr_gpu - enr_cpu);
-
-        hChi2EEGPU->Fill(chi2_gpu);
-        hChi2EECPU->Fill(chi2_cpu);
-        hChi2EEGPUvsCPU->Fill(chi2_cpu, chi2_gpu);
-        hChi2EEGPUCPUratio->Fill(chi2_gpu / chi2_cpu);
-        hChi2EEdeltavsCPU->Fill(chi2_cpu, chi2_gpu - chi2_cpu);
-
-        hFlagsEEGPU->Fill(flag_gpu);
-        hFlagsEECPU->Fill(flag_cpu);
-        hFlagsEEGPUvsCPU->Fill(flag_cpu, flag_gpu);
-        hFlagsEEGPUCPUratio->Fill(flag_cpu ? flag_gpu / flag_cpu : -1);
-        hFlagsEEdeltavsCPU->Fill(flag_cpu, flag_gpu - flag_cpu);
-
-        hExtrasEEGPU->Fill(extra_gpu);
-        hExtrasEECPU->Fill(extra_cpu);
-        hExtrasEEGPUvsCPU->Fill(extra_cpu, extra_gpu);
-        hExtrasEEGPUCPUratio->Fill(extra_cpu ? extra_gpu / extra_cpu : -1);
-        hExtrasEEdeltavsCPU->Fill(extra_cpu, extra_gpu - extra_cpu);
-
-        // Check if abs difference between GPU and CPU values for energy and Chi2 are smaller than eps, if not print message
-        // if ((std::abs(enr_gpu - enr_cpu) >= eps_diff) or
-        //      (std::abs(chi2_gpu - chi2_cpu) >= eps_diff) or std::isnan(chi2_gpu))
-        //  {
-        //      printf("EE eventid = %d chid = %d energy_gpu = %f energy_cpu %f chi2_gpu = %f chi2_cpu = %f\n",
-        //          ie, i, enr_gpu, enr_cpu, chi2_gpu, chi2_cpu);
-        //      if (std::isnan(chi2_gpu))
-        //        printf("*** nan ***\n");
-        //  }
-      }
-    }
-
-    //
-    // now the rechit counting
-    //
-    float selected_eb_ratio = (float)selected_gpu_eb_size / cpu_eb_size;
-    float selected_ee_ratio = (float)selected_gpu_ee_size / cpu_ee_size;
-
-    // Filling up the histograms on events sizes for EB and EE on both GPU and CPU
-    hSelectedRechitsEBGPU->Fill(selected_gpu_eb_size);
-    hSelectedRechitsEBCPU->Fill(cpu_eb_size);
-    hSelectedRechitsEEGPU->Fill(selected_gpu_ee_size);
-    hSelectedRechitsEECPU->Fill(cpu_ee_size);
-    hSelectedRechitsEBGPUvsCPU->Fill(cpu_eb_size, selected_gpu_eb_size);
-    hSelectedRechitsEEGPUvsCPU->Fill(cpu_ee_size, selected_gpu_ee_size);
-    hSelectedRechitsEBGPUCPUratio->Fill(selected_eb_ratio);
-    hSelectedRechitsEEGPUCPUratio->Fill(selected_ee_ratio);
-    hSelectedRechitsEBdeltavsCPU->Fill(cpu_eb_size, selected_gpu_eb_size - cpu_eb_size);
-    hSelectedRechitsEEdeltavsCPU->Fill(cpu_ee_size, selected_gpu_ee_size - cpu_ee_size);
-
-    //
-    // now the rechit counting
-    //
-
-    uint positive_cpu_eb_size = 0;
-    uint positive_cpu_ee_size = 0;
-
-    // EB:
-    for (uint32_t i = 0; i < cpu_eb_size; ++i) {
-      auto const enr_cpu = wcpuEB->bareProduct()[i].energy();
-      if (enr_cpu > 0) {
-        positive_cpu_eb_size++;
-      }
-    }
-    // EE:
-    for (uint32_t i = 0; i < cpu_ee_size; ++i) {
-      auto const enr_cpu = wcpuEE->bareProduct()[i].energy();
-      if (enr_cpu > 0) {
-        positive_cpu_ee_size++;
-      }
-    }
-
-    float positive_eb_ratio = (float)positive_gpu_eb_size / positive_cpu_eb_size;
-    float positive_ee_ratio = (float)positive_gpu_ee_size / positive_cpu_ee_size;
-
-    // Filling up the histograms on events sizes for EB and EE on both GPU and CPU
-    hPositiveRechitsEBGPU->Fill(positive_gpu_eb_size);
-    hPositiveRechitsEBCPU->Fill(positive_cpu_eb_size);
-    hPositiveRechitsEEGPU->Fill(positive_gpu_ee_size);
-    hPositiveRechitsEECPU->Fill(positive_cpu_ee_size);
-    hPositiveRechitsEBGPUvsCPU->Fill(positive_cpu_eb_size, positive_gpu_eb_size);
-    hPositiveRechitsEEGPUvsCPU->Fill(positive_cpu_ee_size, positive_gpu_ee_size);
-    hPositiveRechitsEBGPUCPUratio->Fill(positive_eb_ratio);
-    hPositiveRechitsEEGPUCPUratio->Fill(positive_ee_ratio);
-    hPositiveRechitsEBdeltavsCPU->Fill(positive_cpu_eb_size, positive_gpu_eb_size - positive_cpu_eb_size);
-    hPositiveRechitsEEdeltavsCPU->Fill(positive_cpu_ee_size, positive_gpu_ee_size - positive_cpu_ee_size);
-
-    if (cpu_eb_size != selected_gpu_eb_size or cpu_ee_size != selected_gpu_ee_size) {
-      //       std::cerr << ie << ordinal[ie % 10] << " entry:\n"
-      std::cerr << ie << " entry:\n"
-                << "  EB size: " << std::setw(4) << cpu_eb_size << " (cpu) vs " << std::setw(4) << selected_gpu_eb_size
-                << " (gpu)\n"
-                << "  EE size: " << std::setw(4) << cpu_ee_size << " (cpu) vs " << std::setw(4) << selected_gpu_ee_size
-                << " (gpu)" << std::endl;
-    }
-  }
-
-  // Plotting the results:
-  {
-    // Canvases Setup:
-    TCanvas cAllRechits("AllRechits", "AllRechits", 1750, 860);
-    cAllRechits.Divide(3, 2);
-    TCanvas cRechits("Rechits", "Rechits", 1750, 860);
-    cRechits.Divide(3, 2);
-    TCanvas cRechitsPositive("RechitsPositive", "RechitsPositive", 1750, 860);
-    cRechitsPositive.Divide(3, 2);
-    TCanvas cEnergies("Energies", "Energies", 1750, 860);
-    cEnergies.Divide(3, 2);
-    TCanvas cChi2("Chi2", "Chi2", 1750, 860);
-    cChi2.Divide(3, 2);
-    TCanvas cFlags("Flags", "Flags", 1750, 860);
-    cFlags.Divide(3, 2);
-    TCanvas cExtras("Extras", "Extras", 1750, 860);
-    cExtras.Divide(3, 2);
-
-    // Plotting the sizes of GPU vs CPU for each event of EB
-    cAllRechits.cd(1);
-    {
-      gPad->SetLogy();
-      hRechitsEBCPU->SetLineColor(kRed);
-      hRechitsEBCPU->SetLineWidth(2);
-      hRechitsEBCPU->Draw("");
-      hRechitsEBGPU->SetLineColor(kBlue);
-      hRechitsEBGPU->SetLineWidth(2);
-      hRechitsEBGPU->Draw("sames");
-      cAllRechits.Update();
-      auto stats = (TPaveStats *)hRechitsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cAllRechits.cd(4);
-    {
-      gPad->SetLogy();
-      hRechitsEECPU->SetLineColor(kRed);
-      hRechitsEECPU->SetLineWidth(2);
-      hRechitsEECPU->Draw("");
-      hRechitsEEGPU->SetLineColor(kBlue);
-      hRechitsEEGPU->SetLineWidth(2);
-      hRechitsEEGPU->Draw("sames");
-      cAllRechits.Update();
-      auto stats = (TPaveStats *)hRechitsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cAllRechits.cd(2);
-    {
-      gStyle->SetPalette(55);
-      hRechitsEBGPUvsCPU->Draw("COLZ");
-    }
-    cAllRechits.cd(5);
-    {
-      gStyle->SetPalette(55);
-      hRechitsEEGPUvsCPU->Draw("COLZ");
-    }
-    cAllRechits.cd(3);
-    {
-      gPad->SetLogy();
-      //hRechitsEBdeltavsCPU->Draw("COLZ");
-      hRechitsEBGPUCPUratio->Draw("");
-    }
-    cAllRechits.cd(6);
-    {
-      gPad->SetLogy();
-      //hRechitsEEdeltavsCPU->Draw("COLZ");
-      hRechitsEEGPUCPUratio->Draw("");
-    }
-    cAllRechits.SaveAs("ecal-allrechits.root");
-    cAllRechits.SaveAs("ecal-allrechits.png");
-
-    // Plotting the sizes of GPU vs CPU for each event of EB
-    cRechits.cd(1);
-    {
-      gPad->SetLogy();
-      hSelectedRechitsEBCPU->SetLineColor(kRed);
-      hSelectedRechitsEBCPU->SetLineWidth(2);
-      hSelectedRechitsEBCPU->Draw("");
-      hSelectedRechitsEBGPU->SetLineColor(kBlue);
-      hSelectedRechitsEBGPU->SetLineWidth(2);
-      hSelectedRechitsEBGPU->Draw("sames");
-      cRechits.Update();
-      auto stats = (TPaveStats *)hSelectedRechitsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechits.cd(4);
-    {
-      gPad->SetLogy();
-      hSelectedRechitsEECPU->SetLineColor(kRed);
-      hSelectedRechitsEECPU->SetLineWidth(2);
-      hSelectedRechitsEECPU->Draw("");
-      hSelectedRechitsEEGPU->SetLineColor(kBlue);
-      hSelectedRechitsEEGPU->SetLineWidth(2);
-      hSelectedRechitsEEGPU->Draw("sames");
-      cRechits.Update();
-      auto stats = (TPaveStats *)hSelectedRechitsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechits.cd(2);
-    {
-      gStyle->SetPalette(55);
-      hSelectedRechitsEBGPUvsCPU->Draw("COLZ");
-    }
-    cRechits.cd(5);
-    {
-      gStyle->SetPalette(55);
-      hSelectedRechitsEEGPUvsCPU->Draw("COLZ");
-    }
-    cRechits.cd(3);
-    {
-      gPad->SetLogy();
-      //hSelectedRechitsEBdeltavsCPU->Draw("COLZ");
-      hSelectedRechitsEBGPUCPUratio->Draw("");
-    }
-    cRechits.cd(6);
-    {
-      gPad->SetLogy();
-      //hSelectedRechitsEEdeltavsCPU->Draw("COLZ");
-      hSelectedRechitsEEGPUCPUratio->Draw("");
-    }
-    cRechits.SaveAs("ecal-rechits.root");
-    cRechits.SaveAs("ecal-rechits.png");
-
-    // Plotting the sizes of GPU vs CPU for each event of EB
-    cRechitsPositive.cd(1);
-    {
-      gPad->SetLogy();
-      hPositiveRechitsEBCPU->SetLineColor(kRed);
-      hPositiveRechitsEBCPU->SetLineWidth(2);
-      hPositiveRechitsEBCPU->Draw("");
-      hPositiveRechitsEBGPU->SetLineColor(kBlue);
-      hPositiveRechitsEBGPU->SetLineWidth(2);
-      hPositiveRechitsEBGPU->Draw("sames");
-      cRechitsPositive.Update();
-      auto stats = (TPaveStats *)hPositiveRechitsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechitsPositive.cd(4);
-    {
-      gPad->SetLogy();
-      hPositiveRechitsEECPU->SetLineColor(kRed);
-      hPositiveRechitsEECPU->SetLineWidth(2);
-      hPositiveRechitsEECPU->Draw("");
-      hPositiveRechitsEEGPU->SetLineColor(kBlue);
-      hPositiveRechitsEEGPU->SetLineWidth(2);
-      hPositiveRechitsEEGPU->Draw("sames");
-      cRechitsPositive.Update();
-      auto stats = (TPaveStats *)hPositiveRechitsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cRechitsPositive.cd(2);
-    {
-      gStyle->SetPalette(55);
-      hPositiveRechitsEBGPUvsCPU->Draw("COLZ");
-    }
-    cRechitsPositive.cd(5);
-    {
-      gStyle->SetPalette(55);
-      hPositiveRechitsEEGPUvsCPU->Draw("COLZ");
-    }
-    cRechitsPositive.cd(3);
-    {
-      gPad->SetLogy();
-      //hPositiveRechitsEBdeltavsCPU->Draw("COLZ");
-      hPositiveRechitsEBGPUCPUratio->Draw("");
-    }
-    cRechitsPositive.cd(6);
-    {
-      gPad->SetLogy();
-      //hPositiveRechitsEEdeltavsCPU->Draw("COLZ");
-      hPositiveRechitsEEGPUCPUratio->Draw("");
-    }
-    cRechitsPositive.SaveAs("ecal-rechits-positive.root");
-    cRechitsPositive.SaveAs("ecal-rechits-positive.png");
-
-    cEnergies.cd(1);
-    {
-      gPad->SetLogy();
-      hEnergiesEBCPU->SetLineColor(kBlack);
-      hEnergiesEBCPU->SetLineWidth(2);
-      hEnergiesEBCPU->Draw("");
-      hEnergiesEBGPU->SetLineColor(kBlue);
-      hEnergiesEBGPU->SetLineWidth(2);
-      hEnergiesEBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hEnergiesEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cEnergies.cd(4);
-    {
-      gPad->SetLogy();
-      hEnergiesEECPU->SetLineColor(kBlack);
-      hEnergiesEECPU->SetLineWidth(2);
-      hEnergiesEECPU->Draw("");
-      hEnergiesEEGPU->SetLineColor(kBlue);
-      hEnergiesEEGPU->SetLineWidth(2);
-      hEnergiesEEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hEnergiesEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cEnergies.cd(2);
-    { hEnergiesEBGPUvsCPU->Draw("COLZ"); }
-    cEnergies.cd(5);
-    { hEnergiesEEGPUvsCPU->Draw("COLZ"); }
-    cEnergies.cd(3);
-    {
-      gPad->SetLogy();
-      //hEnergiesEBdeltavsCPU->Draw("COLZ");
-      hEnergiesEBGPUCPUratio->Draw("");
-    }
-    cEnergies.cd(6);
-    {
-      gPad->SetLogy();
-      //hEnergiesEEdeltavsCPU->Draw("COLZ");
-      hEnergiesEEGPUCPUratio->Draw("");
-    }
-    cEnergies.SaveAs("ecal-energies.root");
-    cEnergies.SaveAs("ecal-energies.png");
-
-    cChi2.cd(1);
-    {
-      gPad->SetLogy();
-      hChi2EBCPU->SetLineColor(kBlack);
-      hChi2EBCPU->SetLineWidth(2);
-      hChi2EBCPU->Draw("");
-      hChi2EBGPU->SetLineColor(kBlue);
-      hChi2EBGPU->SetLineWidth(2);
-      hChi2EBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hChi2EBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cChi2.cd(4);
-    {
-      gPad->SetLogy();
-      hChi2EECPU->SetLineColor(kBlack);
-      hChi2EECPU->SetLineWidth(2);
-      hChi2EECPU->Draw("");
-      hChi2EEGPU->SetLineColor(kBlue);
-      hChi2EEGPU->SetLineWidth(2);
-      hChi2EEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hChi2EEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cChi2.cd(2);
-    { hChi2EBGPUvsCPU->Draw("COLZ"); }
-    cChi2.cd(5);
-    { hChi2EEGPUvsCPU->Draw("COLZ"); }
-    cChi2.cd(3);
-    {
-      gPad->SetLogy();
-      //hChi2EBdeltavsCPU->Draw("COLZ");
-      hChi2EBGPUCPUratio->Draw("");
-    }
-    cChi2.cd(6);
-    {
-      gPad->SetLogy();
-      //hChi2EEdeltavsCPU->Draw("COLZ");
-      hChi2EEGPUCPUratio->Draw("");
-    }
-    cChi2.SaveAs("ecal-chi2.root");
-    cChi2.SaveAs("ecal-chi2.png");
-
-    cFlags.cd(1);
-    {
-      gPad->SetLogy();
-      hFlagsEBCPU->SetLineColor(kBlack);
-      hFlagsEBCPU->SetLineWidth(2);
-      hFlagsEBCPU->Draw("");
-      hFlagsEBGPU->SetLineColor(kBlue);
-      hFlagsEBGPU->SetLineWidth(2);
-      hFlagsEBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hFlagsEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cFlags.cd(4);
-    {
-      gPad->SetLogy();
-      hFlagsEECPU->SetLineColor(kBlack);
-      hFlagsEECPU->SetLineWidth(2);
-      hFlagsEECPU->Draw("");
-      hFlagsEEGPU->SetLineColor(kBlue);
-      hFlagsEEGPU->SetLineWidth(2);
-      hFlagsEEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hFlagsEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cFlags.cd(2);
-    { hFlagsEBGPUvsCPU->Draw("COLZ"); }
-    cFlags.cd(5);
-    { hFlagsEEGPUvsCPU->Draw("COLZ"); }
-    cFlags.cd(3);
-    {
-      gPad->SetLogy();
-      //hFlagsEBdeltavsCPU->Draw("COLZ");
-      hFlagsEBGPUCPUratio->Draw("");
-    }
-    cFlags.cd(6);
-    {
-      gPad->SetLogy();
-      //hFlagsEEdeltavsCPU->Draw("COLZ");
-      hFlagsEEGPUCPUratio->Draw("");
-    }
-    cFlags.SaveAs("ecal-flags.root");
-    cFlags.SaveAs("ecal-flags.png");
-
-    cExtras.cd(1);
-    {
-      gPad->SetLogy();
-      hExtrasEBCPU->SetLineColor(kBlack);
-      hExtrasEBCPU->SetLineWidth(2);
-      hExtrasEBCPU->Draw("");
-      hExtrasEBGPU->SetLineColor(kBlue);
-      hExtrasEBGPU->SetLineWidth(2);
-      hExtrasEBGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hExtrasEBGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cExtras.cd(4);
-    {
-      gPad->SetLogy();
-      hExtrasEECPU->SetLineColor(kBlack);
-      hExtrasEECPU->SetLineWidth(2);
-      hExtrasEECPU->Draw("");
-      hExtrasEEGPU->SetLineColor(kBlue);
-      hExtrasEEGPU->SetLineWidth(2);
-      hExtrasEEGPU->Draw("sames");
-      gPad->Update();
-      auto stats = (TPaveStats *)hExtrasEEGPU->FindObject("stats");
-      auto y2 = stats->GetY2NDC();
-      auto y1 = stats->GetY1NDC();
-      stats->SetY2NDC(y1);
-      stats->SetY1NDC(y1 - (y2 - y1));
-    }
-    cExtras.cd(2);
-    { hExtrasEBGPUvsCPU->Draw("COLZ"); }
-    cExtras.cd(5);
-    { hExtrasEEGPUvsCPU->Draw("COLZ"); }
-    cExtras.cd(3);
-    {
-      gPad->SetLogy();
-      //hExtrasEBdeltavsCPU->Draw("COLZ");
-      hExtrasEBGPUCPUratio->Draw("");
-    }
-    cExtras.cd(6);
-    {
-      gPad->SetLogy();
-      //hExtrasEEdeltavsCPU->Draw("COLZ");
-      hExtrasEEGPUCPUratio->Draw("");
-    }
-    cExtras.SaveAs("ecal-extras.root");
-    cExtras.SaveAs("ecal-extras.png");
-  }
-
-  // Close all open files
-  rf.Close();
-  rfout.Write();
-  rfout.Close();
-
-  return 0;
-}
diff --git a/RecoLocalCalo/EcalRecProducers/BuildFile.xml b/RecoLocalCalo/EcalRecProducers/BuildFile.xml
index 4852e0b98d1f4..dd9e488b07f96 100644
--- a/RecoLocalCalo/EcalRecProducers/BuildFile.xml
+++ b/RecoLocalCalo/EcalRecProducers/BuildFile.xml
@@ -1,6 +1,5 @@
 <use name="clhep"/>
-<use name="cuda"/>
-<use name="CUDADataFormats/EcalRecHitSoA"/>
+<use name="eigen"/>
 <use name="FWCore/Framework"/>
 
 <export>
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
deleted file mode 100644
index 5a6bb0577c45c..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.cu
+++ /dev/null
@@ -1,487 +0,0 @@
-#include <cstdlib>
-#include <limits>
-
-#include <cuda.h>
-
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariances.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapes.h"
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelation.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalDigi/interface/EcalMGPASample.h"
-#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/Math/interface/approx_exp.h"
-#include "DataFormats/Math/interface/approx_log.h"
-#include "FWCore/Utilities/interface/CMSUnrollLoop.h"
-
-#include "AmplitudeComputationCommonKernels.h"
-#include "KernelHelpers.h"
-
-namespace ecal {
-  namespace multifit {
-
-    ///
-    /// assume kernel launch configuration is
-    /// (MAXSAMPLES * nchannels, blocks)
-    ///
-    __global__ void kernel_prep_1d_and_initialize(EcalPulseShape const* shapes_in,
-                                                  uint16_t const* digis_in_eb,
-                                                  uint32_t const* dids_eb,
-                                                  uint16_t const* digis_in_ee,
-                                                  uint32_t const* dids_ee,
-                                                  SampleVector* amplitudes,
-                                                  SampleVector* amplitudesForMinimizationEB,
-                                                  SampleVector* amplitudesForMinimizationEE,
-                                                  SampleGainVector* gainsNoise,
-                                                  float const* mean_x1,
-                                                  float const* mean_x12,
-                                                  float const* rms_x12,
-                                                  float const* mean_x6,
-                                                  float const* gain6Over1,
-                                                  float const* gain12Over6,
-                                                  bool* hasSwitchToGain6,
-                                                  bool* hasSwitchToGain1,
-                                                  bool* isSaturated,
-                                                  ::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,
-                                                  uint32_t const offsetForInputs,
-                                                  bool const gainSwitchUseMaxSampleEB,
-                                                  bool const gainSwitchUseMaxSampleEE,
-                                                  int const nchannels) {
-      constexpr bool dynamicPedestal = false;  //---- default to false, ok
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-      constexpr int sample_max = 5;
-      constexpr int full_pulse_max = 9;
-      int const tx = threadIdx.x + blockIdx.x * blockDim.x;
-      int const nchannels_per_block = blockDim.x / nsamples;
-      int const ch = tx / nsamples;
-      // for accessing input arrays
-      int const inputCh = ch >= offsetForInputs ? ch - offsetForInputs : ch;
-      int const inputTx = ch >= offsetForInputs ? tx - offsetForInputs * 10 : tx;
-      // eb is first and then ee
-      auto const* digis_in = ch >= offsetForInputs ? digis_in_ee : digis_in_eb;
-      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
-        // assume bool is 1 byte, should be quite safe
-        extern __shared__ char shared_mem[];
-        bool* shr_hasSwitchToGain6 = reinterpret_cast<bool*>(shared_mem);
-        bool* shr_hasSwitchToGain1 = shr_hasSwitchToGain6 + nchannels_per_block * nsamples;
-        bool* shr_hasSwitchToGain0 = shr_hasSwitchToGain1 + nchannels_per_block * nsamples;
-        bool* shr_isSaturated = shr_hasSwitchToGain0 + nchannels_per_block * nsamples;
-        bool* shr_hasSwitchToGain0_tmp = shr_isSaturated + nchannels_per_block * nsamples;
-        char* shr_counts = reinterpret_cast<char*>(shr_hasSwitchToGain0_tmp) + nchannels_per_block * nsamples;
-
-        //
-        // indices
-        //
-        auto const did = DetId{dids[inputCh]};
-        auto const isBarrel = did.subdetId() == EcalBarrel;
-        // TODO offset for ee, 0 for eb
-        auto const hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did.rawId())
-                                       : offsetForHashes + ecal::reconstruction::hashedIndexEE(did.rawId());
-
-        //
-        // pulse shape template
-
-        // will be used in the future for setting state
-        auto const rmsForChecking = rms_x12[hashedId];
-
-        //
-        // amplitudes
-        //
-        int const adc = ecalMGPA::adc(digis_in[inputTx]);
-        int const gainId = ecalMGPA::gainId(digis_in[inputTx]);
-        SampleVector::Scalar amplitude = 0.;
-        SampleVector::Scalar pedestal = 0.;
-        SampleVector::Scalar gainratio = 0.;
-
-        // store into shared mem for initialization
-        shr_hasSwitchToGain6[threadIdx.x] = gainId == EcalMgpaBitwiseGain6;
-        shr_hasSwitchToGain1[threadIdx.x] = gainId == EcalMgpaBitwiseGain1;
-        shr_hasSwitchToGain0_tmp[threadIdx.x] = gainId == EcalMgpaBitwiseGain0;
-        shr_hasSwitchToGain0[threadIdx.x] = shr_hasSwitchToGain0_tmp[threadIdx.x];
-        shr_counts[threadIdx.x] = 0;
-        __syncthreads();
-
-        // non-divergent branch (except for the last 4 threads)
-        if (threadIdx.x <= blockDim.x - 5) {
-          CMS_UNROLL_LOOP
-          for (int i = 0; i < 5; i++)
-            shr_counts[threadIdx.x] += shr_hasSwitchToGain0[threadIdx.x + i];
-        }
-        shr_isSaturated[threadIdx.x] = shr_counts[threadIdx.x] == 5;
-
-        //
-        // unrolled reductions
-        //
-        if (sample < 5) {
-          shr_hasSwitchToGain6[threadIdx.x] =
-              shr_hasSwitchToGain6[threadIdx.x] || shr_hasSwitchToGain6[threadIdx.x + 5];
-          shr_hasSwitchToGain1[threadIdx.x] =
-              shr_hasSwitchToGain1[threadIdx.x] || shr_hasSwitchToGain1[threadIdx.x + 5];
-
-          // duplication of hasSwitchToGain0 in order not to
-          // introduce another syncthreads
-          shr_hasSwitchToGain0_tmp[threadIdx.x] =
-              shr_hasSwitchToGain0_tmp[threadIdx.x] || shr_hasSwitchToGain0_tmp[threadIdx.x + 5];
-        }
-        __syncthreads();
-
-        if (sample < 2) {
-          // note, both threads per channel take value [3] twice to avoid another if
-          shr_hasSwitchToGain6[threadIdx.x] = shr_hasSwitchToGain6[threadIdx.x] ||
-                                              shr_hasSwitchToGain6[threadIdx.x + 2] ||
-                                              shr_hasSwitchToGain6[threadIdx.x + 3];
-          shr_hasSwitchToGain1[threadIdx.x] = shr_hasSwitchToGain1[threadIdx.x] ||
-                                              shr_hasSwitchToGain1[threadIdx.x + 2] ||
-                                              shr_hasSwitchToGain1[threadIdx.x + 3];
-
-          shr_hasSwitchToGain0_tmp[threadIdx.x] = shr_hasSwitchToGain0_tmp[threadIdx.x] ||
-                                                  shr_hasSwitchToGain0_tmp[threadIdx.x + 2] ||
-                                                  shr_hasSwitchToGain0_tmp[threadIdx.x + 3];
-
-          // sample < 2 -> first 2 threads of each channel will be used here
-          // => 0 -> will compare 3 and 4 and put into 0
-          // => 1 -> will compare 4 and 5 and put into 1
-          shr_isSaturated[threadIdx.x] = shr_isSaturated[threadIdx.x + 3] || shr_isSaturated[threadIdx.x + 4];
-        }
-        __syncthreads();
-
-        bool check_hasSwitchToGain0 = false;
-
-        if (sample == 0) {
-          shr_hasSwitchToGain6[threadIdx.x] =
-              shr_hasSwitchToGain6[threadIdx.x] || shr_hasSwitchToGain6[threadIdx.x + 1];
-          shr_hasSwitchToGain1[threadIdx.x] =
-              shr_hasSwitchToGain1[threadIdx.x] || shr_hasSwitchToGain1[threadIdx.x + 1];
-          shr_hasSwitchToGain0_tmp[threadIdx.x] =
-              shr_hasSwitchToGain0_tmp[threadIdx.x] || shr_hasSwitchToGain0_tmp[threadIdx.x + 1];
-
-          hasSwitchToGain6[ch] = shr_hasSwitchToGain6[threadIdx.x];
-          hasSwitchToGain1[ch] = shr_hasSwitchToGain1[threadIdx.x];
-
-          // set only for the threadIdx.x corresponding to sample==0
-          check_hasSwitchToGain0 = shr_hasSwitchToGain0_tmp[threadIdx.x];
-
-          shr_isSaturated[threadIdx.x + 3] = shr_isSaturated[threadIdx.x] || shr_isSaturated[threadIdx.x + 1];
-          isSaturated[ch] = shr_isSaturated[threadIdx.x + 3];
-        }
-
-        // TODO: w/o this sync, there is a race
-        // if (threadIdx == sample_max) below uses max sample thread, not for 0 sample
-        // check if we can remove it
-        __syncthreads();
-
-        // TODO: divergent branch
-        if (gainId == 0 || gainId == 3) {
-          pedestal = mean_x1[hashedId];
-          gainratio = gain6Over1[hashedId] * gain12Over6[hashedId];
-          gainsNoise[ch](sample) = 2;
-        } else if (gainId == 1) {
-          pedestal = mean_x12[hashedId];
-          gainratio = 1.;
-          gainsNoise[ch](sample) = 0;
-        } else if (gainId == 2) {
-          pedestal = mean_x6[hashedId];
-          gainratio = gain12Over6[hashedId];
-          gainsNoise[ch](sample) = 1;
-        }
-
-        // TODO: compile time constant -> branch should be non-divergent
-        if (dynamicPedestal)
-          amplitude = static_cast<SampleVector::Scalar>(adc) * gainratio;
-        else
-          amplitude = (static_cast<SampleVector::Scalar>(adc) - pedestal) * gainratio;
-        amplitudes[ch][sample] = amplitude;
-
-#ifdef ECAL_RECO_CUDA_DEBUG
-        printf("%d %d %d %d %f %f %f\n", tx, ch, sample, adc, amplitude, pedestal, gainratio);
-        if (adc == 0)
-          printf("adc is zero\n");
-#endif
-
-        //
-        // initialization
-        //
-        amplitudesForMinimization[inputCh](sample) = 0;
-        bxs[ch](sample) = sample - 5;
-
-        // select the thread for the max sample
-        //---> hardcoded above to be 5th sample, ok
-        if (sample == sample_max) {
-          //
-          // initialization
-          //
-          acState[ch] = static_cast<char>(MinimizationState::NotFinished);
-          energies[inputCh] = 0;
-          chi2[inputCh] = 0;
-          g_pedestal[inputCh] = 0;
-          uint32_t flag = 0;
-          dids_out[inputCh] = did.rawId();
-
-          // start of this channel in shared mem
-          int const chStart = threadIdx.x - sample_max;
-          // thread for the max sample in shared mem
-          int const threadMax = threadIdx.x;
-          auto const gainSwitchUseMaxSample = isBarrel ? gainSwitchUseMaxSampleEB : gainSwitchUseMaxSampleEE;
-
-          // this flag setting is applied to all of the cases
-          if (shr_hasSwitchToGain6[chStart])
-            flag |= 0x1 << EcalUncalibratedRecHit::kHasSwitchToGain6;
-          if (shr_hasSwitchToGain1[chStart])
-            flag |= 0x1 << EcalUncalibratedRecHit::kHasSwitchToGain1;
-
-          // this corresponds to cpu branching on lastSampleBeforeSaturation
-          // likely false
-          if (check_hasSwitchToGain0) {
-            // assign for the case some sample having gainId == 0
-            //energies[inputCh] = amplitudes[ch][sample_max];
-            energies[inputCh] = amplitude;
-
-            // check if samples before sample_max have true
-            bool saturated_before_max = false;
-            CMS_UNROLL_LOOP
-            for (char ii = 0; ii < 5; ii++)
-              saturated_before_max = saturated_before_max || shr_hasSwitchToGain0[chStart + ii];
-
-            // if saturation is in the max sample and not in the first 5
-            if (!saturated_before_max && shr_hasSwitchToGain0[threadMax])
-              energies[inputCh] = 49140;  // 4095 * 12 (maximum ADC range * MultiGainPreAmplifier (MGPA) gain)
-                                          // This is the actual maximum range that is set when we saturate.
-                                          //---- 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[inputCh] = flag;
-            return;
-          }
-
-          // according to cpu version
-          //            auto max_amplitude = amplitudes[ch][sample_max];
-          auto const max_amplitude = amplitude;
-          // according to cpu version
-          auto shape_value = shapes_in[hashedId].pdfval[full_pulse_max - 7];
-          // note, no syncing as the same thread will be accessing here
-          bool hasGainSwitch =
-              shr_hasSwitchToGain6[chStart] || shr_hasSwitchToGain1[chStart] || shr_isSaturated[chStart + 3];
-
-          // pedestal is final unconditionally
-          g_pedestal[inputCh] = pedestal;
-          if (hasGainSwitch && gainSwitchUseMaxSample) {
-            // thread for sample=0 will access the right guys
-            energies[inputCh] = max_amplitude / shape_value;
-            acState[ch] = static_cast<char>(MinimizationState::Precomputed);
-            flags[inputCh] = flag;
-            return;
-          }
-
-          // this happens cause sometimes rms_x12 is 0...
-          // needs to be checkec why this is the case
-          // general case here is that noisecov is a Zero matrix
-          if (rmsForChecking == 0) {
-            acState[ch] = static_cast<char>(MinimizationState::Precomputed);
-            flags[inputCh] = flag;
-            return;
-          }
-
-          // for the case when no shortcuts were taken
-          flags[inputCh] = flag;
-        }
-      }
-    }
-
-    ///
-    /// assume kernel launch configuration is
-    /// ([MAXSAMPLES, MAXSAMPLES], nchannels)
-    ///
-    __global__ void kernel_prep_2d(SampleGainVector const* gainNoise,
-                                   uint32_t const* dids_eb,
-                                   uint32_t const* dids_ee,
-                                   float const* rms_x12,
-                                   float const* rms_x6,
-                                   float const* rms_x1,
-                                   float const* gain12Over6,
-                                   float const* gain6Over1,
-                                   double const* G12SamplesCorrelationEB,
-                                   double const* G6SamplesCorrelationEB,
-                                   double const* G1SamplesCorrelationEB,
-                                   double const* G12SamplesCorrelationEE,
-                                   double const* G6SamplesCorrelationEE,
-                                   double const* G1SamplesCorrelationEE,
-                                   SampleMatrix* noisecov,
-                                   PulseMatrixType* pulse_matrix,
-                                   EcalPulseShape const* pulse_shape,
-                                   bool const* hasSwitchToGain6,
-                                   bool const* hasSwitchToGain1,
-                                   bool const* isSaturated,
-                                   uint32_t const offsetForHashes,
-                                   uint32_t const offsetForInputs) {
-      int const ch = blockIdx.x;
-      int const tx = threadIdx.x;
-      int const ty = threadIdx.y;
-      constexpr float addPedestalUncertainty = 0.f;
-      constexpr bool dynamicPedestal = false;
-      constexpr bool simplifiedNoiseModelForGainSwitch = true;  //---- default is true
-
-      // to access input arrays (ids and digis only)
-      int const inputCh = ch >= offsetForInputs ? ch - offsetForInputs : ch;
-      auto const* dids = ch >= offsetForInputs ? dids_ee : dids_eb;
-
-      bool tmp0 = hasSwitchToGain6[ch];
-      bool tmp1 = hasSwitchToGain1[ch];
-      auto const did = DetId{dids[inputCh]};
-      auto const isBarrel = did.subdetId() == EcalBarrel;
-      auto const hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did.rawId())
-                                     : offsetForHashes + ecal::reconstruction::hashedIndexEE(did.rawId());
-      auto const G12SamplesCorrelation = isBarrel ? G12SamplesCorrelationEB : G12SamplesCorrelationEE;
-      auto const* G6SamplesCorrelation = isBarrel ? G6SamplesCorrelationEB : G6SamplesCorrelationEE;
-      auto const* G1SamplesCorrelation = isBarrel ? G1SamplesCorrelationEB : G1SamplesCorrelationEE;
-      bool tmp2 = isSaturated[ch];
-      bool hasGainSwitch = tmp0 || tmp1 || tmp2;
-      auto const vidx = std::abs(ty - tx);
-
-      // non-divergent branch for all threads per block
-      if (hasGainSwitch) {
-        // TODO: did not include simplified noise model
-        float noise_value = 0;
-
-        // non-divergent branch - all threads per block
-        // TODO: all of these constants indicate that
-        // that these parts could be splitted into completely different
-        // kernels and run one of them only depending on the config
-        if (simplifiedNoiseModelForGainSwitch) {
-          int isample_max = 5;  // according to cpu defs
-          int gainidx = gainNoise[ch][isample_max];
-
-          // non-divergent branches
-          if (gainidx == 0)
-            noise_value = rms_x12[hashedId] * rms_x12[hashedId] * G12SamplesCorrelation[vidx];
-          if (gainidx == 1)
-            noise_value = gain12Over6[hashedId] * gain12Over6[hashedId] * rms_x6[hashedId] * rms_x6[hashedId] *
-                          G6SamplesCorrelation[vidx];
-          if (gainidx == 2)
-            noise_value = gain12Over6[hashedId] * gain12Over6[hashedId] * gain6Over1[hashedId] * gain6Over1[hashedId] *
-                          rms_x1[hashedId] * rms_x1[hashedId] * G1SamplesCorrelation[vidx];
-          if (!dynamicPedestal && addPedestalUncertainty > 0.f)
-            noise_value += addPedestalUncertainty * addPedestalUncertainty;
-        } else {
-          int gainidx = 0;
-          char mask = gainidx;
-          int pedestal = gainNoise[ch][ty] == mask ? 1 : 0;
-          //            NB: gainratio is 1, that is why it does not appear in the formula
-          noise_value += rms_x12[hashedId] * rms_x12[hashedId] * pedestal * G12SamplesCorrelation[vidx];
-          // non-divergent branch
-          if (!dynamicPedestal && addPedestalUncertainty > 0.f) {
-            noise_value += addPedestalUncertainty * addPedestalUncertainty * pedestal;  // gainratio is 1
-          }
-
-          //
-          gainidx = 1;
-          mask = gainidx;
-          pedestal = gainNoise[ch][ty] == mask ? 1 : 0;
-          noise_value += gain12Over6[hashedId] * gain12Over6[hashedId] * rms_x6[hashedId] * rms_x6[hashedId] *
-                         pedestal * G6SamplesCorrelation[vidx];
-          // non-divergent branch
-          if (!dynamicPedestal && addPedestalUncertainty > 0.f) {
-            noise_value += gain12Over6[hashedId] * gain12Over6[hashedId] * addPedestalUncertainty *
-                           addPedestalUncertainty * pedestal;
-          }
-
-          //
-          gainidx = 2;
-          mask = gainidx;
-          pedestal = gainNoise[ch][ty] == mask ? 1 : 0;
-          float tmp = gain6Over1[hashedId] * gain12Over6[hashedId];
-          noise_value += tmp * tmp * rms_x1[hashedId] * rms_x1[hashedId] * pedestal * G1SamplesCorrelation[vidx];
-          // non-divergent branch
-          if (!dynamicPedestal && addPedestalUncertainty > 0.f) {
-            noise_value += tmp * tmp * addPedestalUncertainty * addPedestalUncertainty * pedestal;
-          }
-        }
-
-        noisecov[ch](ty, tx) = noise_value;
-      } else {
-        auto rms = rms_x12[hashedId];
-        float noise_value = rms * rms * G12SamplesCorrelation[vidx];
-        if (!dynamicPedestal && addPedestalUncertainty > 0.f) {
-          //----  add fully correlated component to noise covariance to inflate pedestal uncertainty
-          noise_value += addPedestalUncertainty * addPedestalUncertainty;
-        }
-        noisecov[ch](ty, tx) = noise_value;
-      }
-
-      // pulse matrix
-      int const posToAccess = 9 - tx + ty;  // see cpu for reference
-      float const value = posToAccess >= 7 ? pulse_shape[hashedId].pdfval[posToAccess - 7] : 0;
-      pulse_matrix[ch](ty, tx) = value;
-    }
-
-    __global__ void kernel_permute_results(SampleVector* amplitudes,
-                                           BXVectorType const* activeBXs,
-                                           ::ecal::reco::StorageScalarType* energies,
-                                           char const* acState,
-                                           int const nchannels) {
-      // constants
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      int const tx = threadIdx.x + blockIdx.x * blockDim.x;
-      int const ch = tx / nsamples;
-      int const sampleidx = tx % nsamples;  // this is to address activeBXs
-
-      if (ch >= nchannels)
-        return;
-
-      // channels that have amplitude precomputed do not need results to be permuted
-      auto const state = static_cast<MinimizationState>(acState[ch]);
-      if (state == MinimizationState::Precomputed)
-        return;
-
-      // configure shared memory and cp into it
-      extern __shared__ char smem[];
-      SampleVector::Scalar* values = reinterpret_cast<SampleVector::Scalar*>(smem);
-      values[threadIdx.x] = amplitudes[ch](sampleidx);
-      __syncthreads();
-
-      // get the sample for this bx
-      auto const sample = static_cast<int>(activeBXs[ch](sampleidx)) + 5;
-
-      // store back to global
-      amplitudes[ch](sample) = values[threadIdx.x];
-
-      // store sample 5 separately
-      // only for the case when minimization was performed
-      // not for cases with precomputed amplitudes
-      if (sample == 5)
-        energies[ch] = values[threadIdx.x];
-    }
-
-  }  // namespace multifit
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
deleted file mode 100644
index 20495ebf49be5..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationCommonKernels.h
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationCommonKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationCommonKernels_h
-
-#include "RecoLocalCalo/EcalRecProducers/interface/EigenMatrixTypes_gpu.h"
-#include "DeclsForKernels.h"
-
-class EcalPulseShape;
-// this flag setting is applied to all of the cases
-class EcalPulseCovariance;
-class EcalUncalibratedRecHit;
-
-namespace ecal {
-  namespace multifit {
-
-    ///
-    /// assume kernel launch configuration is
-    /// (MAXSAMPLES * nchannels, blocks)
-    /// TODO: is there a point to split this kernel further to separate reductions
-    ///
-    __global__ void kernel_prep_1d_and_initialize(EcalPulseShape const* shapes_in,
-                                                  uint16_t const* digis_in_eb,
-                                                  uint32_t const* dids_eb,
-                                                  uint16_t const* digis_in_ee,
-                                                  uint32_t const* dids_ee,
-                                                  SampleVector* amplitudes,
-                                                  SampleVector* amplitudesForMinimizationEB,
-                                                  SampleVector* amplitudesForMinimizationEE,
-                                                  SampleGainVector* gainsNoise,
-                                                  float const* mean_x1,
-                                                  float const* mean_x12,
-                                                  float const* rms_x12,
-                                                  float const* mean_x6,
-                                                  float const* gain6Over1,
-                                                  float const* gain12Over6,
-                                                  bool* hasSwitchToGain6,
-                                                  bool* hasSwitchToGain1,
-                                                  bool* isSaturated,
-                                                  ::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,
-                                                  uint32_t const offsetForInputs,
-                                                  bool const gainSwitchUseMaxSampleEB,
-                                                  bool const gainSwitchUseMaxSampleEE,
-                                                  int const nchannels);
-
-    ///
-    /// assume kernel launch configuration is
-    /// ([MAXSAMPLES, MAXSAMPLES], nchannels)
-    ///
-    __global__ void kernel_prep_2d(SampleGainVector const* gainNoise,
-                                   uint32_t const* dids_eb,
-                                   uint32_t const* dids_ee,
-                                   float const* rms_x12,
-                                   float const* rms_x6,
-                                   float const* rms_x1,
-                                   float const* gain12Over6,
-                                   float const* gain6Over1,
-                                   double const* G12SamplesCorrelationEB,
-                                   double const* G6SamplesCorrelationEB,
-                                   double const* G1SamplesCorrelationEB,
-                                   double const* G12SamplesCorrelationEE,
-                                   double const* G6SamplesCorrelationEE,
-                                   double const* G1SamplesCorrelationEE,
-                                   SampleMatrix* noisecov,
-                                   PulseMatrixType* pulse_matrix,
-                                   EcalPulseShape const* pulse_shape,
-                                   bool const* hasSwitchToGain6,
-                                   bool const* hasSwitchToGain1,
-                                   bool const* isSaturated,
-                                   uint32_t const offsetForHashes,
-                                   uint32_t const offsetForInputs);
-
-    __global__ void kernel_permute_results(SampleVector* amplitudes,
-                                           BXVectorType const* activeBXs,
-                                           ::ecal::reco::StorageScalarType* energies,
-                                           char const* acState,
-                                           int const nchannels);
-
-///
-/// 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);
-#endif  // RUN_BUILD_AOS_RECHIT
-
-  }  // namespace multifit
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationCommonKernels_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
deleted file mode 100644
index e5eff86d15ec7..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.cu
+++ /dev/null
@@ -1,305 +0,0 @@
-#include <cmath>
-#include <limits>
-
-#include <cuda.h>
-
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariances.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapes.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/Math/interface/approx_exp.h"
-#include "DataFormats/Math/interface/approx_log.h"
-#include "FWCore/Utilities/interface/CMSUnrollLoop.h"
-
-#include "AmplitudeComputationCommonKernels.h"
-#include "AmplitudeComputationKernels.h"
-#include "KernelHelpers.h"
-
-namespace ecal {
-  namespace multifit {
-
-    template <typename MatrixType>
-    __device__ __forceinline__ bool update_covariance(EcalPulseCovariance const& pulse_covariance,
-                                                      MatrixType& inverse_cov,
-                                                      SampleVector const& amplitudes) {
-      constexpr int nsamples = SampleVector::RowsAtCompileTime;
-      constexpr int npulses = BXVectorType::RowsAtCompileTime;
-
-      CMS_UNROLL_LOOP
-      for (unsigned int ipulse = 0; ipulse < npulses; ipulse++) {
-        auto const amplitude = amplitudes.coeff(ipulse);
-        if (amplitude == 0)
-          continue;
-
-        // FIXME: ipulse - 5 -> ipulse - firstOffset
-        int bx = ipulse - 5;
-        int first_sample_t = std::max(0, bx + 3);
-        int offset = -3 - bx;
-
-        auto const value_sq = amplitude * amplitude;
-
-        for (int col = first_sample_t; col < nsamples; col++) {
-          for (int row = col; row < nsamples; row++) {
-            inverse_cov(row, col) += value_sq * __ldg(&pulse_covariance.covval[row + offset][col + offset]);
-          }
-        }
-      }
-
-      return true;
-    }
-
-    ///
-    /// launch ctx parameters are (nchannels / block, blocks)
-    /// TODO: trivial impl for now, there must be a way to improve
-    ///
-    /// Conventions:
-    ///   - amplitudes -> solution vector, what we are fitting for
-    ///   - samples -> raw detector responses
-    ///   - passive constraint - satisfied constraint
-    ///   - active constraint - unsatisfied (yet) constraint
-    ///
-    __global__ void kernel_minimize(uint32_t const* dids_eb,
-                                    uint32_t const* dids_ee,
-                                    SampleMatrix const* __restrict__ noisecov,
-                                    EcalPulseCovariance const* __restrict__ pulse_covariance,
-                                    BXVectorType* bxs,
-                                    SampleVector const* __restrict__ samples,
-                                    SampleVector* amplitudesEB,
-                                    SampleVector* amplitudesEE,
-                                    PulseMatrixType const* __restrict__ pulse_matrix,
-                                    ::ecal::reco::StorageScalarType* chi2sEB,
-                                    ::ecal::reco::StorageScalarType* chi2sEE,
-                                    ::ecal::reco::StorageScalarType* energiesEB,
-                                    ::ecal::reco::StorageScalarType* energiesEE,
-                                    char* acState,
-                                    int nchannels,
-                                    int max_iterations,
-                                    uint32_t const offsetForHashes,
-                                    uint32_t const offsetForInputs) {
-      // 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::ColsAtCompileTime;
-      static_assert(NSAMPLES == NPULSES);
-
-      using DataType = SampleVector::Scalar;
-
-      extern __shared__ char shrmem[];
-      DataType* shrMatrixLForFnnlsStorage =
-          reinterpret_cast<DataType*>(shrmem) + calo::multifit::MapSymM<DataType, NPULSES>::total * threadIdx.x;
-      DataType* shrAtAStorage = reinterpret_cast<DataType*>(shrmem) +
-                                calo::multifit::MapSymM<DataType, NPULSES>::total * (threadIdx.x + blockDim.x);
-
-      // channel
-      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
-
-      if (idx < nchannels) {
-        if (static_cast<MinimizationState>(acState[idx]) == MinimizationState::Precomputed)
-          return;
-
-        // get the hash
-        int const inputCh = idx >= offsetForInputs ? idx - offsetForInputs : idx;
-        auto const* dids = idx >= offsetForInputs ? dids_ee : dids_eb;
-        auto const did = DetId{dids[inputCh]};
-        auto const isBarrel = did.subdetId() == EcalBarrel;
-        auto const hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did.rawId())
-                                       : offsetForHashes + ecal::reconstruction::hashedIndexEE(did.rawId());
-
-        // inits
-        int iter = 0;
-        int npassive = 0;
-
-        calo::multifit::ColumnVector<NPULSES, int> pulseOffsets;
-        CMS_UNROLL_LOOP
-        for (int i = 0; i < NPULSES; ++i)
-          pulseOffsets(i) = i;
-
-        calo::multifit::ColumnVector<NPULSES, DataType> resultAmplitudes;
-        CMS_UNROLL_LOOP
-        for (int counter = 0; counter < NPULSES; counter++)
-          resultAmplitudes(counter) = 0;
-
-        // inits
-        //SampleDecompLLT covariance_decomposition;
-        //SampleMatrix inverse_cov;
-        //        SampleVector::Scalar chi2 = 0, chi2_now = 0;
-        float chi2 = 0, chi2_now = 0;
-
-        // loop until ocnverge
-        while (true) {
-          if (iter >= max_iterations)
-            break;
-
-          //inverse_cov = noisecov[idx];
-          //DataType covMatrixStorage[MapSymM<DataType, NSAMPLES>::total];
-          DataType* covMatrixStorage = shrMatrixLForFnnlsStorage;
-          calo::multifit::MapSymM<DataType, NSAMPLES> covMatrix{covMatrixStorage};
-          int counter = 0;
-          CMS_UNROLL_LOOP
-          for (int col = 0; col < NSAMPLES; col++) {
-            CMS_UNROLL_LOOP
-            for (int row = col; row < NSAMPLES; row++)
-              covMatrixStorage[counter++] = __ldg(&noisecov[idx].coeffRef(row, col));
-          }
-          update_covariance(pulse_covariance[hashedId], covMatrix, resultAmplitudes);
-
-          // compute actual covariance decomposition
-          //covariance_decomposition.compute(inverse_cov);
-          //auto const& matrixL = covariance_decomposition.matrixL();
-          DataType matrixLStorage[calo::multifit::MapSymM<DataType, NSAMPLES>::total];
-          calo::multifit::MapSymM<DataType, NSAMPLES> matrixL{matrixLStorage};
-          calo::multifit::compute_decomposition_unrolled(matrixL, covMatrix);
-
-          // L * A = P
-          calo::multifit::ColMajorMatrix<NSAMPLES, NPULSES> A;
-          calo::multifit::solve_forward_subst_matrix(A, pulse_matrix[idx], matrixL);
-
-          // L b = s
-          float reg_b[NSAMPLES];
-          calo::multifit::solve_forward_subst_vector(reg_b, samples[idx], matrixL);
-
-          // FIXME: shared mem
-          //DataType AtAStorage[MapSymM<DataType, NPULSES>::total];
-          calo::multifit::MapSymM<DataType, NPULSES> AtA{shrAtAStorage};
-          //SampleMatrix AtA;
-          SampleVector Atb;
-          CMS_UNROLL_LOOP
-          for (int icol = 0; icol < NPULSES; icol++) {
-            float reg_ai[NSAMPLES];
-
-            // load column icol
-            CMS_UNROLL_LOOP
-            for (int counter = 0; counter < NSAMPLES; counter++)
-              reg_ai[counter] = A(counter, icol);
-
-            // compute diagoanl
-            float sum = 0.f;
-            CMS_UNROLL_LOOP
-            for (int counter = 0; counter < NSAMPLES; counter++)
-              sum += reg_ai[counter] * reg_ai[counter];
-
-            // store
-            AtA(icol, icol) = sum;
-
-            // go thru the other columns
-            CMS_UNROLL_LOOP
-            for (int j = icol + 1; j < NPULSES; j++) {
-              // load column j
-              float reg_aj[NSAMPLES];
-              CMS_UNROLL_LOOP
-              for (int counter = 0; counter < NSAMPLES; counter++)
-                reg_aj[counter] = A(counter, j);
-
-              // accum
-              float sum = 0.f;
-              CMS_UNROLL_LOOP
-              for (int counter = 0; counter < NSAMPLES; counter++)
-                sum += reg_aj[counter] * reg_ai[counter];
-
-              // store
-              //AtA(icol, j) = sum;
-              AtA(j, icol) = sum;
-            }
-
-            // Atb accum
-            float sum_atb = 0.f;
-            CMS_UNROLL_LOOP
-            for (int counter = 0; counter < NSAMPLES; counter++)
-              sum_atb += reg_ai[counter] * reg_b[counter];
-
-            // store atb
-            Atb(icol) = sum_atb;
-          }
-
-          // FIXME: shared mem
-          //DataType matrixLForFnnlsStorage[MapSymM<DataType, NPULSES>::total];
-          calo::multifit::MapSymM<DataType, NPULSES> matrixLForFnnls{shrMatrixLForFnnlsStorage};
-
-          calo::multifit::fnnls(AtA,
-                                Atb,
-                                //amplitudes[idx],
-                                resultAmplitudes,
-                                npassive,
-                                pulseOffsets,
-                                matrixLForFnnls,
-                                1e-11,
-                                500,
-                                16,
-                                2);
-
-          calo::multifit::calculateChiSq(matrixL, pulse_matrix[idx], resultAmplitudes, samples[idx], chi2_now);
-
-          auto deltachi2 = chi2_now - chi2;
-          chi2 = chi2_now;
-
-          if (std::abs(deltachi2) < 1e-3)
-            break;
-
-          //---- AM: TEST
-          //---- it was 3 lines above, now here as in the CPU version
-          ++iter;
-        }
-
-        // store to global output values
-        // FIXME: amplitudes are used in global directly
-        chi2s[inputCh] = chi2;
-        energies[inputCh] = resultAmplitudes(5);
-
-        CMS_UNROLL_LOOP
-        for (int counter = 0; counter < NPULSES; counter++)
-          amplitudes[inputCh](counter) = resultAmplitudes(counter);
-      }
-    }
-
-    namespace v1 {
-
-      void minimization_procedure(EventInputDataGPU const& eventInputGPU,
-                                  EventOutputDataGPU& eventOutputGPU,
-                                  EventDataForScratchGPU& scratch,
-                                  ConditionsProducts const& conditions,
-                                  ConfigurationParameters const& configParameters,
-                                  cudaStream_t cudaStream) {
-        using DataType = SampleVector::Scalar;
-        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.size;
-        auto const nbytesShared = 2 * threads_min *
-                                  calo::multifit::MapSymM<DataType, SampleVector::RowsAtCompileTime>::total *
-                                  sizeof(DataType);
-        kernel_minimize<<<blocks_min, threads_min, nbytesShared, cudaStream>>>(
-            eventInputGPU.ebDigis.ids.get(),
-            eventInputGPU.eeDigis.ids.get(),
-            (SampleMatrix*)scratch.noisecov.get(),
-            conditions.pulseCovariances.values,
-            (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,
-            offsetForInputs);
-        cudaCheck(cudaGetLastError());
-      }
-
-    }  // namespace v1
-
-  }  // namespace multifit
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.h
deleted file mode 100644
index 762de114c4a6a..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/AmplitudeComputationKernels.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationKernels_h
-
-#include "RecoLocalCalo/EcalRecProducers/interface/EigenMatrixTypes_gpu.h"
-#include "DeclsForKernels.h"
-
-class EcalPulseShape;
-class EcalPulseCovariance;
-class EcalUncalibratedRecHit;
-
-namespace ecal {
-  namespace multifit {
-
-    namespace v1 {
-
-      void minimization_procedure(EventInputDataGPU const& eventInputGPU,
-                                  EventOutputDataGPU& eventOutputGPU,
-                                  EventDataForScratchGPU& scratch,
-                                  ConditionsProducts const& conditions,
-                                  ConfigurationParameters const& configParameters,
-                                  cudaStream_t cudaStream);
-
-    }
-
-  }  // namespace multifit
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_AmplitudeComputationKernels_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml b/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
index 40ad5ade53326..a8960fb5ec018 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
+++ b/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
@@ -12,19 +12,11 @@
 <use name="RecoLocalCalo/EcalRecAlgos"/>
 <use name="RecoLocalCalo/EcalRecProducers"/>
 <use name="SimCalorimetry/EcalSimAlgos"/>
-<iftool name="cuda-gcc-support">
-  <use name="cuda"/>
-  <set name="cuda_src" value="*.cu"/>
-<else/>
-  <set name="cuda_src" value=""/>
-</iftool>
-<library file="*.cc ${cuda_src}" name="RecoLocalCaloEcalRecProducersPlugins">
-  <use name="HeterogeneousCore/CUDACore"/>
-  <use name="HeterogeneousCore/CUDAUtilities"/>
+
+<library file="*.cc" name="RecoLocalCaloEcalRecProducersPlugins">
   <flags EDM_PLUGIN="1"/>
 </library>
 
-
 <library file="alpaka/*.cc" name="RecoLocalCaloEcalRecProducersPluginsPortable">
   <use name="alpaka"/>
   <use name="HeterogeneousCore/AlpakaCore"/>
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
deleted file mode 100644
index 68bbc3400f23c..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernels.h
+++ /dev/null
@@ -1,324 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernels_h
-
-#include <vector>
-
-#include <cuda.h>
-#include <cuda_runtime.h>
-
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
-#include "CondFormats/EcalObjects/interface/EcalChannelStatusCode.h"
-#include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
-#include "CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPedestals.h"
-#include "CondFormats/EcalObjects/interface/EcalPedestalsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrections.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
-#include "CondFormats/EcalObjects/interface/EcalWeightSet.h"
-#include "DataFormats/EcalRecHit/interface/RecoTypes.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-#include "RecoLocalCalo/EcalRecProducers/interface/EigenMatrixTypes_gpu.h"
-
-struct EcalPulseShape;
-class EcalSampleMask;
-class EcalTimeBiasCorrections;
-struct EcalPulseCovariance;
-class EcalDigiCollection;
-class EcalXtalGroupId;
-class EcalSamplesCorrelation;
-class EBDigiCollection;
-class EEDigiCollection;
-
-namespace ecal {
-  namespace multifit {
-
-    enum class TimeComputationState : char { NotFinished = 0, Finished = 1 };
-    enum class MinimizationState : char {
-      NotFinished = 0,
-      Finished = 1,
-      Precomputed = 2,
-    };
-
-    //
-    struct EventInputDataGPU {
-      ecal::DigisCollection<calo::common::DevStoragePolicy> const& ebDigis;
-      ecal::DigisCollection<calo::common::DevStoragePolicy> const& eeDigis;
-    };
-
-    // parameters have a fixed type
-    // Can we go by with single precision
-    struct ConfigurationParameters {
-      using type = double;
-      // device ptrs
-      const type *amplitudeFitParametersEB = nullptr, *amplitudeFitParametersEE = nullptr;
-
-      uint32_t timeFitParametersSizeEB, timeFitParametersSizeEE;
-      // device ptrs
-      const type *timeFitParametersEB = nullptr, *timeFitParametersEE = nullptr;
-
-      type timeFitLimitsFirstEB, timeFitLimitsFirstEE;
-      type timeFitLimitsSecondEB, timeFitLimitsSecondEE;
-
-      type timeConstantTermEB, timeConstantTermEE;
-
-      type timeNconstEB, timeNconstEE;
-
-      type amplitudeThreshEE, amplitudeThreshEB;
-
-      type outOfTimeThreshG12pEB, outOfTimeThreshG12mEB;
-      type outOfTimeThreshG12pEE, outOfTimeThreshG12mEE;
-      type outOfTimeThreshG61pEE, outOfTimeThreshG61mEE;
-      type outOfTimeThreshG61pEB, outOfTimeThreshG61mEB;
-
-      std::array<uint32_t, 3> kernelMinimizeThreads;
-
-      bool shouldRunTimingComputation;
-    };
-
-    struct EventOutputDataGPU {
-      UncalibratedRecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
-
-      void allocate(ConfigurationParameters const& configParameters,
-                    uint32_t sizeEB,
-                    uint32_t sizeEE,
-                    cudaStream_t cudaStream) {
-        recHitsEB.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(
-            sizeEB * EcalDataFrame::MAXSAMPLES, cudaStream);
-        recHitsEB.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
-        recHitsEB.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
-        recHitsEB.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
-
-        if (configParameters.shouldRunTimingComputation) {
-          recHitsEB.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
-          recHitsEB.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEB, cudaStream);
-        }
-
-        recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
-        recHitsEB.flags = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
-
-        recHitsEE.amplitudesAll = cms::cuda::make_device_unique<reco::ComputationScalarType[]>(
-            sizeEE * EcalDataFrame::MAXSAMPLES, cudaStream);
-        recHitsEE.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
-        recHitsEE.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
-        recHitsEE.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
-
-        if (configParameters.shouldRunTimingComputation) {
-          recHitsEE.jitter = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
-          recHitsEE.jitterError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(sizeEE, cudaStream);
-        }
-
-        recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
-        recHitsEE.flags = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
-      }
-    };
-
-    template <typename EigenM>
-    constexpr auto getLength() -> uint32_t {
-      return EigenM::RowsAtCompileTime * EigenM::ColsAtCompileTime;
-    }
-
-    struct EventDataForScratchGPU {
-      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,
-                    uint32_t sizeEB,
-                    uint32_t sizeEE,
-                    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 = sizeEB + sizeEE;
-
-        auto alloc = [cudaStream](auto& var, uint32_t size) {
-          using element_type = typename std::remove_reference_t<decltype(var)>::element_type;
-          var = cms::cuda::make_device_unique<element_type[]>(size, cudaStream);
-        };
-
-        alloc(samples, size * svlength);
-        alloc(gainsNoise, size * sgvlength);
-
-        alloc(noisecov, size * smlength);
-        alloc(pulse_matrix, size * pmlength);
-        alloc(activeBXs, size * bxvlength);
-        alloc(acState, size);
-
-        alloc(hasSwitchToGain6, size);
-        alloc(hasSwitchToGain1, size);
-        alloc(isSaturated, size);
-
-        if (configParameters.shouldRunTimingComputation) {
-          alloc(sample_values, size * svlength);
-          alloc(sample_value_errors, size * svlength);
-          alloc(useless_sample_values, size * EcalDataFrame::MAXSAMPLES);
-          alloc(chi2sNullHypot, size);
-          alloc(sum0sNullHypot, size);
-          alloc(sumAAsNullHypot, size);
-          alloc(pedestal_nums, size);
-
-          alloc(tMaxAlphaBetas, size);
-          alloc(tMaxErrorAlphaBetas, size);
-          alloc(accTimeMax, size);
-          alloc(accTimeWgt, size);
-          alloc(ampMaxAlphaBeta, size);
-          alloc(ampMaxError, size);
-          alloc(timeMax, size);
-          alloc(timeError, size);
-          alloc(tcState, size);
-        }
-      }
-    };
-
-    // const refs products to conditions
-    struct ConditionsProducts {
-      EcalPedestalsGPU::Product const& pedestals;
-      EcalGainRatiosGPU::Product const& gainRatios;
-      EcalPulseShapesGPU::Product const& pulseShapes;
-      EcalPulseCovariancesGPU::Product const& pulseCovariances;
-      EcalSamplesCorrelationGPU::Product const& samplesCorrelation;
-      EcalTimeBiasCorrectionsGPU::Product const& timeBiasCorrections;
-      EcalTimeCalibConstantsGPU::Product const& timeCalibConstants;
-      EcalSampleMask const& sampleMask;
-      EcalTimeOffsetConstant const& timeOffsetConstant;
-      uint32_t offsetForHashes;
-      EcalMultifitParametersGPU::Product const& multifitParameters;
-    };
-
-    struct xyz {
-      int x, y, z;
-    };
-
-    struct conf_data {
-      xyz threads;
-      bool runV1;
-      cudaStream_t cuStream;
-    };
-
-  }  // namespace multifit
-}  // namespace ecal
-
-//
-// ECAL Rechit producer
-//
-
-namespace ecal {
-  namespace rechit {
-
-    // parameters that are read in the configuration file for rechit producer
-    struct ConfigurationParameters {
-      // device ptrs
-      const int* ChannelStatusToBeExcluded = nullptr;
-      uint32_t ChannelStatusToBeExcludedSize;
-
-      bool killDeadChannels;
-
-      bool recoverEBIsolatedChannels;
-      bool recoverEEIsolatedChannels;
-      bool recoverEBVFE;
-      bool recoverEEVFE;
-      bool recoverEBFE;
-      bool recoverEEFE;
-
-      float EBLaserMIN;
-      float EELaserMIN;
-      float EBLaserMAX;
-      float EELaserMAX;
-
-      const int* expanded_v_DB_reco_flags;
-      const uint32_t* expanded_Sizes_v_DB_reco_flags;
-      const uint32_t* expanded_flagbit_v_DB_reco_flags;
-      uint32_t expanded_v_DB_reco_flagsSize;
-
-      uint32_t flagmask;
-    };
-
-    struct EventOutputDataGPU {
-      RecHit<::calo::common::DevStoragePolicy> recHitsEB, recHitsEE;
-
-      void allocate(ConfigurationParameters const& configParameters,
-                    uint32_t sizeEB,
-                    uint32_t sizeEE,
-                    cudaStream_t cudaStream) {
-        //---- configParameters -> needed only to decide if to save the timing information or not
-        recHitsEB.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
-        recHitsEB.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
-        recHitsEB.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEB, cudaStream);
-        recHitsEB.flagBits = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
-        recHitsEB.extra = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
-        recHitsEB.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEB, cudaStream);
-
-        recHitsEE.energy = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
-        recHitsEE.time = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
-        recHitsEE.chi2 = cms::cuda::make_device_unique<::ecal::reco::StorageScalarType[]>(sizeEE, cudaStream);
-        recHitsEE.flagBits = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
-        recHitsEE.extra = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
-        recHitsEE.did = cms::cuda::make_device_unique<uint32_t[]>(sizeEE, cudaStream);
-      }
-    };
-
-    struct EventInputDataGPU {
-      ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& ebUncalibRecHits;
-      ecal::UncalibratedRecHit<calo::common::DevStoragePolicy> const& eeUncalibRecHits;
-    };
-
-    // const refs products to conditions
-    struct ConditionsProducts {
-      EcalRechitADCToGeVConstantGPU::Product const& ADCToGeV;
-      EcalIntercalibConstantsGPU::Product const& Intercalib;
-      EcalRechitChannelStatusGPU::Product const& ChannelStatus;
-
-      EcalLaserAPDPNRatiosGPU::Product const& LaserAPDPNRatios;
-      EcalLaserAPDPNRatiosRefGPU::Product const& LaserAPDPNRatiosRef;
-      EcalLaserAlphasGPU::Product const& LaserAlphas;
-      EcalLinearCorrectionsGPU::Product const& LinearCorrections;
-
-      uint32_t offsetForHashes;
-    };
-
-  }  // namespace rechit
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernels_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernelsPhase2.h b/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernelsPhase2.h
deleted file mode 100644
index 6e52962706ee4..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/DeclsForKernelsPhase2.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernelsPhase2_h
-#define RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernelsPhase2_h
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h"
-
-namespace ecal {
-  namespace weights {
-
-    struct EventOutputDataGPU {
-      UncalibratedRecHit<::calo::common::DevStoragePolicy> recHits;
-
-      void allocate(uint32_t digi_size, cudaStream_t cudaStream) {
-        auto const size = digi_size;
-        recHits.amplitudesAll =
-            cms::cuda::make_device_unique<reco::ComputationScalarType[]>(size * EcalDataFrame::MAXSAMPLES, cudaStream);
-        recHits.amplitude = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
-        recHits.amplitudeError = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
-        recHits.chi2 = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
-        recHits.pedestal = cms::cuda::make_device_unique<reco::StorageScalarType[]>(size, cudaStream);
-        recHits.did = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
-        recHits.flags = cms::cuda::make_device_unique<uint32_t[]>(size, cudaStream);
-      }
-    };
-  }  //namespace weights
-}  //namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_DeclsForKernelsPhase2_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
deleted file mode 100644
index 286f4cd2f413c..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPURecHitProducer.cc
+++ /dev/null
@@ -1,168 +0,0 @@
-//#define ECAL_RECO_CUDA_DEBUG
-
-#ifdef ECAL_RECO_CUDA_DEBUG
-#include <iostream>
-#endif
-
-// framework
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-
-// algorithm specific
-
-#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-
-class EcalCPURecHitProducer : public edm::stream::EDProducer<edm::ExternalWork> {
-public:
-  explicit EcalCPURecHitProducer(edm::ParameterSet const& ps);
-  ~EcalCPURecHitProducer() override = default;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  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_;
-
-  OutputProduct recHitsEB_, recHitsEE_;
-  bool containsTimingInformation_;
-};
-
-void EcalCPURecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("recHitsInLabelEB", edm::InputTag{"ecalRecHitProducerGPU", "EcalRecHitsEB"});
-  desc.add<edm::InputTag>("recHitsInLabelEE", edm::InputTag{"ecalRecHitProducerGPU", "EcalRecHitsEE"});
-  desc.add<std::string>("recHitsOutLabelEB", "EcalRecHitsEB");
-  desc.add<std::string>("recHitsOutLabelEE", "EcalRecHitsEE");
-  desc.add<bool>("containsTimingInformation", false);
-
-  confDesc.addWithDefaultLabel(desc);
-}
-
-EcalCPURecHitProducer::EcalCPURecHitProducer(const edm::ParameterSet& ps)
-    : recHitsInEBToken_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsInLabelEB"))},
-      recHitsInEEToken_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsInLabelEE"))},
-      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,
-                                    edm::EventSetup const& setup,
-                                    edm::WaitingTaskWithArenaHolder taskHolder) {
-  // retrieve data/ctx
-  auto const& ebRecHitsProduct = event.get(recHitsInEBToken_);
-  auto const& eeRecHitsProduct = event.get(recHitsInEEToken_);
-  cms::cuda::ScopedContextAcquire ctx{ebRecHitsProduct, std::move(taskHolder)};
-  auto const& ebRecHits = ctx.get(ebRecHitsProduct);
-  auto const& eeRecHits = ctx.get(eeRecHitsProduct);
-
-  // resize the output buffers
-  recHitsEB_.resize(ebRecHits.size);
-  recHitsEE_.resize(eeRecHits.size);
-
-#ifdef ECAL_RECO_CUDA_DEBUG
-  std::cout << " [EcalCPURecHitProducer::acquire] ebRecHits.size = " << ebRecHits.size << std::endl;
-  std::cout << " [EcalCPURecHitProducer::acquire] eeRecHits.size = " << eeRecHits.size << std::endl;
-#endif
-
-  // enqeue transfers
-  cudaCheck(cudaMemcpyAsync(recHitsEB_.did.data(),
-                            ebRecHits.did.get(),
-                            recHitsEB_.did.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(recHitsEE_.did.data(),
-                            eeRecHits.did.get(),
-                            recHitsEE_.did.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  //
-  //     ./DataFormats/EcalRecHit/interface/RecoTypes.h:using StorageScalarType = float;
-  //
-
-  cudaCheck(cudaMemcpyAsync(recHitsEB_.energy.data(),
-                            ebRecHits.energy.get(),
-                            recHitsEB_.energy.size() * sizeof(::ecal::reco::StorageScalarType),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(recHitsEE_.energy.data(),
-                            eeRecHits.energy.get(),
-                            recHitsEE_.energy.size() * sizeof(::ecal::reco::StorageScalarType),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-
-  cudaCheck(cudaMemcpyAsync(recHitsEB_.chi2.data(),
-                            ebRecHits.chi2.get(),
-                            recHitsEB_.chi2.size() * sizeof(::ecal::reco::StorageScalarType),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(recHitsEE_.chi2.data(),
-                            eeRecHits.chi2.get(),
-                            recHitsEE_.chi2.size() * sizeof(::ecal::reco::StorageScalarType),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-
-  cudaCheck(cudaMemcpyAsync(recHitsEB_.extra.data(),
-                            ebRecHits.extra.get(),
-                            recHitsEB_.extra.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(recHitsEE_.extra.data(),
-                            eeRecHits.extra.get(),
-                            recHitsEE_.extra.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-
-  cudaCheck(cudaMemcpyAsync(recHitsEB_.flagBits.data(),
-                            ebRecHits.flagBits.get(),
-                            recHitsEB_.flagBits.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(recHitsEE_.flagBits.data(),
-                            eeRecHits.flagBits.get(),
-                            recHitsEE_.flagBits.size() * sizeof(uint32_t),
-                            cudaMemcpyDeviceToHost,
-                            ctx.stream()));
-
-#ifdef ECAL_RECO_CUDA_DEBUG
-  for (unsigned int ieb = 0; ieb < ebRecHits.size; ieb++) {
-    if (recHitsEB_.extra[ieb] != 0)
-      std::cout << " [ " << ieb << " :: " << ebRecHits.size << " ] [ " << recHitsEB_.did[ieb]
-                << " ] eb extra = " << recHitsEB_.extra[ieb] << std::endl;
-  }
-
-  for (unsigned int ieb = 0; ieb < ebRecHits.size; ieb++) {
-    if (recHitsEB_.energy[ieb] != 0)
-      std::cout << " [ " << ieb << " :: " << ebRecHits.size << " ] [ " << recHitsEB_.did[ieb]
-                << " ] eb energy = " << recHitsEB_.energy[ieb] << std::endl;
-  }
-
-  for (unsigned int iee = 0; iee < eeRecHits.size; iee++) {
-    if (recHitsEE_.energy[iee] != 0)
-      std::cout << " [ " << iee << " :: " << eeRecHits.size << " ] [ " << recHitsEE_.did[iee]
-                << " ] ee energy = " << recHitsEE_.energy[iee] << std::endl;
-  }
-#endif
-}
-
-void EcalCPURecHitProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
-  // put into event
-  event.emplace(recHitsOutEBToken_, std::move(recHitsEB_));
-  event.emplace(recHitsOutEEToken_, std::move(recHitsEE_));
-}
-
-DEFINE_FWK_MODULE(EcalCPURecHitProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
deleted file mode 100644
index 60600b0376d3e..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalCPUUncalibRecHitProducer.cc
+++ /dev/null
@@ -1,131 +0,0 @@
-#include <iostream>
-
-// framework
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
-
-// algorithm specific
-
-#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-
-class EcalCPUUncalibRecHitProducer : public edm::stream::EDProducer<edm::ExternalWork> {
-public:
-  explicit EcalCPUUncalibRecHitProducer(edm::ParameterSet const& ps);
-  ~EcalCPUUncalibRecHitProducer() override;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  const bool isPhase2_;
-  using InputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
-  const edm::EDGetTokenT<InputProduct> recHitsInEBToken_, recHitsInEEToken_;
-  using OutputProduct = ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
-  const edm::EDPutTokenT<OutputProduct> recHitsOutEBToken_, recHitsOutEEToken_;
-
-  OutputProduct recHitsEB_, recHitsEE_;
-  const bool containsTimingInformation_;
-};
-
-void EcalCPUUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("recHitsInLabelEB", edm::InputTag{"ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEB"});
-  desc.add<std::string>("recHitsOutLabelEB", "EcalUncalibRecHitsEB");
-  desc.add<bool>("containsTimingInformation", false);
-  desc.ifValue(
-      edm::ParameterDescription<bool>("isPhase2", false, true),
-      false >> (edm::ParameterDescription<edm::InputTag>(
-                    "recHitsInLabelEE", edm::InputTag{"ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEE"}, true) and
-                edm::ParameterDescription<std::string>("recHitsOutLabelEE", "EcalUncalibRecHitsEE", true)) or
-          true >> edm::EmptyGroupDescription());
-
-  confDesc.add("ecalCPUUncalibRecHitProducer", desc);
-}
-
-EcalCPUUncalibRecHitProducer::EcalCPUUncalibRecHitProducer(const edm::ParameterSet& ps)
-    : isPhase2_{ps.getParameter<bool>("isPhase2")},
-      recHitsInEBToken_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsInLabelEB"))},
-      recHitsInEEToken_{isPhase2_ ? edm::EDGetTokenT<InputProduct>{}
-                                  : consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsInLabelEE"))},
-      recHitsOutEBToken_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEB"))},
-      recHitsOutEEToken_{isPhase2_ ? edm::EDPutTokenT<OutputProduct>{}
-                                   : produces<OutputProduct>(ps.getParameter<std::string>("recHitsOutLabelEE"))},
-      containsTimingInformation_{ps.getParameter<bool>("containsTimingInformation")} {}
-
-EcalCPUUncalibRecHitProducer::~EcalCPUUncalibRecHitProducer() {}
-
-void EcalCPUUncalibRecHitProducer::acquire(edm::Event const& event,
-                                           edm::EventSetup const& setup,
-                                           edm::WaitingTaskWithArenaHolder taskHolder) {
-  // retrieve data/ctx
-  auto const& ebRecHitsProduct = event.get(recHitsInEBToken_);
-  cms::cuda::ScopedContextAcquire ctx{ebRecHitsProduct, std::move(taskHolder)};
-  auto const& ebRecHits = ctx.get(ebRecHitsProduct);
-
-  // resize the output buffers
-  recHitsEB_.resize(ebRecHits.size);
-
-  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.get());
-  lambdaToTransfer(recHitsEB_.amplitudesAll, ebRecHits.amplitudesAll.get());
-  lambdaToTransfer(recHitsEB_.amplitude, ebRecHits.amplitude.get());
-  lambdaToTransfer(recHitsEB_.chi2, ebRecHits.chi2.get());
-  lambdaToTransfer(recHitsEB_.pedestal, ebRecHits.pedestal.get());
-  lambdaToTransfer(recHitsEB_.flags, ebRecHits.flags.get());
-  if (containsTimingInformation_) {
-    lambdaToTransfer(recHitsEB_.jitter, ebRecHits.jitter.get());
-    lambdaToTransfer(recHitsEB_.jitterError, ebRecHits.jitterError.get());
-  }
-  if (isPhase2_) {
-    lambdaToTransfer(recHitsEB_.amplitudeError, ebRecHits.amplitudeError.get());
-
-  } else {
-    auto const& eeRecHitsProduct = event.get(recHitsInEEToken_);
-    auto const& eeRecHits = ctx.get(eeRecHitsProduct);
-    recHitsEE_.resize(eeRecHits.size);
-    lambdaToTransfer(recHitsEE_.did, eeRecHits.did.get());
-    lambdaToTransfer(recHitsEE_.amplitudesAll, eeRecHits.amplitudesAll.get());
-    lambdaToTransfer(recHitsEE_.amplitude, eeRecHits.amplitude.get());
-    lambdaToTransfer(recHitsEE_.chi2, eeRecHits.chi2.get());
-    lambdaToTransfer(recHitsEE_.pedestal, eeRecHits.pedestal.get());
-    lambdaToTransfer(recHitsEE_.flags, eeRecHits.flags.get());
-    if (containsTimingInformation_) {
-      lambdaToTransfer(recHitsEE_.jitter, eeRecHits.jitter.get());
-      lambdaToTransfer(recHitsEE_.jitterError, eeRecHits.jitterError.get());
-    }
-  }
-}
-
-void EcalCPUUncalibRecHitProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
-  // tmp vectors
-  auto recHitsOutEB = std::make_unique<OutputProduct>(std::move(recHitsEB_));
-  // put into event
-  event.put(recHitsOutEBToken_, std::move(recHitsOutEB));
-
-  if (!isPhase2_) {
-    auto recHitsOutEE = std::make_unique<OutputProduct>(std::move(recHitsEE_));
-    event.put(recHitsOutEEToken_, std::move(recHitsOutEE));
-  }
-}
-
-DEFINE_FWK_MODULE(EcalCPUUncalibRecHitProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalESProducersGPUDefs.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalESProducersGPUDefs.cc
deleted file mode 100644
index 5bdadecc75ef8..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalESProducersGPUDefs.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
-#include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
-#include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
-#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRefRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAlphasRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLinearCorrectionsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
-#include "CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPedestalsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h"
-
-using EcalPedestalsGPUESProducer = ConvertingESProducerT<EcalPedestalsRcd, EcalPedestalsGPU, EcalPedestals>;
-
-using EcalGainRatiosGPUESProducer = ConvertingESProducerT<EcalGainRatiosRcd, EcalGainRatiosGPU, EcalGainRatios>;
-
-using EcalPulseShapesGPUESProducer = ConvertingESProducerT<EcalPulseShapesRcd, EcalPulseShapesGPU, EcalPulseShapes>;
-
-using EcalPulseCovariancesGPUESProducer =
-    ConvertingESProducerT<EcalPulseCovariancesRcd, EcalPulseCovariancesGPU, EcalPulseCovariances>;
-
-using EcalSamplesCorrelationGPUESProducer =
-    ConvertingESProducerT<EcalSamplesCorrelationRcd, EcalSamplesCorrelationGPU, EcalSamplesCorrelation>;
-
-using EcalTimeBiasCorrectionsGPUESProducer =
-    ConvertingESProducerT<EcalTimeBiasCorrectionsRcd, EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrections>;
-
-using EcalTimeCalibConstantsGPUESProducer =
-    ConvertingESProducerT<EcalTimeCalibConstantsRcd, EcalTimeCalibConstantsGPU, EcalTimeCalibConstants>;
-
-using EcalRechitADCToGeVConstantGPUESProducer =
-    ConvertingESProducerT<EcalADCToGeVConstantRcd, EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstant>;
-
-using EcalIntercalibConstantsGPUESProducer =
-    ConvertingESProducerT<EcalIntercalibConstantsRcd, EcalIntercalibConstantsGPU, EcalIntercalibConstants>;
-
-using EcalRechitChannelStatusGPUESProducer =
-    ConvertingESProducerT<EcalChannelStatusRcd, EcalRechitChannelStatusGPU, EcalChannelStatus>;
-
-using EcalLaserAPDPNRatiosGPUESProducer =
-    ConvertingESProducerT<EcalLaserAPDPNRatiosRcd, EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatios>;
-
-using EcalLaserAPDPNRatiosRefGPUESProducer =
-    ConvertingESProducerT<EcalLaserAPDPNRatiosRefRcd, EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRef>;
-
-using EcalLaserAlphasGPUESProducer = ConvertingESProducerT<EcalLaserAlphasRcd, EcalLaserAlphasGPU, EcalLaserAlphas>;
-
-using EcalLinearCorrectionsGPUESProducer =
-    ConvertingESProducerT<EcalLinearCorrectionsRcd, EcalLinearCorrectionsGPU, EcalLinearCorrections>;
-
-//
-// This below also creates the .py config files, as described in HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h
-//
-
-DEFINE_FWK_EVENTSETUP_MODULE(EcalPedestalsGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalGainRatiosGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalPulseShapesGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalPulseCovariancesGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalSamplesCorrelationGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalTimeBiasCorrectionsGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalTimeCalibConstantsGPUESProducer);
-
-DEFINE_FWK_EVENTSETUP_MODULE(EcalRechitADCToGeVConstantGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalIntercalibConstantsGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalRechitChannelStatusGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalLaserAPDPNRatiosGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalLaserAPDPNRatiosRefGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalLaserAlphasGPUESProducer);
-DEFINE_FWK_EVENTSETUP_MODULE(EcalLinearCorrectionsGPUESProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc
deleted file mode 100644
index 185ce2a0f910e..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalMultifitParametersGPUESProducer.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-#include <array>
-#include <tuple>
-#include <utility>
-
-#include "CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h"
-#include "FWCore/Framework/interface/ESProducer.h"
-#include "FWCore/Framework/interface/ESProductHost.h"
-#include "FWCore/Framework/interface/ESTransientHandle.h"
-#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/ModuleFactory.h"
-#include "FWCore/Framework/interface/SourceFactory.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 "HeterogeneousCore/CUDACore/interface/JobConfigurationGPURecord.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(JobConfigurationGPURecord 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<JobConfigurationGPURecord>();
-}
-
-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(
-    JobConfigurationGPURecord const&) {
-  return std::make_unique<EcalMultifitParametersGPU>(
-      pset_.getParameter<std::vector<double>>("EBamplitudeFitParameters"),
-      pset_.getParameter<std::vector<double>>("EEamplitudeFitParameters"),
-      pset_.getParameter<std::vector<double>>("EBtimeFitParameters"),
-      pset_.getParameter<std::vector<double>>("EEtimeFitParameters"));
-}
-
-DEFINE_FWK_EVENTSETUP_SOURCE(EcalMultifitParametersGPUESProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalPhase2DigiToGPUProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalPhase2DigiToGPUProducer.cc
deleted file mode 100644
index a97d57626cdfb..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalPhase2DigiToGPUProducer.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/host_unique_ptr.h"
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h"
-
-#include "DeclsForKernelsPhase2.h"
-
-class EcalPhase2DigiToGPUProducer : public edm::stream::EDProducer<> {
-public:
-  explicit EcalPhase2DigiToGPUProducer(const edm::ParameterSet& ps);
-  ~EcalPhase2DigiToGPUProducer() override = default;
-  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
-
-  void produce(edm::Event& evt, edm::EventSetup const& setup) override;
-
-private:
-  const edm::EDGetTokenT<EBDigiCollectionPh2> digiCollectionToken_;
-  const edm::EDPutTokenT<cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>>
-      digisCollectionToken_;
-};
-
-void EcalPhase2DigiToGPUProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("BarrelDigis", edm::InputTag("simEcalUnsuppressedDigis", ""));
-  desc.add<std::string>("digisLabelEB", "ebDigis");
-
-  descriptions.addWithDefaultLabel(desc);
-}
-
-EcalPhase2DigiToGPUProducer::EcalPhase2DigiToGPUProducer(const edm::ParameterSet& ps)
-    : digiCollectionToken_(consumes<EBDigiCollectionPh2>(ps.getParameter<edm::InputTag>("BarrelDigis"))),
-      digisCollectionToken_(produces<cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>>(
-          ps.getParameter<std::string>("digisLabelEB"))) {}
-
-void EcalPhase2DigiToGPUProducer::produce(edm::Event& event, edm::EventSetup const& setup) {
-  cms::cuda::ScopedContextProduce ctx{event.streamID()};
-
-  //input data from event
-  const auto& pdigis = event.get(digiCollectionToken_);
-
-  const uint32_t size = pdigis.size();
-
-  ecal::DigisCollection<::calo::common::DevStoragePolicy> digis;
-  digis.size = size;
-
-  //allocate device pointers for output
-  digis.ids = cms::cuda::make_device_unique<uint32_t[]>(size, ctx.stream());
-  digis.data = cms::cuda::make_device_unique<uint16_t[]>(size * EcalDataFrame_Ph2::MAXSAMPLES, ctx.stream());
-
-  //allocate host pointers for holding product data and id vectors
-  auto idstmp = cms::cuda::make_host_unique<uint32_t[]>(size, ctx.stream());
-  auto datatmp = cms::cuda::make_host_unique<uint16_t[]>(size * EcalDataFrame_Ph2::MAXSAMPLES, ctx.stream());
-
-  //iterate over digis
-  uint32_t i = 0;
-  for (const auto& pdigi : pdigis) {
-    const int nSamples = pdigi.size();
-    //assign id to output vector
-    idstmp.get()[i] = pdigi.id();
-    //iterate over sample in digi
-    for (int sample = 0; sample < nSamples; ++sample) {
-      //get samples from input digi
-      EcalLiteDTUSample thisSample = pdigi[sample];
-      //assign adc data to output
-      datatmp.get()[i * nSamples + sample] = thisSample.raw();
-    }
-    ++i;
-  }
-
-  //copy output vectors into member variable device pointers for the output struct
-  cudaCheck(
-      cudaMemcpyAsync(digis.ids.get(), idstmp.get(), size * sizeof(uint32_t), cudaMemcpyHostToDevice, ctx.stream()));
-  cudaCheck(cudaMemcpyAsync(digis.data.get(),
-                            datatmp.get(),
-                            size * EcalDataFrame_Ph2::MAXSAMPLES * sizeof(uint16_t),
-                            cudaMemcpyHostToDevice,
-                            ctx.stream()));
-
-  //emplace output in the context
-  ctx.emplace(event, digisCollectionToken_, std::move(digis));
-}
-
-DEFINE_FWK_MODULE(EcalPhase2DigiToGPUProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
deleted file mode 100644
index 8e77a58b66f4a..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.cu
+++ /dev/null
@@ -1,674 +0,0 @@
-#include <cuda.h>
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-
-#include "EcalRecHitBuilderKernels.h"
-#include "KernelHelpers.h"
-
-namespace ecal {
-  namespace rechit {
-
-    // uncalibrecHit flags
-    enum UncalibRecHitFlags {
-      kGood = -1,  // channel is good (mutually exclusive with other states)  setFlagBit(kGood) reset flags_ to zero
-      kPoorReco,   // channel has been badly reconstructed (e.g. bad shape, bad chi2 etc.)
-      kSaturated,  // saturated channel
-      kOutOfTime,  // channel out of time
-      kLeadingEdgeRecovered,  // saturated channel: energy estimated from the leading edge before saturation
-      kHasSwitchToGain6,      // at least one data frame is in G6
-      kHasSwitchToGain1       // at least one data frame is in G1
-    };
-
-    // recHit flags
-    enum RecHitFlags {
-      RecHitFlags_kGood = 0,  // channel ok, the energy and time measurement are reliable
-      RecHitFlags_kPoorReco,  // the energy is available from the UncalibRecHit, but approximate (bad shape, large chi2)
-      RecHitFlags_kOutOfTime,  // the energy is available from the UncalibRecHit (sync reco), but the event is out of time
-      RecHitFlags_kFaultyHardware,  // The energy is available from the UncalibRecHit, channel is faulty at some hardware level (e.g. noisy)
-      RecHitFlags_kNoisy,      // the channel is very noisy
-      RecHitFlags_kPoorCalib,  // the energy is available from the UncalibRecHit, but the calibration of the channel is poor
-      RecHitFlags_kSaturated,             // saturated channel (recovery not tried)
-      RecHitFlags_kLeadingEdgeRecovered,  // saturated channel: energy estimated from the leading edge before saturation
-      RecHitFlags_kNeighboursRecovered,   // saturated/isolated dead: energy estimated from neighbours
-      RecHitFlags_kTowerRecovered,        // channel in TT with no data link, info retrieved from Trigger Primitive
-      RecHitFlags_kDead,                  // channel is dead and any recovery fails
-      RecHitFlags_kKilled,                // MC only flag: the channel is killed in the real detector
-      RecHitFlags_kTPSaturated,           // the channel is in a region with saturated TP
-      RecHitFlags_kL1SpikeFlag,           // the channel is in a region with TP with sFGVB = 0
-      RecHitFlags_kWeird,                 // the signal is believed to originate from an anomalous deposit (spike)
-      RecHitFlags_kDiWeird,               // the signal is anomalous, and neighbors another anomalous signal
-      RecHitFlags_kHasSwitchToGain6,      // at least one data frame is in G6
-      RecHitFlags_kHasSwitchToGain1,      // at least one data frame is in G1
-      //
-      RecHitFlags_kUnknown  // to ease the interface with functions returning flags.
-    };
-
-    // status code
-    enum EcalChannelStatusCode_Code {
-      kOk = 0,
-      kDAC,
-      kNoLaser,
-      kNoisy,
-      kNNoisy,
-      kNNNoisy,
-      kNNNNoisy,
-      kNNNNNoisy,
-      kFixedG6,
-      kFixedG1,
-      kFixedG0,
-      kNonRespondingIsolated,
-      kDeadVFE,
-      kDeadFE,
-      kNoDataNoTP
-    };
-
-    __global__ void kernel_create_ecal_rehit(
-        // configuration
-        int const* ChannelStatusToBeExcluded,
-        uint32_t ChannelStatusToBeExcludedSize,
-        bool const killDeadChannels,
-        bool const recoverEBIsolatedChannels,
-        bool const recoverEEIsolatedChannels,
-        bool const recoverEBVFE,
-        bool const recoverEEVFE,
-        bool const recoverEBFE,
-        bool const recoverEEFE,
-        float const EBLaserMIN,
-        float const EELaserMIN,
-        float const EBLaserMAX,
-        float const EELaserMAX,
-        // for flags setting
-        int const* expanded_v_DB_reco_flags,  // FIXME AM: to be checked
-        uint32_t const* expanded_Sizes_v_DB_reco_flags,
-        uint32_t const* expanded_flagbit_v_DB_reco_flags,
-        uint32_t expanded_v_DB_reco_flagsSize,
-        uint32_t flagmask,
-        // conditions
-        float const* adc2gev,
-        float const* intercalib,
-        uint16_t const* status,
-        float const* apdpnrefs,
-        float const* alphas,
-        // input for transparency corrections
-        float const* p1,
-        float const* p2,
-        float const* p3,
-        edm::TimeValue_t const* t1,
-        edm::TimeValue_t const* t2,
-        edm::TimeValue_t const* t3,
-        // input for linear corrections
-        float const* lp1,
-        float const* lp2,
-        float const* lp3,
-        edm::TimeValue_t const* lt1,
-        edm::TimeValue_t const* lt2,
-        edm::TimeValue_t const* lt3,
-        // time, used for time dependent corrections
-        edm::TimeValue_t const event_time,
-        // input
-        uint32_t const* did_eb,
-        uint32_t const* did_ee,
-        ::ecal::reco::StorageScalarType const* amplitude_eb,  // in adc counts
-        ::ecal::reco::StorageScalarType const* amplitude_ee,  // in adc counts
-        ::ecal::reco::StorageScalarType const* time_eb,
-        ::ecal::reco::StorageScalarType const* time_ee,
-        ::ecal::reco::StorageScalarType const* chi2_eb,
-        ::ecal::reco::StorageScalarType const* chi2_ee,
-        uint32_t const* flags_eb,
-        uint32_t const* flags_ee,
-        // output
-        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,
-        uint32_t const offsetForHashes) {
-      //
-      //    NB: energy   "type_wrapper<reco::StorageScalarType, L>::type" most likely std::vector<float>
-      //
-
-      for (int ch = threadIdx.x + blockDim.x * blockIdx.x; ch < nchannels; ch += blockDim.x * gridDim.x) {
-        bool isEndcap = (ch >= nChannelsBarrel);
-
-        int const inputCh = isEndcap ? ch - nChannelsBarrel : ch;
-
-        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
-                                        : adc2gev[0];  // eb
-
-        // first EB and then EE
-
-        ::ecal::reco::StorageScalarType const* amplitude = isEndcap ? amplitude_ee : amplitude_eb;
-
-        ::ecal::reco::StorageScalarType const* chi2_in = isEndcap ? chi2_ee : chi2_eb;
-
-        uint32_t const* flags_in = isEndcap ? flags_ee : flags_eb;
-
-        // simple copy
-        did[inputCh] = didCh[inputCh];
-
-        auto const did_to_use = DetId{didCh[inputCh]};
-
-        auto const isBarrel = did_to_use.subdetId() == EcalBarrel;
-        auto const hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did_to_use.rawId())
-                                       : offsetForHashes + ecal::reconstruction::hashedIndexEE(did_to_use.rawId());
-
-        float const intercalib_to_use = intercalib[hashedId];
-
-        // get laser coefficient
-        float lasercalib = 1.;
-
-        //
-        // AM: ideas
-        //
-        //    One possibility is to create the map of laser corrections once on CPU
-        //    for all crystals and push them on GPU.
-        //    Then only if the LS is different, update the laser correction
-        //    The variation within a LS is not worth pursuing (<< 0.1% !!)
-        //    and below the precision we can claim on the laser corrections (right?).
-        //    This will save quite some time (also for the CPU version?)
-        //
-
-        int iLM = 1;
-
-        if (isBarrel) {
-          iLM = ecal::reconstruction::laser_monitoring_region_EB(did_to_use.rawId());
-        } else {
-          iLM = ecal::reconstruction::laser_monitoring_region_EE(did_to_use.rawId());
-        }
-
-        long long t_i = 0, t_f = 0;
-        float p_i = 0, p_f = 0;
-        long long lt_i = 0, lt_f = 0;
-        float lp_i = 0, lp_f = 0;
-
-        // laser
-        if (event_time >= t1[iLM - 1] && event_time < t2[iLM - 1]) {
-          t_i = t1[iLM - 1];
-          t_f = t2[iLM - 1];
-          p_i = p1[hashedId];
-          p_f = p2[hashedId];
-        } else if (event_time >= t2[iLM - 1] && event_time <= t3[iLM - 1]) {
-          t_i = t2[iLM - 1];
-          t_f = t3[iLM - 1];
-          p_i = p2[hashedId];
-          p_f = p3[hashedId];
-        } else if (event_time < t1[iLM - 1]) {
-          t_i = t1[iLM - 1];
-          t_f = t2[iLM - 1];
-          p_i = p1[hashedId];
-          p_f = p2[hashedId];
-
-        } else if (event_time > t3[iLM - 1]) {
-          t_i = t2[iLM - 1];
-          t_f = t3[iLM - 1];
-          p_i = p2[hashedId];
-          p_f = p3[hashedId];
-        }
-
-        // linear corrections
-        if (event_time >= lt1[iLM - 1] && event_time < lt2[iLM - 1]) {
-          lt_i = lt1[iLM - 1];
-          lt_f = lt2[iLM - 1];
-          lp_i = lp1[hashedId];
-          lp_f = lp2[hashedId];
-        } else if (event_time >= lt2[iLM - 1] && event_time <= lt3[iLM - 1]) {
-          lt_i = lt2[iLM - 1];
-          lt_f = lt3[iLM - 1];
-          lp_i = lp2[hashedId];
-          lp_f = lp3[hashedId];
-        } else if (event_time < lt1[iLM - 1]) {
-          lt_i = lt1[iLM - 1];
-          lt_f = lt2[iLM - 1];
-          lp_i = lp1[hashedId];
-          lp_f = lp2[hashedId];
-
-        } else if (event_time > lt3[iLM - 1]) {
-          lt_i = lt2[iLM - 1];
-          lt_f = lt3[iLM - 1];
-          lp_i = lp2[hashedId];
-          lp_f = lp3[hashedId];
-        }
-
-        // apdpnref and alpha
-        float apdpnref = apdpnrefs[hashedId];
-        float alpha = alphas[hashedId];
-
-        // now calculate transparency correction
-        if (apdpnref != 0 && (t_i - t_f) != 0 && (lt_i - lt_f) != 0) {
-          long long tt = event_time;  // never subtract two unsigned!
-          float interpolatedLaserResponse =
-              p_i / apdpnref + float(tt - t_i) * (p_f - p_i) / (apdpnref * float(t_f - t_i));
-
-          float interpolatedLinearResponse =
-              lp_i / apdpnref + float(tt - lt_i) * (lp_f - lp_i) / (apdpnref * float(lt_f - lt_i));  // FIXED BY FC
-
-          if (interpolatedLinearResponse > 2.f || interpolatedLinearResponse < 0.1f) {
-            interpolatedLinearResponse = 1.f;
-          }
-          if (interpolatedLaserResponse <= 0.) {
-            // AM :  how the heck is it possible?
-            //             interpolatedLaserResponse = 0.0001;
-            lasercalib = 1.;
-
-          } else {
-            float interpolatedTransparencyResponse = interpolatedLaserResponse / interpolatedLinearResponse;
-
-            // ... and now this:
-            lasercalib = 1.f / (std::pow(interpolatedTransparencyResponse, alpha) * interpolatedLinearResponse);
-          }
-        }
-
-        //
-        // Check for channels to be excluded from reconstruction
-        //
-        // Default energy not to be updated if "ChannelStatusToBeExcluded"
-        // Exploited later by the module "EcalRecHitConvertGPU2CPUFormat"
-        energy[inputCh] = -1;  //un-physical default
-
-        // truncate the chi2
-        if (chi2_in[inputCh] > 64)
-          chi2[inputCh] = 64;
-        else
-          chi2[inputCh] = chi2_in[inputCh];
-
-        // default values for the flags
-        flagBits[inputCh] = 0;
-        extra[inputCh] = 0;
-
-        static const int chStatusMask = 0x1f;
-        // ChannelStatusToBeExcluded is a "int" then I put "dbstatus" to be the same
-        int dbstatus = EcalChannelStatusCode_Code((status[hashedId]) & chStatusMask);
-        if (ChannelStatusToBeExcludedSize != 0) {
-          bool skip_this_channel = false;
-          for (int ich_to_check = 0; ich_to_check < ChannelStatusToBeExcludedSize; ich_to_check++) {
-            if (ChannelStatusToBeExcluded[ich_to_check] == dbstatus) {
-              skip_this_channel = true;
-              break;
-            }
-          }
-          if (skip_this_channel) {
-            // skip this channel
-            continue;
-          }
-        }
-
-        // Take our association map of dbstatuses-> recHit flagbits and return the apporpriate flagbit word
-
-        //
-        // AM: get the smaller "flagbit_counter" with match
-        //
-
-        uint32_t temporary_flagBits = 0;
-
-        int iterator_flags = 0;
-        bool need_to_exit = false;
-        int flagbit_counter = 0;
-        while (!need_to_exit) {
-          iterator_flags = 0;
-          for (unsigned int i = 0; i != expanded_v_DB_reco_flagsSize; ++i) {
-            // check the correct "flagbit"
-            if (expanded_flagbit_v_DB_reco_flags[i] == flagbit_counter) {
-              for (unsigned int j = 0; j < expanded_Sizes_v_DB_reco_flags[i]; j++) {
-                if (expanded_v_DB_reco_flags[iterator_flags] == dbstatus) {
-                  temporary_flagBits = 0x1 << expanded_flagbit_v_DB_reco_flags[i];
-                  need_to_exit = true;
-                  break;  // also from the big loop!!!
-                }
-                iterator_flags++;
-              }
-            } else {
-              // if not, got to the next bunch directly
-              iterator_flags += expanded_Sizes_v_DB_reco_flags[i];
-            }
-
-            if (need_to_exit) {
-              break;
-            }
-          }
-          flagbit_counter += 1;
-        }
-
-        flagBits[inputCh] = temporary_flagBits;
-
-        if ((flagmask & temporary_flagBits) && killDeadChannels) {
-          // skip this channel
-          continue;
-        }
-
-        //
-        // multiply the adc counts with factors to get GeV
-        //
-
-        //         energy[ch] = amplitude[inputCh] * adc2gev_to_use * intercalib_to_use ;
-        energy[inputCh] = amplitude[inputCh] * adc2gev_to_use * intercalib_to_use * lasercalib;
-
-        // Time is not saved so far, FIXME
-        //         time[ch] = time_in[inputCh];
-
-        // NB: calculate the "flagBits extra"  --> not really "flags", but actually an encoded version of energy uncertainty, time unc., ...
-
-        //
-        // extra packing ...
-        //
-
-        uint32_t offset;
-        uint32_t width;
-        uint32_t value;
-
-        float chi2_temp = chi2[inputCh];
-        if (chi2_temp > 64)
-          chi2_temp = 64;
-        // use 7 bits
-        uint32_t rawChi2 = lround(chi2_temp / 64. * ((1 << 7) - 1));
-
-        offset = 0;
-        width = 7;
-        value = 0;
-
-        uint32_t mask = ((1 << width) - 1) << offset;
-        value &= ~mask;
-        value |= (rawChi2 & ((1U << width) - 1)) << offset;
-
-        // rawEnergy is actually "error" !!!
-        uint32_t rawEnergy = 0;
-
-        // AM: FIXME: this is not propagated currently to the uncalibrecHit collection SOA
-        //            if you want to store this in "extra", we need first to add it to the uncalibrecHit results
-        //            then it will be something like the following
-        //         amplitudeError[inputCh] * adc2gev_to_use * intercalib_to_use * lasercalib
-        //
-        //
-
-        float amplitudeError_ch = 0.;  // amplitudeError[ch];
-
-        if (amplitudeError_ch > 0.001) {
-          static constexpr float p10[] = {1.e-2f, 1.e-1f, 1.f, 1.e1f, 1.e2f, 1.e3f, 1.e4f, 1.e5f, 1.e6f};
-          int b = amplitudeError_ch < p10[4] ? 0 : 5;
-          for (; b < 9; ++b)
-            if (amplitudeError_ch < p10[b])
-              break;
-
-          uint16_t exponent = b;
-
-          static constexpr float ip10[] = {1.e5f, 1.e4f, 1.e3f, 1.e2f, 1.e1f, 1.e0f, 1.e-1f, 1.e-2f, 1.e-3f, 1.e-4};
-          uint16_t significand = lround(amplitudeError_ch * ip10[exponent]);
-          // use 13 bits (3 exponent, 10 significand)
-          rawEnergy = exponent << 10 | significand;
-        }
-
-        offset = 8;
-        width = 13;
-        // value from last change, ok
-
-        mask = ((1 << width) - 1) << offset;
-        value &= ~mask;
-        value |= (rawEnergy & ((1U << width) - 1)) << offset;
-
-        uint32_t jitterErrorBits = 0;
-        jitterErrorBits = jitterErrorBits & 0xFF;
-
-        offset = 24;
-        width = 8;
-        // value from last change, ok
-
-        mask = ((1 << width) - 1) << offset;
-        value &= ~mask;
-        value |= (jitterErrorBits & ((1U << width) - 1)) << offset;
-
-        //
-        // now finally set "extra[ch]"
-        //
-        extra[inputCh] = value;
-
-        //
-        // additional flags setting
-        //
-        // using correctly the flags as calculated at the UncalibRecHit stage
-        //
-        // Now fill flags
-
-        bool good = true;
-
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::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[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
-          good = false;
-        }
-
-        //
-        // AM: why do we have two tests one after the other checking almost the same thing???
-        // Please clean up the code, ... also the original one!
-        //
-        // uncalibRH.isSaturated() --->
-        //
-        //                                   bool EcalUncalibratedRecHit::isSaturated() const {
-        //                                     return EcalUncalibratedRecHit::checkFlag(kSaturated);
-        //                                   }
-        //
-        //
-
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kSaturated))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kSaturated));
-          good = false;
-        }
-
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kOutOfTime))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kOutOfTime));
-          good = false;
-        }
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kPoorReco))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorReco));
-          good = false;
-        }
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kHasSwitchToGain6))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain6));
-        }
-        if (flags_in[inputCh] & (0x1 << (UncalibRecHitFlags::kHasSwitchToGain1))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kHasSwitchToGain1));
-        }
-
-        if (good) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kGood));
-        }
-
-        if ((isBarrel && (lasercalib < EBLaserMIN || lasercalib > EBLaserMAX)) ||
-            (!isBarrel && (lasercalib < EELaserMIN || lasercalib > EELaserMAX))) {
-          flagBits[inputCh] |= (0x1 << (RecHitFlags::RecHitFlags_kPoorCalib));
-        }
-
-        // recover, killing, and other stuff
-
-        //
-        // Structure:
-        //  EB
-        //  EE
-        //
-        //
-        //  - single MVA
-        //  - democratic sharing
-        //  - kill all the other cases
-        //
-
-        bool is_Single = false;
-        bool is_FE = false;
-        bool is_VFE = false;
-
-        bool is_recoverable = false;  // DetIdToBeRecovered
-
-        if (dbstatus == 10 || dbstatus == 11 || dbstatus == 12) {
-          is_recoverable = true;
-        }
-
-        if (is_recoverable) {
-          if (dbstatus == EcalChannelStatusCode_Code::kDeadVFE) {
-            is_VFE = true;
-          } else if (dbstatus == EcalChannelStatusCode_Code::kDeadVFE) {
-            is_FE = true;
-          } else {
-            is_Single = true;
-          }
-
-          // EB
-          if (isBarrel) {
-            if (is_Single || is_FE || is_VFE) {
-              // single MVA
-              if (is_Single && (recoverEBIsolatedChannels || !killDeadChannels)) {
-              }
-              // decmocratic sharing
-              else if (is_FE && (recoverEBFE || !killDeadChannels)) {
-              }
-              // kill all the other cases
-              else {
-                energy[inputCh] = 0.;  // Need to set also the flags ...
-              }
-            }
-          }
-          // EE
-          else {
-            if (is_Single || is_FE || is_VFE) {
-              // single MVA
-              if (is_Single && (recoverEBIsolatedChannels || !killDeadChannels)) {
-              }
-              // decmocratic sharing
-              else if (is_FE && (recoverEBFE || !killDeadChannels)) {
-                //
-                //  Code is definitely too long ...
-                //
-
-              }
-              // kill all the other cases
-              else {
-                energy[inputCh] = 0.;  // Need to set also the flags ...
-              }
-            }
-          }
-        }
-
-      }  // end channel
-    }
-
-    // host version, to be called by the plugin
-    void create_ecal_rehit(EventInputDataGPU const& eventInputGPU,
-                           EventOutputDataGPU& eventOutputGPU,
-                           //     eventDataForScratchGPU_,
-                           ConditionsProducts const& conditions,
-                           ConfigurationParameters const& configParameters,
-                           uint32_t const nChannelsBarrel,
-                           edm::TimeValue_t const event_time,
-                           cudaStream_t cudaStream) {
-      int nchannels = eventInputGPU.ebUncalibRecHits.size + eventInputGPU.eeUncalibRecHits.size;
-
-      unsigned int nchannels_per_block = 16;
-      unsigned int threads_min = nchannels_per_block;
-      unsigned int blocks_min = (nchannels + threads_min - 1) / threads_min;  // TEST : to be optimized (AM)
-
-      //
-      // kernel create rechit
-      //
-
-      kernel_create_ecal_rehit<<<blocks_min, threads_min, 0, cudaStream>>>(
-          // configuration
-          configParameters.ChannelStatusToBeExcluded,
-          configParameters.ChannelStatusToBeExcludedSize,
-          configParameters.killDeadChannels,
-          configParameters.recoverEBIsolatedChannels,
-          configParameters.recoverEEIsolatedChannels,
-          configParameters.recoverEBVFE,
-          configParameters.recoverEEVFE,
-          configParameters.recoverEBFE,
-          configParameters.recoverEEFE,
-          configParameters.EBLaserMIN,
-          configParameters.EELaserMIN,
-          configParameters.EBLaserMAX,
-          configParameters.EELaserMAX,
-          // for flags setting
-          configParameters.expanded_v_DB_reco_flags,
-          configParameters.expanded_Sizes_v_DB_reco_flags,
-          configParameters.expanded_flagbit_v_DB_reco_flags,
-          configParameters.expanded_v_DB_reco_flagsSize,
-          configParameters.flagmask,
-          // conditions
-          conditions.ADCToGeV.adc2gev,
-          conditions.Intercalib.values,
-          conditions.ChannelStatus.status,
-          conditions.LaserAPDPNRatiosRef.values,
-          conditions.LaserAlphas.values,
-          // input for transparency corrections
-          conditions.LaserAPDPNRatios.p1,
-          conditions.LaserAPDPNRatios.p2,
-          conditions.LaserAPDPNRatios.p3,
-          conditions.LaserAPDPNRatios.t1,
-          conditions.LaserAPDPNRatios.t2,
-          conditions.LaserAPDPNRatios.t3,
-          // input for linear corrections
-          conditions.LinearCorrections.p1,
-          conditions.LinearCorrections.p2,
-          conditions.LinearCorrections.p3,
-          conditions.LinearCorrections.t1,
-          conditions.LinearCorrections.t2,
-          conditions.LinearCorrections.t3,
-          // time, used for time dependent corrections
-          event_time,
-          // input
-          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.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,
-          conditions.offsetForHashes);
-    }
-
-  }  // namespace rechit
-
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
deleted file mode 100644
index 8d468a0f7f1ec..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitBuilderKernels.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_EcalRecHitBuilderKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_EcalRecHitBuilderKernels_h
-
-//
-// Builder of ECAL RecHits on GPU
-//
-
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/Provenance/interface/Timestamp.h"
-
-#include "DeclsForKernels.h"
-
-namespace ecal {
-  namespace rechit {
-
-    __global__ void kernel_create_ecal_rehit(
-        // configuration
-        int const* ChannelStatusToBeExcluded,
-        uint32_t ChannelStatusToBeExcludedSize,
-        bool killDeadChannels,
-        bool const recoverEBIsolatedChannels,
-        bool const recoverEEIsolatedChannels,
-        bool const recoverEBVFE,
-        bool const recoverEEVFE,
-        bool const recoverEBFE,
-        bool const recoverEEFE,
-        // for flags setting
-        int const* expanded_v_DB_reco_flags,
-        uint32_t const* expanded_Sizes_v_DB_reco_flags,
-        uint32_t const* expanded_flagbit_v_DB_reco_flags,
-        uint32_t expanded_v_DB_reco_flagsSize,
-        uint32_t flagmask,
-        // conditions
-        float const* adc2gev,
-        float const* intercalib,
-        uint16_t const* status,
-        float const* apdpnrefs,
-        float const* alphas,
-        // input for transparency corrections
-        float const* p1,
-        float const* p2,
-        float const* p3,
-        edm::TimeValue_t const* t1,
-        edm::TimeValue_t const* t2,
-        edm::TimeValue_t const* t3,
-        // input for linear corrections
-        float const* lp1,
-        float const* lp2,
-        float const* lp3,
-        edm::TimeValue_t const* lt1,
-        edm::TimeValue_t const* lt2,
-        edm::TimeValue_t const* lt3,
-        // time, used for time dependent corrections
-        edm::TimeValue_t const event_time,
-        // input
-        uint32_t const* did_eb,
-        uint32_t const* did_ee,
-        ::ecal::reco::StorageScalarType const* amplitude_eb,  // in adc counts
-        ::ecal::reco::StorageScalarType const* amplitude_ee,  // in adc counts
-        ::ecal::reco::StorageScalarType const* time_eb,
-        ::ecal::reco::StorageScalarType const* time_ee,
-        ::ecal::reco::StorageScalarType const* chi2_eb,
-        ::ecal::reco::StorageScalarType const* chi2_ee,
-        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,
-        int const nchannels,
-        uint32_t const nChannelsBarrel,
-        uint32_t const offsetForHashes);
-
-    // host version, to be called by the plugin
-
-    void create_ecal_rehit(EventInputDataGPU const& eventInputGPU,
-                           EventOutputDataGPU& eventOutputGPU,
-                           ConditionsProducts const& conditions,
-                           ConfigurationParameters const& configParameters,
-                           uint32_t const nChannelsBarrel,
-                           edm::TimeValue_t const event_time,
-                           cudaStream_t cudaStream);
-
-  }  // namespace rechit
-
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_EcalRecHitBuilderKernels_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
deleted file mode 100644
index b71747a57db78..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitConvertGPU2CPUFormat.cc
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-
-class EcalRecHitConvertGPU2CPUFormat : public edm::stream::EDProducer<> {
-public:
-  explicit EcalRecHitConvertGPU2CPUFormat(edm::ParameterSet const& ps);
-  ~EcalRecHitConvertGPU2CPUFormat() override;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  using InputProduct = ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  const edm::EDGetTokenT<InputProduct> recHitsGPUEB_;
-  const edm::EDGetTokenT<InputProduct> recHitsGPUEE_;
-
-  const std::string recHitsLabelCPUEB_, recHitsLabelCPUEE_;
-};
-
-void EcalRecHitConvertGPU2CPUFormat::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("recHitsLabelGPUEB", edm::InputTag("ecalRecHitProducerGPU", "EcalRecHitsGPUEB"));
-  desc.add<edm::InputTag>("recHitsLabelGPUEE", edm::InputTag("ecalRecHitProducerGPU", "EcalRecHitsGPUEE"));
-
-  desc.add<std::string>("recHitsLabelCPUEB", "EcalRecHitsEB");
-  desc.add<std::string>("recHitsLabelCPUEE", "EcalRecHitsEE");
-
-  confDesc.addWithDefaultLabel(desc);
-}
-
-EcalRecHitConvertGPU2CPUFormat::EcalRecHitConvertGPU2CPUFormat(const edm::ParameterSet& ps)
-    : 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_);
-  produces<EERecHitCollection>(recHitsLabelCPUEE_);
-}
-
-EcalRecHitConvertGPU2CPUFormat::~EcalRecHitConvertGPU2CPUFormat() {}
-
-void EcalRecHitConvertGPU2CPUFormat::produce(edm::Event& event, edm::EventSetup const& setup) {
-  auto const& hRecHitsGPUEB = event.get(recHitsGPUEB_);
-  auto const& hRecHitsGPUEE = event.get(recHitsGPUEE_);
-
-  auto recHitsCPUEB = std::make_unique<EBRecHitCollection>();
-  auto recHitsCPUEE = std::make_unique<EERecHitCollection>();
-  recHitsCPUEB->reserve(hRecHitsGPUEB.energy.size());
-  recHitsCPUEE->reserve(hRecHitsGPUEE.energy.size());
-
-  for (uint32_t i = 0; i < hRecHitsGPUEB.energy.size(); ++i) {
-    //
-    // Save only if energy is >= 0 !
-    // This is extremely important because the channels that were supposed
-    // to be excluded get "-1" as energy
-    //
-
-    if (hRecHitsGPUEB.energy[i] >= 0) {
-      recHitsCPUEB->emplace_back(DetId{hRecHitsGPUEB.did[i]},
-                                 hRecHitsGPUEB.energy[i],
-                                 hRecHitsGPUEB.time[i],
-                                 hRecHitsGPUEB.extra[i],
-                                 hRecHitsGPUEB.flagBits[i]);
-    }
-  }
-
-  for (uint32_t i = 0; i < hRecHitsGPUEE.energy.size(); ++i) {
-    //
-    // Save only if energy is >= 0 !
-    // This is extremely important because the channels that were supposed
-    // to be excluded get "-1" as energy
-    //
-
-    if (hRecHitsGPUEE.energy[i] >= 0) {
-      recHitsCPUEE->emplace_back(DetId{hRecHitsGPUEE.did[i]},
-                                 hRecHitsGPUEE.energy[i],
-                                 hRecHitsGPUEE.time[i],
-                                 hRecHitsGPUEE.extra[i],
-                                 hRecHitsGPUEE.flagBits[i]);
-    }
-  }
-
-  event.put(std::move(recHitsCPUEB), recHitsLabelCPUEB_);
-  event.put(std::move(recHitsCPUEE), recHitsLabelCPUEE_);
-}
-
-DEFINE_FWK_MODULE(EcalRecHitConvertGPU2CPUFormat);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc
deleted file mode 100644
index ddc902c9aba6e..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitParametersGPUESProducer.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-#include <array>
-#include <tuple>
-#include <utility>
-
-#include "CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-#include "FWCore/Framework/interface/ESProducer.h"
-#include "FWCore/Framework/interface/ESProductHost.h"
-#include "FWCore/Framework/interface/ESTransientHandle.h"
-#include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/ModuleFactory.h"
-#include "FWCore/Framework/interface/SourceFactory.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 "HeterogeneousCore/CUDACore/interface/JobConfigurationGPURecord.h"
-#include "CommonTools/Utils/interface/StringToEnumValue.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHit.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(JobConfigurationGPURecord 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<JobConfigurationGPURecord>();
-}
-
-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
-  d.add<std::vector<std::string>>("ChannelStatusToBeExcluded",
-                                  {
-                                      "kDAC",
-                                      "kNoisy",
-                                      "kNNoisy",
-                                      "kFixedG6",
-                                      "kFixedG1",
-                                      "kFixedG0",
-                                      "kNonRespondingIsolated",
-                                      "kDeadVFE",
-                                      "kDeadFE",
-                                      "kNoDataNoTP",
-                                  });
-
-  // reco flags association to DB flag
-  edm::ParameterSetDescription desc_list_flagsMapDBReco;
-  desc_list_flagsMapDBReco.add<std::vector<std::string>>("kGood", {"kOk", "kDAC", "kNoLaser", "kNoisy"});
-  desc_list_flagsMapDBReco.add<std::vector<std::string>>("kNoisy", {"kNNoisy", "kFixedG6", "kFixedG1"});
-  desc_list_flagsMapDBReco.add<std::vector<std::string>>("kNeighboursRecovered",
-                                                         {"kFixedG0", "kNonRespondingIsolated", "kDeadVFE"});
-  desc_list_flagsMapDBReco.add<std::vector<std::string>>("kTowerRecovered", {"kDeadFE"});
-  desc_list_flagsMapDBReco.add<std::vector<std::string>>("kDead", {"kNoDataNoTP"});
-
-  d.add<edm::ParameterSetDescription>("flagsMapDBReco", desc_list_flagsMapDBReco);
-
-  desc.addWithDefaultLabel(d);
-}
-
-std::unique_ptr<EcalRecHitParametersGPU> EcalRecHitParametersGPUESProducer::produce(JobConfigurationGPURecord const&) {
-  auto const& channelStatusToBeExcluded = StringToEnumValue<EcalChannelStatusCode::Code>(
-      pset_.getParameter<std::vector<std::string>>("ChannelStatusToBeExcluded"));
-
-  //     https://github.com/cms-sw/cmssw/blob/266e21cfc9eb409b093e4cf064f4c0a24c6ac293/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitWorkerSimple.cc
-
-  // Translate string representation of flagsMapDBReco into enum values
-  const edm::ParameterSet& p = pset_.getParameter<edm::ParameterSet>("flagsMapDBReco");
-  std::vector<std::string> recoflagbitsStrings = p.getParameterNames();
-
-  std::vector<EcalRecHitParametersGPU::DBStatus> status;
-  status.reserve(recoflagbitsStrings.size());
-  for (auto const& recoflagbitsString : recoflagbitsStrings) {
-    EcalRecHit::Flags recoflagbit = (EcalRecHit::Flags)StringToEnumValue<EcalRecHit::Flags>(recoflagbitsString);
-    std::vector<std::string> dbstatus_s = p.getParameter<std::vector<std::string>>(recoflagbitsString);
-
-    std::vector<uint32_t> db_reco_flags;
-    db_reco_flags.reserve(dbstatus_s.size());
-    for (auto const& dbstatusString : dbstatus_s) {
-      EcalChannelStatusCode::Code dbstatus =
-          (EcalChannelStatusCode::Code)StringToEnumValue<EcalChannelStatusCode::Code>(dbstatusString);
-      db_reco_flags.push_back(dbstatus);
-    }
-    status.emplace_back(static_cast<int>(recoflagbit), db_reco_flags);
-  }
-
-  return std::make_unique<EcalRecHitParametersGPU>(channelStatusToBeExcluded, status);
-}
-
-DEFINE_FWK_EVENTSETUP_SOURCE(EcalRecHitParametersGPUESProducer);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
deleted file mode 100644
index 86dbacbf69e3e..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecHitProducerGPU.cc
+++ /dev/null
@@ -1,243 +0,0 @@
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "CommonTools/Utils/interface/StringToEnumValue.h"
-#include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
-#include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
-#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRefRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLaserAlphasRcd.h"
-#include "CondFormats/DataRecord/interface/EcalLinearCorrectionsRcd.h"
-#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
-#include "DataFormats/EcalRecHit/interface/RecoTypes.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/ServiceRegistry/interface/Service.h"
-#include "FWCore/Utilities/interface/ESGetToken.h"
-#include "HeterogeneousCore/CUDACore/interface/JobConfigurationGPURecord.h"
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAServices/interface/CUDAInterface.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-#include "EcalRecHitBuilderKernels.h"
-
-class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
-public:
-  explicit EcalRecHitProducerGPU(edm::ParameterSet const& ps);
-  ~EcalRecHitProducerGPU() override;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  // data
-  uint32_t neb_, nee_;  // extremely important, in particular neb_
-
-  // gpu input
-  using InputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
-  edm::EDGetTokenT<InputProduct> uncalibRecHitsInEBToken_;
-  edm::EDGetTokenT<InputProduct> uncalibRecHitsInEEToken_;
-
-  // event data
-  ecal::rechit::EventOutputDataGPU eventOutputDataGPU_;
-
-  cms::cuda::ContextState cudaState_;
-
-  // gpu output
-  using OutputProduct = cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>;
-  edm::EDPutTokenT<OutputProduct> recHitsTokenEB_, recHitsTokenEE_;
-
-  // configuration parameters
-  ecal::rechit::ConfigurationParameters configParameters_;
-
-  // conditions tokens
-  edm::ESGetToken<EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstantRcd> tokenADCToGeVConstant_;
-  edm::ESGetToken<EcalIntercalibConstantsGPU, EcalIntercalibConstantsRcd> tokenIntercalibConstants_;
-  edm::ESGetToken<EcalRechitChannelStatusGPU, EcalChannelStatusRcd> tokenChannelStatus_;
-  edm::ESGetToken<EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatiosRcd> tokenLaserAPDPNRatios_;
-  edm::ESGetToken<EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRefRcd> tokenLaserAPDPNRatiosRef_;
-  edm::ESGetToken<EcalLaserAlphasGPU, EcalLaserAlphasRcd> tokenLaserAlphas_;
-  edm::ESGetToken<EcalLinearCorrectionsGPU, EcalLinearCorrectionsRcd> tokenLinearCorrections_;
-  edm::ESGetToken<EcalRecHitParametersGPU, JobConfigurationGPURecord> tokenRecHitParameters_;
-
-  // conditions handles
-  edm::ESHandle<EcalIntercalibConstantsGPU> IntercalibConstantsHandle_;
-  edm::ESHandle<EcalRecHitParametersGPU> recHitParametersHandle_;
-
-  // Associate reco flagbit (outer vector) to many db status flags (inner vector)
-  std::vector<int>
-      expanded_v_DB_reco_flags_;  // Transform a map in a vector      // FIXME AM: int or uint32 to be checked
-  std::vector<uint32_t> expanded_Sizes_v_DB_reco_flags_;    // Saving the size for each piece
-  std::vector<uint32_t> expanded_flagbit_v_DB_reco_flags_;  // And the "key" for each key
-
-  uint32_t flagmask_;  // do not propagate channels with these flags on
-};
-
-void EcalRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("uncalibrecHitsInLabelEB",
-                          edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEB"));
-  desc.add<edm::InputTag>("uncalibrecHitsInLabelEE",
-                          edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEE"));
-
-  desc.add<std::string>("recHitsLabelEB", "EcalRecHitsGPUEB");
-  desc.add<std::string>("recHitsLabelEE", "EcalRecHitsGPUEE");
-
-  desc.add<bool>("killDeadChannels", true);
-
-  desc.add<double>("EBLaserMIN", 0.01);
-  desc.add<double>("EELaserMIN", 0.01);
-  desc.add<double>("EBLaserMAX", 30.0);
-  desc.add<double>("EELaserMAX", 30.0);
-}
-
-EcalRecHitProducerGPU::EcalRecHitProducerGPU(const edm::ParameterSet& ps) {
-  //---- input
-  uncalibRecHitsInEBToken_ = consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEB"));
-  uncalibRecHitsInEEToken_ = consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEE"));
-
-  //---- output
-  recHitsTokenEB_ = produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"));
-  recHitsTokenEE_ = produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEE"));
-
-  bool killDeadChannels = ps.getParameter<bool>("killDeadChannels");
-  configParameters_.killDeadChannels = killDeadChannels;
-
-  configParameters_.EBLaserMIN = ps.getParameter<double>("EBLaserMIN");
-  configParameters_.EELaserMIN = ps.getParameter<double>("EELaserMIN");
-  configParameters_.EBLaserMAX = ps.getParameter<double>("EBLaserMAX");
-  configParameters_.EELaserMAX = ps.getParameter<double>("EELaserMAX");
-
-  flagmask_ = 0;
-  flagmask_ |= 0x1 << EcalRecHit::kNeighboursRecovered;
-  flagmask_ |= 0x1 << EcalRecHit::kTowerRecovered;
-  flagmask_ |= 0x1 << EcalRecHit::kDead;
-  flagmask_ |= 0x1 << EcalRecHit::kKilled;
-  flagmask_ |= 0x1 << EcalRecHit::kTPSaturated;
-  flagmask_ |= 0x1 << EcalRecHit::kL1SpikeFlag;
-
-  configParameters_.flagmask = flagmask_;
-
-  // for recovery and killing
-
-  configParameters_.recoverEBIsolatedChannels = ps.getParameter<bool>("recoverEBIsolatedChannels");
-  configParameters_.recoverEEIsolatedChannels = ps.getParameter<bool>("recoverEEIsolatedChannels");
-  configParameters_.recoverEBVFE = ps.getParameter<bool>("recoverEBVFE");
-  configParameters_.recoverEEVFE = ps.getParameter<bool>("recoverEEVFE");
-  configParameters_.recoverEBFE = ps.getParameter<bool>("recoverEBFE");
-  configParameters_.recoverEEFE = ps.getParameter<bool>("recoverEEFE");
-
-  // conditions tokens
-  tokenADCToGeVConstant_ = esConsumes<EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstantRcd>();
-  tokenIntercalibConstants_ = esConsumes<EcalIntercalibConstantsGPU, EcalIntercalibConstantsRcd>();
-  tokenChannelStatus_ = esConsumes<EcalRechitChannelStatusGPU, EcalChannelStatusRcd>();
-  tokenLaserAPDPNRatios_ = esConsumes<EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatiosRcd>();
-  tokenLaserAPDPNRatiosRef_ = esConsumes<EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRefRcd>();
-  tokenLaserAlphas_ = esConsumes<EcalLaserAlphasGPU, EcalLaserAlphasRcd>();
-  tokenLinearCorrections_ = esConsumes<EcalLinearCorrectionsGPU, EcalLinearCorrectionsRcd>();
-  tokenRecHitParameters_ = esConsumes<EcalRecHitParametersGPU, JobConfigurationGPURecord>();
-}
-
-EcalRecHitProducerGPU::~EcalRecHitProducerGPU() {}
-
-void EcalRecHitProducerGPU::acquire(edm::Event const& event,
-                                    edm::EventSetup const& setup,
-                                    edm::WaitingTaskWithArenaHolder holder) {
-  // cuda products
-  auto const& ebUncalibRecHitsProduct = event.get(uncalibRecHitsInEBToken_);
-  auto const& eeUncalibRecHitsProduct = event.get(uncalibRecHitsInEEToken_);
-  // raii
-  cms::cuda::ScopedContextAcquire ctx{ebUncalibRecHitsProduct, std::move(holder), cudaState_};
-  // get actual object
-  auto const& ebUncalibRecHits = ctx.get(ebUncalibRecHitsProduct);
-  auto const& eeUncalibRecHits = ctx.get(eeUncalibRecHitsProduct);
-
-  ecal::rechit::EventInputDataGPU inputDataGPU{ebUncalibRecHits, eeUncalibRecHits};
-
-  neb_ = ebUncalibRecHits.size;
-  nee_ = eeUncalibRecHits.size;
-
-  // stop here if there are no uncalibRecHits
-  if (neb_ + nee_ == 0)
-    return;
-
-  int nchannelsEB = ebUncalibRecHits.size;  // --> offsetForInput, first EB and then EE
-
-  // conditions
-  // - laser correction
-  // - IC
-  // - adt2gev
-
-  //
-  IntercalibConstantsHandle_ = setup.getHandle(tokenIntercalibConstants_);
-  recHitParametersHandle_ = setup.getHandle(tokenRecHitParameters_);
-
-  auto const& ADCToGeVConstantProduct = setup.getData(tokenADCToGeVConstant_).getProduct(ctx.stream());
-  auto const& IntercalibConstantsProduct = IntercalibConstantsHandle_->getProduct(ctx.stream());
-  auto const& ChannelStatusProduct = setup.getData(tokenChannelStatus_).getProduct(ctx.stream());
-
-  auto const& LaserAPDPNRatiosProduct = setup.getData(tokenLaserAPDPNRatios_).getProduct(ctx.stream());
-  auto const& LaserAPDPNRatiosRefProduct = setup.getData(tokenLaserAPDPNRatiosRef_).getProduct(ctx.stream());
-  auto const& LaserAlphasProduct = setup.getData(tokenLaserAlphas_).getProduct(ctx.stream());
-  auto const& LinearCorrectionsProduct = setup.getData(tokenLinearCorrections_).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.get();
-  configParameters_.ChannelStatusToBeExcludedSize = std::get<0>(recHitParametersHandle_->getValues()).get().size();
-  configParameters_.expanded_v_DB_reco_flags = recHitParametersProduct.expanded_v_DB_reco_flags.get();
-  configParameters_.expanded_Sizes_v_DB_reco_flags = recHitParametersProduct.expanded_Sizes_v_DB_reco_flags.get();
-  configParameters_.expanded_flagbit_v_DB_reco_flags = recHitParametersProduct.expanded_flagbit_v_DB_reco_flags.get();
-  configParameters_.expanded_v_DB_reco_flagsSize = std::get<3>(recHitParametersHandle_->getValues()).get().size();
-
-  // bundle up conditions
-  ecal::rechit::ConditionsProducts conditions{ADCToGeVConstantProduct,
-                                              IntercalibConstantsProduct,
-                                              ChannelStatusProduct,
-                                              LaserAPDPNRatiosProduct,
-                                              LaserAPDPNRatiosRefProduct,
-                                              LaserAlphasProduct,
-                                              LinearCorrectionsProduct,
-                                              IntercalibConstantsHandle_->getOffset()};
-
-  // dev mem
-  eventOutputDataGPU_.allocate(configParameters_, neb_, nee_, ctx.stream());
-
-  //
-  // schedule algorithms
-  //
-
-  edm::TimeValue_t event_time = event.time().value();
-
-  ecal::rechit::create_ecal_rehit(
-      inputDataGPU, eventOutputDataGPU_, conditions, configParameters_, nchannelsEB, event_time, ctx.stream());
-
-  cudaCheck(cudaGetLastError());
-}
-
-void EcalRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
-  cms::cuda::ScopedContextProduce ctx{cudaState_};
-
-  eventOutputDataGPU_.recHitsEB.size = neb_;
-  eventOutputDataGPU_.recHitsEE.size = nee_;
-
-  // put into the event
-  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
deleted file mode 100644
index 4ddfd56346dee..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitConvertGPU2CPUFormat.cc
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
-#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
-
-class EcalUncalibRecHitConvertGPU2CPUFormat : public edm::stream::EDProducer<> {
-public:
-  explicit EcalUncalibRecHitConvertGPU2CPUFormat(edm::ParameterSet const& ps);
-  ~EcalUncalibRecHitConvertGPU2CPUFormat() override;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  using InputProduct = ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>;
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  const bool isPhase2_;
-  const edm::EDGetTokenT<InputProduct> recHitsGPUEB_;
-  const edm::EDGetTokenT<InputProduct> recHitsGPUEE_;
-
-  const std::string recHitsLabelCPUEB_;
-  const std::string recHitsLabelCPUEE_;
-};
-
-void EcalUncalibRecHitConvertGPU2CPUFormat::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("recHitsLabelGPUEB", edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEB"));
-  desc.add<std::string>("recHitsLabelCPUEB", "EcalUncalibRecHitsEB");
-  desc.ifValue(
-      edm::ParameterDescription<bool>("isPhase2", false, true),
-      false >>
-              (edm::ParameterDescription<edm::InputTag>(
-                   "recHitsLabelGPUEE", edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEE"), true) and
-               edm::ParameterDescription<std::string>("recHitsLabelCPUEE", "EcalUncalibRecHitsEE", true)) or
-          true >> edm::EmptyGroupDescription());
-  confDesc.add("ecalUncalibRecHitConvertGPU2CPUFormat", desc);
-}
-
-EcalUncalibRecHitConvertGPU2CPUFormat::EcalUncalibRecHitConvertGPU2CPUFormat(const edm::ParameterSet& ps)
-    : isPhase2_{ps.getParameter<bool>("isPhase2")},
-      recHitsGPUEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEB"))},
-      recHitsGPUEE_{isPhase2_ ? edm::EDGetTokenT<InputProduct>{}
-                              : consumes<InputProduct>(ps.getParameter<edm::InputTag>("recHitsLabelGPUEE"))},
-      recHitsLabelCPUEB_{ps.getParameter<std::string>("recHitsLabelCPUEB")},
-      recHitsLabelCPUEE_{isPhase2_ ? std::string{""} : ps.getParameter<std::string>("recHitsLabelCPUEE")} {
-  produces<EBUncalibratedRecHitCollection>(recHitsLabelCPUEB_);
-  if (!isPhase2_)
-    produces<EEUncalibratedRecHitCollection>(recHitsLabelCPUEE_);
-}
-
-EcalUncalibRecHitConvertGPU2CPUFormat::~EcalUncalibRecHitConvertGPU2CPUFormat() {}
-
-void EcalUncalibRecHitConvertGPU2CPUFormat::produce(edm::Event& event, edm::EventSetup const& setup) {
-  auto const& recHitsGPUEB = event.get(recHitsGPUEB_);
-  auto recHitsCPUEB = std::make_unique<EBUncalibratedRecHitCollection>();
-  recHitsCPUEB->reserve(recHitsGPUEB.amplitude.size());
-
-  for (uint32_t i = 0; i < recHitsGPUEB.amplitude.size(); ++i) {
-    recHitsCPUEB->emplace_back(DetId{recHitsGPUEB.did[i]},
-                               recHitsGPUEB.amplitude[i],
-                               recHitsGPUEB.pedestal[i],
-                               recHitsGPUEB.jitter[i],
-                               recHitsGPUEB.chi2[i],
-                               recHitsGPUEB.flags[i]);
-    if (isPhase2_)
-      (*recHitsCPUEB)[i].setAmplitudeError(recHitsGPUEB.amplitudeError[i]);
-    (*recHitsCPUEB)[i].setJitterError(recHitsGPUEB.jitterError[i]);
-    auto const offset = i * EcalDataFrame::MAXSAMPLES;
-    for (uint32_t sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample)
-      (*recHitsCPUEB)[i].setOutOfTimeAmplitude(sample, recHitsGPUEB.amplitudesAll[offset + sample]);
-  }
-  if (!isPhase2_) {
-    auto const& recHitsGPUEE = event.get(recHitsGPUEE_);
-    auto recHitsCPUEE = std::make_unique<EEUncalibratedRecHitCollection>();
-    recHitsCPUEE->reserve(recHitsGPUEE.amplitude.size());
-    for (uint32_t i = 0; i < recHitsGPUEE.amplitude.size(); ++i) {
-      recHitsCPUEE->emplace_back(DetId{recHitsGPUEE.did[i]},
-                                 recHitsGPUEE.amplitude[i],
-                                 recHitsGPUEE.pedestal[i],
-                                 recHitsGPUEE.jitter[i],
-                                 recHitsGPUEE.chi2[i],
-                                 recHitsGPUEE.flags[i]);
-      (*recHitsCPUEE)[i].setJitterError(recHitsGPUEE.jitterError[i]);
-      auto const offset = i * EcalDataFrame::MAXSAMPLES;
-      for (uint32_t sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
-        (*recHitsCPUEE)[i].setOutOfTimeAmplitude(sample, recHitsGPUEE.amplitudesAll[offset + sample]);
-      }
-    }
-    event.put(std::move(recHitsCPUEE), recHitsLabelCPUEE_);
-  }
-  event.put(std::move(recHitsCPUEB), recHitsLabelCPUEB_);
-}
-
-DEFINE_FWK_MODULE(EcalUncalibRecHitConvertGPU2CPUFormat);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.cu
deleted file mode 100644
index 6d4f0b9a24220..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.cu
+++ /dev/null
@@ -1,304 +0,0 @@
-#include <iostream>
-#include <limits>
-
-#include <cuda.h>
-
-#include "CondFormats/EcalObjects/interface/EcalMGPAGainRatio.h"
-#include "CondFormats/EcalObjects/interface/EcalPedestals.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariances.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapes.h"
-#include "CondFormats/EcalObjects/interface/EcalSampleMask.h"
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelation.h"
-#include "CondFormats/EcalObjects/interface/EcalXtalGroupId.h"
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-
-#include "AmplitudeComputationCommonKernels.h"
-#include "AmplitudeComputationKernels.h"
-#include "EcalUncalibRecHitMultiFitAlgoGPU.h"
-#include "TimeComputationKernels.h"
-
-//#define DEBUG
-
-//#define ECAL_RECO_CUDA_DEBUG
-
-namespace ecal {
-  namespace multifit {
-
-    void entryPoint(EventInputDataGPU const& eventInputGPU,
-                    EventOutputDataGPU& eventOutputGPU,
-                    EventDataForScratchGPU& scratch,
-                    ConditionsProducts const& conditions,
-                    ConfigurationParameters const& configParameters,
-                    cudaStream_t cudaStream) {
-      using digis_type = std::vector<uint16_t>;
-      using dids_type = std::vector<uint32_t>;
-      // accodring to the cpu setup  //----> hardcoded
-      bool const gainSwitchUseMaxSampleEB = true;
-      // accodring to the cpu setup  //----> hardcoded
-      bool const gainSwitchUseMaxSampleEE = false;
-
-      uint32_t const offsetForHashes = conditions.offsetForHashes;
-      uint32_t const offsetForInputs = eventInputGPU.ebDigis.size;
-      unsigned int totalChannels = eventInputGPU.ebDigis.size + eventInputGPU.eeDigis.size;
-
-      //
-      // 1d preparation kernel
-      //
-      unsigned int nchannels_per_block = 32;
-      unsigned int threads_1d = 10 * nchannels_per_block;
-      unsigned int blocks_1d = threads_1d > 10 * totalChannels ? 1 : (totalChannels * 10 + threads_1d - 1) / threads_1d;
-      int shared_bytes = nchannels_per_block * EcalDataFrame::MAXSAMPLES *
-                         (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.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.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,
-          gainSwitchUseMaxSampleEE,
-          totalChannels);
-      cudaCheck(cudaGetLastError());
-
-      //
-      // 2d preparation kernel
-      //
-      int blocks_2d = totalChannels;
-      dim3 threads_2d{10, 10};
-      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,
-                                                               conditions.gainRatios.gain12Over6,
-                                                               conditions.gainRatios.gain6Over1,
-                                                               conditions.samplesCorrelation.EBG12SamplesCorrelation,
-                                                               conditions.samplesCorrelation.EBG6SamplesCorrelation,
-                                                               conditions.samplesCorrelation.EBG1SamplesCorrelation,
-                                                               conditions.samplesCorrelation.EEG12SamplesCorrelation,
-                                                               conditions.samplesCorrelation.EEG6SamplesCorrelation,
-                                                               conditions.samplesCorrelation.EEG1SamplesCorrelation,
-                                                               (SampleMatrix*)scratch.noisecov.get(),
-                                                               (PulseMatrixType*)scratch.pulse_matrix.get(),
-                                                               conditions.pulseShapes.values,
-                                                               scratch.hasSwitchToGain6.get(),
-                                                               scratch.hasSwitchToGain1.get(),
-                                                               scratch.isSaturated.get(),
-                                                               offsetForHashes,
-                                                               offsetForInputs);
-      cudaCheck(cudaGetLastError());
-
-      // run minimization kernels
-      v1::minimization_procedure(eventInputGPU, eventOutputGPU, scratch, conditions, configParameters, cudaStream);
-
-      if (configParameters.shouldRunTimingComputation) {
-        //
-        // TODO: this guy can run concurrently with other kernels,
-        // there is no dependence on the order of execution
-        //
-        unsigned int threads_time_init = threads_1d;
-        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.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,
-            conditions.pedestals.mean_x12,
-            conditions.pedestals.mean_x6,
-            conditions.pedestals.mean_x1,
-            conditions.gainRatios.gain12Over6,
-            conditions.gainRatios.gain6Over1,
-            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(),
-            conditions.sampleMask.getEcalSampleMaskRecordEE(),
-            totalChannels);
-        cudaCheck(cudaGetLastError());
-
-        //
-        // TODO: small kernel only for EB. It needs to be checked if
-        /// fusing such small kernels is beneficial in here
-        //
-        // we are running only over EB digis
-        // therefore we need to create threads/blocks only for that
-        unsigned int const threadsFixMGPA = threads_1d;
-        unsigned int const blocksFixMGPA =
-            threadsFixMGPA > 10 * eventInputGPU.ebDigis.size
-                ? 1
-                : (10 * eventInputGPU.ebDigis.size + threadsFixMGPA - 1) / threadsFixMGPA;
-        kernel_time_compute_fixMGPAslew<<<blocksFixMGPA, threadsFixMGPA, 0, cudaStream>>>(
-            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);
-        cudaCheck(cudaGetLastError());
-
-        int sharedBytes = EcalDataFrame::MAXSAMPLES * nchannels_per_block * 4 * sizeof(SampleVector::Scalar);
-        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.get(),
-            scratch.sample_value_errors.get(),
-            scratch.useless_sample_values.get(),
-            scratch.chi2sNullHypot.get(),
-            scratch.sum0sNullHypot.get(),
-            scratch.sumAAsNullHypot.get(),
-            totalChannels);
-        cudaCheck(cudaGetLastError());
-
-        unsigned int nchannels_per_block_makeratio = 10;
-        unsigned int threads_makeratio = 45 * nchannels_per_block_makeratio;
-        unsigned int blocks_makeratio = threads_makeratio > 45 * totalChannels
-                                            ? 1
-                                            : (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.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.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,
-            configParameters.timeFitLimitsFirstEE,
-            configParameters.timeFitLimitsSecondEB,
-            configParameters.timeFitLimitsSecondEE,
-            totalChannels,
-            offsetForInputs);
-        cudaCheck(cudaGetLastError());
-
-        auto const threads_findamplchi2 = threads_1d;
-        auto const blocks_findamplchi2 = blocks_1d;
-        int const sharedBytesFindAmplChi2 = 2 * threads_findamplchi2 * sizeof(SampleVector::Scalar);
-        kernel_time_compute_findamplchi2_and_finish<<<blocks_findamplchi2,
-                                                      threads_findamplchi2,
-                                                      sharedBytesFindAmplChi2,
-                                                      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.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());
-
-        auto const threads_timecorr = 32;
-        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.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.get(),
-            scratch.timeError.get(),
-            conditions.pedestals.rms_x12,
-            conditions.timeCalibConstants.values,
-            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,
-            configParameters.timeConstantTermEE,
-            conditions.timeOffsetConstant.getEBValue(),
-            conditions.timeOffsetConstant.getEEValue(),
-            configParameters.timeNconstEB,
-            configParameters.timeNconstEE,
-            configParameters.amplitudeThreshEB,
-            configParameters.amplitudeThreshEE,
-            configParameters.outOfTimeThreshG12pEB,
-            configParameters.outOfTimeThreshG12pEE,
-            configParameters.outOfTimeThreshG12mEB,
-            configParameters.outOfTimeThreshG12mEE,
-            configParameters.outOfTimeThreshG61pEB,
-            configParameters.outOfTimeThreshG61pEE,
-            configParameters.outOfTimeThreshG61mEB,
-            configParameters.outOfTimeThreshG61mEE,
-            offsetForHashes,
-            offsetForInputs,
-            totalChannels);
-        cudaCheck(cudaGetLastError());
-      }
-    }
-
-  }  // namespace multifit
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.h
deleted file mode 100644
index c84047a8bf8e7..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitMultiFitAlgoGPU.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitMultiFitAlgoGPU_h
-#define RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitMultiFitAlgoGPU_h
-
-#include <vector>
-
-#include <cuda.h>
-
-#include "DeclsForKernels.h"
-
-namespace ecal {
-  namespace multifit {
-
-    void entryPoint(EventInputDataGPU const&,
-                    EventOutputDataGPU&,
-                    EventDataForScratchGPU&,
-                    ConditionsProducts const&,
-                    ConfigurationParameters const&,
-                    cudaStream_t);
-
-  }  // namespace multifit
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitMultiFitAlgoGPU_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.cu
deleted file mode 100644
index 0ed3ede25734e..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.cu
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-
-#include "EcalUncalibRecHitPhase2WeightsKernels.h"
-#include "EcalUncalibRecHitPhase2WeightsAlgoGPU.h"
-
-namespace ecal {
-  namespace weights {
-
-    void phase2Weights(ecal::DigisCollection<calo::common::DevStoragePolicy> const& digis,
-                       EventOutputDataGPU& eventOutputGPU,
-                       cms::cuda::device::unique_ptr<double[]>& weights_d,
-                       cudaStream_t cudaStream) {
-      unsigned int const totalChannels = digis.size;
-      // 64 threads per block best occupancy from Nsight compute profiler
-      unsigned int const threads_1d = 64;
-      unsigned int const blocks_1d = (totalChannels + threads_1d - 1) / threads_1d;
-      int shared_bytes = EcalDataFrame_Ph2::MAXSAMPLES * sizeof(double) +
-                         threads_1d * (EcalDataFrame_Ph2::MAXSAMPLES * (sizeof(uint16_t)) + sizeof(float));
-      Phase2WeightsKernel<<<blocks_1d, threads_1d, shared_bytes, cudaStream>>>(
-          digis.data.get(),
-          digis.ids.get(),
-          eventOutputGPU.recHits.amplitude.get(),
-          eventOutputGPU.recHits.amplitudeError.get(),
-          eventOutputGPU.recHits.did.get(),
-          totalChannels,
-          weights_d.get(),
-          eventOutputGPU.recHits.flags.get());
-      cudaCheck(cudaGetLastError());
-    }
-
-  }  // namespace weights
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.h
deleted file mode 100644
index 82e0ebca59f32..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsAlgoGPU.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitPhase2WeightsAlgoGPU_h
-#define RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitPhase2WeightsAlgoGPU_h
-
-#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
-
-#include "DeclsForKernelsPhase2.h"
-
-namespace ecal {
-  namespace weights {
-
-    void phase2Weights(ecal::DigisCollection<calo::common::DevStoragePolicy> const&,
-                       EventOutputDataGPU&,
-                       cms::cuda::device::unique_ptr<double[]>&,
-                       cudaStream_t);
-
-  }  // namespace weights
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitPhase2WeightsAlgoGPU_h
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.cu b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.cu
deleted file mode 100644
index 66b977c91ed16..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.cu
+++ /dev/null
@@ -1,65 +0,0 @@
-#include <cuda.h>
-
-#include "FWCore/Utilities/interface/CMSUnrollLoop.h"
-#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h"
-#include "DataFormats/EcalDigi/interface/EcalConstants.h"
-
-#include "EcalUncalibRecHitPhase2WeightsKernels.h"
-
-namespace ecal {
-  namespace weights {
-
-    __global__ void Phase2WeightsKernel(uint16_t const* digis_in,
-                                        uint32_t const* __restrict__ dids,
-                                        ::ecal::reco::StorageScalarType* __restrict__ amplitude,
-                                        ::ecal::reco::StorageScalarType* __restrict__ amplitudeError,
-                                        uint32_t* __restrict__ dids_out,
-                                        int const nchannels,
-                                        double const* __restrict__ weights,
-                                        uint32_t* __restrict__ flags) {
-      constexpr int nsamples = EcalDataFrame_Ph2::MAXSAMPLES;
-      unsigned int nchannels_per_block = blockDim.x;
-
-      // copy data from global to shared memory
-      extern __shared__ char shared_mem[];
-      double* shr_weights = reinterpret_cast<double*>(shared_mem);                       // nsamples elements
-      float* shr_amp = reinterpret_cast<float*>(shr_weights + nsamples);                 // nchannels_per_block elements
-      uint16_t* shr_digis = reinterpret_cast<uint16_t*>(shr_amp + nchannels_per_block);  // nchannels_per_block elements
-      for (int i = 0; i < nsamples; ++i)
-        shr_weights[i] = weights[i];
-
-      unsigned int const threadx = threadIdx.x;
-      unsigned int const blockx = blockIdx.x;
-
-      for (int sample = 0; sample < nsamples; ++sample) {
-        int const idx = threadx * nsamples + sample;
-        shr_digis[idx] = digis_in[blockx * nchannels_per_block * nsamples + idx];
-      }
-      shr_amp[threadx] = 0.;
-
-      __syncthreads();
-
-      const auto first = threadIdx.x + blockIdx.x * blockDim.x;
-      const auto stride = blockDim.x * gridDim.x;
-      for (auto tx = first; tx < nchannels; tx += stride) {
-        auto const did = DetId{dids[tx]};
-        CMS_UNROLL_LOOP
-        for (int sample = 0; sample < nsamples; ++sample) {
-          const unsigned int idx = threadx * nsamples + sample;
-          const auto shr_digi = shr_digis[idx];
-          shr_amp[threadx] += (static_cast<float>(ecalLiteDTU::adc(shr_digi)) *
-                               ecalPh2::gains[ecalLiteDTU::gainId(shr_digi)] * shr_weights[sample]);
-        }
-        const unsigned int tdx = threadx * nsamples;
-        amplitude[tx] = shr_amp[threadx];
-        amplitudeError[tx] = 1.0f;
-        dids_out[tx] = did.rawId();
-        flags[tx] = 0;
-        if (ecalLiteDTU::gainId(shr_digis[tdx + nsamples - 1])) {
-          flags[tx] = 0x1 << EcalUncalibratedRecHit::kHasSwitchToGain1;
-        }
-      }  //if within nchannels
-    }  //kernel
-  }  //namespace weights
-}  //namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.h
deleted file mode 100644
index 22fd89eccdefa..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsKernels.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitPhase2WeightsKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_EcalUncalibRecHitPhase2WeightsKernels_h
-
-#include "DeclsForKernelsPhase2.h"
-
-namespace ecal {
-  namespace weights {
-
-    __global__ void Phase2WeightsKernel(uint16_t const* digis_in_eb,
-                                        uint32_t const* dids_eb,
-                                        ::ecal::reco::StorageScalarType* amplitudeEB,
-                                        ::ecal::reco::StorageScalarType* amplitudeErrorEB,
-                                        uint32_t* dids_outEB,
-                                        int const nchannels,
-                                        double const* weights_d,
-                                        uint32_t* flagsEB);
-  }  //namespace weights
-}  //namespace ecal
-
-#endif
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsProducerGPU.cc
deleted file mode 100644
index 7f38911d720dc..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitPhase2WeightsProducerGPU.cc
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
-
-#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h"
-
-#include "EcalUncalibRecHitPhase2WeightsAlgoGPU.h"
-#include "DeclsForKernelsPhase2.h"
-
-class EcalUncalibRecHitPhase2WeightsProducerGPU : public edm::stream::EDProducer<> {
-public:
-  explicit EcalUncalibRecHitPhase2WeightsProducerGPU(edm::ParameterSet const &ps);
-  ~EcalUncalibRecHitPhase2WeightsProducerGPU() override = default;
-  static void fillDescriptions(edm::ConfigurationDescriptions &);
-
-private:
-  void produce(edm::Event &, edm::EventSetup const &) override;
-
-private:
-  const std::vector<double, cms::cuda::HostAllocator<double>> weights_;
-
-  using InputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
-  const edm::EDGetTokenT<InputProduct> digisToken_;
-  using OutputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
-  const edm::EDPutTokenT<OutputProduct> recHitsToken_;
-
-  // event data
-  ecal::weights::EventOutputDataGPU eventOutputDataGPU_;
-};
-
-// constructor with initialisation of elements
-EcalUncalibRecHitPhase2WeightsProducerGPU::EcalUncalibRecHitPhase2WeightsProducerGPU(const edm::ParameterSet &ps)
-    :  // use lambda to initialise the vector with CUDA::HostAllocator from a normal vector
-      weights_([tmp = ps.getParameter<std::vector<double>>("weights")] {
-        return std::vector<double, cms::cuda::HostAllocator<double>>(tmp.begin(), tmp.end());
-      }()),
-      digisToken_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEB"))},
-      recHitsToken_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"))} {}
-
-void EcalUncalibRecHitPhase2WeightsProducerGPU::fillDescriptions(edm::ConfigurationDescriptions &descriptions) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
-  //The below weights values should be kept up to date with those on the CPU version of this module
-  desc.add<std::vector<double>>("weights",
-                                {-0.121016,
-                                 -0.119899,
-                                 -0.120923,
-                                 -0.0848959,
-                                 0.261041,
-                                 0.509881,
-                                 0.373591,
-                                 0.134899,
-                                 -0.0233605,
-                                 -0.0913195,
-                                 -0.112452,
-                                 -0.118596,
-                                 -0.121737,
-                                 -0.121737,
-                                 -0.121737,
-                                 -0.121737});
-
-  desc.add<edm::InputTag>("digisLabelEB", edm::InputTag("simEcalUnsuppressedDigis", ""));
-
-  descriptions.addWithDefaultLabel(desc);
-}
-
-void EcalUncalibRecHitPhase2WeightsProducerGPU::produce(edm::Event &event, const edm::EventSetup &setup) {
-  // cuda products
-  auto const &digisProduct = event.get(digisToken_);
-  // raii
-  cms::cuda::ScopedContextProduce ctx{digisProduct};
-
-  // get actual obj
-  auto const &digis = ctx.get(digisProduct);
-
-  const uint32_t size = digis.size;
-
-  // do not run the algo if there are no digis
-  if (size > 0) {
-    auto weights_d = cms::cuda::make_device_unique<double[]>(EcalDataFrame_Ph2::MAXSAMPLES, ctx.stream());
-
-    cudaCheck(cudaMemcpyAsync(weights_d.get(),
-                              weights_.data(),
-                              EcalDataFrame_Ph2::MAXSAMPLES * sizeof(double),
-                              cudaMemcpyHostToDevice,
-                              ctx.stream()));
-
-    // output on GPU
-    eventOutputDataGPU_.allocate(size, ctx.stream());
-
-    ecal::weights::phase2Weights(digis, eventOutputDataGPU_, weights_d, ctx.stream());
-  }
-
-  // set the size of digis
-  eventOutputDataGPU_.recHits.size = size;
-
-  // put into the event
-  ctx.emplace(event, recHitsToken_, std::move(eventOutputDataGPU_.recHits));
-}
-
-DEFINE_FWK_MODULE(EcalUncalibRecHitPhase2WeightsProducerGPU);
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
deleted file mode 100644
index 5f8dc3da5bc1d..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
+++ /dev/null
@@ -1,264 +0,0 @@
-#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
-#include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalSampleMaskRcd.h"
-#include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeOffsetConstantRcd.h"
-#include "CondFormats/EcalObjects/interface/EcalGainRatiosGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalMultifitParametersGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPedestalsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseCovariancesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalPulseShapesGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalSamplesCorrelationGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeBiasCorrectionsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeCalibConstantsGPU.h"
-#include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
-#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h"
-#include "FWCore/Framework/interface/Event.h"
-#include "FWCore/Framework/interface/EventSetup.h"
-#include "FWCore/Framework/interface/MakerMacros.h"
-#include "FWCore/Framework/interface/stream/EDProducer.h"
-#include "FWCore/ParameterSet/interface/ParameterSet.h"
-#include "FWCore/Utilities/interface/ESInputTag.h"
-#include "HeterogeneousCore/CUDACore/interface/JobConfigurationGPURecord.h"
-#include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
-#include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
-
-#include "DeclsForKernels.h"
-#include "EcalUncalibRecHitMultiFitAlgoGPU.h"
-
-class EcalUncalibRecHitProducerGPU : public edm::stream::EDProducer<> {
-public:
-  explicit EcalUncalibRecHitProducerGPU(edm::ParameterSet const& ps);
-  ~EcalUncalibRecHitProducerGPU() override;
-  static void fillDescriptions(edm::ConfigurationDescriptions&);
-
-private:
-  void produce(edm::Event&, edm::EventSetup const&) override;
-
-private:
-  using InputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>;
-  const edm::EDGetTokenT<InputProduct> digisTokenEB_, digisTokenEE_;
-  using OutputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
-  const edm::EDPutTokenT<OutputProduct> recHitsTokenEB_, recHitsTokenEE_;
-
-  // conditions tokens
-  const edm::ESGetToken<EcalPedestalsGPU, EcalPedestalsRcd> pedestalsToken_;
-  const edm::ESGetToken<EcalGainRatiosGPU, EcalGainRatiosRcd> gainRatiosToken_;
-  const edm::ESGetToken<EcalPulseShapesGPU, EcalPulseShapesRcd> pulseShapesToken_;
-  const edm::ESGetToken<EcalPulseCovariancesGPU, EcalPulseCovariancesRcd> pulseCovariancesToken_;
-  const edm::ESGetToken<EcalSamplesCorrelationGPU, EcalSamplesCorrelationRcd> samplesCorrelationToken_;
-  const edm::ESGetToken<EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrectionsRcd> timeBiasCorrectionsToken_;
-  const edm::ESGetToken<EcalTimeCalibConstantsGPU, EcalTimeCalibConstantsRcd> timeCalibConstantsToken_;
-  const edm::ESGetToken<EcalSampleMask, EcalSampleMaskRcd> sampleMaskToken_;
-  const edm::ESGetToken<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd> timeOffsetConstantToken_;
-  const edm::ESGetToken<EcalMultifitParametersGPU, JobConfigurationGPURecord> multifitParametersToken_;
-
-  // configuration parameters
-  ecal::multifit::ConfigurationParameters configParameters_;
-};
-
-void EcalUncalibRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
-  edm::ParameterSetDescription desc;
-
-  desc.add<edm::InputTag>("digisLabelEB", edm::InputTag("ecalRawToDigiGPU", "ebDigis"));
-  desc.add<edm::InputTag>("digisLabelEE", edm::InputTag("ecalRawToDigiGPU", "eeDigis"));
-
-  desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
-  desc.add<std::string>("recHitsLabelEE", "EcalUncalibRecHitsEE");
-
-  desc.add<edm::ESInputTag>("timeCalibTag", edm::ESInputTag());
-  desc.add<edm::ESInputTag>("timeOffsetTag", edm::ESInputTag());
-  desc.add<double>("EBtimeFitLimits_Lower", 0.2);
-  desc.add<double>("EBtimeFitLimits_Upper", 1.4);
-  desc.add<double>("EEtimeFitLimits_Lower", 0.2);
-  desc.add<double>("EEtimeFitLimits_Upper", 1.4);
-  desc.add<double>("EBtimeConstantTerm", .6);
-  desc.add<double>("EEtimeConstantTerm", 1.0);
-  desc.add<double>("EBtimeNconst", 28.5);
-  desc.add<double>("EEtimeNconst", 31.8);
-  desc.add<double>("outOfTimeThresholdGain12pEB", 5);
-  desc.add<double>("outOfTimeThresholdGain12mEB", 5);
-  desc.add<double>("outOfTimeThresholdGain61pEB", 5);
-  desc.add<double>("outOfTimeThresholdGain61mEB", 5);
-  desc.add<double>("outOfTimeThresholdGain12pEE", 1000);
-  desc.add<double>("outOfTimeThresholdGain12mEE", 1000);
-  desc.add<double>("outOfTimeThresholdGain61pEE", 1000);
-  desc.add<double>("outOfTimeThresholdGain61mEE", 1000);
-  desc.add<double>("amplitudeThresholdEB", 10);
-  desc.add<double>("amplitudeThresholdEE", 10);
-  desc.addUntracked<std::vector<uint32_t>>("kernelMinimizeThreads", {32, 1, 1});
-  desc.add<bool>("shouldRunTimingComputation", true);
-  confDesc.addWithDefaultLabel(desc);
-}
-
-EcalUncalibRecHitProducerGPU::EcalUncalibRecHitProducerGPU(const edm::ParameterSet& ps)
-    : digisTokenEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEB"))},
-      digisTokenEE_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("digisLabelEE"))},
-      recHitsTokenEB_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"))},
-      recHitsTokenEE_{produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEE"))},
-      pedestalsToken_{esConsumes<EcalPedestalsGPU, EcalPedestalsRcd>()},
-      gainRatiosToken_{esConsumes<EcalGainRatiosGPU, EcalGainRatiosRcd>()},
-      pulseShapesToken_{esConsumes<EcalPulseShapesGPU, EcalPulseShapesRcd>()},
-      pulseCovariancesToken_{esConsumes<EcalPulseCovariancesGPU, EcalPulseCovariancesRcd>()},
-      samplesCorrelationToken_{esConsumes<EcalSamplesCorrelationGPU, EcalSamplesCorrelationRcd>()},
-      timeBiasCorrectionsToken_{esConsumes<EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrectionsRcd>()},
-      timeCalibConstantsToken_{esConsumes<EcalTimeCalibConstantsGPU, EcalTimeCalibConstantsRcd>(
-          ps.getParameter<edm::ESInputTag>("timeCalibTag"))},
-      sampleMaskToken_{esConsumes<EcalSampleMask, EcalSampleMaskRcd>()},
-      timeOffsetConstantToken_{esConsumes<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd>(
-          ps.getParameter<edm::ESInputTag>("timeOffsetTag"))},
-      multifitParametersToken_{esConsumes<EcalMultifitParametersGPU, JobConfigurationGPURecord>()} {
-  std::pair<double, double> EBtimeFitLimits, EEtimeFitLimits;
-  EBtimeFitLimits.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
-  EBtimeFitLimits.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
-  EEtimeFitLimits.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
-  EEtimeFitLimits.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
-
-  auto EBtimeConstantTerm = ps.getParameter<double>("EBtimeConstantTerm");
-  auto EEtimeConstantTerm = ps.getParameter<double>("EEtimeConstantTerm");
-  auto EBtimeNconst = ps.getParameter<double>("EBtimeNconst");
-  auto EEtimeNconst = ps.getParameter<double>("EEtimeNconst");
-
-  auto outOfTimeThreshG12pEB = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
-  auto outOfTimeThreshG12mEB = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
-  auto outOfTimeThreshG61pEB = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
-  auto outOfTimeThreshG61mEB = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
-  auto outOfTimeThreshG12pEE = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
-  auto outOfTimeThreshG12mEE = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
-  auto outOfTimeThreshG61pEE = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
-  auto outOfTimeThreshG61mEE = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
-  auto amplitudeThreshEB = ps.getParameter<double>("amplitudeThresholdEB");
-  auto amplitudeThreshEE = ps.getParameter<double>("amplitudeThresholdEE");
-
-  // switch to run timing computation kernels
-  configParameters_.shouldRunTimingComputation = ps.getParameter<bool>("shouldRunTimingComputation");
-
-  // minimize kernel launch conf
-  auto threadsMinimize = ps.getUntrackedParameter<std::vector<uint32_t>>("kernelMinimizeThreads");
-  configParameters_.kernelMinimizeThreads[0] = threadsMinimize[0];
-  configParameters_.kernelMinimizeThreads[1] = threadsMinimize[1];
-  configParameters_.kernelMinimizeThreads[2] = threadsMinimize[2];
-
-  //
-  // configuration and physics parameters: done once
-  // assume there is a single device
-  // use sync copying
-  //
-
-  // time fit parameters and limits
-  configParameters_.timeFitLimitsFirstEB = EBtimeFitLimits.first;
-  configParameters_.timeFitLimitsSecondEB = EBtimeFitLimits.second;
-  configParameters_.timeFitLimitsFirstEE = EEtimeFitLimits.first;
-  configParameters_.timeFitLimitsSecondEE = EEtimeFitLimits.second;
-
-  // time constant terms
-  configParameters_.timeConstantTermEB = EBtimeConstantTerm;
-  configParameters_.timeConstantTermEE = EEtimeConstantTerm;
-
-  // time N const
-  configParameters_.timeNconstEB = EBtimeNconst;
-  configParameters_.timeNconstEE = EEtimeNconst;
-
-  // amplitude threshold for time flags
-  configParameters_.amplitudeThreshEB = amplitudeThreshEB;
-  configParameters_.amplitudeThreshEE = amplitudeThreshEE;
-
-  // out of time thresholds gain-dependent
-  configParameters_.outOfTimeThreshG12pEB = outOfTimeThreshG12pEB;
-  configParameters_.outOfTimeThreshG12pEE = outOfTimeThreshG12pEE;
-  configParameters_.outOfTimeThreshG61pEB = outOfTimeThreshG61pEB;
-  configParameters_.outOfTimeThreshG61pEE = outOfTimeThreshG61pEE;
-  configParameters_.outOfTimeThreshG12mEB = outOfTimeThreshG12mEB;
-  configParameters_.outOfTimeThreshG12mEE = outOfTimeThreshG12mEE;
-  configParameters_.outOfTimeThreshG61mEB = outOfTimeThreshG61mEB;
-  configParameters_.outOfTimeThreshG61mEE = outOfTimeThreshG61mEE;
-}
-
-EcalUncalibRecHitProducerGPU::~EcalUncalibRecHitProducerGPU() {}
-
-void EcalUncalibRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
-  //DurationMeasurer<std::chrono::milliseconds> timer{std::string{"produce duration"}};
-
-  // cuda products
-  auto const& ebDigisProduct = event.get(digisTokenEB_);
-  auto const& eeDigisProduct = event.get(digisTokenEE_);
-  // event data
-  ecal::multifit::EventOutputDataGPU eventOutputDataGPU;
-
-  // raii
-  cms::cuda::ScopedContextProduce ctx{ebDigisProduct};
-
-  // get actual obj
-  auto const& ebDigis = ctx.get(ebDigisProduct);
-  auto const& eeDigis = ctx.get(eeDigisProduct);
-  ecal::multifit::EventInputDataGPU inputDataGPU{ebDigis, eeDigis};
-  const uint32_t neb = ebDigis.size;
-  const uint32_t nee = eeDigis.size;
-
-  // stop here if there are no digis
-  if (neb + nee > 0) {
-    // conditions
-    auto const& timeCalibConstantsData = setup.getData(timeCalibConstantsToken_);
-    auto const& sampleMaskData = setup.getData(sampleMaskToken_);
-    auto const& timeOffsetConstantData = setup.getData(timeOffsetConstantToken_);
-    auto const& multifitParametersData = setup.getData(multifitParametersToken_);
-
-    auto const& pedestals = setup.getData(pedestalsToken_).getProduct(ctx.stream());
-    auto const& gainRatios = setup.getData(gainRatiosToken_).getProduct(ctx.stream());
-    auto const& pulseShapes = setup.getData(pulseShapesToken_).getProduct(ctx.stream());
-    auto const& pulseCovariances = setup.getData(pulseCovariancesToken_).getProduct(ctx.stream());
-    auto const& samplesCorrelation = setup.getData(samplesCorrelationToken_).getProduct(ctx.stream());
-    auto const& timeBiasCorrections = setup.getData(timeBiasCorrectionsToken_).getProduct(ctx.stream());
-    auto const& timeCalibConstants = timeCalibConstantsData.getProduct(ctx.stream());
-    auto const& multifitParameters = multifitParametersData.getProduct(ctx.stream());
-
-    // assign ptrs/values: this is done not to change how things look downstream
-    configParameters_.amplitudeFitParametersEB = multifitParameters.amplitudeFitParametersEB.get();
-    configParameters_.amplitudeFitParametersEE = multifitParameters.amplitudeFitParametersEE.get();
-    configParameters_.timeFitParametersEB = multifitParameters.timeFitParametersEB.get();
-    configParameters_.timeFitParametersEE = multifitParameters.timeFitParametersEE.get();
-    configParameters_.timeFitParametersSizeEB = multifitParametersData.getValues()[2].get().size();
-    configParameters_.timeFitParametersSizeEE = multifitParametersData.getValues()[3].get().size();
-
-    // bundle up conditions
-    ecal::multifit::ConditionsProducts conditions{pedestals,
-                                                  gainRatios,
-                                                  pulseShapes,
-                                                  pulseCovariances,
-                                                  samplesCorrelation,
-                                                  timeBiasCorrections,
-                                                  timeCalibConstants,
-                                                  sampleMaskData,
-                                                  timeOffsetConstantData,
-                                                  timeCalibConstantsData.getOffset(),
-                                                  multifitParameters};
-
-    // dev mem
-    eventOutputDataGPU.allocate(configParameters_, neb, nee, ctx.stream());
-
-    // scratch mem
-    ecal::multifit::EventDataForScratchGPU eventDataForScratchGPU;
-    eventDataForScratchGPU.allocate(configParameters_, neb, nee, ctx.stream());
-
-    //
-    // schedule algorithms
-    //
-    ecal::multifit::entryPoint(
-        inputDataGPU, eventOutputDataGPU, eventDataForScratchGPU, conditions, configParameters_, ctx.stream());
-  }
-
-  // set the size of eb and ee
-  eventOutputDataGPU.recHitsEB.size = neb;
-  eventOutputDataGPU.recHitsEE.size = nee;
-
-  // put into the event
-  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
deleted file mode 100644
index e67802f44c8df..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.cu
+++ /dev/null
@@ -1,1133 +0,0 @@
-#include <cmath>
-#include <limits>
-
-#include <cuda.h>
-
-#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
-#include "DataFormats/EcalDigi/interface/EcalMGPASample.h"
-#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHit.h"
-#include "DataFormats/Math/interface/approx_exp.h"
-#include "DataFormats/Math/interface/approx_log.h"
-#include "FWCore/Utilities/interface/CMSUnrollLoop.h"
-
-#include "TimeComputationKernels.h"
-#include "KernelHelpers.h"
-
-//#define DEBUG
-
-//#define ECAL_RECO_CUDA_DEBUG
-
-namespace ecal {
-  namespace multifit {
-
-    __device__ __forceinline__ bool use_sample(unsigned int sample_mask, unsigned int sample) {
-      return sample_mask & (0x1 << (EcalDataFrame::MAXSAMPLES - (sample + 1)));
-    }
-
-    __global__ void kernel_time_compute_nullhypot(SampleVector::Scalar const* sample_values,
-                                                  SampleVector::Scalar const* sample_value_errors,
-                                                  bool const* useless_sample_values,
-                                                  SampleVector::Scalar* chi2s,
-                                                  SampleVector::Scalar* sum0s,
-                                                  SampleVector::Scalar* sumAAs,
-                                                  const int nchannels) {
-      using ScalarType = SampleVector::Scalar;
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      int tx = threadIdx.x + blockDim.x * blockIdx.x;
-      int ltx = threadIdx.x;
-      int ch = tx / nsamples;
-      int nchannels_per_block = blockDim.x / nsamples;
-
-      // threads that return here should not affect the __syncthreads() below since they have exitted the kernel
-      if (ch >= nchannels)
-        return;
-
-      int sample = tx % nsamples;
-
-      // shared mem inits
-      extern __shared__ char sdata[];
-      char* s_sum0 = sdata;
-      SampleVector::Scalar* s_sum1 = reinterpret_cast<SampleVector::Scalar*>(s_sum0 + nchannels_per_block * nsamples);
-      SampleVector::Scalar* s_sumA = s_sum1 + nchannels_per_block * nsamples;
-      SampleVector::Scalar* s_sumAA = s_sumA + nchannels_per_block * nsamples;
-
-      // TODO make sure no div by 0
-      const auto inv_error =
-          useless_sample_values[tx] ? 0.0 : 1.0 / (sample_value_errors[tx] * sample_value_errors[tx]);
-      const auto sample_value = sample_values[tx];
-      s_sum0[ltx] = useless_sample_values[tx] ? 0 : 1;
-      s_sum1[ltx] = inv_error;
-      s_sumA[ltx] = sample_value * inv_error;
-      s_sumAA[ltx] = sample_value * sample_value * inv_error;
-      __syncthreads();
-
-      // 5 threads for [0, 4] samples
-      if (sample < 5) {
-        s_sum0[ltx] += s_sum0[ltx + 5];
-        s_sum1[ltx] += s_sum1[ltx + 5];
-        s_sumA[ltx] += s_sumA[ltx + 5];
-        s_sumAA[ltx] += s_sumAA[ltx + 5];
-      }
-      __syncthreads();
-
-      if (sample < 2) {
-        // note double counting of sample 3
-        s_sum0[ltx] += s_sum0[ltx + 2] + s_sum0[ltx + 3];
-        s_sum1[ltx] += s_sum1[ltx + 2] + s_sum1[ltx + 3];
-        s_sumA[ltx] += s_sumA[ltx + 2] + s_sumA[ltx + 3];
-        s_sumAA[ltx] += s_sumAA[ltx + 2] + s_sumAA[ltx + 3];
-      }
-      __syncthreads();
-
-      if (sample == 0) {
-        // note, subtract to remove the double counting of sample == 3
-        const auto sum0 = s_sum0[ltx] + s_sum0[ltx + 1] - s_sum0[ltx + 3];
-        const auto sum1 = s_sum1[ltx] + s_sum1[ltx + 1] - s_sum1[ltx + 3];
-        const auto sumA = s_sumA[ltx] + s_sumA[ltx + 1] - s_sumA[ltx + 3];
-        const auto sumAA = s_sumAA[ltx] + s_sumAA[ltx + 1] - s_sumAA[ltx + 3];
-        const auto chi2 = sum0 > 0 ? (sumAA - sumA * sumA / sum1) / sum0 : static_cast<ScalarType>(0);
-        chi2s[ch] = chi2;
-        sum0s[ch] = sum0;
-        sumAAs[ch] = sumAA;
-
-#ifdef DEBUG_TC_NULLHYPOT
-        if (ch == 0) {
-          printf("chi2 = %f sum0 = %d sumAA = %f\n", chi2, static_cast<int>(sum0), sumAA);
-        }
-#endif
-      }
-    }
-
-    constexpr float fast_expf(float x) { return unsafe_expf<6>(x); }
-    constexpr float fast_logf(float x) { return unsafe_logf<7>(x); }
-
-    //#define DEBUG_TC_MAKERATIO
-    //
-    // launch ctx parameters are
-    // 45 threads per channel, X channels per block, Y blocks
-    // 45 comes from: 10 samples for i <- 0 to 9 and for j <- i+1 to 9
-    // TODO: it might be much beter to use 32 threads per channel instead of 45
-    // to simplify the synchronization
-    //
-    __global__ void kernel_time_compute_makeratio(SampleVector::Scalar const* sample_values,
-                                                  SampleVector::Scalar const* sample_value_errors,
-                                                  uint32_t const* dids_eb,
-                                                  uint32_t const* dids_ee,
-                                                  bool const* useless_sample_values,
-                                                  char const* pedestal_nums,
-                                                  ConfigurationParameters::type const* amplitudeFitParametersEB,
-                                                  ConfigurationParameters::type const* amplitudeFitParametersEE,
-                                                  ConfigurationParameters::type const* timeFitParametersEB,
-                                                  ConfigurationParameters::type const* timeFitParametersEE,
-                                                  SampleVector::Scalar const* sumAAsNullHypot,
-                                                  SampleVector::Scalar const* sum0sNullHypot,
-                                                  SampleVector::Scalar* tMaxAlphaBetas,
-                                                  SampleVector::Scalar* tMaxErrorAlphaBetas,
-                                                  SampleVector::Scalar* g_accTimeMax,
-                                                  SampleVector::Scalar* g_accTimeWgt,
-                                                  TimeComputationState* g_state,
-                                                  unsigned const int timeFitParameters_sizeEB,
-                                                  unsigned const int timeFitParameters_sizeEE,
-                                                  ConfigurationParameters::type const timeFitLimits_firstEB,
-                                                  ConfigurationParameters::type const timeFitLimits_firstEE,
-                                                  ConfigurationParameters::type const timeFitLimits_secondEB,
-                                                  ConfigurationParameters::type const timeFitLimits_secondEE,
-                                                  const int nchannels,
-                                                  uint32_t const offsetForInputs) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr int nthreads_per_channel = 45;  // n=10, n(n-1)/2
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int gtx = threadIdx.x + blockDim.x * blockIdx.x;
-      const int ch = gtx / nthreads_per_channel;
-      const int ltx = threadIdx.x % nthreads_per_channel;
-      const int ch_start = ch * nsamples;
-      const auto* dids = ch >= offsetForInputs ? dids_ee : dids_eb;
-      const int inputCh = ch >= offsetForInputs ? ch - offsetForInputs : ch;
-
-      // remove inactive threads
-      // threads that return here should not affect the __syncthreads() below since they have exitted the kernel
-      if (ch >= nchannels)
-        return;
-
-      const auto did = DetId{dids[inputCh]};
-      const auto isBarrel = did.subdetId() == EcalBarrel;
-      const auto* amplitudeFitParameters = isBarrel ? amplitudeFitParametersEB : amplitudeFitParametersEE;
-      const auto* timeFitParameters = isBarrel ? timeFitParametersEB : timeFitParametersEE;
-      const auto timeFitParameters_size = isBarrel ? timeFitParameters_sizeEB : timeFitParameters_sizeEE;
-      const auto timeFitLimits_first = isBarrel ? timeFitLimits_firstEB : timeFitLimits_firstEE;
-      const auto timeFitLimits_second = isBarrel ? timeFitLimits_secondEB : timeFitLimits_secondEE;
-
-      extern __shared__ char smem[];
-      ScalarType* shr_chi2s = reinterpret_cast<ScalarType*>(smem);
-      ScalarType* shr_time_wgt = shr_chi2s + blockDim.x;
-      ScalarType* shr_time_max = shr_time_wgt + blockDim.x;
-      ScalarType* shrTimeMax = shr_time_max + blockDim.x;
-      ScalarType* shrTimeWgt = shrTimeMax + blockDim.x;
-
-      // map tx -> (sample_i, sample_j)
-      int sample_i, sample_j = 0;
-      if (ltx >= 0 && ltx <= 8) {
-        sample_i = 0;
-        sample_j = 1 + ltx;
-      } else if (ltx <= 16) {
-        sample_i = 1;
-        sample_j = 2 + ltx - 9;
-      } else if (ltx <= 23) {
-        sample_i = 2;
-        sample_j = 3 + ltx - 17;
-      } else if (ltx <= 29) {
-        sample_i = 3;
-        sample_j = 4 + ltx - 24;
-      } else if (ltx <= 34) {
-        sample_i = 4;
-        sample_j = 5 + ltx - 30;
-      } else if (ltx <= 38) {
-        sample_i = 5;
-        sample_j = 6 + ltx - 35;
-      } else if (ltx <= 41) {
-        sample_i = 6;
-        sample_j = 7 + ltx - 39;
-      } else if (ltx <= 43) {
-        sample_i = 7;
-        sample_j = 8 + ltx - 42;
-      } else if (ltx <= 44) {
-        sample_i = 8;
-        sample_j = 9;
-      } else
-        assert(false);
-
-      const auto tx_i = ch_start + sample_i;
-      const auto tx_j = ch_start + sample_j;
-
-      //
-      // note, given the way we partition the block, with 45 threads per channel
-      // we will end up with inactive threads which need to be dragged along
-      // through the synching point
-      //
-      bool const condForUselessSamples = useless_sample_values[tx_i] || useless_sample_values[tx_j] ||
-                                         sample_values[tx_i] <= 1 || sample_values[tx_j] <= 1;
-
-      //
-      // see cpu implementation for explanation
-      //
-      ScalarType chi2 = std::numeric_limits<ScalarType>::max();
-      ScalarType tmax = 0;
-      ScalarType tmaxerr = 0;
-      shrTimeMax[threadIdx.x] = 0;
-      shrTimeWgt[threadIdx.x] = 0;
-      bool internalCondForSkipping1 = true;
-      bool internalCondForSkipping2 = true;
-      if (!condForUselessSamples) {
-        const auto rtmp = sample_values[tx_i] / sample_values[tx_j];
-        const auto invampl_i = 1.0 / sample_values[tx_i];
-        const auto relErr2_i = sample_value_errors[tx_i] * sample_value_errors[tx_i] * invampl_i * invampl_i;
-        const auto invampl_j = 1.0 / sample_values[tx_j];
-        const auto relErr2_j = sample_value_errors[tx_j] * sample_value_errors[tx_j] * invampl_j * invampl_j;
-        const auto err1 = rtmp * rtmp * (relErr2_i + relErr2_j);
-        auto err2 = sample_value_errors[tx_j] * (sample_values[tx_i] - sample_values[tx_j]) * (invampl_j * invampl_j);
-        // TODO non-divergent branch for a block if each block has 1 channel
-        // otherwise non-divergent for groups of 45 threads
-        // at this point, pedestal_nums[ch] can be either 0, 1 or 2
-        if (pedestal_nums[ch] == 2)
-          err2 *= err2 * 0.5;
-        const auto err3 = (0.289 * 0.289) * (invampl_j * invampl_j);
-        const auto total_error = std::sqrt(err1 + err2 + err3);
-
-        const auto alpha = amplitudeFitParameters[0];
-        const auto beta = amplitudeFitParameters[1];
-        const auto alphabeta = alpha * beta;
-        const auto invalphabeta = 1.0 / alphabeta;
-
-        // variables instead of a struct
-        const auto ratio_index = sample_i;
-        const auto ratio_step = sample_j - sample_i;
-        const auto ratio_value = rtmp;
-        const auto ratio_error = total_error;
-
-        const auto rlim_i_j = fast_expf(static_cast<ScalarType>(sample_j - sample_i) / beta) - 0.001;
-        internalCondForSkipping1 = !(total_error < 1.0 && rtmp > 0.001 && rtmp < rlim_i_j);
-        if (!internalCondForSkipping1) {
-          //
-          // precompute.
-          // in cpu version this was done conditionally
-          // however easier to do it here (precompute) and then just filter out
-          // if not needed
-          //
-          const auto l_timeFitLimits_first = timeFitLimits_first;
-          const auto l_timeFitLimits_second = timeFitLimits_second;
-          if (ratio_step == 1 && ratio_value >= l_timeFitLimits_first && ratio_value <= l_timeFitLimits_second) {
-            const auto time_max_i = static_cast<ScalarType>(ratio_index);
-            auto u = timeFitParameters[timeFitParameters_size - 1];
-            CMS_UNROLL_LOOP
-            for (int k = timeFitParameters_size - 2; k >= 0; k--)
-              u = u * ratio_value + timeFitParameters[k];
-
-            auto du = (timeFitParameters_size - 1) * (timeFitParameters[timeFitParameters_size - 1]);
-            for (int k = timeFitParameters_size - 2; k >= 1; k--)
-              du = du * ratio_value + k * timeFitParameters[k];
-
-            const auto error2 = ratio_error * ratio_error * du * du;
-            const auto time_max = error2 > 0 ? (time_max_i - u) / error2 : static_cast<ScalarType>(0);
-            const auto time_wgt = error2 > 0 ? 1.0 / error2 : static_cast<ScalarType>(0);
-
-            // store into shared mem
-            // note, this name is essentially identical to the one used
-            // below.
-            shrTimeMax[threadIdx.x] = error2 > 0 ? time_max : 0;
-            shrTimeWgt[threadIdx.x] = error2 > 0 ? time_wgt : 0;
-          } else {
-            shrTimeMax[threadIdx.x] = 0;
-            shrTimeWgt[threadIdx.x] = 0;
-          }
-
-          // continue with ratios
-          const auto stepOverBeta = static_cast<SampleVector::Scalar>(ratio_step) / beta;
-          const auto offset = static_cast<SampleVector::Scalar>(ratio_index) + alphabeta;
-          const auto rmin = std::max(ratio_value - ratio_error, 0.001);
-          const auto rmax = std::min(ratio_value + ratio_error,
-                                     fast_expf(static_cast<SampleVector::Scalar>(ratio_step) / beta) - 0.001);
-          const auto time1 = offset - ratio_step / (fast_expf((stepOverBeta - fast_logf(rmin)) / alpha) - 1.0);
-          const auto time2 = offset - ratio_step / (fast_expf((stepOverBeta - fast_logf(rmax)) / alpha) - 1.0);
-
-          // set these guys
-          tmax = 0.5 * (time1 + time2);
-          tmaxerr = 0.5 * std::sqrt((time1 - time2) * (time1 - time2));
-#ifdef DEBUG_TC_MAKERATIO
-          if (ch == 1 || ch == 0)
-            printf("ch = %d ltx = %d tmax = %f tmaxerr = %f time1 = %f time2 = %f offset = %f rmin = %f rmax = %f\n",
-                   ch,
-                   ltx,
-                   tmax,
-                   tmaxerr,
-                   time1,
-                   time2,
-                   offset,
-                   rmin,
-                   rmax);
-#endif
-
-          SampleVector::Scalar sumAf = 0;
-          SampleVector::Scalar sumff = 0;
-          const int itmin = std::max(-1, static_cast<int>(std::floor(tmax - alphabeta)));
-          auto loffset = (static_cast<ScalarType>(itmin) - tmax) * invalphabeta;
-          // TODO: data dependence
-          for (int it = itmin + 1; it < nsamples; it++) {
-            loffset += invalphabeta;
-            if (useless_sample_values[ch_start + it])
-              continue;
-            const auto inverr2 = 1.0 / (sample_value_errors[ch_start + it] * sample_value_errors[ch_start + it]);
-            const auto term1 = 1.0 + loffset;
-            const auto f = (term1 > 1e-6) ? fast_expf(alpha * (fast_logf(term1) - loffset)) : 0;
-            sumAf += sample_values[ch_start + it] * (f * inverr2);
-            sumff += f * (f * inverr2);
-          }
-
-          const auto sumAA = sumAAsNullHypot[ch];
-          const auto sum0 = sum0sNullHypot[ch];
-          chi2 = sumAA;
-          // TODO: sum0 can not be 0 below, need to introduce the check upfront
-          if (sumff > 0) {
-            chi2 = sumAA - sumAf * (sumAf / sumff);
-          }
-          chi2 /= sum0;
-
-#ifdef DEBUG_TC_MAKERATIO
-          if (ch == 1 || ch == 0)
-            printf("ch = %d ltx = %d sumAf = %f sumff = %f sumAA = %f sum0 = %d tmax = %f tmaxerr = %f chi2 = %f\n",
-                   ch,
-                   ltx,
-                   sumAf,
-                   sumff,
-                   sumAA,
-                   static_cast<int>(sum0),
-                   tmax,
-                   tmaxerr,
-                   chi2);
-#endif
-
-          if (chi2 > 0 && tmax > 0 && tmaxerr > 0)
-            internalCondForSkipping2 = false;
-          else
-            chi2 = std::numeric_limits<ScalarType>::max();
-        }
-      }
-
-      // store into smem
-      shr_chi2s[threadIdx.x] = chi2;
-      __syncthreads();
-
-      // find min chi2 - quite crude for now
-      // TODO validate/check
-      char iter = nthreads_per_channel / 2 + nthreads_per_channel % 2;
-      bool oddElements = nthreads_per_channel % 2;
-      CMS_UNROLL_LOOP
-      while (iter >= 1) {
-        if (ltx < iter)
-          // for odd ns, the last guy will just store itself
-          // exception is for ltx == 0 and iter==1
-          shr_chi2s[threadIdx.x] = oddElements && (ltx == iter - 1 && ltx > 0)
-                                       ? shr_chi2s[threadIdx.x]
-                                       : std::min(shr_chi2s[threadIdx.x], shr_chi2s[threadIdx.x + iter]);
-        __syncthreads();
-        oddElements = iter % 2;
-        iter = iter == 1 ? iter / 2 : iter / 2 + iter % 2;
-      }
-
-      // filter out inactive or useless samples threads
-      if (!condForUselessSamples && !internalCondForSkipping1 && !internalCondForSkipping2) {
-        // min chi2, now compute weighted average of tmax measurements
-        // see cpu version for more explanation
-        const auto chi2min = shr_chi2s[threadIdx.x - ltx];
-        const auto chi2Limit = chi2min + 1.0;
-        const auto inverseSigmaSquared = chi2 < chi2Limit ? 1.0 / (tmaxerr * tmaxerr) : 0.0;
-
-#ifdef DEBUG_TC_MAKERATIO
-        if (ch == 1 || ch == 0)
-          printf("ch = %d ltx = %d chi2min = %f chi2Limit = %f inverseSigmaSquared = %f\n",
-                 ch,
-                 ltx,
-                 chi2min,
-                 chi2Limit,
-                 inverseSigmaSquared);
-#endif
-
-        // store into shared mem and run reduction
-        // TODO: check if cooperative groups would be better
-        // TODO: check if shuffling intrinsics are better
-        shr_time_wgt[threadIdx.x] = inverseSigmaSquared;
-        shr_time_max[threadIdx.x] = tmax * inverseSigmaSquared;
-      } else {
-        shr_time_wgt[threadIdx.x] = 0;
-        shr_time_max[threadIdx.x] = 0;
-      }
-      __syncthreads();
-
-      // reduce to compute time_max and time_wgt
-      iter = nthreads_per_channel / 2 + nthreads_per_channel % 2;
-      oddElements = nthreads_per_channel % 2;
-      CMS_UNROLL_LOOP
-      while (iter >= 1) {
-        if (ltx < iter) {
-          shr_time_wgt[threadIdx.x] = oddElements && (ltx == iter - 1 && ltx > 0)
-                                          ? shr_time_wgt[threadIdx.x]
-                                          : shr_time_wgt[threadIdx.x] + shr_time_wgt[threadIdx.x + iter];
-          shr_time_max[threadIdx.x] = oddElements && (ltx == iter - 1 && ltx > 0)
-                                          ? shr_time_max[threadIdx.x]
-                                          : shr_time_max[threadIdx.x] + shr_time_max[threadIdx.x + iter];
-          shrTimeMax[threadIdx.x] = oddElements && (ltx == iter - 1 && ltx > 0)
-                                        ? shrTimeMax[threadIdx.x]
-                                        : shrTimeMax[threadIdx.x] + shrTimeMax[threadIdx.x + iter];
-          shrTimeWgt[threadIdx.x] = oddElements && (ltx == iter - 1 && ltx > 0)
-                                        ? shrTimeWgt[threadIdx.x]
-                                        : shrTimeWgt[threadIdx.x] + shrTimeWgt[threadIdx.x + iter];
-        }
-
-        __syncthreads();
-        oddElements = iter % 2;
-        iter = iter == 1 ? iter / 2 : iter / 2 + iter % 2;
-      }
-
-      // load from shared memory the 0th guy (will contain accumulated values)
-      // compute
-      // store into global mem
-      if (ltx == 0) {
-        const auto tmp_time_max = shr_time_max[threadIdx.x];
-        const auto tmp_time_wgt = shr_time_wgt[threadIdx.x];
-
-        // we are done if there number of time ratios is 0
-        if (tmp_time_wgt == 0 && tmp_time_max == 0) {
-          g_state[ch] = TimeComputationState::Finished;
-          return;
-        }
-
-        // no div by 0
-        const auto tMaxAlphaBeta = tmp_time_max / tmp_time_wgt;
-        const auto tMaxErrorAlphaBeta = 1.0 / std::sqrt(tmp_time_wgt);
-
-        tMaxAlphaBetas[ch] = tMaxAlphaBeta;
-        tMaxErrorAlphaBetas[ch] = tMaxErrorAlphaBeta;
-        g_accTimeMax[ch] = shrTimeMax[threadIdx.x];
-        g_accTimeWgt[ch] = shrTimeWgt[threadIdx.x];
-        g_state[ch] = TimeComputationState::NotFinished;
-
-#ifdef DEBUG_TC_MAKERATIO
-        printf("ch = %d time_max = %f time_wgt = %f\n", ch, tmp_time_max, tmp_time_wgt);
-        printf("ch = %d tMaxAlphaBeta = %f tMaxErrorAlphaBeta = %f timeMax = %f timeWgt = %f\n",
-               ch,
-               tMaxAlphaBeta,
-               tMaxErrorAlphaBeta,
-               shrTimeMax[threadIdx.x],
-               shrTimeWgt[threadIdx.x]);
-#endif
-      }
-    }
-
-    /// launch ctx parameters are
-    /// 10 threads per channel, N channels per block, Y blocks
-    /// TODO: do we need to keep the state around or can be removed?!
-    //#define DEBUG_FINDAMPLCHI2_AND_FINISH
-    __global__ void kernel_time_compute_findamplchi2_and_finish(
-        SampleVector::Scalar const* sample_values,
-        SampleVector::Scalar const* sample_value_errors,
-        uint32_t const* dids_eb,
-        uint32_t const* dids_ee,
-        bool const* useless_samples,
-        SampleVector::Scalar const* g_tMaxAlphaBeta,
-        SampleVector::Scalar const* g_tMaxErrorAlphaBeta,
-        SampleVector::Scalar const* g_accTimeMax,
-        SampleVector::Scalar const* g_accTimeWgt,
-        ConfigurationParameters::type const* amplitudeFitParametersEB,
-        ConfigurationParameters::type const* amplitudeFitParametersEE,
-        SampleVector::Scalar const* sumAAsNullHypot,
-        SampleVector::Scalar const* sum0sNullHypot,
-        SampleVector::Scalar const* chi2sNullHypot,
-        TimeComputationState* g_state,
-        SampleVector::Scalar* g_ampMaxAlphaBeta,
-        SampleVector::Scalar* g_ampMaxError,
-        SampleVector::Scalar* g_timeMax,
-        SampleVector::Scalar* g_timeError,
-        const int nchannels,
-        uint32_t const offsetForInputs) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int gtx = threadIdx.x + blockIdx.x * blockDim.x;
-      const int ch = gtx / nsamples;
-      const int sample = threadIdx.x % nsamples;
-      const auto* dids = ch >= offsetForInputs ? dids_ee : dids_eb;
-      const int inputCh = ch >= offsetForInputs ? ch - offsetForInputs : ch;
-
-      // configure shared mem
-      // per block, we need #threads per block * 2 * sizeof(ScalarType)
-      // we run with N channels per block
-      extern __shared__ char smem[];
-      ScalarType* shr_sumAf = reinterpret_cast<ScalarType*>(smem);
-      ScalarType* shr_sumff = shr_sumAf + blockDim.x;
-
-      if (ch >= nchannels)
-        return;
-
-      auto state = g_state[ch];
-      const auto did = DetId{dids[inputCh]};
-      const auto* amplitudeFitParameters =
-          did.subdetId() == EcalBarrel ? amplitudeFitParametersEB : amplitudeFitParametersEE;
-
-      // TODO is that better than storing into global and launching another kernel
-      // for the first 10 threads
-      if (state == TimeComputationState::NotFinished) {
-        const auto alpha = amplitudeFitParameters[0];
-        const auto beta = amplitudeFitParameters[1];
-        const auto alphabeta = alpha * beta;
-        const auto invalphabeta = 1.0 / alphabeta;
-        const auto tMaxAlphaBeta = g_tMaxAlphaBeta[ch];
-        const auto sample_value = sample_values[gtx];
-        const auto sample_value_error = sample_value_errors[gtx];
-        const auto inverr2 =
-            useless_samples[gtx] ? static_cast<ScalarType>(0) : 1.0 / (sample_value_error * sample_value_error);
-        const auto offset = (static_cast<ScalarType>(sample) - tMaxAlphaBeta) * invalphabeta;
-        const auto term1 = 1.0 + offset;
-        const auto f = term1 > 1e-6 ? fast_expf(alpha * (fast_logf(term1) - offset)) : static_cast<ScalarType>(0.0);
-        const auto sumAf = sample_value * (f * inverr2);
-        const auto sumff = f * (f * inverr2);
-
-        // store into shared mem
-        shr_sumAf[threadIdx.x] = sumAf;
-        shr_sumff[threadIdx.x] = sumff;
-      } else {
-        shr_sumAf[threadIdx.x] = 0;
-        shr_sumff[threadIdx.x] = 0;
-      }
-      __syncthreads();
-
-      // reduce
-      // unroll completely here (but hardcoded)
-      if (sample < 5) {
-        shr_sumAf[threadIdx.x] += shr_sumAf[threadIdx.x + 5];
-        shr_sumff[threadIdx.x] += shr_sumff[threadIdx.x + 5];
-      }
-      __syncthreads();
-
-      if (sample < 2) {
-        // will need to subtract for ltx = 3, we double count here
-        shr_sumAf[threadIdx.x] += shr_sumAf[threadIdx.x + 2] + shr_sumAf[threadIdx.x + 3];
-        shr_sumff[threadIdx.x] += shr_sumff[threadIdx.x + 2] + shr_sumff[threadIdx.x + 3];
-      }
-      __syncthreads();
-
-      if (sample == 0) {
-        // exit if the state is done
-        // note, we do not exit before all __synchtreads are finished
-        if (state == TimeComputationState::Finished) {
-          g_timeMax[ch] = 5;
-          g_timeError[ch] = -999;
-          return;
-        }
-
-        // subtract to avoid double counting
-        const auto sumff = shr_sumff[threadIdx.x] + shr_sumff[threadIdx.x + 1] - shr_sumff[threadIdx.x + 3];
-        const auto sumAf = shr_sumAf[threadIdx.x] + shr_sumAf[threadIdx.x + 1] - shr_sumAf[threadIdx.x + 3];
-
-        const auto ampMaxAlphaBeta = sumff > 0 ? sumAf / sumff : 0;
-        const auto sumAA = sumAAsNullHypot[ch];
-        const auto sum0 = sum0sNullHypot[ch];
-        const auto nullChi2 = chi2sNullHypot[ch];
-        if (sumff > 0) {
-          const auto chi2AlphaBeta = (sumAA - sumAf * sumAf / sumff) / sum0;
-          if (chi2AlphaBeta > nullChi2) {
-            // null hypothesis is better
-            state = TimeComputationState::Finished;
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-            printf("ch = %d chi2AlphaBeta = %f nullChi2 = %f sumAA = %f sumAf = %f sumff = %f sum0 = %f\n",
-                   ch,
-                   chi2AlphaBeta,
-                   nullChi2,
-                   sumAA,
-                   sumAf,
-                   sumff,
-                   sum0);
-#endif
-          }
-
-          // store to global
-          g_ampMaxAlphaBeta[ch] = ampMaxAlphaBeta;
-        } else {
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-          printf("ch = %d sum0 = %f sumAA = %f sumff = %f sumAf = %f\n", ch, sum0, sumAA, sumff, sumAf);
-#endif
-          state = TimeComputationState::Finished;
-        }
-
-        // store the state to global and finish calcs
-        g_state[ch] = state;
-        if (state == TimeComputationState::Finished) {
-          // store default values into global
-          g_timeMax[ch] = 5;
-          g_timeError[ch] = -999;
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-          printf("ch = %d finished state\n", ch);
-#endif
-          return;
-        }
-
-        const auto ampMaxError = g_ampMaxError[ch];
-        const auto test_ratio = ampMaxAlphaBeta / ampMaxError;
-        const auto accTimeMax = g_accTimeMax[ch];
-        const auto accTimeWgt = g_accTimeWgt[ch];
-        const auto tMaxAlphaBeta = g_tMaxAlphaBeta[ch];
-        const auto tMaxErrorAlphaBeta = g_tMaxErrorAlphaBeta[ch];
-        // branch to separate large vs small pulses
-        // see cpu version for more info
-        if (test_ratio > 5.0 && accTimeWgt > 0) {
-          const auto tMaxRatio = accTimeWgt > 0 ? accTimeMax / accTimeWgt : static_cast<ScalarType>(0);
-          const auto tMaxErrorRatio = accTimeWgt > 0 ? 1.0 / std::sqrt(accTimeWgt) : static_cast<ScalarType>(0);
-
-          if (test_ratio > 10.0) {
-            g_timeMax[ch] = tMaxRatio;
-            g_timeError[ch] = tMaxErrorRatio;
-
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-            printf("ch = %d tMaxRatio = %f tMaxErrorRatio = %f\n", ch, tMaxRatio, tMaxErrorRatio);
-#endif
-          } else {
-            const auto timeMax = (tMaxAlphaBeta * (10.0 - ampMaxAlphaBeta / ampMaxError) +
-                                  tMaxRatio * (ampMaxAlphaBeta / ampMaxError - 5.0)) /
-                                 5.0;
-            const auto timeError = (tMaxErrorAlphaBeta * (10.0 - ampMaxAlphaBeta / ampMaxError) +
-                                    tMaxErrorRatio * (ampMaxAlphaBeta / ampMaxError - 5.0)) /
-                                   5.0;
-            state = TimeComputationState::Finished;
-            g_state[ch] = state;
-            g_timeMax[ch] = timeMax;
-            g_timeError[ch] = timeError;
-
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-            printf("ch = %d timeMax = %f timeError = %f\n", ch, timeMax, timeError);
-#endif
-          }
-        } else {
-          state = TimeComputationState::Finished;
-          g_state[ch] = state;
-          g_timeMax[ch] = tMaxAlphaBeta;
-          g_timeError[ch] = tMaxErrorAlphaBeta;
-
-#ifdef DEBUG_FINDAMPLCHI2_AND_FINISH
-          printf("ch = %d tMaxAlphaBeta = %f tMaxErrorAlphaBeta = %f\n", ch, tMaxAlphaBeta, tMaxErrorAlphaBeta);
-#endif
-        }
-      }
-    }
-
-    __global__ void kernel_time_compute_fixMGPAslew(uint16_t const* digis_eb,
-                                                    uint16_t const* digis_ee,
-                                                    SampleVector::Scalar* sample_values,
-                                                    SampleVector::Scalar* sample_value_errors,
-                                                    bool* useless_sample_values,
-                                                    unsigned const int sample_mask,
-                                                    const int nchannels,
-                                                    uint32_t const offsetForInputs) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int gtx = threadIdx.x + blockIdx.x * blockDim.x;
-      const int ch = gtx / nsamples;
-      const int sample = threadIdx.x % nsamples;
-      const int inputGtx = ch >= offsetForInputs ? gtx - offsetForInputs * nsamples : gtx;
-      const auto* digis = ch >= offsetForInputs ? digis_ee : digis_eb;
-
-      // remove thread for sample 0, oversubscribing is easier than ....
-      if (ch >= nchannels || sample == 0)
-        return;
-
-      if (!use_sample(sample_mask, sample))
-        return;
-
-      const auto gainIdPrev = ecalMGPA::gainId(digis[inputGtx - 1]);
-      const auto gainIdNext = ecalMGPA::gainId(digis[inputGtx]);
-      if (gainIdPrev >= 1 && gainIdPrev <= 3 && gainIdNext >= 1 && gainIdNext <= 3 && gainIdPrev < gainIdNext) {
-        sample_values[gtx - 1] = 0;
-        sample_value_errors[gtx - 1] = 1e+9;
-        useless_sample_values[gtx - 1] = true;
-      }
-    }
-
-    __global__ void kernel_time_compute_ampl(SampleVector::Scalar const* sample_values,
-                                             SampleVector::Scalar const* sample_value_errors,
-                                             uint32_t const* dids,
-                                             bool const* useless_samples,
-                                             SampleVector::Scalar const* g_timeMax,
-                                             SampleVector::Scalar const* amplitudeFitParametersEB,
-                                             SampleVector::Scalar const* amplitudeFitParametersEE,
-                                             SampleVector::Scalar* g_amplitudeMax,
-                                             const int nchannels) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr ScalarType corr4 = 1.;
-      constexpr ScalarType corr6 = 1.;
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int gtx = threadIdx.x + blockIdx.x * blockDim.x;
-      const int ch = gtx / nsamples;
-      const int sample = threadIdx.x % nsamples;
-
-      if (ch >= nchannels)
-        return;
-
-      const auto did = DetId{dids[ch]};
-      const auto* amplitudeFitParameters =
-          did.subdetId() == EcalBarrel ? amplitudeFitParametersEB : amplitudeFitParametersEE;
-
-      // configure shared mem
-      extern __shared__ char smem[];
-      ScalarType* shr_sum1 = reinterpret_cast<ScalarType*>(smem);
-      auto* shr_sumA = shr_sum1 + blockDim.x;
-      auto* shr_sumF = shr_sumA + blockDim.x;
-      auto* shr_sumAF = shr_sumF + blockDim.x;
-      auto* shr_sumFF = shr_sumAF + blockDim.x;
-
-      const auto alpha = amplitudeFitParameters[0];
-      const auto beta = amplitudeFitParameters[1];
-      const auto timeMax = g_timeMax[ch];
-      const auto pedestalLimit = timeMax - (alpha * beta) - 1.0;
-      const auto sample_value = sample_values[gtx];
-      const auto sample_value_error = sample_value_errors[gtx];
-      const auto inverr2 =
-          sample_value_error > 0 ? 1. / (sample_value_error * sample_value_error) : static_cast<ScalarType>(0);
-      const auto termOne = 1 + (sample - timeMax) / (alpha * beta);
-      const auto f = termOne > 1.e-5 ? fast_expf(alpha * fast_logf(termOne) - (sample - timeMax) / beta)
-                                     : static_cast<ScalarType>(0.);
-
-      bool const cond = ((sample < pedestalLimit) || (f > 0.6 * corr6 && sample <= timeMax) ||
-                         (f > 0.4 * corr4 && sample >= timeMax)) &&
-                        !useless_samples[gtx];
-
-      // store into shared mem
-      shr_sum1[threadIdx.x] = cond ? inverr2 : static_cast<ScalarType>(0);
-      shr_sumA[threadIdx.x] = cond ? sample_value * inverr2 : static_cast<ScalarType>(0);
-      shr_sumF[threadIdx.x] = cond ? f * inverr2 : static_cast<ScalarType>(0);
-      shr_sumAF[threadIdx.x] = cond ? (f * inverr2) * sample_value : static_cast<ScalarType>(0);
-      shr_sumFF[threadIdx.x] = cond ? f * (f * inverr2) : static_cast<ScalarType>(0);
-
-      // reduction
-      if (sample <= 4) {
-        shr_sum1[threadIdx.x] += shr_sum1[threadIdx.x + 5];
-        shr_sumA[threadIdx.x] += shr_sumA[threadIdx.x + 5];
-        shr_sumF[threadIdx.x] += shr_sumF[threadIdx.x + 5];
-        shr_sumAF[threadIdx.x] += shr_sumAF[threadIdx.x + 5];
-        shr_sumFF[threadIdx.x] += shr_sumFF[threadIdx.x + 5];
-      }
-      __syncthreads();
-
-      if (sample < 2) {
-        // note: we double count sample 3
-        shr_sum1[threadIdx.x] += shr_sum1[threadIdx.x + 2] + shr_sum1[threadIdx.x + 3];
-        shr_sumA[threadIdx.x] += shr_sumA[threadIdx.x + 2] + shr_sumA[threadIdx.x + 3];
-        shr_sumF[threadIdx.x] += shr_sumF[threadIdx.x + 2] + shr_sumF[threadIdx.x + 3];
-        shr_sumAF[threadIdx.x] += shr_sumAF[threadIdx.x + 2] + shr_sumAF[threadIdx.x + 3];
-        shr_sumFF[threadIdx.x] += shr_sumFF[threadIdx.x + 2] + shr_sumFF[threadIdx.x + 3];
-      }
-      __syncthreads();
-
-      if (sample == 0) {
-        const auto sum1 = shr_sum1[threadIdx.x] + shr_sum1[threadIdx.x + 1] - shr_sum1[threadIdx.x + 3];
-        const auto sumA = shr_sumA[threadIdx.x] + shr_sumA[threadIdx.x + 1] - shr_sumA[threadIdx.x + 3];
-        const auto sumF = shr_sumF[threadIdx.x] + shr_sumF[threadIdx.x + 1] - shr_sumF[threadIdx.x + 3];
-        const auto sumAF = shr_sumAF[threadIdx.x] + shr_sumAF[threadIdx.x + 1] - shr_sumAF[threadIdx.x + 3];
-        const auto sumFF = shr_sumFF[threadIdx.x] + shr_sumFF[threadIdx.x + 1] - shr_sumFF[threadIdx.x + 3];
-
-        const auto denom = sumFF * sum1 - sumF * sumF;
-        const auto condForDenom = sum1 > 0 && std::abs(denom) > 1.e-20;
-        const auto amplitudeMax = condForDenom ? (sumAF * sum1 - sumA * sumF) / denom : static_cast<ScalarType>(0.);
-
-        // store into global mem
-        g_amplitudeMax[ch] = amplitudeMax;
-      }
-    }
-
-    //#define ECAL_RECO_CUDA_TC_INIT_DEBUG
-    __global__ void kernel_time_computation_init(uint16_t const* digis_eb,
-                                                 uint32_t const* dids_eb,
-                                                 uint16_t const* digis_ee,
-                                                 uint32_t const* dids_ee,
-                                                 float const* rms_x12,
-                                                 float const* rms_x6,
-                                                 float const* rms_x1,
-                                                 float const* mean_x12,
-                                                 float const* mean_x6,
-                                                 float const* mean_x1,
-                                                 float const* gain12Over6,
-                                                 float const* gain6Over1,
-                                                 SampleVector::Scalar* sample_values,
-                                                 SampleVector::Scalar* sample_value_errors,
-                                                 SampleVector::Scalar* ampMaxError,
-                                                 bool* useless_sample_values,
-                                                 char* pedestal_nums,
-                                                 uint32_t const offsetForHashes,
-                                                 uint32_t const offsetForInputs,
-                                                 unsigned const int sample_maskEB,
-                                                 unsigned const int sample_maskEE,
-                                                 int nchannels) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int tx = threadIdx.x + blockDim.x * blockIdx.x;
-      const int ch = tx / nsamples;
-      const int inputTx = ch >= offsetForInputs ? tx - offsetForInputs * nsamples : tx;
-      const int inputCh = ch >= offsetForInputs ? ch - offsetForInputs : ch;
-      const auto* digis = ch >= offsetForInputs ? digis_ee : digis_eb;
-      const auto* dids = ch >= offsetForInputs ? dids_ee : dids_eb;
-
-      // threads that return here should not affect the __syncthreads() below since they have exitted the kernel
-      if (ch >= nchannels)
-        return;
-
-      // indices/inits
-      const int sample = tx % nsamples;
-      const int input_ch_start = inputCh * nsamples;
-      SampleVector::Scalar pedestal = 0.;
-      int num = 0;
-
-      // configure shared mem
-      extern __shared__ char smem[];
-      ScalarType* shrSampleValues = reinterpret_cast<SampleVector::Scalar*>(smem);
-      ScalarType* shrSampleValueErrors = shrSampleValues + blockDim.x;
-
-      // 0 and 1 sample values
-      const auto adc0 = ecalMGPA::adc(digis[input_ch_start]);
-      const auto gainId0 = ecalMGPA::gainId(digis[input_ch_start]);
-      const auto adc1 = ecalMGPA::adc(digis[input_ch_start + 1]);
-      const auto gainId1 = ecalMGPA::gainId(digis[input_ch_start + 1]);
-      const auto did = DetId{dids[inputCh]};
-      const auto isBarrel = did.subdetId() == EcalBarrel;
-      const auto sample_mask = did.subdetId() == EcalBarrel ? sample_maskEB : sample_maskEE;
-      const auto hashedId = isBarrel ? ecal::reconstruction::hashedIndexEB(did.rawId())
-                                     : offsetForHashes + ecal::reconstruction::hashedIndexEE(did.rawId());
-
-      // set pedestal
-      // TODO this branch is non-divergent for a group of 10 threads
-      if (gainId0 == 1 && use_sample(sample_mask, 0)) {
-        pedestal = static_cast<SampleVector::Scalar>(adc0);
-        num = 1;
-
-        const auto diff = adc1 - adc0;
-        if (gainId1 == 1 && use_sample(sample_mask, 1) && std::abs(diff) < 3 * rms_x12[hashedId]) {
-          pedestal = (pedestal + static_cast<SampleVector::Scalar>(adc1)) / 2.0;
-          num = 2;
-        }
-      } else {
-        pedestal = mean_x12[ch];
-      }
-
-      // ped subtracted and gain-renormalized samples.
-      const auto gainId = ecalMGPA::gainId(digis[inputTx]);
-      const auto adc = ecalMGPA::adc(digis[inputTx]);
-
-      bool bad = false;
-      SampleVector::Scalar sample_value, sample_value_error;
-      // TODO divergent branch
-      // TODO: piece below is general both for amplitudes and timing
-      // potentially there is a way to reduce the amount of code...
-      if (!use_sample(sample_mask, sample)) {
-        bad = true;
-        sample_value = 0;
-        sample_value_error = 0;
-      } else if (gainId == 1) {
-        sample_value = static_cast<SampleVector::Scalar>(adc) - pedestal;
-        sample_value_error = rms_x12[hashedId];
-      } else if (gainId == 2) {
-        sample_value = (static_cast<SampleVector::Scalar>(adc) - mean_x6[hashedId]) * gain12Over6[hashedId];
-        sample_value_error = rms_x6[hashedId] * gain12Over6[hashedId];
-      } else if (gainId == 3) {
-        sample_value =
-            (static_cast<SampleVector::Scalar>(adc) - mean_x1[hashedId]) * gain6Over1[hashedId] * gain12Over6[hashedId];
-        sample_value_error = rms_x1[hashedId] * gain6Over1[hashedId] * gain12Over6[hashedId];
-      } else {
-        sample_value = 0;
-        sample_value_error = 0;
-        bad = true;
-      }
-
-      // TODO: make sure we save things correctly when sample is useless
-      const auto useless_sample = (sample_value_error <= 0) | bad;
-      useless_sample_values[tx] = useless_sample;
-      sample_values[tx] = sample_value;
-      sample_value_errors[tx] = useless_sample ? 1e+9 : sample_value_error;
-
-      // DEBUG
-#ifdef ECAL_RECO_CUDA_TC_INIT_DEBUG
-      if (ch == 0) {
-        printf("sample = %d sample_value = %f sample_value_error = %f useless = %c\n",
-               sample,
-               sample_value,
-               sample_value_error,
-               useless_sample ? '1' : '0');
-      }
-#endif
-
-      // store into the shared mem
-      shrSampleValues[threadIdx.x] = sample_value_error > 0 ? sample_value : std::numeric_limits<ScalarType>::min();
-      shrSampleValueErrors[threadIdx.x] = sample_value_error;
-      __syncthreads();
-
-      // perform the reduction with min
-      if (sample < 5) {
-        // note, if equal -> we keep the value with lower sample as for cpu
-        shrSampleValueErrors[threadIdx.x] = shrSampleValues[threadIdx.x] < shrSampleValues[threadIdx.x + 5]
-                                                ? shrSampleValueErrors[threadIdx.x + 5]
-                                                : shrSampleValueErrors[threadIdx.x];
-        shrSampleValues[threadIdx.x] = std::max(shrSampleValues[threadIdx.x], shrSampleValues[threadIdx.x + 5]);
-      }
-      __syncthreads();
-
-      // a bit of an overkill, but easier than to compare across 3 values
-      if (sample < 3) {
-        shrSampleValueErrors[threadIdx.x] = shrSampleValues[threadIdx.x] < shrSampleValues[threadIdx.x + 3]
-                                                ? shrSampleValueErrors[threadIdx.x + 3]
-                                                : shrSampleValueErrors[threadIdx.x];
-        shrSampleValues[threadIdx.x] = std::max(shrSampleValues[threadIdx.x], shrSampleValues[threadIdx.x + 3]);
-      }
-      __syncthreads();
-
-      if (sample < 2) {
-        shrSampleValueErrors[threadIdx.x] = shrSampleValues[threadIdx.x] < shrSampleValues[threadIdx.x + 2]
-                                                ? shrSampleValueErrors[threadIdx.x + 2]
-                                                : shrSampleValueErrors[threadIdx.x];
-        shrSampleValues[threadIdx.x] = std::max(shrSampleValues[threadIdx.x], shrSampleValues[threadIdx.x + 2]);
-      }
-      __syncthreads();
-
-      if (sample == 0) {
-        // we only needd the max error
-        const auto maxSampleValueError = shrSampleValues[threadIdx.x] < shrSampleValues[threadIdx.x + 1]
-                                             ? shrSampleValueErrors[threadIdx.x + 1]
-                                             : shrSampleValueErrors[threadIdx.x];
-
-        // # pedestal samples used
-        pedestal_nums[ch] = num;
-        // this is used downstream
-        ampMaxError[ch] = maxSampleValueError;
-
-        // DEBUG
-#ifdef ECAL_RECO_CUDA_TC_INIT_DEBUG
-        if (ch == 0) {
-          printf("pedestal_nums = %d ampMaxError = %f\n", num, maxSampleValueError);
-        }
-#endif
-      }
-    }
-
-    ///
-    /// launch context parameters: 1 thread per channel
-    ///
-    //#define DEBUG_TIME_CORRECTION
-    __global__ void kernel_time_correction_and_finalize(
-        //        SampleVector::Scalar 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,
-        uint32_t const* dids_ee,
-        float const* amplitudeBinsEB,
-        float const* amplitudeBinsEE,
-        float const* shiftBinsEB,
-        float const* shiftBinsEE,
-        SampleVector::Scalar const* g_timeMax,
-        SampleVector::Scalar const* g_timeError,
-        float const* g_rms_x12,
-        float const* timeCalibConstant,
-        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,
-        ConfigurationParameters::type const timeConstantTermEE,
-        float const offsetTimeValueEB,
-        float const offsetTimeValueEE,
-        ConfigurationParameters::type const timeNconstEB,
-        ConfigurationParameters::type const timeNconstEE,
-        ConfigurationParameters::type const amplitudeThresholdEB,
-        ConfigurationParameters::type const amplitudeThresholdEE,
-        ConfigurationParameters::type const outOfTimeThreshG12pEB,
-        ConfigurationParameters::type const outOfTimeThreshG12pEE,
-        ConfigurationParameters::type const outOfTimeThreshG12mEB,
-        ConfigurationParameters::type const outOfTimeThreshG12mEE,
-        ConfigurationParameters::type const outOfTimeThreshG61pEB,
-        ConfigurationParameters::type const outOfTimeThreshG61pEE,
-        ConfigurationParameters::type const outOfTimeThreshG61mEB,
-        ConfigurationParameters::type const outOfTimeThreshG61mEE,
-        uint32_t const offsetForHashes,
-        uint32_t const offsetForInputs,
-        const int nchannels) {
-      using ScalarType = SampleVector::Scalar;
-
-      // constants
-      constexpr int nsamples = EcalDataFrame::MAXSAMPLES;
-
-      // indices
-      const int gtx = threadIdx.x + blockIdx.x * blockDim.x;
-      const int inputGtx = gtx >= offsetForInputs ? gtx - offsetForInputs : gtx;
-      const auto* dids = gtx >= offsetForInputs ? dids_ee : dids_eb;
-      const auto& digis = gtx >= offsetForInputs ? digis_ee : digis_eb;
-
-      // filter out outside of range threads
-      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())
-                                     : offsetForHashes + ecal::reconstruction::hashedIndexEE(did.rawId());
-      const auto* amplitudeBins = isBarrel ? amplitudeBinsEB : amplitudeBinsEE;
-      const auto* shiftBins = isBarrel ? shiftBinsEB : shiftBinsEE;
-      const auto amplitudeBinsSize = isBarrel ? amplitudeBinsSizeEB : amplitudeBinsSizeEE;
-      const auto timeConstantTerm = isBarrel ? timeConstantTermEB : timeConstantTermEE;
-      const auto timeNconst = isBarrel ? timeNconstEB : timeNconstEE;
-      const auto offsetTimeValue = isBarrel ? offsetTimeValueEB : offsetTimeValueEE;
-      const auto amplitudeThreshold = isBarrel ? amplitudeThresholdEB : amplitudeThresholdEE;
-      const auto outOfTimeThreshG12p = isBarrel ? outOfTimeThreshG12pEB : outOfTimeThreshG12pEE;
-      const auto outOfTimeThreshG12m = isBarrel ? outOfTimeThreshG12mEB : outOfTimeThreshG12mEE;
-      const auto outOfTimeThreshG61p = isBarrel ? outOfTimeThreshG61pEB : outOfTimeThreshG61pEE;
-      const auto outOfTimeThreshG61m = isBarrel ? outOfTimeThreshG61mEB : outOfTimeThreshG61mEE;
-
-      // load some
-      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])
-          myBin = bin;
-        else
-          break;
-      }
-
-      ScalarType correction = 0;
-      if (myBin == -1) {
-        correction = shiftBins[0];
-      } else if (myBin == amplitudeBinsSize - 1) {
-        correction = shiftBins[myBin];
-      } else {
-        correction = shiftBins[myBin + 1] - shiftBins[myBin];
-        correction *= (amplitude - amplitudeBins[myBin]) / (amplitudeBins[myBin + 1] - amplitudeBins[myBin]);
-        correction += shiftBins[myBin];
-      }
-
-      // correction * 1./25.
-      correction = correction * 0.04;
-      const auto timeMax = g_timeMax[gtx];
-      const auto timeError = g_timeError[gtx];
-      const auto jitter = timeMax - 5 + correction;
-      const auto jitterError =
-          std::sqrt(timeError * timeError + timeConstantTerm * timeConstantTerm * 0.04 * 0.04);  // 0.04 = 1./25.
-
-#ifdef DEBUG_TIME_CORRECTION
-      printf("ch = %d timeMax = %f timeError = %f jitter = %f correction = %f\n",
-             gtx,
-             timeMax,
-             timeError,
-             jitter,
-             correction);
-//    }
-#endif
-
-      // store back to  global
-      g_jitter[inputGtx] = jitter;
-      g_jitterError[inputGtx] = jitterError;
-
-      // set the flag
-      // TODO: replace with something more efficient (if required),
-      // for now just to make it work
-      if (amplitude > amplitudeThreshold * rms_x12) {
-        auto threshP = outOfTimeThreshG12p;
-        auto threshM = outOfTimeThreshG12m;
-        if (amplitude > 3000.) {
-          for (int isample = 0; isample < nsamples; isample++) {
-            int gainid = ecalMGPA::gainId(digis[nsamples * inputGtx + isample]);
-            if (gainid != 1) {
-              threshP = outOfTimeThreshG61p;
-              threshM = outOfTimeThreshG61m;
-              break;
-            }
-          }
-        }
-
-        const auto correctedTime = (timeMax - 5) * 25 + timeCalibConst + offsetTimeValue;
-        const auto nterm = timeNconst * rms_x12 / amplitude;
-        const auto sigmat = std::sqrt(nterm * nterm + timeConstantTerm * timeConstantTerm);
-        if (correctedTime > sigmat * threshP || correctedTime < -sigmat * threshM)
-          flags[inputGtx] |= 0x1 << EcalUncalibratedRecHit::kOutOfTime;
-      }
-    }
-
-  }  // namespace multifit
-}  // namespace ecal
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h b/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
deleted file mode 100644
index 30cf742d44d10..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/plugins/TimeComputationKernels.h
+++ /dev/null
@@ -1,185 +0,0 @@
-#ifndef RecoLocalCalo_EcalRecProducers_plugins_TimeComputationKernels_h
-#define RecoLocalCalo_EcalRecProducers_plugins_TimeComputationKernels_h
-
-#include <iostream>
-#include <limits>
-
-#include <cuda.h>
-
-#include "DataFormats/Math/interface/approx_exp.h"
-#include "DataFormats/Math/interface/approx_log.h"
-#include "RecoLocalCalo/EcalRecProducers/interface/EigenMatrixTypes_gpu.h"
-
-#include "DeclsForKernels.h"
-
-//#define DEBUG
-
-//#define ECAL_RECO_CUDA_DEBUG
-
-namespace ecal {
-  namespace multifit {
-
-    __global__ void kernel_time_compute_nullhypot(SampleVector::Scalar const* sample_values,
-                                                  SampleVector::Scalar const* sample_value_errors,
-                                                  bool const* useless_sample_values,
-                                                  SampleVector::Scalar* chi2s,
-                                                  SampleVector::Scalar* sum0s,
-                                                  SampleVector::Scalar* sumAAs,
-                                                  int const nchannels);
-    //
-    // launch ctx parameters are
-    // 45 threads per channel, X channels per block, Y blocks
-    // 45 comes from: 10 samples for i <- 0 to 9 and for j <- i+1 to 9
-    // TODO: it might be much beter to use 32 threads per channel instead of 45
-    // to simplify the synchronization
-    //
-    __global__ void kernel_time_compute_makeratio(SampleVector::Scalar const* sample_values,
-                                                  SampleVector::Scalar const* sample_value_errors,
-                                                  uint32_t const* dids_eb,
-                                                  uint32_t const* dids_ee,
-                                                  bool const* useless_sample_values,
-                                                  char const* pedestal_nums,
-                                                  ConfigurationParameters::type const* amplitudeFitParametersEB,
-                                                  ConfigurationParameters::type const* amplitudeFitParametersEE,
-                                                  ConfigurationParameters::type const* timeFitParametersEB,
-                                                  ConfigurationParameters::type const* timeFitParametersEE,
-                                                  SampleVector::Scalar const* sumAAsNullHypot,
-                                                  SampleVector::Scalar const* sum0sNullHypot,
-                                                  SampleVector::Scalar* tMaxAlphaBetas,
-                                                  SampleVector::Scalar* tMaxErrorAlphaBetas,
-                                                  SampleVector::Scalar* g_accTimeMax,
-                                                  SampleVector::Scalar* g_accTimeWgt,
-                                                  TimeComputationState* g_state,
-                                                  unsigned int const timeFitParameters_sizeEB,
-                                                  unsigned int const timeFitParameters_sizeEE,
-                                                  ConfigurationParameters::type const timeFitLimits_firstEB,
-                                                  ConfigurationParameters::type const timeFitLimits_firstEE,
-                                                  ConfigurationParameters::type const timeFitLimits_secondEB,
-                                                  ConfigurationParameters::type const timeFitLimits_secondEE,
-                                                  int const nchannels,
-                                                  uint32_t const offsetForInputs);
-
-    /// launch ctx parameters are
-    /// 10 threads per channel, N channels per block, Y blocks
-    /// TODO: do we need to keep the state around or can be removed?!
-    //#define DEBUG_FINDAMPLCHI2_AND_FINISH
-    __global__ void kernel_time_compute_findamplchi2_and_finish(
-        SampleVector::Scalar const* sample_values,
-        SampleVector::Scalar const* sample_value_errors,
-        uint32_t const* dids_eb,
-        uint32_t const* dids_ee,
-        bool const* useless_samples,
-        SampleVector::Scalar const* g_tMaxAlphaBeta,
-        SampleVector::Scalar const* g_tMaxErrorAlphaBeta,
-        SampleVector::Scalar const* g_accTimeMax,
-        SampleVector::Scalar const* g_accTimeWgt,
-        ConfigurationParameters::type const* amplitudeFitParametersEB,
-        ConfigurationParameters::type const* amplitudeFitParametersEE,
-        SampleVector::Scalar const* sumAAsNullHypot,
-        SampleVector::Scalar const* sum0sNullHypot,
-        SampleVector::Scalar const* chi2sNullHypot,
-        TimeComputationState* g_state,
-        SampleVector::Scalar* g_ampMaxAlphaBeta,
-        SampleVector::Scalar* g_ampMaxError,
-        SampleVector::Scalar* g_timeMax,
-        SampleVector::Scalar* g_timeError,
-        int const nchannels,
-        uint32_t const offsetForInputs);
-
-    __global__ void kernel_time_compute_fixMGPAslew(uint16_t const* digis_eb,
-                                                    uint16_t const* digis_ee,
-                                                    SampleVector::Scalar* sample_values,
-                                                    SampleVector::Scalar* sample_value_errors,
-                                                    bool* useless_sample_values,
-                                                    unsigned int const sample_mask,
-                                                    int const nchannels,
-                                                    uint32_t const offsetForInputs);
-
-    __global__ void kernel_time_compute_ampl(SampleVector::Scalar const* sample_values,
-                                             SampleVector::Scalar const* sample_value_errors,
-                                             uint32_t const* dids_eb,
-                                             uint32_t const* dids_ed,
-                                             bool const* useless_samples,
-                                             SampleVector::Scalar const* g_timeMax,
-                                             SampleVector::Scalar const* amplitudeFitParametersEB,
-                                             SampleVector::Scalar const* amplitudeFitParametersEE,
-                                             SampleVector::Scalar* g_amplitudeMax,
-                                             int const nchannels,
-                                             uint32_t const offsetForInputs);
-
-    //#define ECAL_RECO_CUDA_TC_INIT_DEBUG
-    __global__ void kernel_time_computation_init(uint16_t const* digis_eb,
-                                                 uint32_t const* dids_eb,
-                                                 uint16_t const* digis_ee,
-                                                 uint32_t const* dids_ee,
-                                                 float const* rms_x12,
-                                                 float const* rms_x6,
-                                                 float const* rms_x1,
-                                                 float const* mean_x12,
-                                                 float const* mean_x6,
-                                                 float const* mean_x1,
-                                                 float const* gain12Over6,
-                                                 float const* gain6Over1,
-                                                 SampleVector::Scalar* sample_values,
-                                                 SampleVector::Scalar* sample_value_errors,
-                                                 SampleVector::Scalar* ampMaxError,
-                                                 bool* useless_sample_values,
-                                                 char* pedestal_nums,
-                                                 uint32_t const offsetForHashes,
-                                                 uint32_t const offsetForInputs,
-                                                 unsigned int const sample_maskEB,
-                                                 unsigned int const sample_maskEE,
-                                                 int nchannels);
-
-    ///
-    /// launch context parameters: 1 thread per channel
-    ///
-    //#define DEBUG_TIME_CORRECTION
-    __global__ void kernel_time_correction_and_finalize(
-        //        SampleVector::Scalar 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,
-        uint32_t const* dids_ee,
-        float const* amplitudeBinsEB,
-        float const* amplitudeBinsEE,
-        float const* shiftBinsEB,
-        float const* shiftBinsEE,
-        SampleVector::Scalar const* g_timeMax,
-        SampleVector::Scalar const* g_timeError,
-        float const* g_rms_x12,
-        float const* timeCalibConstant,
-        ::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,
-        ConfigurationParameters::type const timeConstantTermEE,
-        float const offsetTimeValueEB,
-        float const offsetTimeValueEE,
-        ConfigurationParameters::type const timeNconstEB,
-        ConfigurationParameters::type const timeNconstEE,
-        ConfigurationParameters::type const amplitudeThresholdEB,
-        ConfigurationParameters::type const amplitudeThresholdEE,
-        ConfigurationParameters::type const outOfTimeThreshG12pEB,
-        ConfigurationParameters::type const outOfTimeThreshG12pEE,
-        ConfigurationParameters::type const outOfTimeThreshG12mEB,
-        ConfigurationParameters::type const outOfTimeThreshG12mEE,
-        ConfigurationParameters::type const outOfTimeThreshG61pEB,
-        ConfigurationParameters::type const outOfTimeThreshG61pEE,
-        ConfigurationParameters::type const outOfTimeThreshG61mEB,
-        ConfigurationParameters::type const outOfTimeThreshG61mEE,
-        uint32_t const offsetForHashes,
-        uint32_t const offsetForInputs,
-        int const nchannels);
-
-  }  // namespace multifit
-}  // namespace ecal
-
-#endif  // RecoLocalCalo_EcalRecProducers_plugins_TimeComputationKernels_h
diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalRecHitGPU_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalRecHitGPU_cfi.py
deleted file mode 100644
index db04ea9a0a8d3..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/python/ecalRecHitGPU_cfi.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-
-from RecoLocalCalo.EcalRecAlgos.ecalCleaningAlgo import cleaningAlgoConfig 
-
-# rechit producer
-ecalRecHitGPU = cms.EDProducer("EcalRecHitProducerGPU",
-                               
-    uncalibrecHitsInLabelEB = cms.InputTag("ecalUncalibRecHitProducerGPU","EcalUncalibRecHitsEB"),
-    uncalibrecHitsInLabelEE = cms.InputTag("ecalUncalibRecHitProducerGPU","EcalUncalibRecHitsEE"),
-          
-    recHitsLabelEB = cms.string("EcalRecHitsEB"),
-    recHitsLabelEE = cms.string("EcalRecHitsEE"),
- 
-    ## db statuses to be exluded from reconstruction (some will be recovered)
-    ChannelStatusToBeExcluded = cms.vstring(   'kDAC',
-                                               'kNoisy',
-                                               'kNNoisy',
-                                               'kFixedG6',
-                                               'kFixedG1',
-                                               'kFixedG0',
-                                               'kNonRespondingIsolated',
-                                               'kDeadVFE',
-                                               'kDeadFE',
-                                               'kNoDataNoTP',
-                                               #
-                                               # AM should I add them here?????
-                                               # next ones from "flagsMapDBReco"
-                                               # but not defined in "EcalChannelStatusCode.h"
-                                               # but they are defined in "EcalRecHit.h"
-                                               #
-                                               #'kKilled',
-                                               #'kTPSaturated',
-                                               #'kL1SpikeFlag',
-                                               ),
-    
-    ## avoid propagation of dead channels other than after recovery
-    killDeadChannels = cms.bool(True),
-    
-    ## define maximal and minimal values for the laser corrections
-    
-    EBLaserMIN = cms.double(0.01),
-    EELaserMIN = cms.double(0.01),
-
-    EBLaserMAX = cms.double(30.0),
-    EELaserMAX = cms.double(30.0),
-
-    ## reco flags association to DB flag
-    flagsMapDBReco = cms.PSet(
-        kGood  = cms.vstring('kOk','kDAC','kNoLaser','kNoisy'),
-        kNoisy = cms.vstring('kNNoisy','kFixedG6','kFixedG1'),
-        kNeighboursRecovered = cms.vstring('kFixedG0',
-                                           'kNonRespondingIsolated',
-                                           'kDeadVFE'),
-        kTowerRecovered = cms.vstring('kDeadFE'),
-        kDead           = cms.vstring('kNoDataNoTP')
-        ), 
-
-    ## for channel recovery
-    recoverEBIsolatedChannels = cms.bool(False),
-    recoverEEIsolatedChannels = cms.bool(False),
-    recoverEBVFE  = cms.bool(False),
-    recoverEEVFE  = cms.bool(False),
-    recoverEBFE = cms.bool(True),
-    recoverEEFE = cms.bool(True),
-)
-
-##
-## Modify for the tau embedding methods cleaning step
-##
-from Configuration.ProcessModifiers.tau_embedding_cleaning_cff import tau_embedding_cleaning
-from TauAnalysis.MCEmbeddingTools.Cleaning_RECO_cff import tau_embedding_ecalRecHit_cleaner
-tau_embedding_cleaning.toReplaceWith(ecalRecHitGPU, tau_embedding_ecalRecHit_cleaner)
\ No newline at end of file
diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHitPhase2GPU_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHitPhase2GPU_cfi.py
deleted file mode 100644
index 7da113721cd17..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHitPhase2GPU_cfi.py
+++ /dev/null
@@ -1,2 +0,0 @@
-import  RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitPhase2WeightsProducerGPU_cfi as _mod
-ecalUncalibRecHitPhase2GPU = _mod.ecalUncalibRecHitPhase2WeightsProducerGPU.clone()
diff --git a/RecoLocalCalo/EcalRecProducers/test/ecalRawDecodingAndMultifit.py b/RecoLocalCalo/EcalRecProducers/test/ecalRawDecodingAndMultifit.py
deleted file mode 100644
index 18809efab8cdc..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/test/ecalRawDecodingAndMultifit.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-from Configuration.StandardSequences.Eras import eras
-
-process = cms.Process('RECO', eras.Run2_2018)
-
-# import of standard configurations
-process.load('Configuration.StandardSequences.Services_cff')
-process.load('FWCore.MessageService.MessageLogger_cfi')
-process.load('HeterogeneousCore.CUDACore.ProcessAcceleratorCUDA_cfi')
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
-process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
-
-# Other statements
-from Configuration.AlCa.GlobalTag import GlobalTag
-process.GlobalTag = GlobalTag(process.GlobalTag, '102X_dataRun2_HLT_v2', '')
-
-
-process.maxEvents = cms.untracked.PSet(
-    input = cms.untracked.int32(100)
-)
-
-# load data using the DAQ source
-import sys, os, inspect
-sys.path.append(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
-process.load('sourceFromRawCmggpu_cff')
-
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load("RecoLocalCalo.Configuration.hcalLocalReco_cff")
-process.load("EventFilter.HcalRawToDigi.HcalRawToDigi_cfi")
-process.load("EventFilter.EcalRawToDigi.EcalUnpackerData_cfi")
-process.load("RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi")
-
-# load both cpu and gpu plugins
-process.load("RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi")
-
-# for validation of gpu multifit products
-process.load("RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi")
-process.load("EventFilter.EcalRawToDigi.ecalCPUDigisProducer_cfi")
-
-process.load("EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi")
-process.load("EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi")
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi")
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalRechitADCToGeVConstantGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalIntercalibConstantsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalRechitChannelStatusGPUESProducer_cfi")
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosRefGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAlphasGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLinearCorrectionsGPUESProducer_cfi")
-
-# force HLT configuration for ecalMultiFitUncalibRecHit
-process.ecalMultiFitUncalibRecHit.algoPSet = cms.PSet(
-    EBtimeFitLimits_Upper = cms.double(1.4),
-    EEtimeFitLimits_Lower = cms.double(0.2),
-    timealgo = cms.string("None"),
-    EBtimeNconst = cms.double(28.5),
-    prefitMaxChiSqEE = cms.double(10.0),
-    outOfTimeThresholdGain12mEB = cms.double(5.0),
-    outOfTimeThresholdGain12mEE = cms.double(1000.0),
-    EEtimeFitParameters = cms.vdouble(-2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277),
-    prefitMaxChiSqEB = cms.double(25.0),
-    simplifiedNoiseModelForGainSwitch = cms.bool(True),
-    EBtimeFitParameters = cms.vdouble(-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621),
-    selectiveBadSampleCriteriaEB = cms.bool(False),
-    dynamicPedestalsEB = cms.bool(False),
-    useLumiInfoRunHeader = cms.bool(False),
-    EBamplitudeFitParameters = cms.vdouble(1.138, 1.652),
-    doPrefitEE = cms.bool(False),
-    dynamicPedestalsEE = cms.bool(False),
-    selectiveBadSampleCriteriaEE = cms.bool(False),
-    outOfTimeThresholdGain61pEE = cms.double(1000.0),
-    outOfTimeThresholdGain61pEB = cms.double(5.0),
-    activeBXs = cms.vint32(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4),
-    doPrefitEB = cms.bool(False),
-    addPedestalUncertaintyEE = cms.double(0.0),
-    addPedestalUncertaintyEB = cms.double(0.0),
-    gainSwitchUseMaxSampleEB = cms.bool(True),
-    EEtimeNconst = cms.double(31.8),
-    EEamplitudeFitParameters = cms.vdouble(1.89, 1.4),
-    outOfTimeThresholdGain12pEB = cms.double(5.0),
-    gainSwitchUseMaxSampleEE = cms.bool(False),
-    mitigateBadSamplesEB = cms.bool(False),
-    outOfTimeThresholdGain12pEE = cms.double(1000.0),
-    ampErrorCalculation = cms.bool(False),
-    mitigateBadSamplesEE = cms.bool(False),
-    amplitudeThresholdEB = cms.double(10.0),
-    amplitudeThresholdEE = cms.double(10.0),
-    EBtimeFitLimits_Lower = cms.double(0.2),
-    EEtimeFitLimits_Upper = cms.double(1.4),
-    outOfTimeThresholdGain61mEE = cms.double(1000.0),
-    EEtimeConstantTerm = cms.double(1.0),
-    EBtimeConstantTerm = cms.double(0.6),
-    outOfTimeThresholdGain61mEB = cms.double(5.0)
-)
-
-process.ecalDigis = process.ecalEBunpacker.clone()
-process.ecalDigis.InputLabel = cms.InputTag('rawDataCollector')
-
-process.out = cms.OutputModule("PoolOutputModule",
-    fileName = cms.untracked.string("test.root")
-)
-
-process.finalize = cms.EndPath(process.out)
-
-process.bunchSpacing = cms.Path(
-    process.bunchSpacingProducer
-)
-
-process.digiPath = cms.Path(
-    process.ecalDigis +
-    process.ecalRawToDigiGPU +
-    process.ecalCPUDigisProducer
-)
-
-process.recoPath = cms.Path(
-    process.ecalMultiFitUncalibRecHit +
-    process.ecalUncalibRecHitProducerGPU +
-    process.ecalCPUUncalibRecHitProducer
-)
-
-process.schedule = cms.Schedule(
-    process.bunchSpacing,
-    process.digiPath,
-    process.recoPath,
-    process.finalize
-)
-
-process.options = cms.untracked.PSet(
-    numberOfThreads = cms.untracked.uint32(4),
-    numberOfStreams = cms.untracked.uint32(4),
-    TryToContinue = cms.untracked.vstring('ProductNotFound'),
-    wantSummary = cms.untracked.bool(True)
-)
diff --git a/RecoLocalCalo/EcalRecProducers/test/testEcalRechitProducer_cfg.py b/RecoLocalCalo/EcalRecProducers/test/testEcalRechitProducer_cfg.py
deleted file mode 100644
index e8f8e26ca29e1..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/test/testEcalRechitProducer_cfg.py
+++ /dev/null
@@ -1,281 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-
-from Configuration.StandardSequences.Eras import eras
-
-process = cms.Process('RECO', eras.Run2_2018)
-
-# import of standard configurations
-process.load('Configuration.StandardSequences.Services_cff')
-process.load('FWCore.MessageService.MessageLogger_cfi')
-process.load('HeterogeneousCore.CUDACore.ProcessAcceleratorCUDA_cfi')
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
-process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
-
-# Other statements
-from Configuration.AlCa.GlobalTag import GlobalTag
-process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2022_realistic', '')
-
-process.maxEvents = cms.untracked.PSet(
-    input = cms.untracked.int32(1000)
-)
-
-# load data using the DAQ source
-import sys, os, inspect
-sys.path.append(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
-process.load('sourceFromRawCmggpu_cff')
-
-#-----------------------------------------
-# CMSSW/Hcal non-DQM Related Module import
-#-----------------------------------------
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load("RecoLocalCalo.Configuration.hcalLocalReco_cff")
-#process.load("RecoLocalCalo.Configuration.ecalLocalRecoSequence_cff")
-process.load("EventFilter.HcalRawToDigi.HcalRawToDigi_cfi")
-process.load("EventFilter.EcalRawToDigi.EcalUnpackerData_cfi")
-process.load("RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi")
-
-# load both cpu and gpu plugins
-#
-# ../cfipython/slc7_amd64_gcc700/RecoLocalCalo/EcalRecProducers/ecalUncalibRecHitProducerGPU_cfi.py
-#
-process.load("RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi")
-
-# for validation of gpu multifit products
-process.load("RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi")
-process.load("EventFilter.EcalRawToDigi.ecalCPUDigisProducer_cfi")
-
-process.load("EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi")
-process.load("EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi")
-
-#process.ecalUncalibRecHitProducerGPU.kernelsVersion = 0
-#process.ecalUncalibRecHitProducerGPU.kernelMinimizeThreads = cms.vuint32(16, 1, 1)
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi")
-
-#process.ecalMultiFitUncalibRecHitgpu.algoPSet.threads = cms.vint32(256, 1, 1)
-
-#from RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi import ecalMultifitParametersGPUESProducer
-process.load("RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi")
-
-#
-#
-#   No "JobConfigurationGPURecord" record found in the EventSetup.n
-#    #--->
-#
-process.load("RecoLocalCalo.EcalRecProducers.ecalRecHitParametersGPUESProducer_cfi")
-#ecalRecHitParametersGPUESProducer_cfi.py
-
-
-##
-## force HLT configuration for ecalMultiFitUncalibRecHit
-##
-
-process.ecalMultiFitUncalibRecHit.algoPSet = cms.PSet( 
-      EBtimeFitLimits_Upper = cms.double( 1.4 ),
-      EEtimeFitLimits_Lower = cms.double( 0.2 ),
-      timealgo = cms.string( "None" ),
-      EBtimeNconst = cms.double( 28.5 ),
-      prefitMaxChiSqEE = cms.double( 10.0 ),
-      outOfTimeThresholdGain12mEB = cms.double( 5.0 ),
-      outOfTimeThresholdGain12mEE = cms.double( 1000.0 ),
-      EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ),
-      prefitMaxChiSqEB = cms.double( 25.0 ),
-      simplifiedNoiseModelForGainSwitch = cms.bool( True ),
-      EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ),
-      selectiveBadSampleCriteriaEB = cms.bool( False ),
-      dynamicPedestalsEB = cms.bool( False ),
-      useLumiInfoRunHeader = cms.bool( False ),
-      EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ),
-      doPrefitEE = cms.bool( False ),
-      dynamicPedestalsEE = cms.bool( False ),
-      selectiveBadSampleCriteriaEE = cms.bool( False ),
-      outOfTimeThresholdGain61pEE = cms.double( 1000.0 ),
-      outOfTimeThresholdGain61pEB = cms.double( 5.0 ),
-      activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ),
-      doPrefitEB = cms.bool( False ),
-      addPedestalUncertaintyEE = cms.double( 0.0 ),
-      addPedestalUncertaintyEB = cms.double( 0.0 ),
-      gainSwitchUseMaxSampleEB = cms.bool( True ),
-      EEtimeNconst = cms.double( 31.8 ),
-      EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ),
-      outOfTimeThresholdGain12pEB = cms.double( 5.0 ),
-      gainSwitchUseMaxSampleEE = cms.bool( False ),
-      mitigateBadSamplesEB = cms.bool( False ),
-      outOfTimeThresholdGain12pEE = cms.double( 1000.0 ),
-      ampErrorCalculation = cms.bool( False ),
-      mitigateBadSamplesEE = cms.bool( False ),
-      amplitudeThresholdEB = cms.double( 10.0 ),
-      amplitudeThresholdEE = cms.double( 10.0 ),
-      EBtimeFitLimits_Lower = cms.double( 0.2 ),
-      EEtimeFitLimits_Upper = cms.double( 1.4 ),
-      outOfTimeThresholdGain61mEE = cms.double( 1000.0 ),
-      EEtimeConstantTerm = cms.double( 1.0 ),
-      EBtimeConstantTerm = cms.double( 0.6 ),
-      outOfTimeThresholdGain61mEB = cms.double( 5.0 )
-)     
-      
-##    
-    
-    
-    
-process.load('Configuration.StandardSequences.Reconstruction_cff')
-#process.ecalRecHit
-
-    
-process.load("RecoLocalCalo.EcalRecProducers.ecalRechitADCToGeVConstantGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalRechitChannelStatusGPUESProducer_cfi")
-#process.load("RecoLocalCalo.EcalRecProducers.ecalADCToGeVConstantGPUESProducer_cfi")
-#process.load("RecoLocalCalo.EcalRecProducers.ecalChannelStatusGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalIntercalibConstantsGPUESProducer_cfi")
-    
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAPDPNRatiosRefGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLaserAlphasGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalLinearCorrectionsGPUESProducer_cfi")
-    
-process.load("RecoLocalCalo.EcalRecProducers.ecalRecHitGPU_cfi")
-process.ecalRecHitProducerGPU = process.ecalRecHitGPU.clone()
- 
- 
-process.load("RecoLocalCalo.EcalRecProducers.ecalCPURecHitProducer_cfi")
-
- 
-#
-# AM : TEST to see if the number of rechits matches
-#
-#process.ecalRecHit.killDeadChannels = cms.bool(False)
-#
-#process.ecalRecHit.recoverEBFE = cms.bool(False)
-#process.ecalRecHit.recoverEBIsolatedChannels = cms.bool(False)
-#process.ecalRecHit.recoverEBVFE = cms.bool(False)
-##
-#process.ecalRecHit.recoverEEFE = cms.bool(False)
-#process.ecalRecHit.recoverEEIsolatedChannels = cms.bool(False)
-#process.ecalRecHit.recoverEEVFE = cms.bool(False)
-#
-#process.ecalRecHit.skipTimeCalib = cms.bool(True)
-#
-#process.ecalRecHitProducerGPU.killDeadChannels = cms.bool(False)
-#
-#
-#process.ecalRecHitProducerGPU.recoverEBFE = cms.bool(False)
-#process.ecalRecHitProducerGPU.recoverEBIsolatedChannels = cms.bool(False)
-#process.ecalRecHitProducerGPU.recoverEBVFE = cms.bool(False)
-#process.ecalRecHitProducerGPU.recoverEEFE = cms.bool(False)
-#process.ecalRecHitProducerGPU.recoverEEIsolatedChannels = cms.bool(False)
-#process.ecalRecHitProducerGPU.recoverEEVFE = cms.bool(False)
-#
-#
-#
-# TEST
-#
-#process.ecalRecHit.ChannelStatusToBeExcluded = cms.vstring( 
-                                                          #'kDAC', 
-                                                          #'kNoisy', 
-                                                          #'kNNoisy', 
-                                                          #'kFixedG6', 
-                                                          #'kFixedG1', 
-                                                          #'kFixedG0', 
-                                                          #'kNonRespondingIsolated',
-                                                          #'kDeadVFE', 
-                                                          #'kDeadFE', 
-                                                          #'kNoDataNoTP'
-                                                          #)
-#process.ecalRecHitProducerGPU.ChannelStatusToBeExcluded = cms.vstring(
-                                                          #'kDAC', 
-                                                          #'kNoisy', 
-                                                          #'kNNoisy', 
-                                                          #'kFixedG6', 
-                                                          #'kFixedG1', 
-                                                          #'kFixedG0', 
-                                                          #'kNonRespondingIsolated',
-                                                          #'kDeadVFE', 
-                                                          #'kDeadFE', 
-                                                          #'kNoDataNoTP'
-                                                          #)
-#
-#
-
-    #ChannelStatusToBeExcluded = cms.vstring(
-        #'kDAC', 
-        #'kNoisy', 
-        #'kNNoisy', 
-        #'kFixedG6', 
-        #'kFixedG1', 
-        #'kFixedG0', 
-        #'kNonRespondingIsolated', 
-        #'kDeadVFE', 
-        #'kDeadFE', 
-        #'kNoDataNoTP'
-    #),
-
-
-
-#process.hcalDigis.silent = cms.untracked.bool(False)
-#process.hcalDigis.InputLabel = rawTag
-process.ecalDigis = process.ecalEBunpacker.clone()
-process.ecalDigis.InputLabel = cms.InputTag('rawDataCollector')
-#process.hbheprerecogpu.processQIE11 = cms.bool(True)
-
-process.out = cms.OutputModule(
-    "PoolOutputModule",
-    fileName = cms.untracked.string("testRechit.root")
-)
-
-#process.out = cms.OutputModule("AsciiOutputModule",
-#    outputCommands = cms.untracked.vstring(
-#        'keep *_ecalMultiFitUncalibRecHit_*_*', 
-#    ),
-#    verbosity = cms.untracked.uint32(0)
-#)
-process.finalize = cms.EndPath(process.out)
-
-process.bunchSpacing = cms.Path(
-    process.bunchSpacingProducer
-)
-
-process.digiPath = cms.Path(
-    #process.hcalDigis
-    process.ecalDigis
-    *process.ecalRawToDigiGPU    
-    *process.ecalCPUDigisProducer
-)
-
-process.recoPath = cms.Path(
-    (process.ecalMultiFitUncalibRecHit+process.ecalDetIdToBeRecovered)
-    #process.ecalMultiFitUncalibRecHit
-    *process.ecalRecHit
-#   gpu
-    *process.ecalUncalibRecHitProducerGPU
-    *process.ecalCPUUncalibRecHitProducer
-    *process.ecalRecHitProducerGPU
-    *process.ecalCPURecHitProducer
-)
-
-process.schedule = cms.Schedule(
-    process.bunchSpacing,
-    process.digiPath,
-    process.recoPath,
-#    process.ecalecalLocalRecoSequence
-    process.finalize
-)
-
-process.options = cms.untracked.PSet(
-    numberOfThreads = cms.untracked.uint32(4),
-    numberOfStreams = cms.untracked.uint32(4),
-    TryToContinue = cms.untracked.vstring('ProductNotFound'),
-    wantSummary = cms.untracked.bool(True)
-)
-
-#
-#process.DependencyGraph = cms.Service("DependencyGraph")
-
-
diff --git a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU.py b/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU.py
deleted file mode 100644
index 5841efff024e8..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU.py
+++ /dev/null
@@ -1,141 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-
-from Configuration.Eras.Era_Phase2C10_cff import Phase2C10
-from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel
-from Configuration.ProcessModifiers.gpu_cff import gpu
-from Configuration.ProcessModifiers.gpuValidationEcal_cff import gpuValidationEcal
-
-process = cms.Process('RECO',Phase2C10,phase2_ecal_devel, gpu, gpuValidationEcal)
-
-# import of standard configurations
-process.load('Configuration.StandardSequences.Services_cff')
-process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
-process.load('FWCore.MessageService.MessageLogger_cfi')
-process.load('Configuration.EventContent.EventContent_cff')
-process.load('SimGeneral.MixingModule.mixNoPU_cfi')
-process.load('Configuration.Geometry.GeometryExtendedRun4D60Reco_cff')
-process.load('Configuration.StandardSequences.MagneticField_cff')
-process.load('Configuration.StandardSequences.RawToDigi_cff')
-process.load('Configuration.StandardSequences.L1Reco_cff')
-process.load('Configuration.StandardSequences.Reconstruction_cff')
-process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
-process.load('DQMOffline.Configuration.DQMOfflineMC_cff')
-process.load('RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitPhase2_cff')
-process.load('RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi')
-
-process.maxEvents = cms.untracked.PSet(
-    input = cms.untracked.int32(100),
-    output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
-)
-
-process.load('HLTrigger.Timer.FastTimerService_cfi')
-process.FastTimerService.enableDQM = False
-process.FastTimerService.printRunSummary = False
-process.FastTimerService.printJobSummary = True
-process.FastTimerService.writeJSONSummary = True
-process.FastTimerService.jsonFileName = 'resources.json'
-process.MessageLogger.FastReport = cms.untracked.PSet()
-
-
-
-# Input source
-process.source = cms.Source("PoolSource",
-    fileNames = cms.untracked.vstring('/store/group/dpg_ecal/comm_ecal/upgrade/Phase2CMSSW///RelValTTbar_14TeV_ecaldigi_123X_mcRun4_realistic_v3_2026D77noPU-v1.root'),
-    secondaryFileNames = cms.untracked.vstring()
-)
-
-process.options = cms.untracked.PSet(
-    IgnoreCompletely = cms.untracked.vstring(),
-    Rethrow = cms.untracked.vstring(),
-    TryToContinue = cms.untracked.vstring(),
-    allowUnscheduled = cms.obsolete.untracked.bool,
-    canDeleteEarly = cms.untracked.vstring(),
-    emptyRunLumiMode = cms.obsolete.untracked.string,
-    eventSetup = cms.untracked.PSet(
-        forceNumberOfConcurrentIOVs = cms.untracked.PSet(
-            allowAnyLabel_=cms.required.untracked.uint32
-        ),
-        numberOfConcurrentIOVs = cms.untracked.uint32(1)
-    ),
-    fileMode = cms.untracked.string('FULLMERGE'),
-    forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
-    makeTriggerResults = cms.obsolete.untracked.bool,
-    numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(1),
-    numberOfConcurrentRuns = cms.untracked.uint32(1),
-    numberOfStreams = cms.untracked.uint32(0),
-    numberOfThreads = cms.untracked.uint32(1),
-    printDependencies = cms.untracked.bool(False),
-    sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
-    throwIfIllegalParameter = cms.untracked.bool(True),
-    wantSummary = cms.untracked.bool(True)
-)
-
-# Production Info
-process.configurationMetadata = cms.untracked.PSet(
-    annotation = cms.untracked.string('step3GPU nevts:10'),
-    name = cms.untracked.string('Applications'),
-    version = cms.untracked.string('$Revision: 1.19 $')
-)
-
-# Set up the DQM GPU validation task
-process.ecalMonitorTaskEcalOnly.workers = ["GpuTask"]
-process.ecalMonitorTaskEcalOnly.collectionTags.EBCpuUncalibRecHit = "ecalUncalibRecHitPhase2Legacy:EcalUncalibRecHitsEB"
-process.ecalMonitorTaskEcalOnly.collectionTags.EBGpuUncalibRecHit = "ecalUncalibRecHitPhase2:EcalUncalibRecHitsEB"
-
-# Output definition
-outputCommand = process.FEVTDEBUGHLTEventContent.outputCommands
-outputCommand.append('keep *_ecalUncalibRecHitPhase2*_*_RECO')
-process.FEVTDEBUGHLToutput = cms.OutputModule("PoolOutputModule",
-    dataset = cms.untracked.PSet(
-        dataTier = cms.untracked.string('GEN-SIM-RECO'),
-        filterName = cms.untracked.string('')
-    ),
-    fileName = cms.untracked.string('file:step3GPU.root'),
-    outputCommands = outputCommand,
-    splitLevel = cms.untracked.int32(0)
-)
-
-process.DQMoutput = cms.OutputModule("DQMRootOutputModule",
-    dataset = cms.untracked.PSet(
-        dataTier = cms.untracked.string('DQMIO'),
-        filterName = cms.untracked.string('')
-    ),
-    fileName = cms.untracked.string('file:step3GPU_inDQM.root'),
-    outputCommands = process.DQMEventContent.outputCommands,
-    splitLevel = cms.untracked.int32(0)
-)
-
-# Additional output definition
-
-# Other statements
-from Configuration.AlCa.GlobalTag import GlobalTag
-process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_T15', '')
-
-# Path and EndPath definitions
-process.L1Reco_step = cms.Path(process.L1Reco)
-process.reconstruction_step = cms.Path(cms.Sequence(cms.Task(
-    process.bunchSpacingProducer,
-    process.ecalUncalibRecHitPhase2Task
-)))
-process.dqmoffline_step = cms.EndPath(process.DQMOfflineEcalOnly)
-
-process.FEVTDEBUGHLToutput_step = cms.EndPath(process.FEVTDEBUGHLToutput)
-process.DQMoutput_step = cms.EndPath(process.DQMoutput)
-
-# Schedule definition
-process.schedule = cms.Schedule(process.L1Reco_step,process.reconstruction_step,process.dqmoffline_step,process.FEVTDEBUGHLToutput_step,process.DQMoutput_step)
-from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask
-associatePatAlgosToolsTask(process)
-
-
-
-# Customisation from command line
-
-#Have logErrorHarvester wait for the same EDProducers to finish as those providing data for the OutputModule
-from FWCore.Modules.logErrorHarvester_cff import customiseLogErrorHarvesterUsingOutputCommands
-process = customiseLogErrorHarvesterUsingOutputCommands(process)
-
-# Add early deletion of temporary data products to reduce peak memory need
-from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete
-process = customiseEarlyDelete(process)
-# End adding early deletion
diff --git a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU_harvesting.py b/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU_harvesting.py
deleted file mode 100644
index bdf6424a32385..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRecHitPhase2WeightsProducerGPU_harvesting.py
+++ /dev/null
@@ -1,95 +0,0 @@
-# Auto generated configuration file
-# using: 
-# Revision: 1.19 
-# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v 
-# with command line options: step4 -s HARVESTING:@ecalOnlyValidation+@ecal --conditions auto:phase1_2021_realistic --mc --geometry DB:Extended --scenario pp --filetype DQM --era Run3 -n 100 --filein file:step3GPU_inDQM.root --fileout file:step4.root
-import FWCore.ParameterSet.Config as cms
-
-from Configuration.Eras.Era_Run3_cff import Run3
-
-process = cms.Process('HARVESTING',Run3)
-
-# import of standard configurations
-process.load('Configuration.StandardSequences.Services_cff')
-process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
-process.load('FWCore.MessageService.MessageLogger_cfi')
-process.load('Configuration.EventContent.EventContent_cff')
-process.load('SimGeneral.MixingModule.mixNoPU_cfi')
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load('Configuration.StandardSequences.MagneticField_cff')
-process.load('Configuration.StandardSequences.DQMSaverAtRunEnd_cff')
-process.load('Configuration.StandardSequences.Harvesting_cff')
-process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
-
-process.maxEvents = cms.untracked.PSet(
-    input = cms.untracked.int32(100),
-    output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
-)
-
-# Input source
-process.source = cms.Source("DQMRootSource",
-    fileNames = cms.untracked.vstring('file:step3GPU_inDQM.root')
-)
-
-process.options = cms.untracked.PSet(
-    IgnoreCompletely = cms.untracked.vstring(),
-    Rethrow = cms.untracked.vstring('ProductNotFound'),
-    TryToContinue = cms.untracked.vstring(),
-    allowUnscheduled = cms.obsolete.untracked.bool,
-    canDeleteEarly = cms.untracked.vstring(),
-    deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
-    dumpOptions = cms.untracked.bool(False),
-    emptyRunLumiMode = cms.obsolete.untracked.string,
-    eventSetup = cms.untracked.PSet(
-        forceNumberOfConcurrentIOVs = cms.untracked.PSet(
-            allowAnyLabel_=cms.required.untracked.uint32
-        ),
-        numberOfConcurrentIOVs = cms.untracked.uint32(0)
-    ),
-    fileMode = cms.untracked.string('FULLMERGE'),
-    forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
-    makeTriggerResults = cms.obsolete.untracked.bool,
-    numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
-    numberOfConcurrentRuns = cms.untracked.uint32(1),
-    numberOfStreams = cms.untracked.uint32(0),
-    numberOfThreads = cms.untracked.uint32(1),
-    printDependencies = cms.untracked.bool(False),
-    sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
-    throwIfIllegalParameter = cms.untracked.bool(True),
-    wantSummary = cms.untracked.bool(False)
-)
-
-# Production Info
-process.configurationMetadata = cms.untracked.PSet(
-    annotation = cms.untracked.string('step4 nevts:100'),
-    name = cms.untracked.string('Applications'),
-    version = cms.untracked.string('$Revision: 1.19 $')
-)
-
-# Output definition
-
-# Additional output definition
-
-# Other statements
-from Configuration.AlCa.GlobalTag import GlobalTag
-process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_T15', '')
-
-# Path and EndPath definitions
-process.postValidation_ECAL_step = cms.Path(process.postValidation_ECAL)
-process.DQMHarvestEcal_step = cms.Path(process.DQMHarvestEcal)
-process.DQMCertEcal_step = cms.Path(process.DQMCertEcal)
-process.dqmsave_step = cms.Path(process.DQMSaver)
-
-# Schedule definition
-process.schedule = cms.Schedule(process.postValidation_ECAL_step,process.DQMHarvestEcal_step,process.DQMCertEcal_step,process.dqmsave_step)
-from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask
-associatePatAlgosToolsTask(process)
-
-
-
-# Customisation from command line
-
-# Add early deletion of temporary data products to reduce peak memory need
-from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete
-process = customiseEarlyDelete(process)
-# End adding early deletion
diff --git a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRechitProducer_cfg.py b/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRechitProducer_cfg.py
deleted file mode 100644
index f389209f32d0b..0000000000000
--- a/RecoLocalCalo/EcalRecProducers/test/testEcalUncalibRechitProducer_cfg.py
+++ /dev/null
@@ -1,202 +0,0 @@
-import FWCore.ParameterSet.Config as cms
-
-from Configuration.StandardSequences.Eras import eras
-
-process = cms.Process('RECO', eras.Run2_2018)
-
-# import of standard configurations
-process.load('Configuration.StandardSequences.Services_cff')
-#process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
-process.load('FWCore.MessageService.MessageLogger_cfi')
-process.load('HeterogeneousCore.CUDACore.ProcessAcceleratorCUDA_cfi')
-#process.load('Configuration.EventContent.EventContent_cff')
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
-#process.load('Configuration.StandardSequences.RawToDigi_Data_cff')
-#process.load('Configuration.StandardSequences.Reconstruction_Data_cff')
-#process.load('DQMOffline.Configuration.DQMOffline_cff')
-process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
-
-
-
-
-
-
-# Other statements
-from Configuration.AlCa.GlobalTag import GlobalTag
-process.GlobalTag = GlobalTag(process.GlobalTag, '102X_dataRun2_HLT_v2', '')
-
-
-process.maxEvents = cms.untracked.PSet(
-    #input = cms.untracked.int32(100)
-    input = cms.untracked.int32(1000)
-)
-
-# load data using the DAQ source
-import sys, os, inspect
-sys.path.append(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))
-process.load('sourceFromRawCmggpu_cff')
-
-#-----------------------------------------
-# CMSSW/Hcal non-DQM Related Module import
-#-----------------------------------------
-process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
-process.load("RecoLocalCalo.Configuration.hcalLocalReco_cff")
-#process.load("RecoLocalCalo.Configuration.ecalLocalRecoSequence_cff")
-process.load("EventFilter.HcalRawToDigi.HcalRawToDigi_cfi")
-process.load("EventFilter.EcalRawToDigi.EcalUnpackerData_cfi")
-process.load("RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi")
-
-# load both cpu and gpu plugins
-#
-# ../cfipython/slc7_amd64_gcc700/RecoLocalCalo/EcalRecProducers/ecalUncalibRecHitProducerGPU_cfi.py
-#
-process.load("RecoLocalCalo.EcalRecProducers.ecalUncalibRecHitProducerGPU_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalMultiFitUncalibRecHit_cfi")
-
-# for validation of gpu multifit products
-process.load("RecoLocalCalo.EcalRecProducers.ecalCPUUncalibRecHitProducer_cfi")
-#
-# ../cfipython/slc7_amd64_gcc700/RecoLocalCalo/EcalRecProducers/ecalCPUUncalibRecHitProducer_cfi.py
-#
-
-process.load("EventFilter.EcalRawToDigi.ecalRawToDigiGPU_cfi")
-process.load("EventFilter.EcalRawToDigi.ecalElectronicsMappingGPUESProducer_cfi")
-
-#process.ecalUncalibRecHitProducerGPU.kernelsVersion = 0
-#process.ecalUncalibRecHitProducerGPU.kernelMinimizeThreads = cms.vuint32(16, 1, 1)
-#
-# process.ecalUncalibRecHitProducerGPU.shouldRunTimingComputation = cms.bool(False)
-#
-
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalPedestalsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalGainRatiosGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseShapesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalPulseCovariancesGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalSamplesCorrelationGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeBiasCorrectionsGPUESProducer_cfi")
-process.load("RecoLocalCalo.EcalRecProducers.ecalTimeCalibConstantsGPUESProducer_cfi")
-
-#process.ecalMultiFitUncalibRecHitgpu.algoPSet.threads = cms.vint32(256, 1, 1)
-
-
-process.load("RecoLocalCalo.EcalRecProducers.ecalMultifitParametersGPUESProducer_cfi")
-
-
-
-##
-## force HLT configuration for ecalMultiFitUncalibRecHit
-##
-
-process.ecalMultiFitUncalibRecHit.algoPSet = cms.PSet( 
-      EBtimeFitLimits_Upper = cms.double( 1.4 ),
-      EEtimeFitLimits_Lower = cms.double( 0.2 ),
-      timealgo = cms.string( "None" ),   # ----> no timing computation for CPU version
-      EBtimeNconst = cms.double( 28.5 ),
-      prefitMaxChiSqEE = cms.double( 10.0 ),
-      outOfTimeThresholdGain12mEB = cms.double( 5.0 ),
-      outOfTimeThresholdGain12mEE = cms.double( 1000.0 ),
-      EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ),
-      prefitMaxChiSqEB = cms.double( 25.0 ),
-      simplifiedNoiseModelForGainSwitch = cms.bool( True ),
-      EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ),
-      selectiveBadSampleCriteriaEB = cms.bool( False ),
-      dynamicPedestalsEB = cms.bool( False ),
-      useLumiInfoRunHeader = cms.bool( False ),
-      EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ),
-      doPrefitEE = cms.bool( False ),
-      dynamicPedestalsEE = cms.bool( False ),
-      selectiveBadSampleCriteriaEE = cms.bool( False ),
-      outOfTimeThresholdGain61pEE = cms.double( 1000.0 ),
-      outOfTimeThresholdGain61pEB = cms.double( 5.0 ),
-      activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ),
-      doPrefitEB = cms.bool( False ),
-      addPedestalUncertaintyEE = cms.double( 0.0 ),
-      addPedestalUncertaintyEB = cms.double( 0.0 ),
-      gainSwitchUseMaxSampleEB = cms.bool( True ),
-      EEtimeNconst = cms.double( 31.8 ),
-      EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ),
-      outOfTimeThresholdGain12pEB = cms.double( 5.0 ),
-      gainSwitchUseMaxSampleEE = cms.bool( False ),
-      mitigateBadSamplesEB = cms.bool( False ),
-      outOfTimeThresholdGain12pEE = cms.double( 1000.0 ),
-      ampErrorCalculation = cms.bool( False ),
-      mitigateBadSamplesEE = cms.bool( False ),
-      amplitudeThresholdEB = cms.double( 10.0 ),
-      amplitudeThresholdEE = cms.double( 10.0 ),
-      EBtimeFitLimits_Lower = cms.double( 0.2 ),
-      EEtimeFitLimits_Upper = cms.double( 1.4 ),
-      outOfTimeThresholdGain61mEE = cms.double( 1000.0 ),
-      EEtimeConstantTerm = cms.double( 1.0 ),
-      EBtimeConstantTerm = cms.double( 0.6 ),
-      outOfTimeThresholdGain61mEB = cms.double( 5.0 )
-)     
-      
-##    
-    
-    
-    
-#process.load('Configuration.StandardSequences.Reconstruction_cff')
-#process.ecalRecHit
-
-    
-    
-#process.load("RecoLocalCalo.EcalRecProducers.ecalRecHitGPU_cfi")
-#process.ecalRecHitGPU
-    
-
-
-#process.hcalDigis.silent = cms.untracked.bool(False)
-#process.hcalDigis.InputLabel = rawTag
-process.ecalDigis = process.ecalEBunpacker.clone()
-process.ecalDigis.InputLabel = cms.InputTag('rawDataCollector')
-#process.hbheprerecogpu.processQIE11 = cms.bool(True)
-
-process.out = cms.OutputModule(
-    "PoolOutputModule",
-    fileName = cms.untracked.string("test_uncalib.root")
-)
-
-#process.out = cms.OutputModule("AsciiOutputModule",
-#    outputCommands = cms.untracked.vstring(
-#        'keep *_ecalMultiFitUncalibRecHit_*_*', 
-#    ),
-#    verbosity = cms.untracked.uint32(0)
-#)
-process.finalize = cms.EndPath(process.out)
-
-process.bunchSpacing = cms.Path(
-    process.bunchSpacingProducer
-)
-
-process.digiPath = cms.Path(
-    #process.hcalDigis
-    process.ecalDigis
-    *process.ecalRawToDigiGPU    
-)
-
-process.recoPath = cms.Path(
-    #(process.ecalMultiFitUncalibRecHit+process.ecalDetIdToBeRecovered)
-    process.ecalMultiFitUncalibRecHit
-    #*process.ecalRecHit
-#   gpu
-    *process.ecalUncalibRecHitProducerGPU
-    *process.ecalCPUUncalibRecHitProducer
-    #*process.ecalRecHitGPU
-)
-
-process.schedule = cms.Schedule(
-    process.bunchSpacing,
-    process.digiPath,
-    process.recoPath,
-#    process.ecalecalLocalRecoSequence
-    process.finalize
-)
-
-process.options = cms.untracked.PSet(
-    numberOfThreads = cms.untracked.uint32(8),
-    numberOfStreams = cms.untracked.uint32(8),
-    TryToContinue = cms.untracked.vstring('ProductNotFound'),
-    wantSummary = cms.untracked.bool(True)
-)