Merge c9c2844 into sapling-pr-archive-ktf

Author: ktf

Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseCalibratorSpec.h

@@ -56,17 +56,17 @@ class NoiseCalibratorSpec : public Task
   void sendOutputCcdbMerge(DataAllocator& output);
   void sendOutputCcdbDcs(DataAllocator& output);
   void sendOutputDcs(DataAllocator& output);
+  void sendOutputDcsMerge(DataAllocator& output);
   void setOutputDcs(const o2::itsmft::NoiseMap& payload);
   o2::itsmft::NoiseMap mNoiseMap{936};
   std::unique_ptr<CALIBRATOR> mCalibrator = nullptr;
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
   std::string mPath;
-  std::string mPathMerge;
+  std::string mPathSingle;
   std::string mMeta;
 
   std::vector<std::array<int, 3>> mNoiseMapForDcs;
   std::string mPathDcs;
-  std::string mPathDcsMerge;
   std::string mOutputType;
 
   double mThresh;

Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx

@@ -48,7 +48,7 @@ void NoiseCalibratorSpec::init(InitContext& ic)
   LOGP(info, "Setting the probability threshold to {} with relative error {}", probT, probTRelErr);
   mStopMeOnly = ic.options().get<bool>("stop-me-only");
   mPath = ic.options().get<std::string>("path-CCDB");
-  mPathMerge = ic.options().get<std::string>("path-CCDB-merge");
+  mPathSingle = ic.options().get<std::string>("path-CCDB-single");
 
   mMeta = ic.options().get<std::string>("meta");
   mStart = ic.options().get<int64_t>("tstart");
@@ -173,7 +173,7 @@ void NoiseCalibratorSpec::sendOutputCcdbDcs(DataAllocator& output)
   const auto& payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
 
-  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPathSingle, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info);
   info.setFileName(flName);
@@ -244,7 +244,7 @@ void NoiseCalibratorSpec::sendOutputCcdb(DataAllocator& output)
   const auto& payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
 
-  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPathSingle, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info);
   info.setFileName(flName);
@@ -301,16 +301,16 @@ void NoiseCalibratorSpec::sendOutputCcdbMerge(DataAllocator& output)
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
   map<string, string> headers;
   map<std::string, std::string> filter;
-  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPath, filter, -1, &headers);
+  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
   long validtime = std::stol(headers["Valid-From"]);
   auto mergedPL = payload;
   if (validtime > 0) {
     validtime = validtime - 1;
-    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPath, filter, validtime, &headers);
+    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, validtime, &headers);
     auto bufferPL = payloadPrev2->merge(payloadPrev1);
     mergedPL = payload.merge(&bufferPL);
   }
-  o2::ccdb::CcdbObjectInfo info(mPathMerge, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&mergedPL, &info);
   info.setFileName(flName);
@@ -382,6 +382,75 @@ void NoiseCalibratorSpec::sendOutputDcs(DataAllocator& output)
   output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
 }
 
+void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
+{
+
+  LOG(info) << "DCS mode";
+
+  static bool done = false;
+  if (done) {
+    return;
+  }
+  done = true;
+
+  mCalibrator->finalize();
+
+  long tstart = mStart;
+  if (tstart == -1) {
+    tstart = o2::ccdb::getCurrentTimestamp();
+  }
+  long tend = mEnd;
+  if (tend == -1) {
+    constexpr long SECONDSPERYEAR = 365 * 24 * 60 * 60;
+    tend = o2::ccdb::getFutureTimestamp(SECONDSPERYEAR);
+  }
+
+  std::map<std::string, std::string> meta;
+  auto toKeyValPairs = [&meta](std::vector<std::string> const& tokens) {
+    for (auto& token : tokens) {
+      auto keyval = Str::tokenize(token, '=', false);
+      if (keyval.size() != 2) {
+        LOG(error) << "Illegal command-line key/value string: " << token;
+        continue;
+      }
+      Str::trim(keyval[1]);
+      meta[keyval[0]] = keyval[1];
+    }
+  };
+  toKeyValPairs(Str::tokenize(mMeta, ';', true));
+
+  long startTF, endTF;
+
+  auto payload = mCalibrator->getNoiseMap();
+  //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
+
+  map<string, string> headers;
+  map<std::string, std::string> filter;
+  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
+  long validtime = std::stol(headers["Valid-From"]);
+  auto mergedPL = payload;
+  if (validtime > 0) {
+    validtime = validtime - 1;
+    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, validtime, &headers);
+    auto bufferPL = payloadPrev2->merge(payloadPrev1);
+    mergedPL = payload.merge(&bufferPL);
+  }
+
+  setOutputDcs(mergedPL);
+  o2::ccdb::CcdbObjectInfo infoDcs(mPathDcs, "NoiseMap", "noise.root", meta, tstart, tend);
+  auto flNameDcs = o2::ccdb::CcdbApi::generateFileName("noise");
+  auto imageDcs = o2::ccdb::CcdbApi::createObjectImage(&mNoiseMapForDcs, &infoDcs);
+  infoDcs.setFileName(flNameDcs);
+  LOG(info) << "Sending object " << infoDcs.getPath() << "/" << infoDcs.getFileName()
+            << " of size " << imageDcs->size()
+            << " bytes, valid for " << infoDcs.getStartValidityTimestamp()
+            << " : " << infoDcs.getEndValidityTimestamp();
+
+  using clbUtilsDcs = o2::calibration::Utils;
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+}
+
 void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)
 {
   if (mOutputType.compare("CCDB") == 0) {
@@ -390,11 +459,12 @@ void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)
     LOG(info) << "Sending an object to Production-CCDB-Merge";
     sendOutputCcdbMerge(ec.outputs());
   } else if (mOutputType.compare("DCS") == 0) {
-    LOG(info) << "Sending an object to DCS-CCDB";
-    sendOutputDcs(ec.outputs());
+    LOG(info) << "Sending an object to DCS-Merge";
+    sendOutputDcsMerge(ec.outputs());
   } else {
-    LOG(info) << "Sending an object to Production-CCDB and DCS-CCDB";
-    sendOutputCcdbDcs(ec.outputs());
+    LOG(info) << "Sending an object to Production-CCDB, Production-CCDB-Merge and DCS-Merge";
+    sendOutputCcdb(ec.outputs());
+    sendOutputDcsMerge(ec.outputs());
     sendOutputCcdbMerge(ec.outputs());
   }
 }
@@ -454,7 +524,7 @@ DataProcessorSpec getNoiseCalibratorSpec(bool useDigits)
       {"tstart", VariantType::Int64, -1ll, {"Start of validity timestamp"}},
       {"tend", VariantType::Int64, -1ll, {"End of validity timestamp"}},
       {"path-CCDB", VariantType::String, "/MFT/Calib/NoiseMap", {"Path to write to in CCDB"}},
-      {"path-CCDB-merge", VariantType::String, "/MFT/Calib/NoiseMapMerged", {"Path to write merged file to in CCDB"}},
+      {"path-CCDB-single", VariantType::String, "/MFT/Calib/NoiseMapSingle", {"Path to write merged file to in CCDB"}},
       {"path-DCS", VariantType::String, "/MFT/Config/NoiseMap", {"Path to write to in DCS"}},
       {"meta", VariantType::String, "", {"meta data to write in CCDB"}},
       {"send-to-server", VariantType::String, "CCDB-DCS", {"meta data to write in DCS-CCDB"}},

Framework/Core/include/Framework/DeviceMetricsInfo.h

@@ -12,14 +12,14 @@
 #ifndef O2_FRAMEWORK_DEVICEMETRICSINFO_H_
 #define O2_FRAMEWORK_DEVICEMETRICSINFO_H_
 
-#include "Framework/RuntimeError.h"
 #include "Framework/CompilerBuiltins.h"
 #include "Framework/Traits.h"
 #include <array>
 #include <cstddef>
 #include <cstdint>
 #include <span>
 #include <vector>
+#include <iosfwd>
 
 namespace o2::framework
 {

GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx

@@ -706,6 +706,8 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
       }
       AllocateRegisteredMemory(clustererNN.mMemoryId);
+      // nnApplications[lane].createBoundary(clustererNNShadow);
+      // nnApplications[lane].createIndexLookup(clustererNNShadow);
     });
     if (doGPU) {
       WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);

GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx

@@ -65,33 +65,6 @@ void* GPUTPCNNClusterizer::setIOPointers(void* mem)
   return mem;
 }
 
-// std::vector<int32_t> GPUTPCNNClusterizer::pointerSizes() {
-//   std::vector<int32_t> sizes(7, -1);
-//   if (mNnClusterizerBatchedMode > 0) {
-//     if (mNnInferenceInputDType == 0 && mNnClusterizerElementSize > 0) {
-//       sizes[0] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData16
-//     } else if (mNnInferenceInputDType == 1 && mNnClusterizerElementSize > 0) {
-//       sizes[1] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData32
-//     }
-//     sizes[2] = 2 * mNnClusterizerBatchedMode; // mClusterFlags
-//     if (mNnClusterizerModelClassNumOutputNodes > 0) {
-//       sizes[3] = mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes; // modelProbabilities
-//     }
-//     if (!mNnClusterizerUseCfRegression) {
-//       if (mNnClusterizerModelReg1NumOutputNodes > 0) {
-//         sizes[4] = mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes; // outputDataReg1
-//       }
-//       if (mNnClusterizerModelReg2NumOutputNodes > 0) {
-//         sizes[5] = mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes; // outputDataReg2
-//       }
-//     }
-//   }
-//   if (mNnClusterizerTotalClusters > 0) {
-//     sizes[6] = mNnClusterizerTotalClusters; // mOutputDataClass
-//   }
-//   return sizes;
-// }
-
 void GPUTPCNNClusterizer::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();

GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h

@@ -37,31 +37,51 @@ class GPUTPCNNClusterizer : public GPUProcessor
 
   // Neural network clusterization
 
-  int mNnClusterizerSizeInputRow = 3;
-  int mNnClusterizerSizeInputPad = 3;
-  int mNnClusterizerSizeInputTime = 3;
-  int mNnClusterizerElementSize = -1;
-  bool mNnClusterizerAddIndexData = true;
+  int32_t mNnClusterizerSizeInputRow = 3;
+  int32_t mNnClusterizerSizeInputPad = 3;
+  int32_t mNnClusterizerSizeInputTime = 3;
+  int32_t mNnClusterizerChargeArraySize = -1;
+  int32_t mNnClusterizerElementSize = -1;
+  int8_t mNnClusterizerAddIndexData = 1;
   float mNnClassThreshold = 0.01;
-  bool mNnSigmoidTrafoClassThreshold = 1;
-  bool mNnClusterizerSetDeconvolutionFlags = true;
-  int mNnClusterizerUseCfRegression = 0;
-  int mNnClusterizerBatchedMode = 1;
-  int mNnClusterizerTotalClusters = 1;
-  int mNnClusterizerVerbosity = 0;
-  int mNnClusterizerBoundaryFillValue = -1;
-  int mNnClusterizerModelClassNumOutputNodes = -1;
-  int mNnClusterizerModelReg1NumOutputNodes = -1;
-  int mNnClusterizerModelReg2NumOutputNodes = -1;
-  int mNnInferenceInputDType = 0;  // 0: float16, 1: float32
-  int mNnInferenceOutputDType = 0; // 0: float16, 1: float32
-  int mISector = -1;
-  int mDeviceId = -1;
+  int8_t mNnSigmoidTrafoClassThreshold = 1;
+  int8_t mNnClusterizerSetDeconvolutionFlags = 1;
+  int32_t mNnClusterizerUseCfRegression = 0;
+  int32_t mNnClusterizerBatchedMode = 1;
+  int32_t mNnClusterizerTotalClusters = 1;
+  int32_t mNnClusterizerVerbosity = 0;
+  int32_t mNnClusterizerBoundaryFillValue = -1;
+  int32_t mNnClusterizerModelClassNumOutputNodes = -1;
+  int32_t mNnClusterizerModelReg1NumOutputNodes = -1;
+  int32_t mNnClusterizerModelReg2NumOutputNodes = -1;
+  int32_t mNnInferenceInputDType = 0;  // 0: float16, 1: float32
+  int32_t mNnInferenceOutputDType = 0; // 0: float16, 1: float32
+  int32_t mISector = -1;
+  int32_t mDeviceId = -1;
+
+  // GPU optimizations
+  uint32_t mNnClusterizerFullRowSize = 0;
+  uint32_t mNnClusterizerFullPadSize = 0;
+  uint32_t mNnClusterizerFullTimeSize = 0;
+  uint32_t mNnClusterizerPadTimeSize = 0;
+  uint32_t mNnClusterizerRowTimeSize = 0;
+  uint32_t mNnClusterizerRowTimeSizeFull = 0;
+
+  // Boundary lookup table
+  // int32_t mBoundaryMapSizeRow = 0;
+  // int32_t mBoundaryMapSizePadsPerRow = 0;
+  // int32_t mBoundaryMapSize = 0;
+  // int32_t mBoundaryPadding = 11; // Padding on each side of the boundary map to account for pad_offset
+  // int8_t* mIsBoundary = nullptr;
+
+  // Index lookup table
+  // int32_t mIndexLookupSize = 0;
+  // int32_t* mIndexLookup = nullptr;
 
   // Memory allocation for neural network
 
-  bool* mClusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
-  int* mOutputDataClass = nullptr;
+  int8_t* mClusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
+  int32_t* mOutputDataClass = nullptr;
 
   // FP32
   float* mInputData_32 = nullptr;

GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx

@@ -19,6 +19,8 @@
 #include "GPUSettings.h"
 #include "ML/3rdparty/GPUORTFloat16.h"
 #include "GPUReconstruction.h"
+#include "GPUTPCGeometry.h"
+#include "DataFormatsTPC/Constants.h"
 
 #ifdef GPUCA_HAS_ONNX
 #include <onnxruntime_cxx_api.h>
@@ -87,8 +89,20 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
   clustererNN.mNnClusterizerSizeInputPad = settings.nnClusterizerSizeInputPad;
   clustererNN.mNnClusterizerSizeInputTime = settings.nnClusterizerSizeInputTime;
+  clustererNN.mNnClusterizerFullRowSize = 2 * settings.nnClusterizerSizeInputRow + 1;
+  clustererNN.mNnClusterizerFullPadSize = 2 * settings.nnClusterizerSizeInputPad + 1;
+  clustererNN.mNnClusterizerFullTimeSize = 2 * settings.nnClusterizerSizeInputTime + 1;
+  clustererNN.mNnClusterizerChargeArraySize = clustererNN.mNnClusterizerFullRowSize * clustererNN.mNnClusterizerFullPadSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerPadTimeSize = clustererNN.mNnClusterizerFullPadSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerRowTimeSize = clustererNN.mNnClusterizerFullRowSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerRowTimeSizeFull = clustererNN.mNnClusterizerRowTimeSize + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  clustererNN.mNnClusterizerElementSize = clustererNN.mNnClusterizerChargeArraySize + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  // clustererNN.mBoundaryMapSizeRow = 3 * clustererNN.mNnClusterizerSizeInputRow + o2::tpc::constants::MAXGLOBALPADROW;
+  // clustererNN.mBoundaryPadding = 11; // padding on each side to account for pad_offset. N=11 since then mIsBoundary = 24320 ~< (1.5 x 2^14 = 24576) && N must be bigger than (NPads[row(end_iroc + 1)] - NPads[row(end_iroc)])/2 (=6) for pad_offset to work
+  // clustererNN.mBoundaryMapSizePadsPerRow = GPUTPCGeometry::NPads(o2::tpc::constants::MAXGLOBALPADROW - 1) + 2 * clustererNN.mBoundaryPadding;
+  // clustererNN.mBoundaryMapSize = clustererNN.mBoundaryMapSizeRow * clustererNN.mBoundaryMapSizePadsPerRow;
+  // clustererNN.mIndexLookupSize = 3 * clustererNN.mNnClusterizerChargeArraySize; // local row, pad, time shift from flat index
   clustererNN.mNnClusterizerAddIndexData = settings.nnClusterizerAddIndexData;
-  clustererNN.mNnClusterizerElementSize = ((2 * settings.nnClusterizerSizeInputRow + 1) * (2 * settings.nnClusterizerSizeInputPad + 1) * (2 * settings.nnClusterizerSizeInputTime + 1)) + (settings.nnClusterizerAddIndexData ? 3 : 0);
   clustererNN.mNnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
   clustererNN.mNnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
   clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
@@ -116,6 +130,39 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   }
 }
 
+// void GPUTPCNNClusterizerHost::createBoundary(GPUTPCNNClusterizer& clustererNN)
+// {
+//   // Call after init of the clustererNN elements
+//   for (int r = 0; r < clustererNN.mBoundaryMapSizeRow; r++) {
+//     int8_t skipCheckInRow = 0;
+//     for (int p = 0; p < clustererNN.mBoundaryMapSizePadsPerRow; p++) {
+//       int32_t i = r * clustererNN.mBoundaryMapSizePadsPerRow + p;
+//       clustererNN.mIsBoundary[i] = 1;
+//       if (!skipCheckInRow && (p >= clustererNN.mBoundaryPadding || r >= clustererNN.mNnClusterizerSizeInputRow)) {
+//         if (r < (GPUTPCGeometry::EndIROC() + clustererNN.mNnClusterizerSizeInputRow)) {
+//           clustererNN.mIsBoundary[i] = (int32_t)((p - clustererNN.mBoundaryPadding) >= static_cast<int>(GPUTPCGeometry::NPads(r - clustererNN.mNnClusterizerSizeInputRow)));
+//         } else if (r >= (GPUTPCGeometry::EndIROC() + 2 * clustererNN.mNnClusterizerSizeInputRow) && r < (o2::tpc::constants::MAXGLOBALPADROW + 2 * clustererNN.mNnClusterizerSizeInputRow)) {
+//           clustererNN.mIsBoundary[i] = (int32_t)((p - clustererNN.mBoundaryPadding) >= static_cast<int>(GPUTPCGeometry::NPads(r - 2 * clustererNN.mNnClusterizerSizeInputRow)));
+//         }
+//         skipCheckInRow = (clustererNN.mIsBoundary[i] == 1); // No need to check further pads in this row
+//       }
+//     }
+//   }
+// }
+
+// void GPUTPCNNClusterizerHost::createIndexLookup(GPUTPCNNClusterizer& clustererNN)
+// {
+//   for (int32_t i = 0; i < clustererNN.mNnClusterizerChargeArraySize; i++) {
+//     int32_t r = CAMath::Floor(i / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
+//     int32_t rest_1 = i % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
+//     int32_t p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad;
+//     int32_t t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
+//     clustererNN.mIndexLookup[3 * i] = r;
+//     clustererNN.mIndexLookup[3 * i + 1] = p;
+//     clustererNN.mIndexLookup[3 * i + 2] = t;
+//   }
+// }
+
 // MockedOrtAllocator implementation to be able to use volatile assignment
 struct MockedOrtAllocator : OrtAllocator {
   MockedOrtAllocator(GPUReconstruction* = nullptr, OrtMemoryInfo* = nullptr);

GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h

@@ -49,6 +49,8 @@ class GPUTPCNNClusterizerHost
 
   void init(const GPUSettingsProcessingNNclusterizer&);
   void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
+  void createBoundary(GPUTPCNNClusterizer&);
+  void createIndexLookup(GPUTPCNNClusterizer&);
 
   // ONNX
   void directOrtAllocator(Ort::Env*, Ort::MemoryInfo*, GPUReconstruction*, bool = false);