diff --git a/RecoLocalCalo/EcalRecAlgos/BuildFile.xml b/RecoLocalCalo/EcalRecAlgos/BuildFile.xml
index 9feae5ae660a2..e9703c868ea19 100644
--- a/RecoLocalCalo/EcalRecAlgos/BuildFile.xml
+++ b/RecoLocalCalo/EcalRecAlgos/BuildFile.xml
@@ -14,7 +14,6 @@
 <use   name="cuda"/>
 <use   name="CUDADataFormats/EcalRecHitSoA"/>
 <use   name="HeterogeneousCore/CUDAUtilities"/>
-<use   name="cuda-api-wrappers"/>
 <use   name="HeterogeneousCore/CUDACore"/>
 
 <export>
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalGainRatiosGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalGainRatiosGPU.h
index 206d37f86d915..41f02518c9fc8 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalGainRatiosGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalGainRatiosGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalGainRatiosGPU {
 public:
@@ -26,7 +26,7 @@ class EcalGainRatiosGPU {
   ~EcalGainRatiosGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalGainRatiosGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h
index 2c244180e98dc..973501ed25a8d 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalPedestalsGPU {
 public:
@@ -27,7 +27,7 @@ class EcalPedestalsGPU {
   ~EcalPedestalsGPU() = default;
 
   // get device pointers
-  Product const &getProduct(cuda::stream_t<> &) const;
+  Product const &getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalPedestalsGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h
index 9fa1727fc7edc..4bc347233e75d 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalPulseCovariancesGPU {
 public:
@@ -25,7 +25,7 @@ class EcalPulseCovariancesGPU {
   ~EcalPulseCovariancesGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalPulseCovariancesGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h
index b86ef35a1bffa..2d9d118b2c024 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalPulseShapesGPU {
 public:
@@ -25,7 +25,7 @@ class EcalPulseShapesGPU {
   ~EcalPulseShapesGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalPulseShapesGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h
index 4312e6e4e2f12..3c9ee6718a5f9 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalSamplesCorrelationGPU {
 public:
@@ -26,7 +26,7 @@ class EcalSamplesCorrelationGPU {
   ~EcalSamplesCorrelationGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalSamplesCorrelationGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h
index a40a7a1089404..93bc395e449a3 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalTimeBiasCorrectionsGPU {
 public:
@@ -28,7 +28,7 @@ class EcalTimeBiasCorrectionsGPU {
   ~EcalTimeBiasCorrectionsGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   //
   static std::string name() { return std::string{"ecalTimeBiasCorrectionsGPU"}; }
diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h
index 42df640d0a642..2c6c3075dde8d 100644
--- a/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h
+++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h
@@ -8,7 +8,7 @@
 #include "HeterogeneousCore/CUDACore/interface/CUDAESProduct.h"
 #endif
 
-#include <cuda/api_wrappers.h>
+#include <cuda_runtime.h>
 
 class EcalTimeCalibConstantsGPU {
 public:
@@ -25,7 +25,7 @@ class EcalTimeCalibConstantsGPU {
   ~EcalTimeCalibConstantsGPU() = default;
 
   // get device pointers
-  Product const& getProduct(cuda::stream_t<>&) const;
+  Product const& getProduct(cudaStream_t) const;
 
   // TODO: do this centrally
   // get offset for hashes. equals number of barrel items
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalGainRatiosGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalGainRatiosGPU.cc
index 5ba220e60c49c..d5980d8a757aa 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalGainRatiosGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalGainRatiosGPU.cc
@@ -27,9 +27,9 @@ EcalGainRatiosGPU::Product::~Product() {
   cudaCheck(cudaFree(gain6Over1));
 }
 
-EcalGainRatiosGPU::Product const& EcalGainRatiosGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalGainRatiosGPU::Product const& EcalGainRatiosGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalGainRatiosGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalGainRatiosGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(cudaMalloc((void**)&product.gain12Over6, this->gain12Over6_.size() * sizeof(float)));
         cudaCheck(cudaMalloc((void**)&product.gain6Over1, this->gain6Over1_.size() * sizeof(float)));
@@ -38,12 +38,12 @@ EcalGainRatiosGPU::Product const& EcalGainRatiosGPU::getProduct(cuda::stream_t<>
                                   this->gain12Over6_.data(),
                                   this->gain12Over6_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.gain6Over1,
                                   this->gain6Over1_.data(),
                                   this->gain6Over1_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalPedestalsGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalPedestalsGPU.cc
index c725045d86ac0..9e3284cd9c7c8 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalPedestalsGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalPedestalsGPU.cc
@@ -44,9 +44,9 @@ EcalPedestalsGPU::Product::~Product() {
   cudaCheck(cudaFree(rms_x1));
 }
 
-EcalPedestalsGPU::Product const& EcalPedestalsGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalPedestalsGPU::Product const& EcalPedestalsGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPedestalsGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalPedestalsGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(cudaMalloc((void**)&product.mean_x12, this->mean_x12_.size() * sizeof(float)));
         cudaCheck(cudaMalloc((void**)&product.rms_x12, this->mean_x12_.size() * sizeof(float)));
@@ -60,32 +60,32 @@ EcalPedestalsGPU::Product const& EcalPedestalsGPU::getProduct(cuda::stream_t<>&
                                   this->mean_x12_.data(),
                                   this->mean_x12_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.rms_x12,
                                   this->rms_x12_.data(),
                                   this->rms_x12_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.mean_x6,
                                   this->mean_x6_.data(),
                                   this->mean_x6_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.rms_x6,
                                   this->rms_x6_.data(),
                                   this->rms_x6_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.mean_x1,
                                   this->mean_x1_.data(),
                                   this->mean_x1_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.rms_x1,
                                   this->rms_x1_.data(),
                                   this->rms_x1_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalPulseCovariancesGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalPulseCovariancesGPU.cc
index e6c59ecf96355..bbeda99652e22 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalPulseCovariancesGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalPulseCovariancesGPU.cc
@@ -11,9 +11,9 @@ EcalPulseCovariancesGPU::Product::~Product() {
   cudaCheck(cudaFree(values));
 }
 
-EcalPulseCovariancesGPU::Product const& EcalPulseCovariancesGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalPulseCovariancesGPU::Product const& EcalPulseCovariancesGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPulseCovariancesGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalPulseCovariancesGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(cudaMalloc((void**)&product.values,
                              (this->valuesEE_.size() + this->valuesEB_.size()) * sizeof(EcalPulseCovariance)));
@@ -26,14 +26,14 @@ EcalPulseCovariancesGPU::Product const& EcalPulseCovariancesGPU::getProduct(cuda
                                   this->valuesEB_.data(),
                                   this->valuesEB_.size() * sizeof(EcalPulseCovariance),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
 
         // transfer ee starting at values + offset
         cudaCheck(cudaMemcpyAsync(product.values + offset,
                                   this->valuesEE_.data(),
                                   this->valuesEE_.size() * sizeof(EcalPulseCovariance),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalPulseShapesGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalPulseShapesGPU.cc
index 95fad8dbdbe31..aee122a01627d 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalPulseShapesGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalPulseShapesGPU.cc
@@ -11,9 +11,9 @@ EcalPulseShapesGPU::Product::~Product() {
   cudaCheck(cudaFree(values));
 }
 
-EcalPulseShapesGPU::Product const& EcalPulseShapesGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalPulseShapesGPU::Product const& EcalPulseShapesGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalPulseShapesGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalPulseShapesGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(cudaMalloc((void**)&product.values,
                              (this->valuesEE_.size() + this->valuesEB_.size()) * sizeof(EcalPulseShape)));
@@ -26,14 +26,14 @@ EcalPulseShapesGPU::Product const& EcalPulseShapesGPU::getProduct(cuda::stream_t
                                   this->valuesEB_.data(),
                                   this->valuesEB_.size() * sizeof(EcalPulseShape),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
 
         // transfer ee starting at values + offset
         cudaCheck(cudaMemcpyAsync(product.values + offset,
                                   this->valuesEE_.data(),
                                   this->valuesEE_.size() * sizeof(EcalPulseShape),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalSamplesCorrelationGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalSamplesCorrelationGPU.cc
index 9841da0d540c8..2a98067f51d9e 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalSamplesCorrelationGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalSamplesCorrelationGPU.cc
@@ -21,9 +21,9 @@ EcalSamplesCorrelationGPU::Product::~Product() {
   cudaCheck(cudaFree(EEG1SamplesCorrelation));
 }
 
-EcalSamplesCorrelationGPU::Product const& EcalSamplesCorrelationGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalSamplesCorrelationGPU::Product const& EcalSamplesCorrelationGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalSamplesCorrelationGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalSamplesCorrelationGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(cudaMalloc((void**)&product.EBG12SamplesCorrelation,
                              this->EBG12SamplesCorrelation_.size() * sizeof(double)));
@@ -42,32 +42,32 @@ EcalSamplesCorrelationGPU::Product const& EcalSamplesCorrelationGPU::getProduct(
                                   this->EBG12SamplesCorrelation_.data(),
                                   this->EBG12SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EBG6SamplesCorrelation,
                                   this->EBG6SamplesCorrelation_.data(),
                                   this->EBG6SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EBG1SamplesCorrelation,
                                   this->EBG1SamplesCorrelation_.data(),
                                   this->EBG1SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EEG12SamplesCorrelation,
                                   this->EEG12SamplesCorrelation_.data(),
                                   this->EEG12SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EEG6SamplesCorrelation,
                                   this->EEG6SamplesCorrelation_.data(),
                                   this->EEG6SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EEG1SamplesCorrelation,
                                   this->EEG1SamplesCorrelation_.data(),
                                   this->EEG1SamplesCorrelation_.size() * sizeof(double),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalTimeBiasCorrectionsGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalTimeBiasCorrectionsGPU.cc
index ddc2eb2f58033..9ab0a6302a9c4 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalTimeBiasCorrectionsGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalTimeBiasCorrectionsGPU.cc
@@ -17,9 +17,9 @@ EcalTimeBiasCorrectionsGPU::Product::~Product() {
   cudaCheck(cudaFree(EETimeCorrShiftBins));
 }
 
-EcalTimeBiasCorrectionsGPU::Product const& EcalTimeBiasCorrectionsGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalTimeBiasCorrectionsGPU::Product const& EcalTimeBiasCorrectionsGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalTimeBiasCorrectionsGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      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();
@@ -37,22 +37,22 @@ EcalTimeBiasCorrectionsGPU::Product const& EcalTimeBiasCorrectionsGPU::getProduc
                                   this->EBTimeCorrAmplitudeBins_.data(),
                                   this->EBTimeCorrAmplitudeBins_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EBTimeCorrShiftBins,
                                   this->EBTimeCorrShiftBins_.data(),
                                   this->EBTimeCorrShiftBins_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EETimeCorrAmplitudeBins,
                                   this->EETimeCorrAmplitudeBins_.data(),
                                   this->EETimeCorrAmplitudeBins_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.EETimeCorrShiftBins,
                                   this->EETimeCorrShiftBins_.data(),
                                   this->EETimeCorrShiftBins_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalTimeCalibConstantsGPU.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalTimeCalibConstantsGPU.cc
index 1f32105734f26..d724a33f1d4e1 100644
--- a/RecoLocalCalo/EcalRecAlgos/src/EcalTimeCalibConstantsGPU.cc
+++ b/RecoLocalCalo/EcalRecAlgos/src/EcalTimeCalibConstantsGPU.cc
@@ -11,9 +11,9 @@ EcalTimeCalibConstantsGPU::Product::~Product() {
   cudaCheck(cudaFree(values));
 }
 
-EcalTimeCalibConstantsGPU::Product const& EcalTimeCalibConstantsGPU::getProduct(cuda::stream_t<>& cudaStream) const {
+EcalTimeCalibConstantsGPU::Product const& EcalTimeCalibConstantsGPU::getProduct(cudaStream_t cudaStream) const {
   auto const& product = product_.dataForCurrentDeviceAsync(
-      cudaStream, [this](EcalTimeCalibConstantsGPU::Product& product, cuda::stream_t<>& cudaStream) {
+      cudaStream, [this](EcalTimeCalibConstantsGPU::Product& product, cudaStream_t cudaStream) {
         // malloc
         cudaCheck(
             cudaMalloc((void**)&product.values, (this->valuesEB_.size() + this->valuesEE_.size()) * sizeof(float)));
@@ -26,12 +26,12 @@ EcalTimeCalibConstantsGPU::Product const& EcalTimeCalibConstantsGPU::getProduct(
                                   this->valuesEB_.data(),
                                   this->valuesEB_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
         cudaCheck(cudaMemcpyAsync(product.values + offset,
                                   this->valuesEE_.data(),
                                   this->valuesEE_.size() * sizeof(float),
                                   cudaMemcpyHostToDevice,
-                                  cudaStream.id()));
+                                  cudaStream));
       });
 
   return product;
diff --git a/RecoLocalCalo/EcalRecProducers/BuildFile.xml b/RecoLocalCalo/EcalRecProducers/BuildFile.xml
index 59d0c5987d7fd..5e92507ee5049 100644
--- a/RecoLocalCalo/EcalRecProducers/BuildFile.xml
+++ b/RecoLocalCalo/EcalRecProducers/BuildFile.xml
@@ -5,7 +5,6 @@
 <use   name="CondFormats/EcalObjects"/>
 <use   name="HeterogeneousCore/CUDACore"/>
 <use   name="HeterogeneousCore/CUDAUtilities"/>
-<use   name="cuda-api-wrappers"/>
 <use   name="cuda"/>
 <export>
   <lib   name="1"/>
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml b/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
index 89e5e9d93c549..b4dfcc1cc3b0d 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
+++ b/RecoLocalCalo/EcalRecProducers/plugins/BuildFile.xml
@@ -16,7 +16,6 @@
 <use   name="CUDADataFormats/EcalRecHitSoA"/>
 <use   name="HeterogeneousCore/CUDACore"/>
 <use   name="HeterogeneousCore/CUDAUtilities"/>
-<use   name="cuda-api-wrappers"/>
 <use   name="cuda"/>
 <library   file="*.cc" name="RecoLocalCaloEcalRecProducersPlugins">
   <flags   EDM_PLUGIN="1"/>
diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
index ccfe2f94faddd..786ba409525e6 100644
--- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
+++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducerGPU.cc
@@ -51,7 +51,7 @@ class EcalUncalibRecHitProducerGPU : public edm::stream::EDProducer<edm::Externa
   void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
   void produce(edm::Event&, edm::EventSetup const&) override;
 
-  void transferToHost(RecHitType& ebRecHits, RecHitType& eeRecHits, cuda::stream_t<>& cudaStream);
+  void transferToHost(RecHitType& ebRecHits, RecHitType& eeRecHits, cudaStream_t cudaStream);
 
 private:
   edm::EDGetTokenT<EBDigiCollection> digisTokenEB_;
@@ -372,7 +372,7 @@ void EcalUncalibRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup co
 
     // TODO
     // for now just sync on the host when transferring back products
-    cudaStreamSynchronize(ctx.stream().id());
+    cudaStreamSynchronize(ctx.stream());
   }
 
   event.put(std::move(ebRecHits_), recHitsLabelEB_);
@@ -381,85 +381,85 @@ void EcalUncalibRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup co
 
 void EcalUncalibRecHitProducerGPU::transferToHost(RecHitType& ebRecHits,
                                                   RecHitType& eeRecHits,
-                                                  cuda::stream_t<>& cudaStream) {
+                                                  cudaStream_t cudaStream) {
   cudaCheck(cudaMemcpyAsync(ebRecHits.amplitude.data(),
                             eventOutputDataGPU_.amplitude,
                             ebRecHits.amplitude.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
   cudaCheck(cudaMemcpyAsync(eeRecHits.amplitude.data(),
                             eventOutputDataGPU_.amplitude + ebRecHits.amplitude.size(),
                             eeRecHits.amplitude.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
 
   cudaCheck(cudaMemcpyAsync(ebRecHits.pedestal.data(),
                             eventOutputDataGPU_.pedestal,
                             ebRecHits.pedestal.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
   cudaCheck(cudaMemcpyAsync(eeRecHits.pedestal.data(),
                             eventOutputDataGPU_.pedestal + ebRecHits.pedestal.size(),
                             eeRecHits.pedestal.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
 
   cudaCheck(cudaMemcpyAsync(ebRecHits.chi2.data(),
                             eventOutputDataGPU_.chi2,
                             ebRecHits.chi2.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
   cudaCheck(cudaMemcpyAsync(eeRecHits.chi2.data(),
                             eventOutputDataGPU_.chi2 + ebRecHits.chi2.size(),
                             eeRecHits.chi2.size() * sizeof(ecal::reco::StorageScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
 
   if (configParameters_.shouldRunTimingComputation) {
     cudaCheck(cudaMemcpyAsync(ebRecHits.jitter.data(),
                               eventOutputDataGPU_.jitter,
                               ebRecHits.jitter.size() * sizeof(ecal::reco::StorageScalarType),
                               cudaMemcpyDeviceToHost,
-                              cudaStream.id()));
+                              cudaStream));
     cudaCheck(cudaMemcpyAsync(eeRecHits.jitter.data(),
                               eventOutputDataGPU_.jitter + ebRecHits.jitter.size(),
                               eeRecHits.jitter.size() * sizeof(ecal::reco::StorageScalarType),
                               cudaMemcpyDeviceToHost,
-                              cudaStream.id()));
+                              cudaStream));
 
     cudaCheck(cudaMemcpyAsync(ebRecHits.jitterError.data(),
                               eventOutputDataGPU_.jitterError,
                               ebRecHits.jitterError.size() * sizeof(ecal::reco::StorageScalarType),
                               cudaMemcpyDeviceToHost,
-                              cudaStream.id()));
+                              cudaStream));
     cudaCheck(cudaMemcpyAsync(eeRecHits.jitterError.data(),
                               eventOutputDataGPU_.jitterError + ebRecHits.jitterError.size(),
                               eeRecHits.jitterError.size() * sizeof(ecal::reco::StorageScalarType),
                               cudaMemcpyDeviceToHost,
-                              cudaStream.id()));
+                              cudaStream));
   }
 
   cudaCheck(cudaMemcpyAsync(ebRecHits.flags.data(),
                             eventOutputDataGPU_.flags,
                             ebRecHits.flags.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
   cudaCheck(cudaMemcpyAsync(eeRecHits.flags.data(),
                             eventOutputDataGPU_.flags + ebRecHits.flags.size(),
                             eeRecHits.flags.size() * sizeof(uint32_t),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
 
   cudaCheck(cudaMemcpyAsync(ebRecHits.amplitudesAll.data(),
                             eventOutputDataGPU_.amplitudesAll,
                             ebRecHits.amplitudesAll.size() * sizeof(ecal::reco::ComputationScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
   cudaCheck(cudaMemcpyAsync(eeRecHits.amplitudesAll.data(),
                             eventOutputDataGPU_.amplitudesAll + ebRecHits.amplitudesAll.size(),
                             eeRecHits.amplitudesAll.size() * sizeof(ecal::reco::ComputationScalarType),
                             cudaMemcpyDeviceToHost,
-                            cudaStream.id()));
+                            cudaStream));
 }
 
 DEFINE_FWK_MODULE(EcalUncalibRecHitProducerGPU);