diff --git a/RecoTracker/LSTCore/interface/PixelSegmentsHostCollection.h b/RecoTracker/LSTCore/interface/PixelSegmentsHostCollection.h
new file mode 100644
index 0000000000000..ff96d0a832099
--- /dev/null
+++ b/RecoTracker/LSTCore/interface/PixelSegmentsHostCollection.h
@@ -0,0 +1,10 @@
+#ifndef RecoTracker_LSTCore_interface_PixelSegmentsHostCollection_h
+#define RecoTracker_LSTCore_interface_PixelSegmentsHostCollection_h
+
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
+#include "DataFormats/Portable/interface/PortableHostCollection.h"
+
+namespace lst {
+  using PixelSegmentsHostCollection = PortableHostCollection<PixelSegmentsSoA>;
+}  // namespace lst
+#endif
diff --git a/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h b/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h
new file mode 100644
index 0000000000000..70e2db3f8ce64
--- /dev/null
+++ b/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h
@@ -0,0 +1,40 @@
+#ifndef RecoTracker_LSTCore_interface_PixelSegmentsSoA_h
+#define RecoTracker_LSTCore_interface_PixelSegmentsSoA_h
+
+#include "DataFormats/SoATemplate/interface/SoALayout.h"
+#include "DataFormats/Portable/interface/PortableCollection.h"
+
+#include "RecoTracker/LSTCore/interface/Common.h"
+
+namespace lst {
+
+  GENERATE_SOA_LAYOUT(PixelSegmentsSoALayout,
+                      SOA_COLUMN(unsigned int, seedIdx),
+                      SOA_COLUMN(int, charge),
+                      SOA_COLUMN(int, superbin),
+                      SOA_COLUMN(uint4, pLSHitsIdxs),
+                      SOA_COLUMN(PixelType, pixelType),
+                      SOA_COLUMN(char, isQuad),
+                      SOA_COLUMN(char, isDup),
+                      SOA_COLUMN(bool, partOfPT5),
+                      SOA_COLUMN(float, ptIn),
+                      SOA_COLUMN(float, ptErr),
+                      SOA_COLUMN(float, px),
+                      SOA_COLUMN(float, py),
+                      SOA_COLUMN(float, pz),
+                      SOA_COLUMN(float, etaErr),
+                      SOA_COLUMN(float, eta),
+                      SOA_COLUMN(float, phi),
+                      SOA_COLUMN(float, score),
+                      SOA_COLUMN(float, circleCenterX),
+                      SOA_COLUMN(float, circleCenterY),
+                      SOA_COLUMN(float, circleRadius))
+
+  using PixelSegmentsSoA = PixelSegmentsSoALayout<>;
+
+  using PixelSegments = PixelSegmentsSoA::View;
+  using PixelSegmentsConst = PixelSegmentsSoA::ConstView;
+
+}  // namespace lst
+
+#endif
diff --git a/RecoTracker/LSTCore/interface/SegmentsHostCollection.h b/RecoTracker/LSTCore/interface/SegmentsHostCollection.h
index 2fa6ac912a732..621d4378c15d2 100644
--- a/RecoTracker/LSTCore/interface/SegmentsHostCollection.h
+++ b/RecoTracker/LSTCore/interface/SegmentsHostCollection.h
@@ -5,6 +5,6 @@
 #include "DataFormats/Portable/interface/PortableHostCollection.h"
 
 namespace lst {
-  using SegmentsHostCollection = PortableHostMultiCollection<SegmentsSoA, SegmentsOccupancySoA, SegmentsPixelSoA>;
+  using SegmentsHostCollection = PortableHostMultiCollection<SegmentsSoA, SegmentsOccupancySoA>;
 }  // namespace lst
 #endif
diff --git a/RecoTracker/LSTCore/interface/SegmentsSoA.h b/RecoTracker/LSTCore/interface/SegmentsSoA.h
index 24df2fb5a42a0..acaf0a571f262 100644
--- a/RecoTracker/LSTCore/interface/SegmentsSoA.h
+++ b/RecoTracker/LSTCore/interface/SegmentsSoA.h
@@ -25,38 +25,13 @@ namespace lst {
                       SOA_COLUMN(unsigned int, nSegments),  //number of segments per inner lower module
                       SOA_COLUMN(unsigned int, totOccupancySegments))
 
-  GENERATE_SOA_LAYOUT(SegmentsPixelSoALayout,
-                      SOA_COLUMN(unsigned int, seedIdx),
-                      SOA_COLUMN(int, charge),
-                      SOA_COLUMN(int, superbin),
-                      SOA_COLUMN(uint4, pLSHitsIdxs),
-                      SOA_COLUMN(PixelType, pixelType),
-                      SOA_COLUMN(char, isQuad),
-                      SOA_COLUMN(char, isDup),
-                      SOA_COLUMN(bool, partOfPT5),
-                      SOA_COLUMN(float, ptIn),
-                      SOA_COLUMN(float, ptErr),
-                      SOA_COLUMN(float, px),
-                      SOA_COLUMN(float, py),
-                      SOA_COLUMN(float, pz),
-                      SOA_COLUMN(float, etaErr),
-                      SOA_COLUMN(float, eta),
-                      SOA_COLUMN(float, phi),
-                      SOA_COLUMN(float, score),
-                      SOA_COLUMN(float, circleCenterX),
-                      SOA_COLUMN(float, circleCenterY),
-                      SOA_COLUMN(float, circleRadius))
-
   using SegmentsSoA = SegmentsSoALayout<>;
   using SegmentsOccupancySoA = SegmentsOccupancySoALayout<>;
-  using SegmentsPixelSoA = SegmentsPixelSoALayout<>;
 
   using Segments = SegmentsSoA::View;
   using SegmentsConst = SegmentsSoA::ConstView;
   using SegmentsOccupancy = SegmentsOccupancySoA::View;
   using SegmentsOccupancyConst = SegmentsOccupancySoA::ConstView;
-  using SegmentsPixel = SegmentsPixelSoA::View;
-  using SegmentsPixelConst = SegmentsPixelSoA::ConstView;
 
 }  // namespace lst
 
diff --git a/RecoTracker/LSTCore/interface/alpaka/PixelSegmentsDeviceCollection.h b/RecoTracker/LSTCore/interface/alpaka/PixelSegmentsDeviceCollection.h
new file mode 100644
index 0000000000000..d7be8a157099c
--- /dev/null
+++ b/RecoTracker/LSTCore/interface/alpaka/PixelSegmentsDeviceCollection.h
@@ -0,0 +1,13 @@
+#ifndef RecoTracker_LSTCore_interface_alpaka_PixelSegmentsDeviceCollection_h
+#define RecoTracker_LSTCore_interface_alpaka_PixelSegmentsDeviceCollection_h
+
+#include "DataFormats/Portable/interface/alpaka/PortableCollection.h"
+
+#include "RecoTracker/LSTCore/interface/alpaka/Common.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
+
+namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
+  using PixelSegmentsDeviceCollection = PortableCollection<PixelSegmentsSoA>;
+}  // namespace ALPAKA_ACCELERATOR_NAMESPACE::lst
+
+#endif
diff --git a/RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h b/RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h
index 934e6314ae320..800e7bc61a439 100644
--- a/RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h
+++ b/RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h
@@ -7,7 +7,7 @@
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
 
 namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
-  using SegmentsDeviceCollection = PortableCollection3<SegmentsSoA, SegmentsOccupancySoA, SegmentsPixelSoA>;
+  using SegmentsDeviceCollection = PortableCollection2<SegmentsSoA, SegmentsOccupancySoA>;
 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE::lst
 
 #endif
diff --git a/RecoTracker/LSTCore/src/alpaka/Kernels.h b/RecoTracker/LSTCore/src/alpaka/Kernels.h
index aa5a2c8788aa4..66733d2d8b881 100644
--- a/RecoTracker/LSTCore/src/alpaka/Kernels.h
+++ b/RecoTracker/LSTCore/src/alpaka/Kernels.h
@@ -9,6 +9,7 @@
 #include "RecoTracker/LSTCore/interface/MiniDoubletsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelQuintupletsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelTripletsSoA.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/QuintupletsSoA.h"
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/TripletsSoA.h"
@@ -30,10 +31,10 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     pixelQuintuplets.isDup()[pixelQuintupletIndex] = true;
   }
 
-  ALPAKA_FN_ACC ALPAKA_FN_INLINE void rmPixelSegmentFromMemory(SegmentsPixel segmentsPixel,
+  ALPAKA_FN_ACC ALPAKA_FN_INLINE void rmPixelSegmentFromMemory(PixelSegments pixelSegments,
                                                                unsigned int pixelSegmentArrayIndex,
                                                                bool secondpass = false) {
-    segmentsPixel.isDup()[pixelSegmentArrayIndex] |= 1 + secondpass;
+    pixelSegments.isDup()[pixelSegmentArrayIndex] |= 1 + secondpass;
   }
 
   ALPAKA_FN_ACC ALPAKA_FN_INLINE int checkHitsT5(unsigned int ix, unsigned int jx, QuintupletsConst quintuplets) {
@@ -321,7 +322,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     ALPAKA_FN_ACC void operator()(Acc2D const& acc,
                                   ModulesConst modules,
                                   SegmentsOccupancyConst segmentsOccupancy,
-                                  SegmentsPixel segmentsPixel,
+                                  PixelSegments pixelSegments,
                                   bool secondpass) const {
       int pixelModuleIndex = modules.nLowerModules();
       unsigned int nPixelSegments = segmentsOccupancy.nSegments()[pixelModuleIndex];
@@ -330,29 +331,29 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         nPixelSegments = n_max_pixel_segments_per_module;
 
       for (unsigned int ix : cms::alpakatools::uniform_elements_y(acc, nPixelSegments)) {
-        if (secondpass && (!segmentsPixel.isQuad()[ix] || (segmentsPixel.isDup()[ix] & 1)))
+        if (secondpass && (!pixelSegments.isQuad()[ix] || (pixelSegments.isDup()[ix] & 1)))
           continue;
 
         unsigned int phits1[Params_pLS::kHits];
-        phits1[0] = segmentsPixel.pLSHitsIdxs()[ix].x;
-        phits1[1] = segmentsPixel.pLSHitsIdxs()[ix].y;
-        phits1[2] = segmentsPixel.pLSHitsIdxs()[ix].z;
-        phits1[3] = segmentsPixel.pLSHitsIdxs()[ix].w;
-        float eta_pix1 = segmentsPixel.eta()[ix];
-        float phi_pix1 = segmentsPixel.phi()[ix];
+        phits1[0] = pixelSegments.pLSHitsIdxs()[ix].x;
+        phits1[1] = pixelSegments.pLSHitsIdxs()[ix].y;
+        phits1[2] = pixelSegments.pLSHitsIdxs()[ix].z;
+        phits1[3] = pixelSegments.pLSHitsIdxs()[ix].w;
+        float eta_pix1 = pixelSegments.eta()[ix];
+        float phi_pix1 = pixelSegments.phi()[ix];
 
         for (unsigned int jx : cms::alpakatools::uniform_elements_x(acc, ix + 1, nPixelSegments)) {
-          float eta_pix2 = segmentsPixel.eta()[jx];
-          float phi_pix2 = segmentsPixel.phi()[jx];
+          float eta_pix2 = pixelSegments.eta()[jx];
+          float phi_pix2 = pixelSegments.phi()[jx];
 
           if (alpaka::math::abs(acc, eta_pix2 - eta_pix1) > 0.1f)
             continue;
 
-          if (secondpass && (!segmentsPixel.isQuad()[jx] || (segmentsPixel.isDup()[jx] & 1)))
+          if (secondpass && (!pixelSegments.isQuad()[jx] || (pixelSegments.isDup()[jx] & 1)))
             continue;
 
-          int8_t quad_diff = segmentsPixel.isQuad()[ix] - segmentsPixel.isQuad()[jx];
-          float score_diff = segmentsPixel.score()[ix] - segmentsPixel.score()[jx];
+          int8_t quad_diff = pixelSegments.isQuad()[ix] - pixelSegments.isQuad()[jx];
+          float score_diff = pixelSegments.score()[ix] - pixelSegments.score()[jx];
           // Always keep quads over trips. If they are the same, we want the object with better score
           int idxToRemove;
           if (quad_diff > 0)
@@ -367,10 +368,10 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
             idxToRemove = ix;
 
           unsigned int phits2[Params_pLS::kHits];
-          phits2[0] = segmentsPixel.pLSHitsIdxs()[jx].x;
-          phits2[1] = segmentsPixel.pLSHitsIdxs()[jx].y;
-          phits2[2] = segmentsPixel.pLSHitsIdxs()[jx].z;
-          phits2[3] = segmentsPixel.pLSHitsIdxs()[jx].w;
+          phits2[0] = pixelSegments.pLSHitsIdxs()[jx].x;
+          phits2[1] = pixelSegments.pLSHitsIdxs()[jx].y;
+          phits2[2] = pixelSegments.pLSHitsIdxs()[jx].z;
+          phits2[3] = pixelSegments.pLSHitsIdxs()[jx].w;
 
           int npMatched = 0;
           for (int i = 0; i < Params_pLS::kHits; i++) {
@@ -390,7 +391,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
           }
           const int minNHitsForDup_pLS = 3;
           if (npMatched >= minNHitsForDup_pLS) {
-            rmPixelSegmentFromMemory(segmentsPixel, idxToRemove, secondpass);
+            rmPixelSegmentFromMemory(pixelSegments, idxToRemove, secondpass);
           }
           if (secondpass) {
             float dEta = alpaka::math::abs(acc, eta_pix1 - eta_pix2);
@@ -398,7 +399,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
             float dR2 = dEta * dEta + dPhi * dPhi;
             if ((npMatched >= 1) || (dR2 < 1e-5f)) {
-              rmPixelSegmentFromMemory(segmentsPixel, idxToRemove, secondpass);
+              rmPixelSegmentFromMemory(pixelSegments, idxToRemove, secondpass);
             }
           }
         }
diff --git a/RecoTracker/LSTCore/src/alpaka/LST.cc b/RecoTracker/LSTCore/src/alpaka/LST.cc
index b2fe87e3a2917..94545c7172a20 100644
--- a/RecoTracker/LSTCore/src/alpaka/LST.cc
+++ b/RecoTracker/LSTCore/src/alpaka/LST.cc
@@ -302,24 +302,19 @@ void LST::run(Queue& queue,
                ptCut);
 
   event.addHitToEvent(in_trkX_, in_trkY_, in_trkZ_, in_hitId_, in_hitIdxs_);
-  event.addPixelSegmentToEvent(in_hitIndices_vec0_,
-                               in_hitIndices_vec1_,
-                               in_hitIndices_vec2_,
-                               in_hitIndices_vec3_,
-                               in_deltaPhi_vec_,
-                               in_ptIn_vec_,
-                               in_ptErr_vec_,
-                               in_px_vec_,
-                               in_py_vec_,
-                               in_pz_vec_,
-                               in_eta_vec_,
-                               in_etaErr_vec_,
-                               in_phi_vec_,
-                               in_charge_vec_,
-                               in_seedIdx_vec_,
-                               in_superbin_vec_,
-                               in_pixelType_vec_,
-                               in_isQuad_vec_);
+  event.addPixelSegmentToEventStart(in_ptIn_vec_,
+                                    in_ptErr_vec_,
+                                    in_px_vec_,
+                                    in_py_vec_,
+                                    in_pz_vec_,
+                                    in_eta_vec_,
+                                    in_etaErr_vec_,
+                                    in_phi_vec_,
+                                    in_charge_vec_,
+                                    in_seedIdx_vec_,
+                                    in_superbin_vec_,
+                                    in_pixelType_vec_,
+                                    in_isQuad_vec_);
   event.createMiniDoublets();
   if (verbose) {
     alpaka::wait(queue);  // event calls are asynchronous: wait before printing
@@ -388,6 +383,9 @@ void LST::run(Queue& queue,
     printf("# of Quintuplets produced endcap layer 5: %d\n", event.getNumberOfQuintupletsByLayerEndcap(4));
   }
 
+  event.addPixelSegmentToEventFinalize(
+      in_hitIndices_vec0_, in_hitIndices_vec1_, in_hitIndices_vec2_, in_hitIndices_vec3_, in_deltaPhi_vec_);
+
   event.pixelLineSegmentCleaning(no_pls_dupclean);
 
   event.createPixelQuintuplets();
diff --git a/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc b/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc
index 94410a5fb7975..06eff7da3b8fb 100644
--- a/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc
+++ b/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc
@@ -151,25 +151,21 @@ void LSTEvent::addHitToEvent(std::vector<float> const& x,
                       nLowerModules_);
 }
 
-void LSTEvent::addPixelSegmentToEvent(std::vector<unsigned int> const& hitIndices0,
-                                      std::vector<unsigned int> const& hitIndices1,
-                                      std::vector<unsigned int> const& hitIndices2,
-                                      std::vector<unsigned int> const& hitIndices3,
-                                      std::vector<float> const& dPhiChange,
-                                      std::vector<float> const& ptIn,
-                                      std::vector<float> const& ptErr,
-                                      std::vector<float> const& px,
-                                      std::vector<float> const& py,
-                                      std::vector<float> const& pz,
-                                      std::vector<float> const& eta,
-                                      std::vector<float> const& etaErr,
-                                      std::vector<float> const& phi,
-                                      std::vector<int> const& charge,
-                                      std::vector<unsigned int> const& seedIdx,
-                                      std::vector<int> const& superbin,
-                                      std::vector<PixelType> const& pixelType,
-                                      std::vector<char> const& isQuad) {
+void LSTEvent::addPixelSegmentToEventStart(std::vector<float> const& ptIn,
+                                           std::vector<float> const& ptErr,
+                                           std::vector<float> const& px,
+                                           std::vector<float> const& py,
+                                           std::vector<float> const& pz,
+                                           std::vector<float> const& eta,
+                                           std::vector<float> const& etaErr,
+                                           std::vector<float> const& phi,
+                                           std::vector<int> const& charge,
+                                           std::vector<unsigned int> const& seedIdx,
+                                           std::vector<int> const& superbin,
+                                           std::vector<PixelType> const& pixelType,
+                                           std::vector<char> const& isQuad) {
   unsigned int size = ptIn.size();
+  pixelSize_ = size;
 
   if (size > n_max_pixel_segments_per_module) {
     lstWarning(
@@ -181,14 +177,69 @@ void LSTEvent::addPixelSegmentToEvent(std::vector<unsigned int> const& hitIndice
     size = n_max_pixel_segments_per_module;
   }
 
-  unsigned int mdSize = 2 * size;
-  uint16_t pixelModuleIndex = pixelMapping_.pixelModuleIndex;
+  pixelModuleIndex_ = pixelMapping_.pixelModuleIndex;
+
+  pixelSegmentsDC_.emplace(n_max_pixel_segments_per_module, queue_);
+
+  PixelSegments pixelSegments = pixelSegmentsDC_->view();
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.ptIn(), size), ptIn, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.ptErr(), size), ptErr, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.px(), size), px, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.py(), size), py, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.pz(), size), pz, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.etaErr(), size), etaErr, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.isQuad(), size), isQuad, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.eta(), size), eta, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.phi(), size), phi, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.charge(), size), charge, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.seedIdx(), size), seedIdx, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), size), superbin, size);
+  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), size), pixelType, size);
+}
+
+void LSTEvent::addPixelSegmentToEventFinalize(std::vector<unsigned int> hitIndices0,
+                                              std::vector<unsigned int> hitIndices1,
+                                              std::vector<unsigned int> hitIndices2,
+                                              std::vector<unsigned int> hitIndices3,
+                                              std::vector<float> deltaPhi_vec) {
+  auto hitIndices0_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, pixelSize_);
+  auto hitIndices1_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, pixelSize_);
+  auto hitIndices2_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, pixelSize_);
+  auto hitIndices3_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, pixelSize_);
+  auto dPhiChange_dev = cms::alpakatools::make_device_buffer<float[]>(queue_, pixelSize_);
+
+  alpaka::memcpy(queue_, hitIndices0_dev, hitIndices0, pixelSize_);
+  alpaka::memcpy(queue_, hitIndices1_dev, hitIndices1, pixelSize_);
+  alpaka::memcpy(queue_, hitIndices2_dev, hitIndices2, pixelSize_);
+  alpaka::memcpy(queue_, hitIndices3_dev, hitIndices3, pixelSize_);
+  alpaka::memcpy(queue_, dPhiChange_dev, deltaPhi_vec, pixelSize_);
+
+  auto const addPixelSegmentToEvent_workdiv = cms::alpakatools::make_workdiv<Acc1D>(max_blocks, 256);
+
+  alpaka::exec<Acc1D>(queue_,
+                      addPixelSegmentToEvent_workdiv,
+                      AddPixelSegmentToEventKernel{},
+                      modules_.const_view<ModulesSoA>(),
+                      rangesDC_->const_view(),
+                      hitsDC_->view<HitsSoA>(),
+                      miniDoubletsDC_->view<MiniDoubletsSoA>(),
+                      segmentsDC_->view<SegmentsSoA>(),
+                      pixelSegmentsDC_->view(),
+                      hitIndices0_dev.data(),
+                      hitIndices1_dev.data(),
+                      hitIndices2_dev.data(),
+                      hitIndices3_dev.data(),
+                      dPhiChange_dev.data(),
+                      pixelModuleIndex_,
+                      pixelSize_);
+}
 
+void LSTEvent::createMiniDoublets() {
   if (!miniDoubletsDC_) {
     // Create a view for the element nLowerModules_ inside rangesOccupancy->miniDoubletModuleOccupancy
     auto rangesOccupancy = rangesDC_->view();
     auto dst_view_miniDoubletModuleOccupancy =
-        cms::alpakatools::make_device_view(queue_, rangesOccupancy.miniDoubletModuleOccupancy()[pixelModuleIndex]);
+        cms::alpakatools::make_device_view(queue_, rangesOccupancy.miniDoubletModuleOccupancy()[nLowerModules_]);
 
     // Create a host buffer for a value to be passed to the device
     auto pixelMaxMDs_buf_h = cms::alpakatools::make_host_buffer<int>(queue_);
@@ -196,12 +247,18 @@ void LSTEvent::addPixelSegmentToEvent(std::vector<unsigned int> const& hitIndice
 
     alpaka::memcpy(queue_, dst_view_miniDoubletModuleOccupancy, pixelMaxMDs_buf_h);
 
+    auto dst_view_miniDoubletModuleOccupancyPix =
+        cms::alpakatools::make_device_view(queue_, rangesOccupancy.miniDoubletModuleOccupancy()[pixelModuleIndex_]);
+
+    alpaka::memcpy(queue_, dst_view_miniDoubletModuleOccupancyPix, pixelMaxMDs_buf_h);
+
     auto const createMDArrayRangesGPU_workDiv = cms::alpakatools::make_workdiv<Acc1D>(1, 1024);
 
     alpaka::exec<Acc1D>(queue_,
                         createMDArrayRangesGPU_workDiv,
                         CreateMDArrayRangesGPU{},
                         modules_.const_view<ModulesSoA>(),
+                        hitsDC_->const_view<HitsRangesSoA>(),
                         rangesDC_->view(),
                         ptCut_);
 
@@ -223,152 +280,20 @@ void LSTEvent::addPixelSegmentToEvent(std::vector<unsigned int> const& hitIndice
     alpaka::memset(queue_, nMDs_view, 0u);
     alpaka::memset(queue_, totOccupancyMDs_view, 0u);
   }
-  if (!segmentsDC_) {
-    // can be optimized here: because we didn't distinguish pixel segments and outer-tracker segments and call them both "segments", so they use the index continuously.
-    // If we want to further study the memory footprint in detail, we can separate the two and allocate different memories to them
-
-    auto const createSegmentArrayRanges_workDiv = cms::alpakatools::make_workdiv<Acc1D>(1, 1024);
-
-    alpaka::exec<Acc1D>(queue_,
-                        createSegmentArrayRanges_workDiv,
-                        CreateSegmentArrayRanges{},
-                        modules_.const_view<ModulesSoA>(),
-                        rangesDC_->view(),
-                        miniDoubletsDC_->const_view<MiniDoubletsSoA>(),
-                        ptCut_);
-
-    auto rangesOccupancy = rangesDC_->view();
-    auto nTotalSegments_view_h = cms::alpakatools::make_host_view(nTotalSegments_);
-    auto nTotalSegments_view_d = cms::alpakatools::make_device_view(queue_, rangesOccupancy.nTotalSegs());
-    alpaka::memcpy(queue_, nTotalSegments_view_h, nTotalSegments_view_d);
-    alpaka::wait(queue_);  // wait to get the value before manipulation
-
-    nTotalSegments_ += n_max_pixel_segments_per_module;
-
-    std::array<int, 3> const segments_sizes{{static_cast<int>(nTotalSegments_),
-                                             static_cast<int>(nLowerModules_ + 1),
-                                             static_cast<int>(n_max_pixel_segments_per_module)}};
-    segmentsDC_.emplace(segments_sizes, queue_);
-
-    auto segmentsOccupancy = segmentsDC_->view<SegmentsOccupancySoA>();
-    auto nSegments_view =
-        cms::alpakatools::make_device_view(queue_, segmentsOccupancy.nSegments(), segmentsOccupancy.metadata().size());
-    auto totOccupancySegments_view = cms::alpakatools::make_device_view(
-        queue_, segmentsOccupancy.totOccupancySegments(), segmentsOccupancy.metadata().size());
-    alpaka::memset(queue_, nSegments_view, 0u);
-    alpaka::memset(queue_, totOccupancySegments_view, 0u);
-  }
 
-  auto hitIndices0_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, size);
-  auto hitIndices1_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, size);
-  auto hitIndices2_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, size);
-  auto hitIndices3_dev = cms::alpakatools::make_device_buffer<unsigned int[]>(queue_, size);
-  auto dPhiChange_dev = cms::alpakatools::make_device_buffer<float[]>(queue_, size);
-
-  alpaka::memcpy(queue_, hitIndices0_dev, hitIndices0, size);
-  alpaka::memcpy(queue_, hitIndices1_dev, hitIndices1, size);
-  alpaka::memcpy(queue_, hitIndices2_dev, hitIndices2, size);
-  alpaka::memcpy(queue_, hitIndices3_dev, hitIndices3, size);
-  alpaka::memcpy(queue_, dPhiChange_dev, dPhiChange, size);
-
-  SegmentsPixel segmentsPixel = segmentsDC_->view<SegmentsPixelSoA>();
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.ptIn(), size), ptIn, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.ptErr(), size), ptErr, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.px(), size), px, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.py(), size), py, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.pz(), size), pz, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.etaErr(), size), etaErr, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.isQuad(), size), isQuad, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.eta(), size), eta, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.phi(), size), phi, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.charge(), size), charge, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.seedIdx(), size), seedIdx, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.superbin(), size), superbin, size);
-  alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, segmentsPixel.pixelType(), size), pixelType, size);
-
-  // Create source views for size and mdSize
-  auto src_view_size = cms::alpakatools::make_host_view(size);
+  unsigned int mdSize = pixelSize_ * 2;
   auto src_view_mdSize = cms::alpakatools::make_host_view(mdSize);
 
-  auto segmentsOccupancy = segmentsDC_->view<SegmentsOccupancySoA>();
-  auto dst_view_segments = cms::alpakatools::make_device_view(queue_, segmentsOccupancy.nSegments()[pixelModuleIndex]);
-  alpaka::memcpy(queue_, dst_view_segments, src_view_size);
-
-  auto dst_view_totOccupancySegments =
-      cms::alpakatools::make_device_view(queue_, segmentsOccupancy.totOccupancySegments()[pixelModuleIndex]);
-  alpaka::memcpy(queue_, dst_view_totOccupancySegments, src_view_size);
-
   auto mdsOccupancy = miniDoubletsDC_->view<MiniDoubletsOccupancySoA>();
-  auto dst_view_nMDs = cms::alpakatools::make_device_view(queue_, mdsOccupancy.nMDs()[pixelModuleIndex]);
+  auto dst_view_nMDs = cms::alpakatools::make_device_view(queue_, mdsOccupancy.nMDs()[pixelModuleIndex_]);
   alpaka::memcpy(queue_, dst_view_nMDs, src_view_mdSize);
 
   auto dst_view_totOccupancyMDs =
-      cms::alpakatools::make_device_view(queue_, mdsOccupancy.totOccupancyMDs()[pixelModuleIndex]);
+      cms::alpakatools::make_device_view(queue_, mdsOccupancy.totOccupancyMDs()[pixelModuleIndex_]);
   alpaka::memcpy(queue_, dst_view_totOccupancyMDs, src_view_mdSize);
 
   alpaka::wait(queue_);  // FIXME: remove synch after inputs refactored to be in pinned memory
 
-  auto const addPixelSegmentToEvent_workdiv = cms::alpakatools::make_workdiv<Acc1D>(max_blocks, 256);
-
-  alpaka::exec<Acc1D>(queue_,
-                      addPixelSegmentToEvent_workdiv,
-                      AddPixelSegmentToEventKernel{},
-                      modules_.const_view<ModulesSoA>(),
-                      rangesDC_->const_view(),
-                      hitsDC_->view<HitsSoA>(),
-                      miniDoubletsDC_->view<MiniDoubletsSoA>(),
-                      segmentsDC_->view<SegmentsSoA>(),
-                      segmentsDC_->view<SegmentsPixelSoA>(),
-                      hitIndices0_dev.data(),
-                      hitIndices1_dev.data(),
-                      hitIndices2_dev.data(),
-                      hitIndices3_dev.data(),
-                      dPhiChange_dev.data(),
-                      pixelModuleIndex,
-                      size);
-}
-
-void LSTEvent::createMiniDoublets() {
-  // Create a view for the element nLowerModules_ inside rangesOccupancy->miniDoubletModuleOccupancy
-  auto rangesOccupancy = rangesDC_->view();
-  auto dst_view_miniDoubletModuleOccupancy =
-      cms::alpakatools::make_device_view(queue_, rangesOccupancy.miniDoubletModuleOccupancy()[nLowerModules_]);
-
-  // Create a host buffer for a value to be passed to the device
-  auto pixelMaxMDs_buf_h = cms::alpakatools::make_host_buffer<int>(queue_);
-  *pixelMaxMDs_buf_h.data() = n_max_pixel_md_per_modules;
-
-  alpaka::memcpy(queue_, dst_view_miniDoubletModuleOccupancy, pixelMaxMDs_buf_h);
-
-  auto const createMDArrayRangesGPU_workDiv = cms::alpakatools::make_workdiv<Acc1D>(1, 1024);
-
-  alpaka::exec<Acc1D>(queue_,
-                      createMDArrayRangesGPU_workDiv,
-                      CreateMDArrayRangesGPU{},
-                      modules_.const_view<ModulesSoA>(),
-                      rangesDC_->view(),
-                      ptCut_);
-
-  auto nTotalMDs_buf_h = cms::alpakatools::make_host_buffer<unsigned int>(queue_);
-  auto nTotalMDs_buf_d = cms::alpakatools::make_device_view(queue_, rangesOccupancy.nTotalMDs());
-  alpaka::memcpy(queue_, nTotalMDs_buf_h, nTotalMDs_buf_d);
-  alpaka::wait(queue_);  // wait to get the data before manipulation
-
-  *nTotalMDs_buf_h.data() += n_max_pixel_md_per_modules;
-  unsigned int nTotalMDs = *nTotalMDs_buf_h.data();
-
-  if (!miniDoubletsDC_) {
-    std::array<int, 2> const mds_sizes{{static_cast<int>(nTotalMDs), static_cast<int>(nLowerModules_ + 1)}};
-    miniDoubletsDC_.emplace(mds_sizes, queue_);
-
-    auto mdsOccupancy = miniDoubletsDC_->view<MiniDoubletsOccupancySoA>();
-    auto nMDs_view = cms::alpakatools::make_device_view(queue_, mdsOccupancy.nMDs(), mdsOccupancy.metadata().size());
-    auto totOccupancyMDs_view =
-        cms::alpakatools::make_device_view(queue_, mdsOccupancy.totOccupancyMDs(), mdsOccupancy.metadata().size());
-    alpaka::memset(queue_, nMDs_view, 0u);
-    alpaka::memset(queue_, totOccupancyMDs_view, 0u);
-  }
-
   constexpr int threadsPerBlockY = 16;
   auto const createMiniDoublets_workDiv =
       cms::alpakatools::make_workdiv<Acc2D>({nLowerModules_ / threadsPerBlockY, 1}, {threadsPerBlockY, 32});
@@ -401,9 +326,26 @@ void LSTEvent::createMiniDoublets() {
 
 void LSTEvent::createSegmentsWithModuleMap() {
   if (!segmentsDC_) {
-    std::array<int, 3> const segments_sizes{{static_cast<int>(nTotalSegments_),
-                                             static_cast<int>(nLowerModules_ + 1),
-                                             static_cast<int>(n_max_pixel_segments_per_module)}};
+    auto const createSegmentArrayRanges_workDiv = cms::alpakatools::make_workdiv<Acc1D>(1, 1024);
+
+    alpaka::exec<Acc1D>(queue_,
+                        createSegmentArrayRanges_workDiv,
+                        CreateSegmentArrayRanges{},
+                        modules_.const_view<ModulesSoA>(),
+                        rangesDC_->view(),
+                        miniDoubletsDC_->const_view<MiniDoubletsSoA>(),
+                        miniDoubletsDC_->const_view<MiniDoubletsOccupancySoA>(),
+                        ptCut_);
+
+    auto rangesOccupancy = rangesDC_->view();
+    auto nTotalSegments_view_h = cms::alpakatools::make_host_view(nTotalSegments_);
+    auto nTotalSegments_view_d = cms::alpakatools::make_device_view(queue_, rangesOccupancy.nTotalSegs());
+    alpaka::memcpy(queue_, nTotalSegments_view_h, nTotalSegments_view_d);
+    alpaka::wait(queue_);  // wait to get the value before manipulation
+
+    nTotalSegments_ += n_max_pixel_segments_per_module;
+
+    std::array<int, 2> const segments_sizes{{static_cast<int>(nTotalSegments_), static_cast<int>(nLowerModules_ + 1)}};
     segmentsDC_.emplace(segments_sizes, queue_);
 
     auto segmentsOccupancy = segmentsDC_->view<SegmentsOccupancySoA>();
@@ -413,6 +355,17 @@ void LSTEvent::createSegmentsWithModuleMap() {
         queue_, segmentsOccupancy.totOccupancySegments(), segmentsOccupancy.metadata().size());
     alpaka::memset(queue_, nSegments_view, 0u);
     alpaka::memset(queue_, totOccupancySegments_view, 0u);
+
+    auto src_view_size = cms::alpakatools::make_host_view(pixelSize_);
+
+    auto dst_view_segments =
+        cms::alpakatools::make_device_view(queue_, segmentsOccupancy.nSegments()[pixelModuleIndex_]);
+    alpaka::memcpy(queue_, dst_view_segments, src_view_size);
+
+    auto dst_view_totOccupancySegments =
+        cms::alpakatools::make_device_view(queue_, segmentsOccupancy.totOccupancySegments()[pixelModuleIndex_]);
+    alpaka::memcpy(queue_, dst_view_totOccupancySegments, src_view_size);
+    alpaka::wait(queue_);
   }
 
   auto const createSegments_workDiv = cms::alpakatools::make_workdiv<Acc3D>({nLowerModules_, 1, 1}, {1, 1, 64});
@@ -451,6 +404,7 @@ void LSTEvent::createTriplets() {
                         CreateTripletArrayRanges{},
                         modules_.const_view<ModulesSoA>(),
                         rangesDC_->view(),
+                        segmentsDC_->const_view<SegmentsSoA>(),
                         segmentsDC_->const_view<SegmentsOccupancySoA>(),
                         ptCut_);
 
@@ -566,7 +520,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets)
                       modules_.const_view<ModulesSoA>(),
                       rangesDC_->const_view(),
                       pixelTripletsDC_->view(),
-                      segmentsDC_->const_view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->const_view(),
                       pixelQuintupletsDC_->const_view());
 
   auto const addpT3asTrackCandidates_workDiv = cms::alpakatools::make_workdiv<Acc1D>(1, 512);
@@ -577,7 +531,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets)
                       nLowerModules_,
                       pixelTripletsDC_->const_view(),
                       trackCandidatesDC_->view(),
-                      segmentsDC_->const_view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->const_view(),
                       rangesDC_->const_view());
 
   // Pull nEligibleT5Modules from the device.
@@ -633,7 +587,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets)
                         CheckHitspLS{},
                         modules_.const_view<ModulesSoA>(),
                         segmentsDC_->const_view<SegmentsOccupancySoA>(),
-                        segmentsDC_->view<SegmentsPixelSoA>(),
+                        pixelSegmentsDC_->view(),
                         true);
   }
 
@@ -648,7 +602,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets)
                       trackCandidatesDC_->view(),
                       segmentsDC_->const_view<SegmentsSoA>(),
                       segmentsDC_->const_view<SegmentsOccupancySoA>(),
-                      segmentsDC_->view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->view(),
                       miniDoubletsDC_->const_view<MiniDoubletsSoA>(),
                       hitsDC_->const_view<HitsSoA>(),
                       quintupletsDC_->const_view<QuintupletsSoA>());
@@ -661,7 +615,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets)
                       nLowerModules_,
                       trackCandidatesDC_->view(),
                       segmentsDC_->const_view<SegmentsOccupancySoA>(),
-                      segmentsDC_->const_view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->const_view(),
                       tc_pls_triplets);
 
   // Check if either n_max_pixel_track_candidates or n_max_nonpixel_track_candidates was reached
@@ -709,18 +663,18 @@ void LSTEvent::createPixelTriplets() {
     alpaka::memset(queue_, totOccupancyPixelTriplets_view, 0u);
   }
   SegmentsOccupancy segmentsOccupancy = segmentsDC_->view<SegmentsOccupancySoA>();
-  SegmentsPixelConst segmentsPixel = segmentsDC_->view<SegmentsPixelSoA>();
+  PixelSegmentsConst pixelSegments = pixelSegmentsDC_->view();
 
   auto superbins_buf = cms::alpakatools::make_host_buffer<int[]>(queue_, n_max_pixel_segments_per_module);
   auto pixelTypes_buf = cms::alpakatools::make_host_buffer<PixelType[]>(queue_, n_max_pixel_segments_per_module);
 
   alpaka::memcpy(queue_,
                  superbins_buf,
-                 cms::alpakatools::make_device_view(queue_, segmentsPixel.superbin(), n_max_pixel_segments_per_module));
+                 cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), n_max_pixel_segments_per_module));
   alpaka::memcpy(
       queue_,
       pixelTypes_buf,
-      cms::alpakatools::make_device_view(queue_, segmentsPixel.pixelType(), n_max_pixel_segments_per_module));
+      cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), n_max_pixel_segments_per_module));
   auto const* superbins = superbins_buf.data();
   auto const* pixelTypes = pixelTypes_buf.data();
 
@@ -798,7 +752,7 @@ void LSTEvent::createPixelTriplets() {
                       rangesDC_->const_view(),
                       miniDoubletsDC_->const_view<MiniDoubletsSoA>(),
                       segmentsDC_->const_view<SegmentsSoA>(),
-                      segmentsDC_->const_view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->const_view(),
                       tripletsDC_->view<TripletsSoA>(),
                       tripletsDC_->const_view<TripletsOccupancySoA>(),
                       pixelTripletsDC_->view(),
@@ -834,6 +788,7 @@ void LSTEvent::createQuintuplets() {
                       modules_.const_view<ModulesSoA>(),
                       tripletsDC_->const_view<TripletsOccupancySoA>(),
                       rangesDC_->view(),
+                      tripletsDC_->view<TripletsSoA>(),
                       ptCut_);
 
   auto nEligibleT5Modules_buf = cms::alpakatools::make_host_buffer<uint16_t>(queue_);
@@ -920,7 +875,7 @@ void LSTEvent::pixelLineSegmentCleaning(bool no_pls_dupclean) {
                         CheckHitspLS{},
                         modules_.const_view<ModulesSoA>(),
                         segmentsDC_->const_view<SegmentsOccupancySoA>(),
-                        segmentsDC_->view<SegmentsPixelSoA>(),
+                        pixelSegmentsDC_->view(),
                         false);
   }
 }
@@ -941,18 +896,18 @@ void LSTEvent::createPixelQuintuplets() {
     alpaka::memset(queue_, buf, 0u);
   }
   SegmentsOccupancy segmentsOccupancy = segmentsDC_->view<SegmentsOccupancySoA>();
-  SegmentsPixelConst segmentsPixel = segmentsDC_->view<SegmentsPixelSoA>();
+  PixelSegmentsConst pixelSegments = pixelSegmentsDC_->view();
 
   auto superbins_buf = cms::alpakatools::make_host_buffer<int[]>(queue_, n_max_pixel_segments_per_module);
   auto pixelTypes_buf = cms::alpakatools::make_host_buffer<PixelType[]>(queue_, n_max_pixel_segments_per_module);
 
   alpaka::memcpy(queue_,
                  superbins_buf,
-                 cms::alpakatools::make_device_view(queue_, segmentsPixel.superbin(), n_max_pixel_segments_per_module));
+                 cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), n_max_pixel_segments_per_module));
   alpaka::memcpy(
       queue_,
       pixelTypes_buf,
-      cms::alpakatools::make_device_view(queue_, segmentsPixel.pixelType(), n_max_pixel_segments_per_module));
+      cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), n_max_pixel_segments_per_module));
   auto const* superbins = superbins_buf.data();
   auto const* pixelTypes = pixelTypes_buf.data();
 
@@ -1030,7 +985,7 @@ void LSTEvent::createPixelQuintuplets() {
                       modules_.const_view<ModulesPixelSoA>(),
                       miniDoubletsDC_->const_view<MiniDoubletsSoA>(),
                       segmentsDC_->const_view<SegmentsSoA>(),
-                      segmentsDC_->view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->view(),
                       tripletsDC_->view<TripletsSoA>(),
                       quintupletsDC_->view<QuintupletsSoA>(),
                       quintupletsDC_->const_view<QuintupletsOccupancySoA>(),
@@ -1057,7 +1012,7 @@ void LSTEvent::createPixelQuintuplets() {
                       nLowerModules_,
                       pixelQuintupletsDC_->const_view(),
                       trackCandidatesDC_->view(),
-                      segmentsDC_->const_view<SegmentsPixelSoA>(),
+                      pixelSegmentsDC_->const_view(),
                       rangesDC_->const_view());
 
 #ifdef WARNINGS
@@ -1473,9 +1428,8 @@ typename TSoA::ConstView LSTEvent::getSegments(bool sync) {
   } else {
     if (!segmentsHC_) {
       segmentsHC_.emplace(
-          cms::alpakatools::
-              CopyToHost<PortableMultiCollection<TDev, SegmentsSoA, SegmentsOccupancySoA, SegmentsPixelSoA>>::copyAsync(
-                  queue_, *segmentsDC_));
+          cms::alpakatools::CopyToHost<PortableMultiCollection<TDev, SegmentsSoA, SegmentsOccupancySoA>>::copyAsync(
+              queue_, *segmentsDC_));
       if (sync)
         alpaka::wait(queue_);  // host consumers expect filled data
     }
@@ -1484,7 +1438,23 @@ typename TSoA::ConstView LSTEvent::getSegments(bool sync) {
 }
 template SegmentsConst LSTEvent::getSegments<SegmentsSoA>(bool);
 template SegmentsOccupancyConst LSTEvent::getSegments<SegmentsOccupancySoA>(bool);
-template SegmentsPixelConst LSTEvent::getSegments<SegmentsPixelSoA>(bool);
+
+template <typename TDev>
+PixelSegmentsConst LSTEvent::getPixelSegments(bool sync) {
+  if constexpr (std::is_same_v<TDev, DevHost>) {
+    return pixelSegmentsDC_->const_view();
+  } else {
+    if (!pixelSegmentsHC_) {
+      pixelSegmentsHC_.emplace(cms::alpakatools::CopyToHost<::PortableCollection<PixelSegmentsSoA, TDev>>::copyAsync(
+          queue_, *pixelSegmentsDC_));
+
+      if (sync)
+        alpaka::wait(queue_);  // host consumers expect filled data
+    }
+  }
+  return pixelSegmentsHC_->const_view();
+}
+template PixelSegmentsConst LSTEvent::getPixelSegments<>(bool);
 
 template <typename TSoA, typename TDev>
 typename TSoA::ConstView LSTEvent::getTriplets(bool sync) {
diff --git a/RecoTracker/LSTCore/src/alpaka/LSTEvent.h b/RecoTracker/LSTCore/src/alpaka/LSTEvent.h
index 7b36c011265a8..11ec7a9d53fa3 100644
--- a/RecoTracker/LSTCore/src/alpaka/LSTEvent.h
+++ b/RecoTracker/LSTCore/src/alpaka/LSTEvent.h
@@ -9,6 +9,7 @@
 #include "RecoTracker/LSTCore/interface/PixelTripletsHostCollection.h"
 #include "RecoTracker/LSTCore/interface/QuintupletsHostCollection.h"
 #include "RecoTracker/LSTCore/interface/SegmentsHostCollection.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsHostCollection.h"
 #include "RecoTracker/LSTCore/interface/TrackCandidatesHostCollection.h"
 #include "RecoTracker/LSTCore/interface/TripletsHostCollection.h"
 #include "RecoTracker/LSTCore/interface/ObjectRangesHostCollection.h"
@@ -21,6 +22,7 @@
 #include "RecoTracker/LSTCore/interface/alpaka/PixelTripletsDeviceCollection.h"
 #include "RecoTracker/LSTCore/interface/alpaka/QuintupletsDeviceCollection.h"
 #include "RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h"
+#include "RecoTracker/LSTCore/interface/alpaka/PixelSegmentsDeviceCollection.h"
 #include "RecoTracker/LSTCore/interface/alpaka/TrackCandidatesDeviceCollection.h"
 #include "RecoTracker/LSTCore/interface/alpaka/TripletsDeviceCollection.h"
 #include "RecoTracker/LSTCore/interface/alpaka/ModulesDeviceCollection.h"
@@ -45,12 +47,15 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     std::array<unsigned int, 6> n_quintuplets_by_layer_barrel_{};
     std::array<unsigned int, 5> n_quintuplets_by_layer_endcap_{};
     unsigned int nTotalSegments_;
+    unsigned int pixelSize_;
+    uint16_t pixelModuleIndex_;
 
     //Device stuff
     std::optional<ObjectRangesDeviceCollection> rangesDC_;
     std::optional<HitsDeviceCollection> hitsDC_;
     std::optional<MiniDoubletsDeviceCollection> miniDoubletsDC_;
     std::optional<SegmentsDeviceCollection> segmentsDC_;
+    std::optional<PixelSegmentsDeviceCollection> pixelSegmentsDC_;
     std::optional<TripletsDeviceCollection> tripletsDC_;
     std::optional<QuintupletsDeviceCollection> quintupletsDC_;
     std::optional<TrackCandidatesDeviceCollection> trackCandidatesDC_;
@@ -62,6 +67,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     std::optional<HitsHostCollection> hitsHC_;
     std::optional<MiniDoubletsHostCollection> miniDoubletsHC_;
     std::optional<SegmentsHostCollection> segmentsHC_;
+    std::optional<PixelSegmentsHostCollection> pixelSegmentsHC_;
     std::optional<TripletsHostCollection> tripletsHC_;
     std::optional<TrackCandidatesHostCollection> trackCandidatesHC_;
     std::optional<ModulesHostCollection> modulesHC_;
@@ -106,26 +112,26 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                        std::vector<float> const& z,
                        std::vector<unsigned int> const& detId,
                        std::vector<unsigned int> const& idxInNtuple);
-    void addPixelSegmentToEvent(std::vector<unsigned int> const& hitIndices0,
-                                std::vector<unsigned int> const& hitIndices1,
-                                std::vector<unsigned int> const& hitIndices2,
-                                std::vector<unsigned int> const& hitIndices3,
-                                std::vector<float> const& dPhiChange,
-                                std::vector<float> const& ptIn,
-                                std::vector<float> const& ptErr,
-                                std::vector<float> const& px,
-                                std::vector<float> const& py,
-                                std::vector<float> const& pz,
-                                std::vector<float> const& eta,
-                                std::vector<float> const& etaErr,
-                                std::vector<float> const& phi,
-                                std::vector<int> const& charge,
-                                std::vector<unsigned int> const& seedIdx,
-                                std::vector<int> const& superbin,
-                                std::vector<PixelType> const& pixelType,
-                                std::vector<char> const& isQuad);
+    void addPixelSegmentToEventStart(std::vector<float> const& ptIn,
+                                     std::vector<float> const& ptErr,
+                                     std::vector<float> const& px,
+                                     std::vector<float> const& py,
+                                     std::vector<float> const& pz,
+                                     std::vector<float> const& eta,
+                                     std::vector<float> const& etaErr,
+                                     std::vector<float> const& phi,
+                                     std::vector<int> const& charge,
+                                     std::vector<unsigned int> const& seedIdx,
+                                     std::vector<int> const& superbin,
+                                     std::vector<PixelType> const& pixelType,
+                                     std::vector<char> const& isQuad);
 
     void createMiniDoublets();
+    void addPixelSegmentToEventFinalize(std::vector<unsigned int> hitIndices0,
+                                        std::vector<unsigned int> hitIndices1,
+                                        std::vector<unsigned int> hitIndices2,
+                                        std::vector<unsigned int> hitIndices3,
+                                        std::vector<float> deltaPhi_vec);
     void createSegmentsWithModuleMap();
     void createTriplets();
     void createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets);
@@ -186,6 +192,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     template <typename TDev = Device>
     PixelTripletsConst getPixelTriplets(bool sync = true);
     template <typename TDev = Device>
+    PixelSegmentsConst getPixelSegments(bool sync = true);
+    template <typename TDev = Device>
     PixelQuintupletsConst getPixelQuintuplets(bool sync = true);
     const TrackCandidatesConst& getTrackCandidates(bool inCMSSW = false, bool sync = true);
     template <typename TSoA, typename TDev = Device>
diff --git a/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h b/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h
index 1e6edecf51f26..4e30e14b1c435 100644
--- a/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h
+++ b/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h
@@ -800,7 +800,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
   }
 
   struct CreateMDArrayRangesGPU {
-    ALPAKA_FN_ACC void operator()(Acc1D const& acc, ModulesConst modules, ObjectRanges ranges, const float ptCut) const {
+    ALPAKA_FN_ACC void operator()(Acc1D const& acc,
+                                  ModulesConst modules,
+                                  HitsRangesConst hitsRanges,
+                                  ObjectRanges ranges,
+                                  const float ptCut) const {
       // implementation is 1D with a single block
       ALPAKA_ASSERT_ACC((alpaka::getWorkDiv<alpaka::Grid, alpaka::Blocks>(acc)[0] == 1));
 
@@ -831,24 +835,28 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
       const auto& occupancy_matrix = (ptCut < 0.8f) ? p06_occupancy_matrix : p08_occupancy_matrix;
 
       for (uint16_t i : cms::alpakatools::uniform_elements(acc, modules.nLowerModules())) {
-        short module_rings = modules.rings()[i];
+        const int nLower = hitsRanges.hitRangesnLower()[i];
+        const int nUpper = hitsRanges.hitRangesnUpper()[i];
+        const int dynamicMDs = nLower * nUpper;
+
+        // Matrix-based cap
         short module_layers = modules.layers()[i];
         short module_subdets = modules.subdets()[i];
+        short module_rings = modules.rings()[i];
         float module_eta = alpaka::math::abs(acc, modules.eta()[i]);
 
         int category_number = getCategoryNumber(module_layers, module_subdets, module_rings);
         int eta_number = getEtaBin(module_eta);
 
-        int occupancy = 0;
-        if (category_number != -1 && eta_number != -1) {
-          occupancy = occupancy_matrix[category_number][eta_number];
-        }
 #ifdef WARNINGS
-        else {
+        if (category_number == -1 || eta_number == -1) {
           printf("Unhandled case in createMDArrayRangesGPU! Module index = %i\n", i);
         }
 #endif
 
+        int occupancy = (category_number != -1 && eta_number != -1)
+                            ? alpaka::math::min(acc, dynamicMDs, occupancy_matrix[category_number][eta_number])
+                            : 0;
         unsigned int nTotMDs = alpaka::atomicAdd(acc, &nTotalMDs, occupancy, alpaka::hierarchy::Threads{});
 
         ranges.miniDoubletModuleIndices()[i] = nTotMDs;
diff --git a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h
index 9b38844828129..c6c88b31a5fce 100644
--- a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h
+++ b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h
@@ -7,6 +7,7 @@
 #include "RecoTracker/LSTCore/interface/ObjectRangesSoA.h"
 #include "RecoTracker/LSTCore/interface/MiniDoubletsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelTripletsSoA.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/QuintupletsSoA.h"
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/TripletsSoA.h"
@@ -469,7 +470,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                     ObjectRangesConst ranges,
                                                                     MiniDoubletsConst mds,
                                                                     SegmentsConst segments,
-                                                                    SegmentsPixelConst segmentsPixel,
+                                                                    PixelSegmentsConst pixelSegments,
                                                                     TripletsConst triplets,
                                                                     QuintupletsConst quintuplets,
                                                                     unsigned int pixelSegmentIndex,
@@ -494,7 +495,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                        ranges,
                                        mds,
                                        segments,
-                                       segmentsPixel,
+                                       pixelSegments,
                                        triplets,
                                        pixelSegmentIndex,
                                        t5InnerT3Index,
@@ -546,16 +547,16 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                      mds.anchorRt()[fourthMDIndex],
                                      mds.anchorRt()[fifthMDIndex]};
 
-    float pixelSegmentPt = segmentsPixel.ptIn()[pixelSegmentArrayIndex];
-    float pixelSegmentPx = segmentsPixel.px()[pixelSegmentArrayIndex];
-    float pixelSegmentPy = segmentsPixel.py()[pixelSegmentArrayIndex];
-    float pixelSegmentPz = segmentsPixel.pz()[pixelSegmentArrayIndex];
-    int pixelSegmentCharge = segmentsPixel.charge()[pixelSegmentArrayIndex];
+    float pixelSegmentPt = pixelSegments.ptIn()[pixelSegmentArrayIndex];
+    float pixelSegmentPx = pixelSegments.px()[pixelSegmentArrayIndex];
+    float pixelSegmentPy = pixelSegments.py()[pixelSegmentArrayIndex];
+    float pixelSegmentPz = pixelSegments.pz()[pixelSegmentArrayIndex];
+    int pixelSegmentCharge = pixelSegments.charge()[pixelSegmentArrayIndex];
 
     rzChiSquared = 0;
 
     //get the appropriate centers
-    pixelRadius = segmentsPixel.circleRadius()[pixelSegmentArrayIndex];
+    pixelRadius = pixelSegments.circleRadius()[pixelSegmentArrayIndex];
 
     if (pixelRadius < 5.0f * kR1GeVf) {  //only apply r-z chi2 cuts for <5GeV tracks
       rzChiSquared = computePT5RZChiSquared(acc,
@@ -595,8 +596,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                     mds.anchorY()[fifthMDIndex]};
 
     //get the appropriate centers
-    centerX = segmentsPixel.circleCenterX()[pixelSegmentArrayIndex];
-    centerY = segmentsPixel.circleCenterY()[pixelSegmentArrayIndex];
+    centerX = pixelSegments.circleCenterX()[pixelSegmentArrayIndex];
+    centerY = pixelSegments.circleCenterY()[pixelSegmentArrayIndex];
 
     float T5CenterX = quintuplets.regressionCenterX()[quintupletIndex];
     float T5CenterY = quintuplets.regressionCenterY()[quintupletIndex];
@@ -640,7 +641,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   ModulesPixelConst modulesPixel,
                                   MiniDoubletsConst mds,
                                   SegmentsConst segments,
-                                  SegmentsPixel segmentsPixel,
+                                  PixelSegments pixelSegments,
                                   Triplets triplets,
                                   Quintuplets quintuplets,
                                   QuintupletsOccupancyConst quintupletsOccupancy,
@@ -661,7 +662,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
           if (modules.moduleType()[quintupletLowerModuleIndex] == TwoS)
             continue;
           uint16_t pixelModuleIndex = modules.nLowerModules();
-          if (segmentsPixel.isDup()[i_pLS])
+          if (pixelSegments.isDup()[i_pLS])
             continue;
           unsigned int nOuterQuintuplets = quintupletsOccupancy.nQuintuplets()[quintupletLowerModuleIndex];
 
@@ -685,7 +686,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                          ranges,
                                                          mds,
                                                          segments,
-                                                         segmentsPixel,
+                                                         pixelSegments,
                                                          triplets,
                                                          quintuplets,
                                                          pixelSegmentIndex,
@@ -733,7 +734,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
                 triplets.partOfPT5()[quintuplets.tripletIndices()[quintupletIndex][0]] = true;
                 triplets.partOfPT5()[quintuplets.tripletIndices()[quintupletIndex][1]] = true;
-                segmentsPixel.partOfPT5()[i_pLS] = true;
+                pixelSegments.partOfPT5()[i_pLS] = true;
                 quintuplets.partOfPT5()[quintupletIndex] = true;
               }  // tot occupancy
             }  // end success
diff --git a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h
index a0d186a052252..571bfd4270547 100644
--- a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h
+++ b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h
@@ -6,6 +6,7 @@
 #include "RecoTracker/LSTCore/interface/ObjectRangesSoA.h"
 #include "RecoTracker/LSTCore/interface/MiniDoubletsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelTripletsSoA.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/QuintupletsSoA.h"
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/TripletsSoA.h"
@@ -20,7 +21,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                 ObjectRangesConst ranges,
                                                                 MiniDoubletsConst mds,
                                                                 SegmentsConst segments,
-                                                                SegmentsPixelConst segmentsPixel,
+                                                                PixelSegmentsConst pixelSegments,
                                                                 uint16_t pixelModuleIndex,
                                                                 uint16_t outerInnerLowerModuleIndex,
                                                                 uint16_t outerOuterLowerModuleIndex,
@@ -37,7 +38,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                 ObjectRangesConst ranges,
                                                                 MiniDoubletsConst mds,
                                                                 SegmentsConst segments,
-                                                                SegmentsPixelConst segmentsPixel,
+                                                                PixelSegmentsConst pixelSegments,
                                                                 uint16_t pixelModuleIndex,
                                                                 uint16_t outerInnerLowerModuleIndex,
                                                                 uint16_t outerOuterLowerModuleIndex,
@@ -120,7 +121,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                      ObjectRangesConst ranges,
                                                                      MiniDoubletsConst mds,
                                                                      SegmentsConst segments,
-                                                                     SegmentsPixelConst segmentsPixel,
+                                                                     PixelSegmentsConst pixelSegments,
                                                                      uint16_t pixelLowerModuleIndex,
                                                                      uint16_t outerInnerLowerModuleIndex,
                                                                      uint16_t outerOuterLowerModuleIndex,
@@ -143,7 +144,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                        ranges,
                                        mds,
                                        segments,
-                                       segmentsPixel,
+                                       pixelSegments,
                                        pixelLowerModuleIndex,
                                        outerInnerLowerModuleIndex,
                                        outerOuterLowerModuleIndex,
@@ -160,7 +161,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                        ranges,
                                        mds,
                                        segments,
-                                       segmentsPixel,
+                                       pixelSegments,
                                        pixelLowerModuleIndex,
                                        outerInnerLowerModuleIndex,
                                        outerOuterLowerModuleIndex,
@@ -633,7 +634,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                  ObjectRangesConst ranges,
                                                                  MiniDoubletsConst mds,
                                                                  SegmentsConst segments,
-                                                                 SegmentsPixelConst segmentsPixel,
+                                                                 PixelSegmentsConst pixelSegments,
                                                                  TripletsConst triplets,
                                                                  unsigned int pixelSegmentIndex,
                                                                  unsigned int tripletIndex,
@@ -660,7 +661,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                              ranges,
                                              mds,
                                              segments,
-                                             segmentsPixel,
+                                             pixelSegments,
                                              pixelModuleIndex,
                                              lowerModuleIndex,
                                              middleModuleIndex,
@@ -675,7 +676,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                              ranges,
                                              mds,
                                              segments,
-                                             segmentsPixel,
+                                             pixelSegments,
                                              pixelModuleIndex,
                                              middleModuleIndex,
                                              upperModuleIndex,
@@ -687,16 +688,16 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
     //pt matching between the pixel ptin and the triplet circle pt
     unsigned int pixelSegmentArrayIndex = pixelSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex];
-    float pixelSegmentPt = segmentsPixel.ptIn()[pixelSegmentArrayIndex];
-    float pixelSegmentPtError = segmentsPixel.ptErr()[pixelSegmentArrayIndex];
-    float pixelSegmentPx = segmentsPixel.px()[pixelSegmentArrayIndex];
-    float pixelSegmentPy = segmentsPixel.py()[pixelSegmentArrayIndex];
-    float pixelSegmentPz = segmentsPixel.pz()[pixelSegmentArrayIndex];
-    int pixelSegmentCharge = segmentsPixel.charge()[pixelSegmentArrayIndex];
+    float pixelSegmentPt = pixelSegments.ptIn()[pixelSegmentArrayIndex];
+    float pixelSegmentPtError = pixelSegments.ptErr()[pixelSegmentArrayIndex];
+    float pixelSegmentPx = pixelSegments.px()[pixelSegmentArrayIndex];
+    float pixelSegmentPy = pixelSegments.py()[pixelSegmentArrayIndex];
+    float pixelSegmentPz = pixelSegments.pz()[pixelSegmentArrayIndex];
+    int pixelSegmentCharge = pixelSegments.charge()[pixelSegmentArrayIndex];
 
-    float pixelG = segmentsPixel.circleCenterX()[pixelSegmentArrayIndex];
-    float pixelF = segmentsPixel.circleCenterY()[pixelSegmentArrayIndex];
-    float pixelRadiusPCA = segmentsPixel.circleRadius()[pixelSegmentArrayIndex];
+    float pixelG = pixelSegments.circleCenterX()[pixelSegmentArrayIndex];
+    float pixelF = pixelSegments.circleCenterY()[pixelSegmentArrayIndex];
+    float pixelRadiusPCA = pixelSegments.circleRadius()[pixelSegmentArrayIndex];
 
     unsigned int pixelInnerMDIndex = segments.mdIndices()[pixelSegmentIndex][0];
     unsigned int pixelOuterMDIndex = segments.mdIndices()[pixelSegmentIndex][1];
@@ -792,7 +793,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   ObjectRangesConst ranges,
                                   MiniDoubletsConst mds,
                                   SegmentsConst segments,
-                                  SegmentsPixelConst segmentsPixel,
+                                  PixelSegmentsConst pixelSegments,
                                   Triplets triplets,
                                   TripletsOccupancyConst tripletsOccupancy,
                                   PixelTriplets pixelTriplets,
@@ -827,9 +828,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
           unsigned int pixelSegmentIndex = ranges.segmentModuleIndices()[pixelModuleIndex] + i_pLS;
 
-          if (segmentsPixel.isDup()[i_pLS])
+          if (pixelSegments.isDup()[i_pLS])
             continue;
-          if (segmentsPixel.partOfPT5()[i_pLS])
+          if (pixelSegments.partOfPT5()[i_pLS])
             continue;  //don't make pT3s for those pixels that are part of pT5
 
           short layer2_adjustment;
@@ -859,7 +860,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                       ranges,
                                                       mds,
                                                       segments,
-                                                      segmentsPixel,
+                                                      pixelSegments,
                                                       triplets,
                                                       pixelSegmentIndex,
                                                       outerTripletIndex,
@@ -879,9 +880,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
               float eta =
                   mds.anchorEta()[segments
                                       .mdIndices()[triplets.segmentIndices()[outerTripletIndex][0]][layer2_adjustment]];
-              float eta_pix = segmentsPixel.eta()[i_pLS];
-              float phi_pix = segmentsPixel.phi()[i_pLS];
-              float pt = segmentsPixel.ptIn()[i_pLS];
+              float eta_pix = pixelSegments.eta()[i_pLS];
+              float phi_pix = pixelSegments.phi()[i_pLS];
+              float pt = pixelSegments.ptIn()[i_pLS];
               float score = rPhiChiSquared + rPhiChiSquaredInwards;
               unsigned int totOccupancyPixelTriplets =
                   alpaka::atomicAdd(acc, &pixelTriplets.totOccupancyPixelTriplets(), 1u, alpaka::hierarchy::Threads{});
@@ -927,7 +928,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                 ObjectRangesConst ranges,
                                                                 MiniDoubletsConst mds,
                                                                 SegmentsConst segments,
-                                                                SegmentsPixelConst segmentsPixel,
+                                                                PixelSegmentsConst pixelSegments,
                                                                 uint16_t pixelModuleIndex,
                                                                 uint16_t outerInnerLowerModuleIndex,
                                                                 uint16_t outerOuterLowerModuleIndex,
@@ -966,13 +967,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
       return false;
 
     unsigned int pixelSegmentArrayIndex = innerSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex];
-    float ptIn = segmentsPixel.ptIn()[pixelSegmentArrayIndex];
+    float ptIn = pixelSegments.ptIn()[pixelSegmentArrayIndex];
     float ptSLo = ptIn;
-    float px = segmentsPixel.px()[pixelSegmentArrayIndex];
-    float py = segmentsPixel.py()[pixelSegmentArrayIndex];
-    float pz = segmentsPixel.pz()[pixelSegmentArrayIndex];
-    float ptErr = segmentsPixel.ptErr()[pixelSegmentArrayIndex];
-    float etaErr = segmentsPixel.etaErr()[pixelSegmentArrayIndex];
+    float px = pixelSegments.px()[pixelSegmentArrayIndex];
+    float py = pixelSegments.py()[pixelSegmentArrayIndex];
+    float pz = pixelSegments.pz()[pixelSegmentArrayIndex];
+    float ptErr = pixelSegments.ptErr()[pixelSegmentArrayIndex];
+    float etaErr = pixelSegments.etaErr()[pixelSegmentArrayIndex];
     ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo));
     ptSLo = alpaka::math::min(acc, 10.0f, ptSLo);
 
@@ -1186,7 +1187,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                                                 ObjectRangesConst ranges,
                                                                 MiniDoubletsConst mds,
                                                                 SegmentsConst segments,
-                                                                SegmentsPixelConst segmentsPixel,
+                                                                PixelSegmentsConst pixelSegments,
                                                                 uint16_t pixelModuleIndex,
                                                                 uint16_t outerInnerLowerModuleIndex,
                                                                 uint16_t outerOuterLowerModuleIndex,
@@ -1224,13 +1225,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
     unsigned int pixelSegmentArrayIndex = innerSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex];
 
-    float ptIn = segmentsPixel.ptIn()[pixelSegmentArrayIndex];
+    float ptIn = pixelSegments.ptIn()[pixelSegmentArrayIndex];
     float ptSLo = ptIn;
-    float px = segmentsPixel.px()[pixelSegmentArrayIndex];
-    float py = segmentsPixel.py()[pixelSegmentArrayIndex];
-    float pz = segmentsPixel.pz()[pixelSegmentArrayIndex];
-    float ptErr = segmentsPixel.ptErr()[pixelSegmentArrayIndex];
-    float etaErr = segmentsPixel.etaErr()[pixelSegmentArrayIndex];
+    float px = pixelSegments.px()[pixelSegmentArrayIndex];
+    float py = pixelSegments.py()[pixelSegmentArrayIndex];
+    float pz = pixelSegments.pz()[pixelSegmentArrayIndex];
+    float ptErr = pixelSegments.ptErr()[pixelSegmentArrayIndex];
+    float etaErr = pixelSegments.etaErr()[pixelSegmentArrayIndex];
 
     ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo));
     ptSLo = alpaka::math::min(acc, 10.0f, ptSLo);
diff --git a/RecoTracker/LSTCore/src/alpaka/Quintuplet.h b/RecoTracker/LSTCore/src/alpaka/Quintuplet.h
index e06dcdf7bd626..d411e5ba9e84c 100644
--- a/RecoTracker/LSTCore/src/alpaka/Quintuplet.h
+++ b/RecoTracker/LSTCore/src/alpaka/Quintuplet.h
@@ -1794,6 +1794,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   ModulesConst modules,
                                   TripletsOccupancyConst tripletsOccupancy,
                                   ObjectRanges ranges,
+                                  Triplets triplets,
                                   const float ptCut) const {
       // implementation is 1D with a single block
       ALPAKA_ASSERT_ACC((alpaka::getWorkDiv<alpaka::Grid, alpaka::Blocks>(acc)[0] == 1));
@@ -1836,27 +1837,43 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
         if (tripletsOccupancy.nTriplets()[i] == 0)
           continue;
-        if (module_subdets == Barrel and module_layers >= 3)
+        if (module_subdets == Barrel && module_layers >= 3)
           continue;
-        if (module_subdets == Endcap and module_layers > 1)
+        if (module_subdets == Endcap && module_layers > 1)
           continue;
 
-        int nEligibleT5Modules = alpaka::atomicAdd(acc, &nEligibleT5Modulesx, 1, alpaka::hierarchy::Threads{});
+        int dynamic_count = 0;
+
+        // How many triplets are in module i?
+        int nTriplets_i = tripletsOccupancy.nTriplets()[i];
+        int firstTripletIdx = ranges.tripletModuleIndices()[i];
+
+        // Loop over all triplets that live in module i
+        for (int t = 0; t < nTriplets_i; t++) {
+          int tripletIndex = firstTripletIdx + t;
+          uint16_t outerModule = triplets.lowerModuleIndices()[tripletIndex][2];
+          dynamic_count += tripletsOccupancy.nTriplets()[outerModule];
+        }
 
         int category_number = getCategoryNumber(module_layers, module_subdets, module_rings);
         int eta_number = getEtaBin(module_eta);
 
-        int occupancy = 0;
-        if (category_number != -1 && eta_number != -1) {
-          occupancy = occupancy_matrix[category_number][eta_number];
-        }
 #ifdef WARNINGS
-        else {
+        if (category_number == -1 || eta_number == -1) {
           printf("Unhandled case in createEligibleModulesListForQuintupletsGPU! Module index = %i\n", i);
         }
 #endif
 
+        // Get matrix-based cap (use dynamic_count as fallback)
+        int matrix_cap =
+            (category_number != -1 && eta_number != -1) ? occupancy_matrix[category_number][eta_number] : 0;
+
+        // Cap occupancy at minimum of dynamic count and matrix value
+        int occupancy = alpaka::math::min(acc, dynamic_count, matrix_cap);
+
+        int nEligibleT5Modules = alpaka::atomicAdd(acc, &nEligibleT5Modulesx, 1, alpaka::hierarchy::Threads{});
         int nTotQ = alpaka::atomicAdd(acc, &nTotalQuintupletsx, occupancy, alpaka::hierarchy::Threads{});
+
         ranges.quintupletModuleIndices()[i] = nTotQ;
         ranges.indicesOfEligibleT5Modules()[nEligibleT5Modules] = i;
         ranges.quintupletModuleOccupancy()[i] = occupancy;
diff --git a/RecoTracker/LSTCore/src/alpaka/Segment.h b/RecoTracker/LSTCore/src/alpaka/Segment.h
index ccd1a7f5994ea..3e70bf4dbe569 100644
--- a/RecoTracker/LSTCore/src/alpaka/Segment.h
+++ b/RecoTracker/LSTCore/src/alpaka/Segment.h
@@ -8,6 +8,7 @@
 #include "RecoTracker/LSTCore/interface/alpaka/Common.h"
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/alpaka/SegmentsDeviceCollection.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/ModulesSoA.h"
 #include "RecoTracker/LSTCore/interface/HitsSoA.h"
 #include "RecoTracker/LSTCore/interface/MiniDoubletsSoA.h"
@@ -207,7 +208,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
   template <typename TAcc>
   ALPAKA_FN_ACC ALPAKA_FN_INLINE void addPixelSegmentToMemory(TAcc const& acc,
                                                               Segments segments,
-                                                              SegmentsPixel segmentsPixel,
+                                                              PixelSegments pixelSegments,
                                                               MiniDoubletsConst mds,
                                                               unsigned int innerMDIndex,
                                                               unsigned int outerMDIndex,
@@ -227,13 +228,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     segments.outerMiniDoubletAnchorHitIndices()[idx] = outerAnchorHitIndex;
     segments.dPhiChanges()[idx] = __F2H(dPhiChange);
 
-    segmentsPixel.isDup()[pixelSegmentArrayIndex] = false;
-    segmentsPixel.partOfPT5()[pixelSegmentArrayIndex] = false;
-    segmentsPixel.score()[pixelSegmentArrayIndex] = score;
-    segmentsPixel.pLSHitsIdxs()[pixelSegmentArrayIndex].x = hitIdxs[0];
-    segmentsPixel.pLSHitsIdxs()[pixelSegmentArrayIndex].y = hitIdxs[1];
-    segmentsPixel.pLSHitsIdxs()[pixelSegmentArrayIndex].z = hitIdxs[2];
-    segmentsPixel.pLSHitsIdxs()[pixelSegmentArrayIndex].w = hitIdxs[3];
+    pixelSegments.isDup()[pixelSegmentArrayIndex] = false;
+    pixelSegments.partOfPT5()[pixelSegmentArrayIndex] = false;
+    pixelSegments.score()[pixelSegmentArrayIndex] = score;
+    pixelSegments.pLSHitsIdxs()[pixelSegmentArrayIndex].x = hitIdxs[0];
+    pixelSegments.pLSHitsIdxs()[pixelSegmentArrayIndex].y = hitIdxs[1];
+    pixelSegments.pLSHitsIdxs()[pixelSegmentArrayIndex].z = hitIdxs[2];
+    pixelSegments.pLSHitsIdxs()[pixelSegmentArrayIndex].w = hitIdxs[3];
 
     //computing circle parameters
     /*
@@ -263,9 +264,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         bestIndex = i;
       }
     }
-    segmentsPixel.circleCenterX()[pixelSegmentArrayIndex] = candidateCenterXs[bestIndex];
-    segmentsPixel.circleCenterY()[pixelSegmentArrayIndex] = candidateCenterYs[bestIndex];
-    segmentsPixel.circleRadius()[pixelSegmentArrayIndex] = circleRadius;
+    pixelSegments.circleCenterX()[pixelSegmentArrayIndex] = candidateCenterXs[bestIndex];
+    pixelSegments.circleCenterY()[pixelSegmentArrayIndex] = candidateCenterYs[bestIndex];
+    pixelSegments.circleRadius()[pixelSegmentArrayIndex] = circleRadius;
   }
 
   template <typename TAcc>
@@ -621,8 +622,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
   };
 
   struct CreateSegmentArrayRanges {
-    ALPAKA_FN_ACC void operator()(
-        Acc1D const& acc, ModulesConst modules, ObjectRanges ranges, MiniDoubletsConst mds, const float ptCut) const {
+    ALPAKA_FN_ACC void operator()(Acc1D const& acc,
+                                  ModulesConst modules,
+                                  ObjectRanges ranges,
+                                  MiniDoubletsConst mds,
+                                  MiniDoubletsOccupancyConst mdsOccupancy,
+                                  const float ptCut) const {
       // implementation is 1D with a single block
       ALPAKA_ASSERT_ACC((alpaka::getWorkDiv<alpaka::Grid, alpaka::Blocks>(acc)[0] == 1));
 
@@ -667,15 +672,25 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         int category_number = getCategoryNumber(module_layers, module_subdets, module_rings);
         int eta_number = getEtaBin(module_eta);
 
-        int occupancy = 0;
-        if (category_number != -1 && eta_number != -1) {
-          occupancy = occupancy_matrix[category_number][eta_number];
+        int dynamic_count = 0;
+        // Calculate dynamic limit based on connected modules
+        unsigned int nInnerMDs = mdsOccupancy.nMDs()[i];
+        for (unsigned int c = 0; c < modules.nConnectedModules()[i]; ++c) {
+          uint16_t connectedModule = modules.moduleMap()[i][c];
+          dynamic_count += nInnerMDs * mdsOccupancy.nMDs()[connectedModule];
         }
+
 #ifdef WARNINGS
-        else {
+        if (category_number == -1 || eta_number == -1) {
           printf("Unhandled case in createSegmentArrayRanges! Module index = %i\n", i);
         }
 #endif
+        // Get matrix-based cap
+        int matrix_cap =
+            (category_number != -1 && eta_number != -1) ? occupancy_matrix[category_number][eta_number] : 0;
+
+        // Cap occupancy at minimum of dynamic count and matrix value
+        int occupancy = alpaka::math::min(acc, dynamic_count, matrix_cap);
 
         int nTotSegs = alpaka::atomicAdd(acc, &nTotalSegments, occupancy, alpaka::hierarchy::Threads{});
         ranges.segmentModuleIndices()[i] = nTotSegs;
@@ -718,7 +733,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   HitsConst hits,
                                   MiniDoublets mds,
                                   Segments segments,
-                                  SegmentsPixel segmentsPixel,
+                                  PixelSegments pixelSegments,
                                   unsigned int* hitIndices0,
                                   unsigned int* hitIndices1,
                                   unsigned int* hitIndices2,
@@ -779,7 +794,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         hits1[3] = hits.idxs()[mds.outerHitIndices()[outerMDIndex]];
         addPixelSegmentToMemory(acc,
                                 segments,
-                                segmentsPixel,
+                                pixelSegments,
                                 mds,
                                 innerMDIndex,
                                 outerMDIndex,
diff --git a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h
index 7970fbdeecda7..d7f27544345ad 100644
--- a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h
+++ b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h
@@ -8,6 +8,7 @@
 #include "RecoTracker/LSTCore/interface/HitsSoA.h"
 #include "RecoTracker/LSTCore/interface/MiniDoubletsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelQuintupletsSoA.h"
+#include "RecoTracker/LSTCore/interface/PixelSegmentsSoA.h"
 #include "RecoTracker/LSTCore/interface/PixelTripletsSoA.h"
 #include "RecoTracker/LSTCore/interface/QuintupletsSoA.h"
 #include "RecoTracker/LSTCore/interface/SegmentsSoA.h"
@@ -111,7 +112,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   ModulesConst modules,
                                   ObjectRangesConst ranges,
                                   PixelTriplets pixelTriplets,
-                                  SegmentsPixelConst segmentsPixel,
+                                  PixelSegmentsConst pixelSegments,
                                   PixelQuintupletsConst pixelQuintuplets) const {
       unsigned int nPixelTriplets = pixelTriplets.nPixelTriplets();
       for (unsigned int pixelTripletIndex : cms::alpakatools::uniform_elements_y(acc, nPixelTriplets)) {
@@ -128,8 +129,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         unsigned int nPixelQuintuplets = pixelQuintuplets.nPixelQuintuplets();
         for (unsigned int pixelQuintupletIndex : cms::alpakatools::uniform_elements_x(acc, nPixelQuintuplets)) {
           unsigned int pLS_jx = pixelQuintuplets.pixelSegmentIndices()[pixelQuintupletIndex];
-          float eta2 = segmentsPixel.eta()[pLS_jx - prefix];
-          float phi2 = segmentsPixel.phi()[pLS_jx - prefix];
+          float eta2 = pixelSegments.eta()[pLS_jx - prefix];
+          float phi2 = pixelSegments.phi()[pLS_jx - prefix];
           float dEta = alpaka::math::abs(acc, (eta1 - eta2));
           float dPhi = reco::deltaPhi(phi1, phi2);
 
@@ -197,18 +198,18 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   TrackCandidates cands,
                                   SegmentsConst segments,
                                   SegmentsOccupancyConst segmentsOccupancy,
-                                  SegmentsPixel segmentsPixel,
+                                  PixelSegments pixelSegments,
                                   MiniDoubletsConst mds,
                                   HitsConst hits,
                                   QuintupletsConst quintuplets) const {
       int pixelModuleIndex = modules.nLowerModules();
       unsigned int nPixels = segmentsOccupancy.nSegments()[pixelModuleIndex];
       for (unsigned int pixelArrayIndex : cms::alpakatools::uniform_elements_y(acc, nPixels)) {
-        if (!segmentsPixel.isQuad()[pixelArrayIndex] || segmentsPixel.isDup()[pixelArrayIndex])
+        if (!pixelSegments.isQuad()[pixelArrayIndex] || pixelSegments.isDup()[pixelArrayIndex])
           continue;
 
-        float eta1 = segmentsPixel.eta()[pixelArrayIndex];
-        float phi1 = segmentsPixel.phi()[pixelArrayIndex];
+        float eta1 = pixelSegments.eta()[pixelArrayIndex];
+        float phi1 = pixelSegments.phi()[pixelArrayIndex];
         unsigned int prefix = ranges.segmentModuleIndices()[pixelModuleIndex];
 
         unsigned int nTrackCandidates = cands.nTrackCandidates();
@@ -224,13 +225,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
             float dR2 = dEta * dEta + dPhi * dPhi;
             if (dR2 < 1e-3f)
-              segmentsPixel.isDup()[pixelArrayIndex] = true;
+              pixelSegments.isDup()[pixelArrayIndex] = true;
           }
           if (type == LSTObjType::pT3) {
             int pLSIndex = pixelTriplets.pixelSegmentIndices()[innerTrackletIdx];
             int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hits);
             if (npMatched > 0)
-              segmentsPixel.isDup()[pixelArrayIndex] = true;
+              pixelSegments.isDup()[pixelArrayIndex] = true;
 
             int pT3Index = innerTrackletIdx;
             float eta2 = __H2F(pixelTriplets.eta_pix()[pT3Index]);
@@ -240,23 +241,23 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
 
             float dR2 = dEta * dEta + dPhi * dPhi;
             if (dR2 < 0.000001f)
-              segmentsPixel.isDup()[pixelArrayIndex] = true;
+              pixelSegments.isDup()[pixelArrayIndex] = true;
           }
           if (type == LSTObjType::pT5) {
             unsigned int pLSIndex = innerTrackletIdx;
             int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hits);
             if (npMatched > 0) {
-              segmentsPixel.isDup()[pixelArrayIndex] = true;
+              pixelSegments.isDup()[pixelArrayIndex] = true;
             }
 
-            float eta2 = segmentsPixel.eta()[pLSIndex - prefix];
-            float phi2 = segmentsPixel.phi()[pLSIndex - prefix];
+            float eta2 = pixelSegments.eta()[pLSIndex - prefix];
+            float phi2 = pixelSegments.phi()[pLSIndex - prefix];
             float dEta = alpaka::math::abs(acc, eta1 - eta2);
             float dPhi = reco::deltaPhi(phi1, phi2);
 
             float dR2 = dEta * dEta + dPhi * dPhi;
             if (dR2 < 0.000001f)
-              segmentsPixel.isDup()[pixelArrayIndex] = true;
+              pixelSegments.isDup()[pixelArrayIndex] = true;
           }
         }
       }
@@ -268,7 +269,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   uint16_t nLowerModules,
                                   PixelTripletsConst pixelTriplets,
                                   TrackCandidates cands,
-                                  SegmentsPixelConst segmentsPixel,
+                                  PixelSegmentsConst pixelSegments,
                                   ObjectRangesConst ranges) const {
       // implementation is 1D with a single block
       ALPAKA_ASSERT_ACC((alpaka::getWorkDiv<alpaka::Grid, alpaka::Blocks>(acc)[0] == 1));
@@ -302,7 +303,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                     pixelTriplets.logicalLayers()[pixelTripletIndex].data(),
                                     pixelTriplets.lowerModuleIndices()[pixelTripletIndex].data(),
                                     pixelTriplets.hitIndices()[pixelTripletIndex].data(),
-                                    segmentsPixel.seedIdx()[pT3PixelIndex - pLS_offset],
+                                    pixelSegments.seedIdx()[pT3PixelIndex - pLS_offset],
                                     __H2F(pixelTriplets.centerX()[pixelTripletIndex]),
                                     __H2F(pixelTriplets.centerY()[pixelTripletIndex]),
                                     radius,
@@ -368,12 +369,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   uint16_t nLowerModules,
                                   TrackCandidates cands,
                                   SegmentsOccupancyConst segmentsOccupancy,
-                                  SegmentsPixelConst segmentsPixel,
+                                  PixelSegmentsConst pixelSegments,
                                   bool tc_pls_triplets) const {
       unsigned int nPixels = segmentsOccupancy.nSegments()[nLowerModules];
       for (unsigned int pixelArrayIndex : cms::alpakatools::uniform_elements(acc, nPixels)) {
-        if ((tc_pls_triplets ? 0 : !segmentsPixel.isQuad()[pixelArrayIndex]) ||
-            (segmentsPixel.isDup()[pixelArrayIndex]))
+        if ((tc_pls_triplets ? 0 : !pixelSegments.isQuad()[pixelArrayIndex]) ||
+            (pixelSegments.isDup()[pixelArrayIndex]))
           continue;
 
         unsigned int trackCandidateIdx =
@@ -392,8 +393,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
           addpLSTrackCandidateToMemory(cands,
                                        pixelArrayIndex,
                                        trackCandidateIdx,
-                                       segmentsPixel.pLSHitsIdxs()[pixelArrayIndex],
-                                       segmentsPixel.seedIdx()[pixelArrayIndex]);
+                                       pixelSegments.pLSHitsIdxs()[pixelArrayIndex],
+                                       pixelSegments.seedIdx()[pixelArrayIndex]);
         }
       }
     }
@@ -404,7 +405,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                   uint16_t nLowerModules,
                                   PixelQuintupletsConst pixelQuintuplets,
                                   TrackCandidates cands,
-                                  SegmentsPixelConst segmentsPixel,
+                                  PixelSegmentsConst pixelSegments,
                                   ObjectRangesConst ranges) const {
       // implementation is 1D with a single block
       ALPAKA_ASSERT_ACC((alpaka::getWorkDiv<alpaka::Grid, alpaka::Blocks>(acc)[0] == 1));
@@ -438,7 +439,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
                                     pixelQuintuplets.logicalLayers()[pixelQuintupletIndex].data(),
                                     pixelQuintuplets.lowerModuleIndices()[pixelQuintupletIndex].data(),
                                     pixelQuintuplets.hitIndices()[pixelQuintupletIndex].data(),
-                                    segmentsPixel.seedIdx()[pT5PixelIndex - pLS_offset],
+                                    pixelSegments.seedIdx()[pT5PixelIndex - pLS_offset],
                                     __H2F(pixelQuintuplets.centerX()[pixelQuintupletIndex]),
                                     __H2F(pixelQuintuplets.centerY()[pixelQuintupletIndex]),
                                     radius,
diff --git a/RecoTracker/LSTCore/src/alpaka/Triplet.h b/RecoTracker/LSTCore/src/alpaka/Triplet.h
index 9b1b25a0827db..eb7dabe25edcc 100644
--- a/RecoTracker/LSTCore/src/alpaka/Triplet.h
+++ b/RecoTracker/LSTCore/src/alpaka/Triplet.h
@@ -805,6 +805,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
     ALPAKA_FN_ACC void operator()(Acc1D const& acc,
                                   ModulesConst modules,
                                   ObjectRanges ranges,
+                                  SegmentsConst segments,
                                   SegmentsOccupancyConst segmentsOccupancy,
                                   const float ptCut) const {
       // implementation is 1D with a single block
@@ -851,15 +852,28 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst {
         int category_number = getCategoryNumber(module_layers, module_subdets, module_rings);
         int eta_number = getEtaBin(module_eta);
 
-        int occupancy = 0;
-        if (category_number != -1 && eta_number != -1) {
-          occupancy = occupancy_matrix[category_number][eta_number];
+        int dynamic_count = 0;
+        // How many segments are in module i?
+        int nSegments_i = segmentsOccupancy.nSegments()[i];
+        int firstSegmentIdx = ranges.segmentRanges()[i][0];
+        // Loop over all segments that live in module i
+        for (int s = 0; s < nSegments_i; ++s) {
+          int segIndex = firstSegmentIdx + s;
+          uint16_t midModule = segments.outerLowerModuleIndices()[segIndex];
+          dynamic_count += segmentsOccupancy.nSegments()[midModule];
         }
+
 #ifdef WARNINGS
-        else {
+        if (category_number == -1 || eta_number == -1) {
           printf("Unhandled case in createTripletArrayRanges! Module index = %i\n", i);
         }
 #endif
+        // Get matrix-based cap
+        int matrix_cap =
+            (category_number != -1 && eta_number != -1) ? occupancy_matrix[category_number][eta_number] : 0;
+
+        // Cap occupancy at minimum of dynamic count and matrix value
+        int occupancy = alpaka::math::min(acc, dynamic_count, matrix_cap);
 
         ranges.tripletModuleOccupancy()[i] = occupancy;
         unsigned int nTotT = alpaka::atomicAdd(acc, &nTotalTriplets, occupancy, alpaka::hierarchy::Threads{});
diff --git a/RecoTracker/LSTCore/standalone/bin/lst.cc b/RecoTracker/LSTCore/standalone/bin/lst.cc
index 17eb4a54628d6..15be796dce378 100644
--- a/RecoTracker/LSTCore/standalone/bin/lst.cc
+++ b/RecoTracker/LSTCore/standalone/bin/lst.cc
@@ -430,11 +430,6 @@ void run_lst() {
                                                      out_trkZ.at(evt),
                                                      out_hitId.at(evt),
                                                      out_hitIdxs.at(evt),
-                                                     out_hitIndices_vec0.at(evt),
-                                                     out_hitIndices_vec1.at(evt),
-                                                     out_hitIndices_vec2.at(evt),
-                                                     out_hitIndices_vec3.at(evt),
-                                                     out_deltaPhi_vec.at(evt),
                                                      out_ptIn_vec.at(evt),
                                                      out_ptErr_vec.at(evt),
                                                      out_px_vec.at(evt),
@@ -453,7 +448,15 @@ void run_lst() {
       timing_LS = runSegment(events.at(omp_get_thread_num()));
       timing_T3 = runT3(events.at(omp_get_thread_num()));
       timing_T5 = runQuintuplet(events.at(omp_get_thread_num()));
-      timing_pLS = runPixelLineSegment(events.at(omp_get_thread_num()), ana.no_pls_dupclean);
+
+      timing_pLS = runPixelLineSegment(events.at(omp_get_thread_num()),
+                                       out_hitIndices_vec0.at(evt),
+                                       out_hitIndices_vec1.at(evt),
+                                       out_hitIndices_vec2.at(evt),
+                                       out_hitIndices_vec3.at(evt),
+                                       out_deltaPhi_vec.at(evt),
+                                       ana.no_pls_dupclean);
+
       timing_pT5 = runPixelQuintuplet(events.at(omp_get_thread_num()));
       timing_pT3 = runpT3(events.at(omp_get_thread_num()));
       timing_TC = runTrackCandidate(events.at(omp_get_thread_num()), ana.no_pls_dupclean, ana.tc_pls_triplets);
diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
index e480aa3608a4b..bf83965f4978e 100644
--- a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
+++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc
@@ -216,11 +216,19 @@ float runQuintuplet(LSTEvent *event) {
 }
 
 //___________________________________________________________________________________________________________________________________________________________________________________________
-float runPixelLineSegment(LSTEvent *event, bool no_pls_dupclean) {
+float runPixelLineSegment(LSTEvent *event,
+                          std::vector<unsigned int> hitIndices_vec0,
+                          std::vector<unsigned int> hitIndices_vec1,
+                          std::vector<unsigned int> hitIndices_vec2,
+                          std::vector<unsigned int> hitIndices_vec3,
+                          std::vector<float> deltaPhi_vec,
+                          bool no_pls_dupclean) {
   TStopwatch my_timer;
   if (ana.verbose >= 2)
     std::cout << "Reco Pixel Line Segment start" << std::endl;
   my_timer.Start();
+  event->addPixelSegmentToEventFinalize(
+      hitIndices_vec0, hitIndices_vec1, hitIndices_vec2, hitIndices_vec3, deltaPhi_vec);
   event->pixelLineSegmentCleaning(no_pls_dupclean);
   event->wait();  // device side event calls are asynchronous: wait to measure time or print
   float pls_elapsed = my_timer.RealTime();
@@ -860,11 +868,6 @@ float addInputsToEventPreLoad(LSTEvent *event,
                               std::vector<float> trkZ,
                               std::vector<unsigned int> hitId,
                               std::vector<unsigned int> hitIdxs,
-                              std::vector<unsigned int> hitIndices_vec0,
-                              std::vector<unsigned int> hitIndices_vec1,
-                              std::vector<unsigned int> hitIndices_vec2,
-                              std::vector<unsigned int> hitIndices_vec3,
-                              std::vector<float> deltaPhi_vec,
                               std::vector<float> ptIn_vec,
                               std::vector<float> ptErr_vec,
                               std::vector<float> px_vec,
@@ -888,24 +891,19 @@ float addInputsToEventPreLoad(LSTEvent *event,
 
   event->addHitToEvent(trkX, trkY, trkZ, hitId, hitIdxs);
 
-  event->addPixelSegmentToEvent(hitIndices_vec0,
-                                hitIndices_vec1,
-                                hitIndices_vec2,
-                                hitIndices_vec3,
-                                deltaPhi_vec,
-                                ptIn_vec,
-                                ptErr_vec,
-                                px_vec,
-                                py_vec,
-                                pz_vec,
-                                eta_vec,
-                                etaErr_vec,
-                                phi_vec,
-                                charge_vec,
-                                seedIdx_vec,
-                                superbin_vec,
-                                pixelType_vec,
-                                isQuad_vec);
+  event->addPixelSegmentToEventStart(ptIn_vec,
+                                     ptErr_vec,
+                                     px_vec,
+                                     py_vec,
+                                     pz_vec,
+                                     eta_vec,
+                                     etaErr_vec,
+                                     phi_vec,
+                                     charge_vec,
+                                     seedIdx_vec,
+                                     superbin_vec,
+                                     pixelType_vec,
+                                     isQuad_vec);
   event->wait();  // device side event calls are asynchronous: wait to measure time or print
   float hit_loading_elapsed = my_timer.RealTime();
 
diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.h b/RecoTracker/LSTCore/standalone/code/core/trkCore.h
index 912143b052d9f..b3abdcc09d672 100644
--- a/RecoTracker/LSTCore/standalone/code/core/trkCore.h
+++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.h
@@ -27,7 +27,13 @@ float runT3(LSTEvent *event);
 float runTrackCandidate(LSTEvent *event, bool no_pls_dupclean, bool tc_pls_triplets);
 float runQuintuplet(LSTEvent *event);
 float runPixelQuintuplet(LSTEvent *event);
-float runPixelLineSegment(LSTEvent *event, bool no_pls_dupclean);
+float runPixelLineSegment(LSTEvent *event,
+                          std::vector<unsigned int> hitIndices_vec0,
+                          std::vector<unsigned int> hitIndices_vec1,
+                          std::vector<unsigned int> hitIndices_vec2,
+                          std::vector<unsigned int> hitIndices_vec3,
+                          std::vector<float> deltaPhi_vec,
+                          bool no_pls_dupclean);
 float runpT3(LSTEvent *event);
 
 // --------------------- ======================== ---------------------
@@ -81,11 +87,6 @@ float addInputsToEventPreLoad(LSTEvent *event,
                               std::vector<float> trkZ,
                               std::vector<unsigned int> hitId,
                               std::vector<unsigned int> hitIdxs,
-                              std::vector<unsigned int> hitIndices_vec0,
-                              std::vector<unsigned int> hitIndices_vec1,
-                              std::vector<unsigned int> hitIndices_vec2,
-                              std::vector<unsigned int> hitIndices_vec3,
-                              std::vector<float> deltaPhi_vec,
                               std::vector<float> ptIn_vec,
                               std::vector<float> ptErr_vec,
                               std::vector<float> px_vec,
diff --git a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc
index 2c52c88e6ccbd..af88cd9d4bbe2 100644
--- a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc
+++ b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc
@@ -411,7 +411,7 @@ void setPixelQuintupletOutputBranches(LSTEvent* event) {
   // ============ pT5 =============
   auto const pixelQuintuplets = event->getPixelQuintuplets();
   auto const quintuplets = event->getQuintuplets<QuintupletsSoA>();
-  auto const segmentsPixel = event->getSegments<SegmentsPixelSoA>();
+  auto const pixelSegments = event->getPixelSegments();
   auto modules = event->getModules<ModulesSoA>();
   int n_accepted_simtrk = ana.tx->getBranch<std::vector<int>>("sim_TC_matched").size();
 
@@ -422,9 +422,9 @@ void setPixelQuintupletOutputBranches(LSTEvent* event) {
   for (unsigned int pT5 = 0; pT5 < nPixelQuintuplets; pT5++) {
     unsigned int T5Index = getT5FrompT5(event, pT5);
     unsigned int pLSIndex = getPixelLSFrompT5(event, pT5);
-    float pt = (__H2F(quintuplets.innerRadius()[T5Index]) * k2Rinv1GeVf * 2 + segmentsPixel.ptIn()[pLSIndex]) / 2;
-    float eta = segmentsPixel.eta()[pLSIndex];
-    float phi = segmentsPixel.phi()[pLSIndex];
+    float pt = (__H2F(quintuplets.innerRadius()[T5Index]) * k2Rinv1GeVf * 2 + pixelSegments.ptIn()[pLSIndex]) / 2;
+    float eta = pixelSegments.eta()[pLSIndex];
+    float phi = pixelSegments.phi()[pLSIndex];
 
     std::vector<unsigned int> hit_idx = getHitIdxsFrompT5(event, pT5);
     std::vector<unsigned int> module_idx = getModuleIdxsFrompT5(event, pT5);
@@ -578,7 +578,7 @@ void setQuintupletOutputBranches(LSTEvent* event) {
 void setPixelTripletOutputBranches(LSTEvent* event) {
   auto const pixelTriplets = event->getPixelTriplets();
   auto modules = event->getModules<ModulesSoA>();
-  SegmentsPixelConst segmentsPixel = event->getSegments<SegmentsPixelSoA>();
+  PixelSegmentsConst pixelSegments = event->getPixelSegments();
   int n_accepted_simtrk = ana.tx->getBranch<std::vector<int>>("sim_TC_matched").size();
 
   unsigned int nPixelTriplets = pixelTriplets.nPixelTriplets();
@@ -588,10 +588,10 @@ void setPixelTripletOutputBranches(LSTEvent* event) {
   for (unsigned int pT3 = 0; pT3 < nPixelTriplets; pT3++) {
     unsigned int T3Index = getT3FrompT3(event, pT3);
     unsigned int pLSIndex = getPixelLSFrompT3(event, pT3);
-    const float pt = segmentsPixel.ptIn()[pLSIndex];
+    const float pt = pixelSegments.ptIn()[pLSIndex];
 
-    float eta = segmentsPixel.eta()[pLSIndex];
-    float phi = segmentsPixel.phi()[pLSIndex];
+    float eta = pixelSegments.eta()[pLSIndex];
+    float phi = pixelSegments.phi()[pLSIndex];
     std::vector<unsigned int> hit_idx = getHitIdxsFrompT3(event, pT3);
     std::vector<unsigned int> hit_type = getHitTypesFrompT3(event, pT3);
 
@@ -984,7 +984,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
   // Get relevant information
   auto const trackCandidates = event->getTrackCandidates();
   auto const quintuplets = event->getQuintuplets<QuintupletsSoA>();
-  auto const segmentsPixel = event->getSegments<SegmentsPixelSoA>();
+  auto const pixelSegments = event->getPixelSegments();
 
   //
   // pictorial representation of a pT5
@@ -1077,9 +1077,9 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
   // And from there we estimate the pt's and we compute pt_T5.
 
   // pixel pt
-  const float pt_pLS = segmentsPixel.ptIn()[pLS];
-  const float eta_pLS = segmentsPixel.eta()[pLS];
-  const float phi_pLS = segmentsPixel.phi()[pLS];
+  const float pt_pLS = pixelSegments.ptIn()[pLS];
+  const float eta_pLS = pixelSegments.eta()[pLS];
+  const float phi_pLS = pixelSegments.phi()[pLS];
   float pt_T5 = __H2F(quintuplets.innerRadius()[T5Index]) * 2 * k2Rinv1GeVf;
   const float pt = (pt_T5 + pt_pLS) / 2;
 
@@ -1096,7 +1096,7 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
   // Get relevant information
   auto const trackCandidates = event->getTrackCandidates();
   auto const triplets = event->getTriplets<TripletsSoA>();
-  auto const segmentsPixel = event->getSegments<SegmentsPixelSoA>();
+  auto const pixelSegments = event->getPixelSegments();
 
   //
   // pictorial representation of a pT3
@@ -1110,9 +1110,9 @@ std::tuple<float, float, float, std::vector<unsigned int>, std::vector<unsigned
   unsigned int T3 = getT3FrompT3(event, pT3);
 
   // pixel pt
-  const float pt_pLS = segmentsPixel.ptIn()[pLS];
-  const float eta_pLS = segmentsPixel.eta()[pLS];
-  const float phi_pLS = segmentsPixel.phi()[pLS];
+  const float pt_pLS = pixelSegments.ptIn()[pLS];
+  const float eta_pLS = pixelSegments.eta()[pLS];
+  const float phi_pLS = pixelSegments.phi()[pLS];
   float pt_T3 = triplets.radius()[T3] * 2 * k2Rinv1GeVf;
 
   // average pt
@@ -1163,15 +1163,15 @@ 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(LSTEvent* event,
                                                                                                unsigned int idx) {
   auto const& trackCandidates = event->getTrackCandidates();
-  SegmentsPixelConst segmentsPixel = event->getSegments<SegmentsPixelSoA>();
+  PixelSegmentsConst pixelSegments = event->getPixelSegments();
 
   // Getting pLS index
   unsigned int pLS = trackCandidates.directObjectIndices()[idx];
 
   // Getting pt eta and phi
-  float pt = segmentsPixel.ptIn()[pLS];
-  float eta = segmentsPixel.eta()[pLS];
-  float phi = segmentsPixel.phi()[pLS];
+  float pt = pixelSegments.ptIn()[pLS];
+  float eta = pixelSegments.eta()[pLS];
+  float phi = pixelSegments.phi()[pLS];
 
   // Getting hit indices and types
   std::vector<unsigned int> hit_idx = getPixelHitIdxsFrompLS(event, pLS);