diff --git a/RecoTracker/LST/plugins/alpaka/LSTProducer.cc b/RecoTracker/LST/plugins/alpaka/LSTProducer.cc
index b93580b0a9fa9..1b34b949c64e5 100644
--- a/RecoTracker/LST/plugins/alpaka/LSTProducer.cc
+++ b/RecoTracker/LST/plugins/alpaka/LSTProducer.cc
@@ -91,7 +91,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
     const bool verbose_, nopLSDupClean_, tcpLSTriplets_;
     edm::EDPutTokenT<LSTOutput> lstOutputToken_;
 
-    SDL::LST<Device> lst_;
+    SDL::LST<Acc3D> lst_;
   };
 
 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE
diff --git a/RecoTracker/LSTCore/interface/LST.h b/RecoTracker/LSTCore/interface/LST.h
index 13aa2ec9896aa..7b44d07e0bb6c 100644
--- a/RecoTracker/LSTCore/interface/LST.h
+++ b/RecoTracker/LSTCore/interface/LST.h
@@ -16,7 +16,7 @@ namespace SDL {
   template <typename>
   class LST;
 
-  template <typename TDev>
+  template <typename TAcc>
   class LST {
   public:
     LST() = default;
@@ -24,7 +24,7 @@ namespace SDL {
     template <typename TQueue>
     void run(TQueue& queue,
              bool verbose,
-             const LSTESData<TDev>* deviceESData,
+             const LSTESData<alpaka::Dev<TAcc>>* deviceESData,
              const std::vector<float> see_px,
              const std::vector<float> see_py,
              const std::vector<float> see_pz,
@@ -72,7 +72,7 @@ namespace SDL {
                       const std::vector<float> ph2_y,
                       const std::vector<float> ph2_z);
 
-    void getOutput(SDL::Event<TDev>& event);
+    void getOutput(SDL::Event<TAcc>& event);
     std::vector<unsigned int> getHitIdxs(const short trackCandidateType,
                                          const unsigned int TCIdx,
                                          const unsigned int* TCHitIndices,
diff --git a/RecoTracker/LSTCore/interface/alpaka/Constants.h b/RecoTracker/LSTCore/interface/alpaka/Constants.h
index b0a5d0e556760..e8a890fbb9ff4 100644
--- a/RecoTracker/LSTCore/interface/alpaka/Constants.h
+++ b/RecoTracker/LSTCore/interface/alpaka/Constants.h
@@ -8,6 +8,9 @@
 #endif
 
 namespace SDL {
+
+  using namespace ALPAKA_ACCELERATOR_NAMESPACE;
+
 // Half precision wrapper functions.
 #if defined(FP16_Base)
 #define __F2H __float2half
@@ -19,7 +22,7 @@ namespace SDL {
   typedef float FPX;
 #endif
 
-  alpaka_common::Vec3D const elementsPerThread(alpaka_common::Vec3D::all(static_cast<alpaka_common::Idx>(1)));
+  Vec3D constexpr elementsPerThread(Vec3D::all(static_cast<Idx>(1)));
 
 // Needed for files that are compiled by g++ to not throw an error.
 // uint4 is defined only for CUDA, so we will have to revisit this soon when running on other backends.
@@ -33,14 +36,14 @@ namespace SDL {
 #endif
 
   // Wrapper function to reduce code boilerplate for defining grid/block sizes.
-  ALPAKA_FN_HOST ALPAKA_FN_INLINE alpaka_common::Vec3D createVec(int x, int y, int z) {
-    return alpaka_common::Vec3D(
-        static_cast<alpaka_common::Idx>(x), static_cast<alpaka_common::Idx>(y), static_cast<alpaka_common::Idx>(z));
+  ALPAKA_FN_HOST ALPAKA_FN_INLINE Vec3D createVec(int x, int y, int z) {
+    return Vec3D(
+        static_cast<Idx>(x), static_cast<Idx>(y), static_cast<Idx>(z));
   }
 
   // Adjust grid and block sizes based on backend configuration
   template <typename Vec>
-  ALPAKA_FN_HOST ALPAKA_FN_INLINE alpaka_common::WorkDiv3D createWorkDiv(const Vec& blocksPerGrid,
+  ALPAKA_FN_HOST ALPAKA_FN_INLINE WorkDiv3D createWorkDiv(const Vec& blocksPerGrid,
                                                                          const Vec& threadsPerBlock,
                                                                          const Vec& elementsPerThreadArg) {
     Vec adjustedBlocks = blocksPerGrid;
@@ -48,16 +51,16 @@ namespace SDL {
 
     // Serial execution, so all launch parameters set to 1.
 #if defined(ALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED)
-    adjustedBlocks = Vec::all(static_cast<alpaka_common::Idx>(1));
-    adjustedThreads = Vec::all(static_cast<alpaka_common::Idx>(1));
+    adjustedBlocks = Vec::all(static_cast<Idx>(1));
+    adjustedThreads = Vec::all(static_cast<Idx>(1));
 #endif
 
     // Threads enabled, set number of blocks to 1.
 #if defined(ALPAKA_ACC_CPU_B_SEQ_T_THREADS_ENABLED)
-    adjustedBlocks = Vec::all(static_cast<alpaka_common::Idx>(1));
+    adjustedBlocks = Vec::all(static_cast<Idx>(1));
 #endif
 
-    return alpaka_common::WorkDiv3D(adjustedBlocks, adjustedThreads, elementsPerThreadArg);
+    return WorkDiv3D(adjustedBlocks, adjustedThreads, elementsPerThreadArg);
   }
 
   // 15 MeV constant from the approximate Bethe-Bloch formula
diff --git a/RecoTracker/LSTCore/src/alpaka/Event.dev.cc b/RecoTracker/LSTCore/src/alpaka/Event.dev.cc
index 37fb4ca02fc0a..230b10d3904bc 100644
--- a/RecoTracker/LSTCore/src/alpaka/Event.dev.cc
+++ b/RecoTracker/LSTCore/src/alpaka/Event.dev.cc
@@ -2,7 +2,7 @@
 
 using namespace ALPAKA_ACCELERATOR_NAMESPACE;
 
-void SDL::Event<Device>::init(bool verbose) {
+void SDL::Event<Acc3D>::init(bool verbose) {
   addObjects = verbose;
   hitsInGPU = nullptr;
   mdsInGPU = nullptr;
@@ -44,7 +44,7 @@ void SDL::Event<Device>::init(bool verbose) {
   }
 }
 
-void SDL::Event<Device>::resetEvent() {
+void SDL::Event<Acc3D>::resetEvent() {
   //reset the arrays
   for (int i = 0; i < 6; i++) {
     n_hits_by_layer_barrel_[i] = 0;
@@ -150,7 +150,7 @@ void SDL::Event<Device>::resetEvent() {
   }
 }
 
-void SDL::Event<Device>::addHitToEvent(std::vector<float> x,
+void SDL::Event<Acc3D>::addHitToEvent(std::vector<float> x,
                                        std::vector<float> y,
                                        std::vector<float> z,
                                        std::vector<unsigned int> detId,
@@ -217,7 +217,7 @@ void SDL::Event<Device>::addHitToEvent(std::vector<float> x,
   alpaka::enqueue(queue, module_ranges_task);
 }
 
-void SDL::Event<Device>::addPixelSegmentToEvent(std::vector<unsigned int> hitIndices0,
+void SDL::Event<Acc3D>::addPixelSegmentToEvent(std::vector<unsigned int> hitIndices0,
                                                 std::vector<unsigned int> hitIndices1,
                                                 std::vector<unsigned int> hitIndices2,
                                                 std::vector<unsigned int> hitIndices3,
@@ -393,7 +393,7 @@ void SDL::Event<Device>::addPixelSegmentToEvent(std::vector<unsigned int> hitInd
   alpaka::wait(queue);
 }
 
-void SDL::Event<Device>::createMiniDoublets() {
+void SDL::Event<Acc3D>::createMiniDoublets() {
   // Create a view for the element nLowerModules_ inside rangesBuffers->miniDoubletModuleOccupancy
   auto dst_view_miniDoubletModuleOccupancy =
       alpaka::createSubView(rangesBuffers->miniDoubletModuleOccupancy_buf, (Idx)1u, (Idx)nLowerModules_);
@@ -469,7 +469,7 @@ void SDL::Event<Device>::createMiniDoublets() {
   }
 }
 
-void SDL::Event<Device>::createSegmentsWithModuleMap() {
+void SDL::Event<Acc3D>::createSegmentsWithModuleMap() {
   if (segmentsInGPU == nullptr) {
     segmentsInGPU = new SDL::segments();
     segmentsBuffers =
@@ -513,7 +513,7 @@ void SDL::Event<Device>::createSegmentsWithModuleMap() {
   }
 }
 
-void SDL::Event<Device>::createTriplets() {
+void SDL::Event<Acc3D>::createTriplets() {
   if (tripletsInGPU == nullptr) {
     Vec3D const threadsPerBlockCreateTrip = createVec(1, 1, 1024);
     Vec3D const blocksPerGridCreateTrip = createVec(1, 1, 1);
@@ -622,7 +622,7 @@ void SDL::Event<Device>::createTriplets() {
   }
 }
 
-void SDL::Event<Device>::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) {
+void SDL::Event<Acc3D>::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) {
   if (trackCandidatesInGPU == nullptr) {
     trackCandidatesInGPU = new SDL::trackCandidates();
     trackCandidatesBuffers = new SDL::trackCandidatesBuffer<Device>(
@@ -787,7 +787,7 @@ void SDL::Event<Device>::createTrackCandidates(bool no_pls_dupclean, bool tc_pls
   }
 }
 
-void SDL::Event<Device>::createPixelTriplets() {
+void SDL::Event<Acc3D>::createPixelTriplets() {
   if (pixelTripletsInGPU == nullptr) {
     pixelTripletsInGPU = new SDL::pixelTriplets();
     pixelTripletsBuffers = new SDL::pixelTripletsBuffer<Device>(N_MAX_PIXEL_TRIPLETS, devAcc, queue);
@@ -906,7 +906,7 @@ void SDL::Event<Device>::createPixelTriplets() {
   alpaka::wait(queue);
 }
 
-void SDL::Event<Device>::createQuintuplets() {
+void SDL::Event<Acc3D>::createQuintuplets() {
   Vec3D const threadsPerBlockCreateQuints = createVec(1, 1, 1024);
   Vec3D const blocksPerGridCreateQuints = createVec(1, 1, 1);
   WorkDiv3D const createEligibleModulesListForQuintupletsGPU_workDiv =
@@ -996,7 +996,7 @@ void SDL::Event<Device>::createQuintuplets() {
   }
 }
 
-void SDL::Event<Device>::pixelLineSegmentCleaning(bool no_pls_dupclean) {
+void SDL::Event<Acc3D>::pixelLineSegmentCleaning(bool no_pls_dupclean) {
   if (!no_pls_dupclean) {
     Vec3D const threadsPerBlockCheckHitspLS = createVec(1, 16, 16);
     Vec3D const blocksPerGridCheckHitspLS = createVec(1, MAX_BLOCKS * 4, MAX_BLOCKS / 4);
@@ -1012,7 +1012,7 @@ void SDL::Event<Device>::pixelLineSegmentCleaning(bool no_pls_dupclean) {
   }
 }
 
-void SDL::Event<Device>::createPixelQuintuplets() {
+void SDL::Event<Acc3D>::createPixelQuintuplets() {
   if (pixelQuintupletsInGPU == nullptr) {
     pixelQuintupletsInGPU = new SDL::pixelQuintuplets();
     pixelQuintupletsBuffers = new SDL::pixelQuintupletsBuffer<Device>(N_MAX_PIXEL_QUINTUPLETS, devAcc, queue);
@@ -1151,7 +1151,7 @@ void SDL::Event<Device>::createPixelQuintuplets() {
 #endif
 }
 
-void SDL::Event<Device>::addMiniDoubletsToEventExplicit() {
+void SDL::Event<Acc3D>::addMiniDoubletsToEventExplicit() {
   auto nMDsCPU_buf = allocBufWrapper<unsigned int>(devHost, nLowerModules_, queue);
   alpaka::memcpy(queue, nMDsCPU_buf, miniDoubletsBuffers->nMDs_buf, nLowerModules_);
 
@@ -1182,7 +1182,7 @@ void SDL::Event<Device>::addMiniDoubletsToEventExplicit() {
   }
 }
 
-void SDL::Event<Device>::addSegmentsToEventExplicit() {
+void SDL::Event<Acc3D>::addSegmentsToEventExplicit() {
   auto nSegmentsCPU_buf = allocBufWrapper<unsigned int>(devHost, nLowerModules_, queue);
   alpaka::memcpy(queue, nSegmentsCPU_buf, segmentsBuffers->nSegments_buf, nLowerModules_);
 
@@ -1209,7 +1209,7 @@ void SDL::Event<Device>::addSegmentsToEventExplicit() {
   }
 }
 
-void SDL::Event<Device>::addQuintupletsToEventExplicit() {
+void SDL::Event<Acc3D>::addQuintupletsToEventExplicit() {
   auto nQuintupletsCPU_buf = allocBufWrapper<unsigned int>(devHost, nLowerModules_, queue);
   alpaka::memcpy(queue, nQuintupletsCPU_buf, quintupletsBuffers->nQuintuplets_buf);
 
@@ -1240,7 +1240,7 @@ void SDL::Event<Device>::addQuintupletsToEventExplicit() {
   }
 }
 
-void SDL::Event<Device>::addTripletsToEventExplicit() {
+void SDL::Event<Acc3D>::addTripletsToEventExplicit() {
   auto nTripletsCPU_buf = allocBufWrapper<unsigned int>(devHost, nLowerModules_, queue);
   alpaka::memcpy(queue, nTripletsCPU_buf, tripletsBuffers->nTriplets_buf);
 
@@ -1266,7 +1266,7 @@ void SDL::Event<Device>::addTripletsToEventExplicit() {
   }
 }
 
-unsigned int SDL::Event<Device>::getNumberOfHits() {
+unsigned int SDL::Event<Acc3D>::getNumberOfHits() {
   unsigned int hits = 0;
   for (auto& it : n_hits_by_layer_barrel_) {
     hits += it;
@@ -1278,22 +1278,22 @@ unsigned int SDL::Event<Device>::getNumberOfHits() {
   return hits;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfHitsByLayer(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfHitsByLayer(unsigned int layer) {
   if (layer == 6)
     return n_hits_by_layer_barrel_[layer];
   else
     return n_hits_by_layer_barrel_[layer] + n_hits_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfHitsByLayerBarrel(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfHitsByLayerBarrel(unsigned int layer) {
   return n_hits_by_layer_barrel_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfHitsByLayerEndcap(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfHitsByLayerEndcap(unsigned int layer) {
   return n_hits_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfMiniDoublets() {
+unsigned int SDL::Event<Acc3D>::getNumberOfMiniDoublets() {
   unsigned int miniDoublets = 0;
   for (auto& it : n_minidoublets_by_layer_barrel_) {
     miniDoublets += it;
@@ -1305,22 +1305,22 @@ unsigned int SDL::Event<Device>::getNumberOfMiniDoublets() {
   return miniDoublets;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfMiniDoubletsByLayer(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfMiniDoubletsByLayer(unsigned int layer) {
   if (layer == 6)
     return n_minidoublets_by_layer_barrel_[layer];
   else
     return n_minidoublets_by_layer_barrel_[layer] + n_minidoublets_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfMiniDoubletsByLayerBarrel(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfMiniDoubletsByLayerBarrel(unsigned int layer) {
   return n_minidoublets_by_layer_barrel_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfMiniDoubletsByLayerEndcap(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfMiniDoubletsByLayerEndcap(unsigned int layer) {
   return n_minidoublets_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfSegments() {
+unsigned int SDL::Event<Acc3D>::getNumberOfSegments() {
   unsigned int segments = 0;
   for (auto& it : n_segments_by_layer_barrel_) {
     segments += it;
@@ -1332,22 +1332,22 @@ unsigned int SDL::Event<Device>::getNumberOfSegments() {
   return segments;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfSegmentsByLayer(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfSegmentsByLayer(unsigned int layer) {
   if (layer == 6)
     return n_segments_by_layer_barrel_[layer];
   else
     return n_segments_by_layer_barrel_[layer] + n_segments_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfSegmentsByLayerBarrel(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfSegmentsByLayerBarrel(unsigned int layer) {
   return n_segments_by_layer_barrel_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfSegmentsByLayerEndcap(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfSegmentsByLayerEndcap(unsigned int layer) {
   return n_segments_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfTriplets() {
+unsigned int SDL::Event<Acc3D>::getNumberOfTriplets() {
   unsigned int triplets = 0;
   for (auto& it : n_triplets_by_layer_barrel_) {
     triplets += it;
@@ -1359,22 +1359,22 @@ unsigned int SDL::Event<Device>::getNumberOfTriplets() {
   return triplets;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfTripletsByLayer(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfTripletsByLayer(unsigned int layer) {
   if (layer == 6)
     return n_triplets_by_layer_barrel_[layer];
   else
     return n_triplets_by_layer_barrel_[layer] + n_triplets_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfTripletsByLayerBarrel(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfTripletsByLayerBarrel(unsigned int layer) {
   return n_triplets_by_layer_barrel_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfTripletsByLayerEndcap(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfTripletsByLayerEndcap(unsigned int layer) {
   return n_triplets_by_layer_endcap_[layer];
 }
 
-int SDL::Event<Device>::getNumberOfPixelTriplets() {
+int SDL::Event<Acc3D>::getNumberOfPixelTriplets() {
   auto nPixelTriplets_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nPixelTriplets_buf, pixelTripletsBuffers->nPixelTriplets_buf);
@@ -1385,7 +1385,7 @@ int SDL::Event<Device>::getNumberOfPixelTriplets() {
   return nPixelTriplets;
 }
 
-int SDL::Event<Device>::getNumberOfPixelQuintuplets() {
+int SDL::Event<Acc3D>::getNumberOfPixelQuintuplets() {
   auto nPixelQuintuplets_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nPixelQuintuplets_buf, pixelQuintupletsBuffers->nPixelQuintuplets_buf);
@@ -1396,7 +1396,7 @@ int SDL::Event<Device>::getNumberOfPixelQuintuplets() {
   return nPixelQuintuplets;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfQuintuplets() {
+unsigned int SDL::Event<Acc3D>::getNumberOfQuintuplets() {
   unsigned int quintuplets = 0;
   for (auto& it : n_quintuplets_by_layer_barrel_) {
     quintuplets += it;
@@ -1408,22 +1408,22 @@ unsigned int SDL::Event<Device>::getNumberOfQuintuplets() {
   return quintuplets;
 }
 
-unsigned int SDL::Event<Device>::getNumberOfQuintupletsByLayer(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfQuintupletsByLayer(unsigned int layer) {
   if (layer == 6)
     return n_quintuplets_by_layer_barrel_[layer];
   else
     return n_quintuplets_by_layer_barrel_[layer] + n_quintuplets_by_layer_endcap_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfQuintupletsByLayerBarrel(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfQuintupletsByLayerBarrel(unsigned int layer) {
   return n_quintuplets_by_layer_barrel_[layer];
 }
 
-unsigned int SDL::Event<Device>::getNumberOfQuintupletsByLayerEndcap(unsigned int layer) {
+unsigned int SDL::Event<Acc3D>::getNumberOfQuintupletsByLayerEndcap(unsigned int layer) {
   return n_quintuplets_by_layer_endcap_[layer];
 }
 
-int SDL::Event<Device>::getNumberOfTrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfTrackCandidates() {
   auto nTrackCandidates_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nTrackCandidates_buf, trackCandidatesBuffers->nTrackCandidates_buf);
@@ -1434,7 +1434,7 @@ int SDL::Event<Device>::getNumberOfTrackCandidates() {
   return nTrackCandidates;
 }
 
-int SDL::Event<Device>::getNumberOfPT5TrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfPT5TrackCandidates() {
   auto nTrackCandidatesPT5_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nTrackCandidatesPT5_buf, trackCandidatesBuffers->nTrackCandidatespT5_buf);
@@ -1445,7 +1445,7 @@ int SDL::Event<Device>::getNumberOfPT5TrackCandidates() {
   return nTrackCandidatesPT5;
 }
 
-int SDL::Event<Device>::getNumberOfPT3TrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfPT3TrackCandidates() {
   auto nTrackCandidatesPT3_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nTrackCandidatesPT3_buf, trackCandidatesBuffers->nTrackCandidatespT3_buf);
@@ -1456,7 +1456,7 @@ int SDL::Event<Device>::getNumberOfPT3TrackCandidates() {
   return nTrackCandidatesPT3;
 }
 
-int SDL::Event<Device>::getNumberOfPLSTrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfPLSTrackCandidates() {
   auto nTrackCandidatesPLS_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nTrackCandidatesPLS_buf, trackCandidatesBuffers->nTrackCandidatespLS_buf);
@@ -1467,7 +1467,7 @@ int SDL::Event<Device>::getNumberOfPLSTrackCandidates() {
   return nTrackCandidatesPLS;
 }
 
-int SDL::Event<Device>::getNumberOfPixelTrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfPixelTrackCandidates() {
   auto nTrackCandidates_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
   auto nTrackCandidatesT5_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
@@ -1481,7 +1481,7 @@ int SDL::Event<Device>::getNumberOfPixelTrackCandidates() {
   return nTrackCandidates - nTrackCandidatesT5;
 }
 
-int SDL::Event<Device>::getNumberOfT5TrackCandidates() {
+int SDL::Event<Acc3D>::getNumberOfT5TrackCandidates() {
   auto nTrackCandidatesT5_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
 
   alpaka::memcpy(queue, nTrackCandidatesT5_buf, trackCandidatesBuffers->nTrackCandidatesT5_buf);
@@ -1492,7 +1492,7 @@ int SDL::Event<Device>::getNumberOfT5TrackCandidates() {
   return nTrackCandidatesT5;
 }
 
-SDL::hitsBuffer<DevHost>* SDL::Event<Device>::getHits()  //std::shared_ptr should take care of garbage collection
+SDL::hitsBuffer<DevHost>* SDL::Event<Acc3D>::getHits()  //std::shared_ptr should take care of garbage collection
 {
   if (hitsInCPU == nullptr) {
     auto nHits_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1515,7 +1515,7 @@ SDL::hitsBuffer<DevHost>* SDL::Event<Device>::getHits()  //std::shared_ptr shoul
   return hitsInCPU;
 }
 
-SDL::hitsBuffer<DevHost>* SDL::Event<Device>::getHitsInCMSSW() {
+SDL::hitsBuffer<DevHost>* SDL::Event<Acc3D>::getHitsInCMSSW() {
   if (hitsInCPU == nullptr) {
     auto nHits_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
     alpaka::memcpy(queue, nHits_buf, hitsBuffers->nHits_buf);
@@ -1532,7 +1532,7 @@ SDL::hitsBuffer<DevHost>* SDL::Event<Device>::getHitsInCMSSW() {
   return hitsInCPU;
 }
 
-SDL::objectRangesBuffer<DevHost>* SDL::Event<Device>::getRanges() {
+SDL::objectRangesBuffer<DevHost>* SDL::Event<Acc3D>::getRanges() {
   if (rangesInCPU == nullptr) {
     rangesInCPU = new SDL::objectRangesBuffer<DevHost>(nModules_, nLowerModules_, devHost, queue);
     rangesInCPU->setData(*rangesInCPU);
@@ -1547,7 +1547,7 @@ SDL::objectRangesBuffer<DevHost>* SDL::Event<Device>::getRanges() {
   return rangesInCPU;
 }
 
-SDL::miniDoubletsBuffer<DevHost>* SDL::Event<Device>::getMiniDoublets() {
+SDL::miniDoubletsBuffer<DevHost>* SDL::Event<Acc3D>::getMiniDoublets() {
   if (mdsInCPU == nullptr) {
     // Get nMemoryLocations parameter to initialize host based mdsInCPU
     auto nMemHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1569,7 +1569,7 @@ SDL::miniDoubletsBuffer<DevHost>* SDL::Event<Device>::getMiniDoublets() {
   return mdsInCPU;
 }
 
-SDL::segmentsBuffer<DevHost>* SDL::Event<Device>::getSegments() {
+SDL::segmentsBuffer<DevHost>* SDL::Event<Acc3D>::getSegments() {
   if (segmentsInCPU == nullptr) {
     // Get nMemoryLocations parameter to initialize host based segmentsInCPU
     auto nMemHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1605,7 +1605,7 @@ SDL::segmentsBuffer<DevHost>* SDL::Event<Device>::getSegments() {
   return segmentsInCPU;
 }
 
-SDL::tripletsBuffer<DevHost>* SDL::Event<Device>::getTriplets() {
+SDL::tripletsBuffer<DevHost>* SDL::Event<Acc3D>::getTriplets() {
   if (tripletsInCPU == nullptr) {
     // Get nMemoryLocations parameter to initialize host based tripletsInCPU
     auto nMemHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1641,7 +1641,7 @@ SDL::tripletsBuffer<DevHost>* SDL::Event<Device>::getTriplets() {
   return tripletsInCPU;
 }
 
-SDL::quintupletsBuffer<DevHost>* SDL::Event<Device>::getQuintuplets() {
+SDL::quintupletsBuffer<DevHost>* SDL::Event<Acc3D>::getQuintuplets() {
   if (quintupletsInCPU == nullptr) {
     // Get nMemoryLocations parameter to initialize host based quintupletsInCPU
     auto nMemHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1677,7 +1677,7 @@ SDL::quintupletsBuffer<DevHost>* SDL::Event<Device>::getQuintuplets() {
   return quintupletsInCPU;
 }
 
-SDL::pixelTripletsBuffer<DevHost>* SDL::Event<Device>::getPixelTriplets() {
+SDL::pixelTripletsBuffer<DevHost>* SDL::Event<Acc3D>::getPixelTriplets() {
   if (pixelTripletsInCPU == nullptr) {
     // Get nPixelTriplets parameter to initialize host based quintupletsInCPU
     auto nPixelTriplets_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1716,7 +1716,7 @@ SDL::pixelTripletsBuffer<DevHost>* SDL::Event<Device>::getPixelTriplets() {
   return pixelTripletsInCPU;
 }
 
-SDL::pixelQuintupletsBuffer<DevHost>* SDL::Event<Device>::getPixelQuintuplets() {
+SDL::pixelQuintupletsBuffer<DevHost>* SDL::Event<Acc3D>::getPixelQuintuplets() {
   if (pixelQuintupletsInCPU == nullptr) {
     // Get nPixelQuintuplets parameter to initialize host based quintupletsInCPU
     auto nPixelQuintuplets_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1752,7 +1752,7 @@ SDL::pixelQuintupletsBuffer<DevHost>* SDL::Event<Device>::getPixelQuintuplets()
   return pixelQuintupletsInCPU;
 }
 
-SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Device>::getTrackCandidates() {
+SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Acc3D>::getTrackCandidates() {
   if (trackCandidatesInCPU == nullptr) {
     // Get nTrackCanHost parameter to initialize host based trackCandidatesInCPU
     auto nTrackCanHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1790,7 +1790,7 @@ SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Device>::getTrackCandidates() {
   return trackCandidatesInCPU;
 }
 
-SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Device>::getTrackCandidatesInCMSSW() {
+SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Acc3D>::getTrackCandidatesInCMSSW() {
   if (trackCandidatesInCPU == nullptr) {
     // Get nTrackCanHost parameter to initialize host based trackCandidatesInCPU
     auto nTrackCanHost_buf = allocBufWrapper<unsigned int>(devHost, 1, queue);
@@ -1818,7 +1818,7 @@ SDL::trackCandidatesBuffer<DevHost>* SDL::Event<Device>::getTrackCandidatesInCMS
   return trackCandidatesInCPU;
 }
 
-SDL::modulesBuffer<DevHost>* SDL::Event<Device>::getModules(bool isFull) {
+SDL::modulesBuffer<DevHost>* SDL::Event<Acc3D>::getModules(bool isFull) {
   if (modulesInCPU == nullptr) {
     // The last input here is just a small placeholder for the allocation.
     modulesInCPU = new SDL::modulesBuffer<DevHost>(devHost, nModules_, nPixels_);
diff --git a/RecoTracker/LSTCore/src/alpaka/Event.h b/RecoTracker/LSTCore/src/alpaka/Event.h
index eeba434b503c0..3c8dea32612af 100644
--- a/RecoTracker/LSTCore/src/alpaka/Event.h
+++ b/RecoTracker/LSTCore/src/alpaka/Event.h
@@ -18,15 +18,17 @@
 
 namespace SDL {
 
-  template <typename TDev>
+  using namespace ALPAKA_ACCELERATOR_NAMESPACE;
+
+  template <typename TAcc>
   class Event;
 
   template <>
-  class Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> {
+  class Event<Acc3D> {
   private:
-    ALPAKA_ACCELERATOR_NAMESPACE::Queue queue;
-    ALPAKA_ACCELERATOR_NAMESPACE::Device devAcc;
-    alpaka_common::DevHost devHost;
+    Queue queue;
+    Device devAcc;
+    DevHost devHost;
     bool addObjects;
 
     std::array<unsigned int, 6> n_hits_by_layer_barrel_;
@@ -45,35 +47,35 @@ namespace SDL {
     //Device stuff
     unsigned int nTotalSegments;
     struct objectRanges* rangesInGPU;
-    struct objectRangesBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* rangesBuffers;
+    struct objectRangesBuffer<Device>* rangesBuffers;
     struct hits* hitsInGPU;
-    struct hitsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* hitsBuffers;
+    struct hitsBuffer<Device>* hitsBuffers;
     struct miniDoublets* mdsInGPU;
-    struct miniDoubletsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* miniDoubletsBuffers;
+    struct miniDoubletsBuffer<Device>* miniDoubletsBuffers;
     struct segments* segmentsInGPU;
-    struct segmentsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* segmentsBuffers;
+    struct segmentsBuffer<Device>* segmentsBuffers;
     struct triplets* tripletsInGPU;
-    struct tripletsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* tripletsBuffers;
+    struct tripletsBuffer<Device>* tripletsBuffers;
     struct quintuplets* quintupletsInGPU;
-    struct quintupletsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* quintupletsBuffers;
+    struct quintupletsBuffer<Device>* quintupletsBuffers;
     struct trackCandidates* trackCandidatesInGPU;
-    struct trackCandidatesBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* trackCandidatesBuffers;
+    struct trackCandidatesBuffer<Device>* trackCandidatesBuffers;
     struct pixelTriplets* pixelTripletsInGPU;
-    struct pixelTripletsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* pixelTripletsBuffers;
+    struct pixelTripletsBuffer<Device>* pixelTripletsBuffers;
     struct pixelQuintuplets* pixelQuintupletsInGPU;
-    struct pixelQuintupletsBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>* pixelQuintupletsBuffers;
+    struct pixelQuintupletsBuffer<Device>* pixelQuintupletsBuffers;
 
     //CPU interface stuff
-    objectRangesBuffer<alpaka_common::DevHost>* rangesInCPU;
-    hitsBuffer<alpaka_common::DevHost>* hitsInCPU;
-    miniDoubletsBuffer<alpaka_common::DevHost>* mdsInCPU;
-    segmentsBuffer<alpaka_common::DevHost>* segmentsInCPU;
-    tripletsBuffer<alpaka_common::DevHost>* tripletsInCPU;
-    trackCandidatesBuffer<alpaka_common::DevHost>* trackCandidatesInCPU;
-    modulesBuffer<alpaka_common::DevHost>* modulesInCPU;
-    quintupletsBuffer<alpaka_common::DevHost>* quintupletsInCPU;
-    pixelTripletsBuffer<alpaka_common::DevHost>* pixelTripletsInCPU;
-    pixelQuintupletsBuffer<alpaka_common::DevHost>* pixelQuintupletsInCPU;
+    objectRangesBuffer<DevHost>* rangesInCPU;
+    hitsBuffer<DevHost>* hitsInCPU;
+    miniDoubletsBuffer<DevHost>* mdsInCPU;
+    segmentsBuffer<DevHost>* segmentsInCPU;
+    tripletsBuffer<DevHost>* tripletsInCPU;
+    trackCandidatesBuffer<DevHost>* trackCandidatesInCPU;
+    modulesBuffer<DevHost>* modulesInCPU;
+    quintupletsBuffer<DevHost>* quintupletsInCPU;
+    pixelTripletsBuffer<DevHost>* pixelTripletsInCPU;
+    pixelQuintupletsBuffer<DevHost>* pixelQuintupletsInCPU;
 
     void init(bool verbose);
 
@@ -85,14 +87,14 @@ namespace SDL {
     const uint16_t nLowerModules_;
     const unsigned int nPixels_;
     const unsigned int nEndCapMap_;
-    const std::shared_ptr<const modulesBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>> modulesBuffers_;
+    const std::shared_ptr<const modulesBuffer<Device>> modulesBuffers_;
     const std::shared_ptr<const pixelMap> pixelMapping_;
-    const std::shared_ptr<const EndcapGeometryBuffer<ALPAKA_ACCELERATOR_NAMESPACE::Device>> endcapGeometryBuffers_;
+    const std::shared_ptr<const EndcapGeometryBuffer<Device>> endcapGeometryBuffers_;
 
   public:
     // Constructor used for CMSSW integration. Uses an external queue.
     template <typename TQueue>
-    Event(bool verbose, TQueue const& q, const LSTESData<ALPAKA_ACCELERATOR_NAMESPACE::Device>* deviceESData)
+    Event(bool verbose, TQueue const& q, const LSTESData<Device>* deviceESData)
         : queue(q),
           devAcc(alpaka::getDev(q)),
           devHost(cms::alpakatools::host()),
@@ -186,18 +188,18 @@ namespace SDL {
     int getNumberOfPixelTriplets();
     int getNumberOfPixelQuintuplets();
 
-    objectRangesBuffer<alpaka_common::DevHost>* getRanges();
-    hitsBuffer<alpaka_common::DevHost>* getHits();
-    hitsBuffer<alpaka_common::DevHost>* getHitsInCMSSW();
-    miniDoubletsBuffer<alpaka_common::DevHost>* getMiniDoublets();
-    segmentsBuffer<alpaka_common::DevHost>* getSegments();
-    tripletsBuffer<alpaka_common::DevHost>* getTriplets();
-    quintupletsBuffer<alpaka_common::DevHost>* getQuintuplets();
-    trackCandidatesBuffer<alpaka_common::DevHost>* getTrackCandidates();
-    trackCandidatesBuffer<alpaka_common::DevHost>* getTrackCandidatesInCMSSW();
-    pixelTripletsBuffer<alpaka_common::DevHost>* getPixelTriplets();
-    pixelQuintupletsBuffer<alpaka_common::DevHost>* getPixelQuintuplets();
-    modulesBuffer<alpaka_common::DevHost>* getModules(bool isFull = false);
+    objectRangesBuffer<DevHost>* getRanges();
+    hitsBuffer<DevHost>* getHits();
+    hitsBuffer<DevHost>* getHitsInCMSSW();
+    miniDoubletsBuffer<DevHost>* getMiniDoublets();
+    segmentsBuffer<DevHost>* getSegments();
+    tripletsBuffer<DevHost>* getTriplets();
+    quintupletsBuffer<DevHost>* getQuintuplets();
+    trackCandidatesBuffer<DevHost>* getTrackCandidates();
+    trackCandidatesBuffer<DevHost>* getTrackCandidatesInCMSSW();
+    pixelTripletsBuffer<DevHost>* getPixelTriplets();
+    pixelQuintupletsBuffer<DevHost>* getPixelQuintuplets();
+    modulesBuffer<DevHost>* getModules(bool isFull = false);
   };
 
 }  // namespace SDL
diff --git a/RecoTracker/LSTCore/src/alpaka/LST.dev.cc b/RecoTracker/LSTCore/src/alpaka/LST.dev.cc
index 27b0fb49e1cd9..1d8700ce7be9e 100644
--- a/RecoTracker/LSTCore/src/alpaka/LST.dev.cc
+++ b/RecoTracker/LSTCore/src/alpaka/LST.dev.cc
@@ -20,7 +20,7 @@ namespace {
 }  // namespace
 
 template <>
-void SDL::LST<Device>::prepareInput(const std::vector<float> see_px,
+void SDL::LST<Acc3D>::prepareInput(const std::vector<float> see_px,
                                     const std::vector<float> see_py,
                                     const std::vector<float> see_pz,
                                     const std::vector<float> see_dxy,
@@ -213,7 +213,7 @@ void SDL::LST<Device>::prepareInput(const std::vector<float> see_px,
 }
 
 template <>
-std::vector<unsigned int> SDL::LST<Device>::getHitIdxs(const short trackCandidateType,
+std::vector<unsigned int> SDL::LST<Acc3D>::getHitIdxs(const short trackCandidateType,
                                                        const unsigned int TCIdx,
                                                        const unsigned int* TCHitIndices,
                                                        const unsigned int* hitIndices) {
@@ -249,7 +249,7 @@ std::vector<unsigned int> SDL::LST<Device>::getHitIdxs(const short trackCandidat
 }
 
 template <>
-void SDL::LST<Device>::getOutput(SDL::Event<Device>& event) {
+void SDL::LST<Acc3D>::getOutput(SDL::Event<Acc3D>& event) {
   std::vector<std::vector<unsigned int>> tc_hitIdxs;
   std::vector<unsigned int> tc_len;
   std::vector<int> tc_seedIdx;
@@ -278,7 +278,7 @@ void SDL::LST<Device>::getOutput(SDL::Event<Device>& event) {
 
 template <>
 template <>
-void SDL::LST<Device>::run(Queue& queue,
+void SDL::LST<Acc3D>::run(Queue& queue,
                            bool verbose,
                            const LSTESData<Device>* deviceESData,
                            const std::vector<float> see_px,
@@ -302,7 +302,7 @@ void SDL::LST<Device>::run(Queue& queue,
                            const std::vector<float> ph2_z,
                            bool no_pls_dupclean,
                            bool tc_pls_triplets) {
-  auto event = SDL::Event<Device>(verbose, queue, deviceESData);
+  auto event = SDL::Event<Acc3D>(verbose, queue, deviceESData);
   prepareInput(see_px,
                see_py,
                see_pz,
diff --git a/RecoTracker/LSTCore/standalone/bin/sdl.cc b/RecoTracker/LSTCore/standalone/bin/sdl.cc
index eab52b42645dd..498b58ea8731a 100644
--- a/RecoTracker/LSTCore/standalone/bin/sdl.cc
+++ b/RecoTracker/LSTCore/standalone/bin/sdl.cc
@@ -384,9 +384,9 @@ void run_sdl() {
 
   full_timer.Reset();
   full_timer.Start();
-  std::vector<SDL::Event<Device> *> events;
+  std::vector<SDL::Event<Acc3D> *> events;
   for (int s = 0; s < ana.streams; s++) {
-    SDL::Event<Device> *event = new SDL::Event<Device>(ana.verbose >= 2, queues[s], &deviceESData);
+    SDL::Event<Acc3D> *event = new SDL::Event<Acc3D>(ana.verbose >= 2, queues[s], &deviceESData);
     events.push_back(event);
   }
   float timeForEventCreation = full_timer.RealTime() * 1000;
diff --git a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc
index debebfb128859..55080b6857d37 100644
--- a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc
+++ b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc
@@ -8,7 +8,7 @@ using namespace ALPAKA_ACCELERATOR_NAMESPACE;
 
 //____________________________________________________________________________________________
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> convertHitsToHitIdxsAndHitTypes(
-    SDL::Event<Device>* event, std::vector<unsigned int> hits) {
+    SDL::Event<Acc3D>* event, std::vector<unsigned int> hits) {
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
   std::vector<unsigned int> hitidxs;
   std::vector<unsigned int> hittypes;
@@ -27,7 +27,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> convertHitsToHi
 // ===============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getPixelHitsFrompLS(SDL::Event<Device>* event, unsigned int pLS) {
+std::vector<unsigned int> getPixelHitsFrompLS(SDL::Event<Acc3D>* event, unsigned int pLS) {
   SDL::segmentsBuffer<alpaka::DevCpu>& segments_ = *(event->getSegments());
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoublets_ = *(event->getMiniDoublets());
   SDL::objectRangesBuffer<alpaka::DevCpu>& rangesInGPU = (*event->getRanges());
@@ -46,7 +46,7 @@ std::vector<unsigned int> getPixelHitsFrompLS(SDL::Event<Device>* event, unsigne
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getPixelHitIdxsFrompLS(SDL::Event<Device>* event, unsigned int pLS) {
+std::vector<unsigned int> getPixelHitIdxsFrompLS(SDL::Event<Acc3D>* event, unsigned int pLS) {
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
   std::vector<unsigned int> hits = getPixelHitsFrompLS(event, pLS);
   std::vector<unsigned int> hitidxs;
@@ -56,14 +56,14 @@ std::vector<unsigned int> getPixelHitIdxsFrompLS(SDL::Event<Device>* event, unsi
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getPixelHitTypesFrompLS(SDL::Event<Device>* event, unsigned int pLS) {
+std::vector<unsigned int> getPixelHitTypesFrompLS(SDL::Event<Acc3D>* event, unsigned int pLS) {
   std::vector<unsigned int> hits = getPixelHitsFrompLS(event, pLS);
   std::vector<unsigned int> hittypes(hits.size(), 0);
   return hittypes;
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompLS(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompLS(SDL::Event<Acc3D>* event,
                                                                                               unsigned pLS) {
   return convertHitsToHitIdxsAndHitTypes(event, getPixelHitsFrompLS(event, pLS));
 }
@@ -73,7 +73,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ==============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFromMD(SDL::Event<Device>* event, unsigned int MD) {
+std::vector<unsigned int> getHitsFromMD(SDL::Event<Acc3D>* event, unsigned int MD) {
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoublets_ = *(event->getMiniDoublets());
   unsigned int hit_1 = miniDoublets_.anchorHitIndices[MD];
   unsigned int hit_2 = miniDoublets_.outerHitIndices[MD];
@@ -81,7 +81,7 @@ std::vector<unsigned int> getHitsFromMD(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromMD(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromMD(SDL::Event<Acc3D>* event,
                                                                                              unsigned MD) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFromMD(event, MD));
 }
@@ -91,7 +91,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ==============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getMDsFromLS(SDL::Event<Device>* event, unsigned int LS) {
+std::vector<unsigned int> getMDsFromLS(SDL::Event<Acc3D>* event, unsigned int LS) {
   SDL::segmentsBuffer<alpaka::DevCpu>& segments_ = *(event->getSegments());
   unsigned int MD_1 = segments_.mdIndices[2 * LS];
   unsigned int MD_2 = segments_.mdIndices[2 * LS + 1];
@@ -99,7 +99,7 @@ std::vector<unsigned int> getMDsFromLS(SDL::Event<Device>* event, unsigned int L
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFromLS(SDL::Event<Device>* event, unsigned int LS) {
+std::vector<unsigned int> getHitsFromLS(SDL::Event<Acc3D>* event, unsigned int LS) {
   std::vector<unsigned int> MDs = getMDsFromLS(event, LS);
   std::vector<unsigned int> hits_0 = getHitsFromMD(event, MDs[0]);
   std::vector<unsigned int> hits_1 = getHitsFromMD(event, MDs[1]);
@@ -107,7 +107,7 @@ std::vector<unsigned int> getHitsFromLS(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromLS(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromLS(SDL::Event<Acc3D>* event,
                                                                                              unsigned LS) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFromLS(event, LS));
 }
@@ -117,7 +117,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ==============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getLSsFromT3(SDL::Event<Device>* event, unsigned int T3) {
+std::vector<unsigned int> getLSsFromT3(SDL::Event<Acc3D>* event, unsigned int T3) {
   SDL::tripletsBuffer<alpaka::DevCpu>& triplets_ = *(event->getTriplets());
   unsigned int LS_1 = triplets_.segmentIndices[2 * T3];
   unsigned int LS_2 = triplets_.segmentIndices[2 * T3 + 1];
@@ -125,7 +125,7 @@ std::vector<unsigned int> getLSsFromT3(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getMDsFromT3(SDL::Event<Device>* event, unsigned int T3) {
+std::vector<unsigned int> getMDsFromT3(SDL::Event<Acc3D>* event, unsigned int T3) {
   std::vector<unsigned int> LSs = getLSsFromT3(event, T3);
   std::vector<unsigned int> MDs_0 = getMDsFromLS(event, LSs[0]);
   std::vector<unsigned int> MDs_1 = getMDsFromLS(event, LSs[1]);
@@ -133,7 +133,7 @@ std::vector<unsigned int> getMDsFromT3(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFromT3(SDL::Event<Device>* event, unsigned int T3) {
+std::vector<unsigned int> getHitsFromT3(SDL::Event<Acc3D>* event, unsigned int T3) {
   std::vector<unsigned int> MDs = getMDsFromT3(event, T3);
   std::vector<unsigned int> hits_0 = getHitsFromMD(event, MDs[0]);
   std::vector<unsigned int> hits_1 = getHitsFromMD(event, MDs[1]);
@@ -142,7 +142,7 @@ std::vector<unsigned int> getHitsFromT3(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT3(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT3(SDL::Event<Acc3D>* event,
                                                                                              unsigned T3) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFromT3(event, T3));
 }
@@ -152,7 +152,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ==============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getT3sFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getT3sFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   SDL::quintupletsBuffer<alpaka::DevCpu>& quintuplets_ = *(event->getQuintuplets());
   unsigned int T3_1 = quintuplets_.tripletIndices[2 * T5];
   unsigned int T3_2 = quintuplets_.tripletIndices[2 * T5 + 1];
@@ -160,7 +160,7 @@ std::vector<unsigned int> getT3sFromT5(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getLSsFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getLSsFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   std::vector<unsigned int> T3s = getT3sFromT5(event, T5);
   std::vector<unsigned int> LSs_0 = getLSsFromT3(event, T3s[0]);
   std::vector<unsigned int> LSs_1 = getLSsFromT3(event, T3s[1]);
@@ -168,7 +168,7 @@ std::vector<unsigned int> getLSsFromT5(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getMDsFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getMDsFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   std::vector<unsigned int> LSs = getLSsFromT5(event, T5);
   std::vector<unsigned int> MDs_0 = getMDsFromLS(event, LSs[0]);
   std::vector<unsigned int> MDs_1 = getMDsFromLS(event, LSs[1]);
@@ -178,7 +178,7 @@ std::vector<unsigned int> getMDsFromT5(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getHitsFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   std::vector<unsigned int> MDs = getMDsFromT5(event, T5);
   std::vector<unsigned int> hits_0 = getHitsFromMD(event, MDs[0]);
   std::vector<unsigned int> hits_1 = getHitsFromMD(event, MDs[1]);
@@ -189,7 +189,7 @@ std::vector<unsigned int> getHitsFromT5(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitIdxsFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getHitIdxsFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
   std::vector<unsigned int> hits = getHitsFromT5(event, T5);
   std::vector<unsigned int> hitidxs;
@@ -198,7 +198,7 @@ std::vector<unsigned int> getHitIdxsFromT5(SDL::Event<Device>* event, unsigned i
   return hitidxs;
 }
 //____________________________________________________________________________________________
-std::vector<unsigned int> getModuleIdxsFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getModuleIdxsFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   std::vector<unsigned int> hits = getHitsFromT5(event, T5);
   std::vector<unsigned int> module_idxs;
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
@@ -208,13 +208,13 @@ std::vector<unsigned int> getModuleIdxsFromT5(SDL::Event<Device>* event, unsigne
   return module_idxs;
 }
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitTypesFromT5(SDL::Event<Device>* event, unsigned int T5) {
+std::vector<unsigned int> getHitTypesFromT5(SDL::Event<Acc3D>* event, unsigned int T5) {
   return {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
   ;
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT5(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT5(SDL::Event<Acc3D>* event,
                                                                                              unsigned T5) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFromT5(event, T5));
 }
@@ -224,7 +224,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ===============
 
 //____________________________________________________________________________________________
-unsigned int getPixelLSFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+unsigned int getPixelLSFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   SDL::pixelTripletsBuffer<alpaka::DevCpu>& pixelTriplets_ = *(event->getPixelTriplets());
   SDL::objectRangesBuffer<alpaka::DevCpu>& rangesInGPU = (*event->getRanges());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
@@ -233,37 +233,37 @@ unsigned int getPixelLSFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
 }
 
 //____________________________________________________________________________________________
-unsigned int getT3FrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+unsigned int getT3FrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   SDL::pixelTriplets& pixelTriplets_ = *(event->getPixelTriplets());
   return pixelTriplets_.tripletIndices[pT3];
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getLSsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getLSsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int T3 = getT3FrompT3(event, pT3);
   return getLSsFromT3(event, T3);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getMDsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getMDsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int T3 = getT3FrompT3(event, pT3);
   return getMDsFromT3(event, T3);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getOuterTrackerHitsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getOuterTrackerHitsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int T3 = getT3FrompT3(event, pT3);
   return getHitsFromT3(event, T3);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getPixelHitsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getPixelHitsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int pLS = getPixelLSFrompT3(event, pT3);
   return getPixelHitsFrompLS(event, pLS);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getHitsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int pLS = getPixelLSFrompT3(event, pT3);
   unsigned int T3 = getT3FrompT3(event, pT3);
   std::vector<unsigned int> pixelHits = getPixelHitsFrompLS(event, pLS);
@@ -273,7 +273,7 @@ std::vector<unsigned int> getHitsFrompT3(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitIdxsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getHitIdxsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
   std::vector<unsigned int> hits = getHitsFrompT3(event, pT3);
   std::vector<unsigned int> hitidxs;
@@ -282,7 +282,7 @@ std::vector<unsigned int> getHitIdxsFrompT3(SDL::Event<Device>* event, unsigned
   return hitidxs;
 }
 //____________________________________________________________________________________________
-std::vector<unsigned int> getModuleIdxsFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getModuleIdxsFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   std::vector<unsigned int> hits = getOuterTrackerHitsFrompT3(event, pT3);
   std::vector<unsigned int> module_idxs;
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
@@ -292,7 +292,7 @@ std::vector<unsigned int> getModuleIdxsFrompT3(SDL::Event<Device>* event, unsign
   return module_idxs;
 }
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitTypesFrompT3(SDL::Event<Device>* event, unsigned int pT3) {
+std::vector<unsigned int> getHitTypesFrompT3(SDL::Event<Acc3D>* event, unsigned int pT3) {
   unsigned int pLS = getPixelLSFrompT3(event, pT3);
   std::vector<unsigned int> pixelHits = getPixelHitsFrompLS(event, pLS);
   // pixel Hits list will be either 3 or 4 and depending on it return accordingly
@@ -303,7 +303,7 @@ std::vector<unsigned int> getHitTypesFrompT3(SDL::Event<Device>* event, unsigned
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT3(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT3(SDL::Event<Acc3D>* event,
                                                                                               unsigned pT3) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFrompT3(event, pT3));
 }
@@ -313,7 +313,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ===============
 
 //____________________________________________________________________________________________
-unsigned int getPixelLSFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+unsigned int getPixelLSFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   SDL::pixelQuintupletsBuffer<alpaka::DevCpu>& pixelQuintuplets_ = *(event->getPixelQuintuplets());
   SDL::objectRangesBuffer<alpaka::DevCpu>& rangesInGPU = (*event->getRanges());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
@@ -322,43 +322,43 @@ unsigned int getPixelLSFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
 }
 
 //____________________________________________________________________________________________
-unsigned int getT5FrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+unsigned int getT5FrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   SDL::pixelQuintupletsBuffer<alpaka::DevCpu>& pixelQuintuplets_ = *(event->getPixelQuintuplets());
   return pixelQuintuplets_.T5Indices[pT5];
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getT3sFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getT3sFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int T5 = getT5FrompT5(event, pT5);
   return getT3sFromT5(event, T5);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getLSsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getLSsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int T5 = getT5FrompT5(event, pT5);
   return getLSsFromT5(event, T5);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getMDsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getMDsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int T5 = getT5FrompT5(event, pT5);
   return getMDsFromT5(event, T5);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getOuterTrackerHitsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getOuterTrackerHitsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int T5 = getT5FrompT5(event, pT5);
   return getHitsFromT5(event, T5);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getPixelHitsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getPixelHitsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int pLS = getPixelLSFrompT5(event, pT5);
   return getPixelHitsFrompLS(event, pLS);
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getHitsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int pLS = getPixelLSFrompT5(event, pT5);
   unsigned int T5 = getT5FrompT5(event, pT5);
   std::vector<unsigned int> pixelHits = getPixelHitsFrompLS(event, pLS);
@@ -368,7 +368,7 @@ std::vector<unsigned int> getHitsFrompT5(SDL::Event<Device>* event, unsigned int
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitIdxsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getHitIdxsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
   std::vector<unsigned int> hits = getHitsFrompT5(event, pT5);
   std::vector<unsigned int> hitidxs;
@@ -378,7 +378,7 @@ std::vector<unsigned int> getHitIdxsFrompT5(SDL::Event<Device>* event, unsigned
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getModuleIdxsFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getModuleIdxsFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   std::vector<unsigned int> hits = getOuterTrackerHitsFrompT5(event, pT5);
   std::vector<unsigned int> module_idxs;
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = *(event->getHits());
@@ -389,7 +389,7 @@ std::vector<unsigned int> getModuleIdxsFrompT5(SDL::Event<Device>* event, unsign
 }
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getHitTypesFrompT5(SDL::Event<Device>* event, unsigned int pT5) {
+std::vector<unsigned int> getHitTypesFrompT5(SDL::Event<Acc3D>* event, unsigned int pT5) {
   unsigned int pLS = getPixelLSFrompT5(event, pT5);
   std::vector<unsigned int> pixelHits = getPixelHitsFrompLS(event, pLS);
   // pixel Hits list will be either 3 or 4 and depending on it return accordingly
@@ -400,7 +400,7 @@ std::vector<unsigned int> getHitTypesFrompT5(SDL::Event<Device>* event, unsigned
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT5(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT5(SDL::Event<Acc3D>* event,
                                                                                               unsigned pT5) {
   return convertHitsToHitIdxsAndHitTypes(event, getHitsFrompT5(event, pT5));
 }
@@ -410,7 +410,7 @@ std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHi
 // ==============
 
 //____________________________________________________________________________________________
-std::vector<unsigned int> getLSsFromTC(SDL::Event<Device>* event, unsigned int TC) {
+std::vector<unsigned int> getLSsFromTC(SDL::Event<Acc3D>* event, unsigned int TC) {
   // Get the type of the track candidate
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   short type = trackCandidatesInGPU.trackCandidateType[TC];
@@ -432,7 +432,7 @@ std::vector<unsigned int> getLSsFromTC(SDL::Event<Device>* event, unsigned int T
 }
 
 //____________________________________________________________________________________________
-std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromTC(SDL::Event<Device>* event,
+std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromTC(SDL::Event<Acc3D>* event,
                                                                                              unsigned TC) {
   // Get the type of the track candidate
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
diff --git a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.h b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.h
index d72edd669fb51..e970462872218 100644
--- a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.h
+++ b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.h
@@ -5,90 +5,92 @@
 #include <tuple>
 #include "Event.h"
 
+using SDLEvent = SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Acc3D>;
+
 enum { kpT5 = 7, kpT3 = 5, kT5 = 4, kpLS = 8 };
 
 // ----* Hit *----
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> convertHitsToHitIdxsAndHitTypes(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, std::vector<unsigned int> hits);
+    SDLEvent* event, std::vector<unsigned int> hits);
 
 // ----* pLS *----
-std::vector<unsigned int> getPixelHitsFrompLS(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getPixelHitsFrompLS(SDLEvent* event,
                                               unsigned int pLS);
-std::vector<unsigned int> getPixelHitIdxsFrompLS(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getPixelHitIdxsFrompLS(SDLEvent* event,
                                                  unsigned int pLS);
-std::vector<unsigned int> getPixelHitTypesFrompLS(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getPixelHitTypesFrompLS(SDLEvent* event,
                                                   unsigned int pLS);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompLS(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned pLS);
+    SDLEvent* event, unsigned pLS);
 
 // ----* MD *----
-std::vector<unsigned int> getHitsFromMD(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int MD);
+std::vector<unsigned int> getHitsFromMD(SDLEvent* event, unsigned int MD);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromMD(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned MD);
+    SDLEvent* event, unsigned MD);
 
 // ----* LS *----
-std::vector<unsigned int> getMDsFromLS(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int LS);
-std::vector<unsigned int> getHitsFromLS(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int LS);
+std::vector<unsigned int> getMDsFromLS(SDLEvent* event, unsigned int LS);
+std::vector<unsigned int> getHitsFromLS(SDLEvent* event, unsigned int LS);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromLS(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned LS);
+    SDLEvent* event, unsigned LS);
 
 // ----* T3 *----
-std::vector<unsigned int> getLSsFromT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T3);
-std::vector<unsigned int> getMDsFromT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T3);
-std::vector<unsigned int> getHitsFromT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T3);
+std::vector<unsigned int> getLSsFromT3(SDLEvent* event, unsigned int T3);
+std::vector<unsigned int> getMDsFromT3(SDLEvent* event, unsigned int T3);
+std::vector<unsigned int> getHitsFromT3(SDLEvent* event, unsigned int T3);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT3(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned T3);
+    SDLEvent* event, unsigned T3);
 
 // ----* T5 *----
-std::vector<unsigned int> getT3sFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getLSsFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getMDsFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getHitsFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getHitIdxsFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getHitTypesFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
-std::vector<unsigned int> getModuleIdxsFromT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int T5);
+std::vector<unsigned int> getT3sFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getLSsFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getMDsFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getHitsFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getHitIdxsFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getHitTypesFromT5(SDLEvent* event, unsigned int T5);
+std::vector<unsigned int> getModuleIdxsFromT5(SDLEvent* event, unsigned int T5);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromT5(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned T5);
+    SDLEvent* event, unsigned T5);
 
 // ----* pT3 *----
-unsigned int getPixelLSFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-unsigned int getT3FrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getLSsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getMDsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getOuterTrackerHitsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+unsigned int getPixelLSFrompT3(SDLEvent* event, unsigned int pT3);
+unsigned int getT3FrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getLSsFrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getMDsFrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getOuterTrackerHitsFrompT3(SDLEvent* event,
                                                      unsigned int pT3);
-std::vector<unsigned int> getPixelHitsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getPixelHitsFrompT3(SDLEvent* event,
                                               unsigned int pT3);
-std::vector<unsigned int> getHitsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getHitIdxsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getHitTypesFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT3);
-std::vector<unsigned int> getModuleIdxsFrompT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getHitsFrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getHitIdxsFrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getHitTypesFrompT3(SDLEvent* event, unsigned int pT3);
+std::vector<unsigned int> getModuleIdxsFrompT3(SDLEvent* event,
                                                unsigned int pT3);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT3(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned pT3);
+    SDLEvent* event, unsigned pT3);
 
 // ----* pT5 *----
-unsigned int getPixelLSFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-unsigned int getT5FrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getT3sFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getLSsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getMDsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getOuterTrackerHitsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+unsigned int getPixelLSFrompT5(SDLEvent* event, unsigned int pT5);
+unsigned int getT5FrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getT3sFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getLSsFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getMDsFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getOuterTrackerHitsFrompT5(SDLEvent* event,
                                                      unsigned int pT5);
-std::vector<unsigned int> getPixelHitsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getPixelHitsFrompT5(SDLEvent* event,
                                               unsigned int pT5);
-std::vector<unsigned int> getHitsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getHitIdxsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getHitTypesFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int pT5);
-std::vector<unsigned int> getModuleIdxsFrompT5(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event,
+std::vector<unsigned int> getHitsFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getHitIdxsFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getHitTypesFrompT5(SDLEvent* event, unsigned int pT5);
+std::vector<unsigned int> getModuleIdxsFrompT5(SDLEvent* event,
                                                unsigned int pT5);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFrompT5(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned pT5);
+    SDLEvent* event, unsigned pT5);
 
 // ----* TC *----
-std::vector<unsigned int> getLSsFromTC(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int TC);
-std::vector<unsigned int> getHitsFromTC(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int TC);
+std::vector<unsigned int> getLSsFromTC(SDLEvent* event, unsigned int TC);
+std::vector<unsigned int> getHitsFromTC(SDLEvent* event, unsigned int TC);
 std::tuple<std::vector<unsigned int>, std::vector<unsigned int>> getHitIdxsAndHitTypesFromTC(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int TC);
+    SDLEvent* event, unsigned int TC);
 
 #endif
diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
index cff1ef733e1f6..db8b2f6ac142d 100644
--- a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
+++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
@@ -22,7 +22,7 @@ bool goodEvent() {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runMiniDoublet(SDL::Event<Device> *event, int evt) {
+float runMiniDoublet(SDL::Event<Acc3D> *event, int evt) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Mini-Doublet start " << evt << std::endl;
@@ -74,7 +74,7 @@ float runMiniDoublet(SDL::Event<Device> *event, int evt) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runSegment(SDL::Event<Device> *event) {
+float runSegment(SDL::Event<Acc3D> *event) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Segment start" << std::endl;
@@ -111,7 +111,7 @@ float runSegment(SDL::Event<Device> *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runT3(SDL::Event<Device> *event) {
+float runT3(SDL::Event<Acc3D> *event) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco T3 start" << std::endl;
@@ -152,7 +152,7 @@ float runT3(SDL::Event<Device> *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runpT3(SDL::Event<Device> *event) {
+float runpT3(SDL::Event<Acc3D> *event) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Pixel Triplet pT3 start" << std::endl;
@@ -168,7 +168,7 @@ float runpT3(SDL::Event<Device> *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runQuintuplet(SDL::Event<Device> *event) {
+float runQuintuplet(SDL::Event<Acc3D> *event) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Quintuplet start" << std::endl;
@@ -213,7 +213,7 @@ float runQuintuplet(SDL::Event<Device> *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runPixelLineSegment(SDL::Event<Device> *event, bool no_pls_dupclean) {
+float runPixelLineSegment(SDL::Event<Acc3D> *event, bool no_pls_dupclean) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Pixel Line Segment start" << std::endl;
@@ -227,7 +227,7 @@ float runPixelLineSegment(SDL::Event<Device> *event, bool no_pls_dupclean) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runPixelQuintuplet(SDL::Event<Device> *event) {
+float runPixelQuintuplet(SDL::Event<Acc3D> *event) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Pixel Quintuplet start" << std::endl;
@@ -243,7 +243,7 @@ float runPixelQuintuplet(SDL::Event<Device> *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runTrackCandidate(SDL::Event<Device> *event, bool no_pls_dupclean, bool tc_pls_triplets) {
+float runTrackCandidate(SDL::Event<Acc3D> *event, bool no_pls_dupclean, bool tc_pls_triplets) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco TrackCandidate start" << std::endl;
@@ -839,7 +839,7 @@ void addInputsToLineSegmentTrackingPreLoad(std::vector<std::vector<float>> &out_
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float addInputsToEventPreLoad(SDL::Event<Device> *event,
+float addInputsToEventPreLoad(SDL::Event<Acc3D> *event,
                               bool useOMP,
                               std::vector<float> trkX,
                               std::vector<float> trkY,
@@ -1143,7 +1143,7 @@ void writeMetaData() {
 // DEPRECATED FUNCTIONS
 
 //__________________________________________________________________________________________
-[[deprecated]] float addInputsToLineSegmentTracking(SDL::Event<Device> &event, bool useOMP) {
+[[deprecated]] float addInputsToLineSegmentTracking(SDL::Event<Acc3D> &event, bool useOMP) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Loading Inputs (i.e. outer tracker hits, and pixel line segements) to the Line Segment Tracking.... "
@@ -1338,6 +1338,6 @@ void writeMetaData() {
 }
 
 //__________________________________________________________________________________________
-[[deprecated]] float addInputsToLineSegmentTrackingUsingExplicitMemory(SDL::Event<Device> &event) {
+[[deprecated]] float addInputsToLineSegmentTrackingUsingExplicitMemory(SDL::Event<Acc3D> &event) {
   return addInputsToLineSegmentTracking(event, true);
 }
diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.h b/RecoTracker/LSTCore/standalone/code/core/trkCore.h
index e32bc5153e04a..6a3d926658890 100644
--- a/RecoTracker/LSTCore/standalone/code/core/trkCore.h
+++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.h
@@ -11,22 +11,24 @@
 #include <numeric>
 #include <filesystem>
 
+using SDLEvent = SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Acc3D>;
+
 // --------------------- ======================== ---------------------
 
 bool goodEvent();
-float runMiniDoublet(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event, int evt);
-float runSegment(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runT4(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runT4x(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runpT4(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runTrackCandidate(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event,
+float runMiniDoublet(SDLEvent *event, int evt);
+float runSegment(SDLEvent *event);
+float runT4(SDLEvent *event);
+float runT4x(SDLEvent *event);
+float runpT4(SDLEvent *event);
+float runT3(SDLEvent *event);
+float runTrackCandidate(SDLEvent *event,
                         bool no_pls_dupclean,
                         bool tc_pls_triplets);
-float runQuintuplet(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runPixelQuintuplet(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
-float runPixelLineSegment(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event, bool no_pls_dupclean);
-float runpT3(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event);
+float runQuintuplet(SDLEvent *event);
+float runPixelQuintuplet(SDLEvent *event);
+float runPixelLineSegment(SDLEvent *event, bool no_pls_dupclean);
+float runpT3(SDLEvent *event);
 
 // --------------------- ======================== ---------------------
 
@@ -71,7 +73,7 @@ void addInputsToLineSegmentTrackingPreLoad(std::vector<std::vector<float>> &out_
                                            std::vector<std::vector<int8_t>> &out_pixelType_vec,
                                            std::vector<std::vector<char>> &out_isQuad_vec);
 
-float addInputsToEventPreLoad(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> *event,
+float addInputsToEventPreLoad(SDLEvent *event,
                               bool useOMP,
                               std::vector<float> trkX,
                               std::vector<float> trkY,
@@ -107,7 +109,7 @@ void writeMetaData();
 // --------------------- ======================== ---------------------
 
 // DEPRECATED FUNCTION
-float addInputsToLineSegmentTrackingUsingExplicitMemory(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> &event);
-float addInputsToLineSegmentTracking(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device> &event, bool useOMP);
+float addInputsToLineSegmentTrackingUsingExplicitMemory(SDLEvent &event);
+float addInputsToLineSegmentTracking(SDLEvent &event, bool useOMP);
 
 #endif
diff --git a/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.cc b/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.cc
index d361cdd165705..a610c40c6188d 100644
--- a/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.cc
+++ b/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.cc
@@ -9,7 +9,7 @@ void createOutputBranches() {
 }
 
 //________________________________________________________________________________________________________________________________
-void fillOutputBranches(SDL::Event<Device>* event) {
+void fillOutputBranches(SDL::Event<Acc3D>* event) {
   setOutputBranches(event);
   setOptionalOutputBranches(event);
   if (ana.gnn_ntuple)
@@ -183,7 +183,7 @@ void createGnnNtupleBranches() {
 }
 
 //________________________________________________________________________________________________________________________________
-void setOutputBranches(SDL::Event<Device>* event) {
+void setOutputBranches(SDL::Event<Acc3D>* event) {
   // ============ Sim tracks =============
   int n_accepted_simtrk = 0;
   for (unsigned int isimtrk = 0; isimtrk < trk.sim_pt().size(); ++isimtrk) {
@@ -278,7 +278,7 @@ void setOutputBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setOptionalOutputBranches(SDL::Event<Device>* event) {
+void setOptionalOutputBranches(SDL::Event<Acc3D>* event) {
 #ifdef CUT_VALUE_DEBUG
 
   setPixelQuintupletOutputBranches(event);
@@ -289,7 +289,7 @@ void setOptionalOutputBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setPixelQuintupletOutputBranches(SDL::Event<Device>* event) {
+void setPixelQuintupletOutputBranches(SDL::Event<Acc3D>* event) {
   // ============ pT5 =============
   SDL::pixelQuintupletsBuffer<alpaka::DevCpu>& pixelQuintupletsInGPU = (*event->getPixelQuintuplets());
   SDL::quintupletsBuffer<alpaka::DevCpu>& quintupletsInGPU = (*event->getQuintuplets());
@@ -365,7 +365,7 @@ void setPixelQuintupletOutputBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setQuintupletOutputBranches(SDL::Event<Device>* event) {
+void setQuintupletOutputBranches(SDL::Event<Acc3D>* event) {
   SDL::quintupletsBuffer<alpaka::DevCpu>& quintupletsInGPU = (*event->getQuintuplets());
   SDL::objectRangesBuffer<alpaka::DevCpu>& rangesInGPU = (*event->getRanges());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
@@ -436,7 +436,7 @@ void setQuintupletOutputBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setPixelTripletOutputBranches(SDL::Event<Device>* event) {
+void setPixelTripletOutputBranches(SDL::Event<Acc3D>* event) {
   SDL::pixelTripletsBuffer<alpaka::DevCpu>& pixelTripletsInGPU = (*event->getPixelTriplets());
   SDL::tripletsBuffer<alpaka::DevCpu>& tripletsInGPU = *(event->getTriplets());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = *(event->getModules());
@@ -501,7 +501,7 @@ void setPixelTripletOutputBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setGnnNtupleBranches(SDL::Event<Device>* event) {
+void setGnnNtupleBranches(SDL::Event<Acc3D>* event) {
   // Get relevant information
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
@@ -642,7 +642,7 @@ void setGnnNtupleBranches(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void setGnnNtupleMiniDoublet(SDL::Event<Device>* event, unsigned int MD) {
+void setGnnNtupleMiniDoublet(SDL::Event<Acc3D>* event, unsigned int MD) {
   // Get relevant information
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = (*event->getHits());
@@ -710,7 +710,7 @@ void setGnnNtupleMiniDoublet(SDL::Event<Device>* event, unsigned int MD) {
 }
 
 //________________________________________________________________________________________________________________________________
-std::tuple<int, float, float, float, int, std::vector<int>> parseTrackCandidate(SDL::Event<Device>* event,
+std::tuple<int, float, float, float, int, std::vector<int>> parseTrackCandidate(SDL::Event<Acc3D>* event,
                                                                                 unsigned int idx) {
   // Get the type of the track candidate
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
@@ -745,7 +745,7 @@ std::tuple<int, float, float, float, int, std::vector<int>> parseTrackCandidate(
 
 //________________________________________________________________________________________________________________________________
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepT5(
-    SDL::Event<Device>* event, unsigned int idx) {
+    SDL::Event<Acc3D>* event, unsigned int idx) {
   // Get relevant information
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   SDL::quintupletsBuffer<alpaka::DevCpu>& quintupletsInGPU = (*event->getQuintuplets());
@@ -857,7 +857,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
 
 //________________________________________________________________________________________________________________________________
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepT3(
-    SDL::Event<Device>* event, unsigned int idx) {
+    SDL::Event<Acc3D>* event, unsigned int idx) {
   // Get relevant information
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   SDL::tripletsBuffer<alpaka::DevCpu>& tripletsInGPU = (*event->getTriplets());
@@ -891,7 +891,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
 }
 
 //________________________________________________________________________________________________________________________________
-std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parseT5(SDL::Event<Device>* event,
+std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parseT5(SDL::Event<Acc3D>* event,
                                                                                               unsigned int idx) {
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   SDL::quintupletsBuffer<alpaka::DevCpu>& quintupletsInGPU = (*event->getQuintuplets());
@@ -926,7 +926,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
 
 //________________________________________________________________________________________________________________________________
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepLS(
-    SDL::Event<Device>* event, unsigned int idx) {
+    SDL::Event<Acc3D>* event, unsigned int idx) {
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
 
@@ -946,7 +946,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
 }
 
 //________________________________________________________________________________________________________________________________
-void printHitMultiplicities(SDL::Event<Device>* event) {
+void printHitMultiplicities(SDL::Event<Acc3D>* event) {
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
   SDL::objectRangesBuffer<alpaka::DevCpu>& rangesInGPU = (*event->getRanges());
 
@@ -961,7 +961,7 @@ void printHitMultiplicities(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printMiniDoubletMultiplicities(SDL::Event<Device>* event) {
+void printMiniDoubletMultiplicities(SDL::Event<Acc3D>* event) {
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
 
@@ -980,7 +980,7 @@ void printMiniDoubletMultiplicities(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printAllObjects(SDL::Event<Device>* event) {
+void printAllObjects(SDL::Event<Acc3D>* event) {
   printMDs(event);
   printLSs(event);
   printpLSs(event);
@@ -988,7 +988,7 @@ void printAllObjects(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printMDs(SDL::Event<Device>* event) {
+void printMDs(SDL::Event<Acc3D>* event) {
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = (*event->getHits());
   SDL::modulesBuffer<alpaka::DevCpu>& modulesInGPU = (*event->getModules());
@@ -1010,7 +1010,7 @@ void printMDs(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printLSs(SDL::Event<Device>* event) {
+void printLSs(SDL::Event<Acc3D>* event) {
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = (*event->getHits());
@@ -1042,7 +1042,7 @@ void printLSs(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printpLSs(SDL::Event<Device>* event) {
+void printpLSs(SDL::Event<Acc3D>* event) {
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
   SDL::hitsBuffer<alpaka::DevCpu>& hitsInGPU = (*event->getHits());
@@ -1072,7 +1072,7 @@ void printpLSs(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void printT3s(SDL::Event<Device>* event) {
+void printT3s(SDL::Event<Acc3D>* event) {
   SDL::tripletsBuffer<alpaka::DevCpu>& tripletsInGPU = (*event->getTriplets());
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
   SDL::miniDoubletsBuffer<alpaka::DevCpu>& miniDoubletsInGPU = (*event->getMiniDoublets());
@@ -1114,7 +1114,7 @@ void printT3s(SDL::Event<Device>* event) {
 }
 
 //________________________________________________________________________________________________________________________________
-void debugPrintOutlierMultiplicities(SDL::Event<Device>* event) {
+void debugPrintOutlierMultiplicities(SDL::Event<Acc3D>* event) {
   SDL::trackCandidatesBuffer<alpaka::DevCpu>& trackCandidatesInGPU = (*event->getTrackCandidates());
   SDL::tripletsBuffer<alpaka::DevCpu>& tripletsInGPU = (*event->getTriplets());
   SDL::segmentsBuffer<alpaka::DevCpu>& segmentsInGPU = (*event->getSegments());
diff --git a/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.h b/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.h
index ec3afb2e1944c..a5f325f986ab7 100644
--- a/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.h
+++ b/RecoTracker/LSTCore/standalone/code/core/write_sdl_ntuple.h
@@ -11,47 +11,49 @@
 #include "trkCore.h"
 #include "AccessHelper.h"
 
+using SDLEvent = SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Acc3D>;
+
 // Common
 void createOutputBranches();
 void createRequiredOutputBranches();
 void createOptionalOutputBranches();
 void createGnnNtupleBranches();
 
-void fillOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setOptionalOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setPixelQuintupletOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setQuintupletOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setPixelTripletOutputBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setGnnNtupleBranches(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void setGnnNtupleMiniDoublet(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int MD);
+void fillOutputBranches(SDLEvent* event);
+void setOutputBranches(SDLEvent* event);
+void setOptionalOutputBranches(SDLEvent* event);
+void setPixelQuintupletOutputBranches(SDLEvent* event);
+void setQuintupletOutputBranches(SDLEvent* event);
+void setPixelTripletOutputBranches(SDLEvent* event);
+void setGnnNtupleBranches(SDLEvent* event);
+void setGnnNtupleMiniDoublet(SDLEvent* event, unsigned int MD);
 
 std::tuple<int, float, float, float, int, std::vector<int>> parseTrackCandidate(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int);
+    SDLEvent* event, unsigned int);
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepT5(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int);
+    SDLEvent* event, unsigned int);
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepT3(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int);
+    SDLEvent* event, unsigned int);
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parseT5(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int);
+    SDLEvent* event, unsigned int);
 std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned int>> parsepLS(
-    SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event, unsigned int);
+    SDLEvent* event, unsigned int);
 
 // Print multiplicities
-void printMiniDoubletMultiplicities(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printHitMultiplicities(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
+void printMiniDoubletMultiplicities(SDLEvent* event);
+void printHitMultiplicities(SDLEvent* event);
 
 // Print objects (GPU)
-void printAllObjects(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printpT4s(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printMDs(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printLSs(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printpLSs(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printT3s(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printT4s(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
-void printTCs(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
+void printAllObjects(SDLEvent* event);
+void printpT4s(SDLEvent* event);
+void printMDs(SDLEvent* event);
+void printLSs(SDLEvent* event);
+void printpLSs(SDLEvent* event);
+void printT3s(SDLEvent* event);
+void printT4s(SDLEvent* event);
+void printTCs(SDLEvent* event);
 
 // Print anomalous multiplicities
-void debugPrintOutlierMultiplicities(SDL::Event<ALPAKA_ACCELERATOR_NAMESPACE::Device>* event);
+void debugPrintOutlierMultiplicities(SDLEvent* event);
 
 #endif