Merge 9f0c915 into sapling-pr-archive-ktf

ktf · web-flow · commit be4ed34e5669 · 2026-05-26T14:09:51.000+02:00
diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -192,12 +192,11 @@ class TrackITSExt : public TrackITS
     getClusterRefs().setEntries(ncl);
   }
 
-  GPUhdi() const int getClusterIndex(int lr) const { return mIndex[lr]; }
+  GPUhdi() int getClusterIndex(int lr) const { return mIndex[lr]; }
 
-  GPUh() const int getFirstLayerClusterIndex() const
+  GPUh() int getFirstLayerClusterIndex() const
   {
-    int firstLayer = getFirstClusterLayer();
-    return getClusterIndex(firstLayer);
+    return getClusterIndex(getFirstClusterLayer());
   }
 
   GPUhdi() void setExternalClusterIndex(int layer, int idx, bool newCluster = false)
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -309,8 +309,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startCellTopologyId{0}; startCellTopologyId < hostTopology.nCells; ++startCellTopologyId) {
       const int startLayer = hostTopology.getCell(startCellTopologyId).hitLayerMask.last();
-      if ((this->mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
-          mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
+      if (!(this->mTrkParams[iteration].StartLayerMask.has(startLayer)) || mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
         continue;
       }
       processNeighboursHandler<NLayers>(startLevel,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -26,6 +26,7 @@
 #include "CommonUtils/EnumFlags.h"
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
+#include "ITStracking/LayerMask.h"
 
 namespace o2::its
 {
@@ -70,10 +71,9 @@ struct TrackingParameters {
   float DiamondCov[6] = {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f};
 
   /// General parameters
-  int ClusterSharing = 0;
   int MinTrackLength = 7;
   int MaxHoles = 0;
-  uint16_t HoleLayerMask = 0;
+  LayerMask HoleLayerMask = 0;
   float NSigmaCut = 5;
   float PVres = 1.e-2f;
   /// Trackleting cuts
@@ -86,7 +86,7 @@ struct TrackingParameters {
   float MaxChi2NDF = 30.f;
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
-  uint16_t StartLayerMask = 0x7F;
+  LayerMask StartLayerMask = 0x7F;
   bool RepeatRefitOut = false;   // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool PerPrimaryVertexProcessing = false;
@@ -103,6 +103,7 @@ struct TrackingParameters {
   float SharedClusterMaxDeltaPhi = 0.05f; // For tracks sharing clusters, maximum allowed delta phi at the cluster position
   float SharedClusterMaxDeltaEta = 0.03f; // For tracks sharing clusters, maximum allowed delta eta at the cluster position
   bool SharedClusterOppositeSign = false; // For tracks sharing clusters, require opposite sign of the tracklets
+  int SharedMaxClusters = 0;              // Maximal allowed shared clusters (excluding first cluster)
 };
 
 struct VertexingParameters {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -24,8 +24,9 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{} MaxHoles:{} HoleMask:{:#x}",
-                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength, MaxHoles, HoleLayerMask);
+  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} TtklMinPt:{:.2f} MinCl:{}", ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, TrackletMinPt, MinTrackLength);
+  auto isSet = [](auto e) { return e >= 0; };
+  auto isAnySet = [&isSet](auto v) { return !v.empty() && std::any_of(v.begin(), v.end(), isSet); };
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;
@@ -37,18 +38,27 @@ std::string TrackingParameters::asString() const
       str += std::format("L{}:{:.2f} ", il, MinPt[slot]);
     }
   }
-  if (!SystErrorY2.empty() || !SystErrorZ2.empty()) {
+  if (isAnySet(SystErrorY2) || isAnySet(SystErrorZ2)) {
     str += " SystErrY/Z:";
     for (size_t i = 0; i < SystErrorY2.size(); i++) {
       str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
     }
   }
-  if (!AddTimeError.empty()) {
+  if (isAnySet(AddTimeError)) {
     str += " AddTimeError:";
     for (unsigned int i : AddTimeError) {
       str += std::format("{} ", i);
     }
   }
+  if (SharedMaxClusters) {
+    str += std::format(" ShaMaxCls:{} ", SharedMaxClusters);
+  }
+  if (AllowSharingFirstCluster) {
+    str += std::format(" ShaClsDPhi:{} ShaClsDEta:{} ShaClsSign:{}", SharedClusterMaxDeltaPhi, SharedClusterMaxDeltaEta, SharedClusterOppositeSign);
+  }
+  if (MaxHoles) {
+    str += std::format(" MaxHoles:{} HoleMask:{}", MaxHoles, HoleLayerMask.asString());
+  }
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -681,8 +681,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackSeedN> trackSeeds(mMemoryPool.get());
     for (int startCellTopologyId{0}; startCellTopologyId < topology.nCells; ++startCellTopologyId) {
       const int startLayer = topology.getCell(startCellTopologyId).hitLayerMask.last();
-      if ((mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
-          mTimeFrame->getCells()[startCellTopologyId].empty()) {
+      if (!(mTrkParams[iteration].StartLayerMask.has(startLayer)) || mTimeFrame->getCells()[startCellTopologyId].empty()) {
         continue;
       }
 
@@ -814,7 +813,7 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS
     }
 
     /// do not account for the first cluster in the shared clusters number if it is allowed
-    if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].ClusterSharing) {
+    if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].SharedMaxClusters) {
       continue;
     }
 
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
@@ -113,8 +113,8 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
       if (paramConfig.contains("PhiBins")) {
         params.PhiBins = paramConfig["PhiBins"].get<int>();
       }
-      if (paramConfig.contains("ClusterSharing")) {
-        params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
+      if (paramConfig.contains("SharedMaxClusters")) {
+        params.SharedMaxClusters = paramConfig["SharedMaxClusters"].get<int>();
       }
       if (paramConfig.contains("MinTrackLength")) {
         params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();
diff --git a/Framework/Core/include/Framework/DataRefUtils.h b/Framework/Core/include/Framework/DataRefUtils.h
@@ -23,6 +23,7 @@
 
 #include <gsl/gsl>
 
+#include <span>
 #include <type_traits>
 #include <typeinfo>
 
@@ -184,6 +185,10 @@ struct DataRefUtils {
   // Decode a CCDB object using the CcdbApi.
   static void* decodeCCDB(DataRef const& ref, std::type_info const& info);
   static std::map<std::string, std::string> extractCCDBHeaders(DataRef const& ref);
+  /// Return a span over the raw CCDB payload bytes, stripping the flattened HTTP
+  /// headers footer that CCDBFetcherHelper appends. Use this when the CCDB entry is
+  /// a binary blob rather than a ROOT-serialised object.
+  static std::span<const char> getCCDBPayloadBlob(DataRef const& ref);
 
   static o2::header::DataHeader::PayloadSizeType getPayloadSize(const DataRef& ref)
   {
diff --git a/Framework/Core/include/Framework/InputRecord.h b/Framework/Core/include/Framework/InputRecord.h
@@ -35,6 +35,7 @@
 #include <memory>
 #include <type_traits>
 #include <concepts>
+#include <span>
 
 #include <fairmq/FwdDecls.h>
 
@@ -45,6 +46,12 @@ namespace o2::framework
 struct CCDBMetadataExtractor {
 };
 
+/// Tag type to retrieve the raw binary payload of a CCDB entry without ROOT
+/// deserialization. The returned span is valid for the duration of the
+/// processing callback. Use as: inputs.get<CCDBBlob>("binding")
+struct CCDBBlob {
+};
+
 struct InputSpec;
 class InputSpan;
 class CallbackService;
@@ -522,6 +529,18 @@ class InputRecord
     return cache.idToMetadata[id];
   }
 
+  template <typename T = DataRef, typename R>
+  std::span<const char> get(R binding, int part = 0) const
+    requires std::same_as<T, CCDBBlob>
+  {
+    auto ref = getRef(binding, part);
+    auto header = DataRefUtils::getHeader<header::DataHeader*>(ref);
+    if (header->payloadSerializationMethod != header::gSerializationMethodCCDB) {
+      throw runtime_error("Attempt to extract CCDBBlob from a non-CCDB-serialized message");
+    }
+    return DataRefUtils::getCCDBPayloadBlob(ref);
+  }
+
   template <typename T>
     requires(std::same_as<T, DataRef>)
   decltype(auto) get(ConcreteDataMatcher matcher, int part = 0)
diff --git a/Framework/Core/src/DPLWebSocket.cxx b/Framework/Core/src/DPLWebSocket.cxx
@@ -516,6 +516,7 @@ struct WriteRequestContext {
 struct BulkWriteRequestContext {
   std::vector<uv_buf_t> buffers;
   ServiceRegistryRef ref;
+  std::vector<char*>* freeList = nullptr; // if non-null, return chunks here instead of freeing
 };
 
 void ws_client_write_callback(uv_write_t* h, int status)
@@ -543,11 +544,14 @@ void ws_client_bulk_write_callback(uv_write_t* h, int status)
   state.loopReason |= (DeviceState::WS_COMMUNICATION | DeviceState::WS_WRITING);
   if (status < 0) {
     LOG(error) << "uv_write error: " << uv_err_name(status);
-    free(h);
-    return;
   }
-  if (context->buffers.size()) {
-    for (auto& b : context->buffers) {
+  // Return chunks to the free list (capped) so flushPending can pre-seed
+  // the backlog for the next cycle without malloc-ing.
+  constexpr size_t kMaxFreeChunks = 4;
+  for (auto& b : context->buffers) {
+    if (context->freeList && b.base && context->freeList->size() < kMaxFreeChunks) {
+      context->freeList->push_back(b.base);
+    } else {
       free(b.base);
     }
   }
@@ -584,4 +588,18 @@ void WSDPLClient::write(std::vector<uv_buf_t>& outputs)
            context->buffers.size(), ws_client_bulk_write_callback);
 }
 
+void WSDPLClient::write(std::vector<uv_buf_t>& outputs, std::vector<char*>& freeList)
+{
+  if (outputs.empty()) {
+    return;
+  }
+  auto* write_req = (uv_write_t*)malloc(sizeof(uv_write_t));
+  auto* context = new BulkWriteRequestContext{.ref = mContext->ref};
+  context->buffers.swap(outputs);
+  context->freeList = &freeList;
+  write_req->data = context;
+  uv_write(write_req, (uv_stream_t*)mStream, &context->buffers.at(0),
+           context->buffers.size(), ws_client_bulk_write_callback);
+}
+
 } // namespace o2::framework
diff --git a/Framework/Core/src/DPLWebSocket.h b/Framework/Core/src/DPLWebSocket.h
@@ -89,6 +89,10 @@ struct WSDPLClient : public HTTPParser {
   /// Helper to write n buffers containing websockets frames to a server
   void write(std::vector<uv_buf_t>& outputs);
 
+  /// Like write() above but recycles the chunk memory into freeList once the
+  /// kernel has consumed the buffers, instead of freeing it.
+  void write(std::vector<uv_buf_t>& outputs, std::vector<char*>& freeList);
+
   /// Dump headers
   void dumpHeaders();
   void sendHandshake();
diff --git a/Framework/Core/src/DataRefUtils.cxx b/Framework/Core/src/DataRefUtils.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <span>
 #include <typeinfo>
 #include <cstring>
 #include "Framework/DataRefUtils.h"
@@ -148,4 +149,19 @@ std::map<std::string, std::string> DataRefUtils::extractCCDBHeaders(DataRef cons
   return res;
 }
 
+std::span<const char> DataRefUtils::getCCDBPayloadBlob(DataRef const& ref)
+{
+  auto* dh = o2::header::get<o2::header::DataHeader*>(ref.header);
+  const char* buff = ref.payload;
+  size_t payloadSize = dh->payloadSize;
+  constexpr char FlatHeaderAnnot[] = "$HEADER$";
+  constexpr size_t Offset = sizeof(int) + sizeof(FlatHeaderAnnot);
+  int headerSize = 0;
+  if (payloadSize >= Offset &&
+      !std::strncmp(buff + payloadSize - sizeof(FlatHeaderAnnot), FlatHeaderAnnot, sizeof(FlatHeaderAnnot))) {
+    headerSize = *reinterpret_cast<const int*>(buff + payloadSize - Offset);
+  }
+  return {buff, payloadSize - headerSize};
+}
+
 } // namespace o2::framework
diff --git a/Framework/Core/src/WSDriverClient.cxx b/Framework/Core/src/WSDriverClient.cxx
@@ -245,7 +245,8 @@ void on_connect(uv_connect_t* connection, int status)
         return false;
       }
       return true;
-    }, &name);
+    },
+                 &name);
   });
 
   client->observe("/signpost:disable", [](std::string_view cmd) {
@@ -263,7 +264,8 @@ void on_connect(uv_connect_t* connection, int status)
         return false;
       }
       return true;
-    }, &name);
+    },
+                 &name);
   });
 
   // Client will be filled in the line after. I can probably have a single
@@ -305,6 +307,12 @@ WSDriverClient::WSDriverClient(ServiceRegistryRef registry, char const* ip, unsi
 
 WSDriverClient::~WSDriverClient()
 {
+  for (auto& buf : mBacklog) {
+    free(buf.base);
+  }
+  for (auto* chunk : mFreeChunks) {
+    free(chunk);
+  }
   free(this->mAwakeMainThread);
 }
 
@@ -371,8 +379,24 @@ void WSDriverClient::flushPending(ServiceRegistryRef mainThreadRef)
     printed1 = false;
     printed2 = false;
   }
-  mClient->write(mBacklog);
-  mBacklog.resize(0);
+  // Return any pre-seeded but unused (zero-length) buffers to the free list
+  // so we don't send pointless zero-byte writes to the kernel.
+  while (!mBacklog.empty() && mBacklog.back().len == 0) {
+    mFreeChunks.push_back(mBacklog.back().base);
+    mBacklog.pop_back();
+  }
+  mClient->write(mBacklog, mFreeChunks);
+  // Pre-seed mBacklog with one recycled chunk from the previous write's callback
+  // so that the next encode_websocket_frames reuses memory instead of malloc-ing.
+  // Only one chunk (64 KB) since encode_websocket_frames appends to outputs.back().
+  if (!mFreeChunks.empty()) {
+    mBacklog.push_back(uv_buf_init(mFreeChunks.back(), 0));
+    mFreeChunks.pop_back();
+  }
+  for (auto* chunk : mFreeChunks) {
+    free(chunk);
+  }
+  mFreeChunks.clear();
 }
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/WSDriverClient.h b/Framework/Core/src/WSDriverClient.h
@@ -56,6 +56,7 @@ class WSDriverClient : public DriverClient
   std::mutex mClientMutex;
   ServiceRegistryRef mRegistry;
   std::vector<uv_buf_t> mBacklog;
+  std::vector<char*> mFreeChunks; ///< recycled WebSocket buffer chunks (main-thread only)
   uv_async_t* mAwakeMainThread = nullptr;
   uv_connect_t* mConnection = nullptr;
   std::unique_ptr<WSDPLClient> mClient;

Original file line number	Diff line number	Diff line change
`@@ -192,12 +192,11 @@ class TrackITSExt : public TrackITS`
`192`	`192`	`getClusterRefs().setEntries(ncl);`
`193`	`193`	`}`
`194`	`194`
`195`		`- GPUhdi() const int getClusterIndex(int lr) const { return mIndex[lr]; }`
	`195`	`+ GPUhdi() int getClusterIndex(int lr) const { return mIndex[lr]; }`
`196`	`196`
`197`		`- GPUh() const int getFirstLayerClusterIndex() const`
	`197`	`+ GPUh() int getFirstLayerClusterIndex() const`
`198`	`198`	`{`
`199`		`- int firstLayer = getFirstClusterLayer();`
`200`		`- return getClusterIndex(firstLayer);`
	`199`	`+ return getClusterIndex(getFirstClusterLayer());`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`GPUhdi() void setExternalClusterIndex(int layer, int idx, bool newCluster = false)`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,9 @@ using namespace o2::its;`
`24`	`24`
`25`	`25`	`std::string TrackingParameters::asString() const`
`26`	`26`	`{`
`27`		`- std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{} MaxHoles:{} HoleMask:{:#x}",`
`28`		`- ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength, MaxHoles, HoleLayerMask);`
	`27`	`+ std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} TtklMinPt:{:.2f} MinCl:{}", ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, TrackletMinPt, MinTrackLength);`
	`28`	`+ auto isSet = [](auto e) { return e >= 0; };`
	`29`	`+ auto isAnySet = [&isSet](auto v) { return !v.empty() && std::any_of(v.begin(), v.end(), isSet); };`
`29`	`30`	`bool first = true;`
`30`	`31`	`for (int il = NLayers; il >= MinTrackLength; il--) {`
`31`	`32`	`int slot = NLayers - il;`
`@@ -37,18 +38,27 @@ std::string TrackingParameters::asString() const`
`37`	`38`	`str += std::format("L{}:{:.2f} ", il, MinPt[slot]);`
`38`	`39`	`}`
`39`	`40`	`}`
`40`		`- if (!SystErrorY2.empty() \|\| !SystErrorZ2.empty()) {`
	`41`	`+ if (isAnySet(SystErrorY2) \|\| isAnySet(SystErrorZ2)) {`
`41`	`42`	`str += " SystErrY/Z:";`
`42`	`43`	`for (size_t i = 0; i < SystErrorY2.size(); i++) {`
`43`	`44`	`str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);`
`44`	`45`	`}`
`45`	`46`	`}`
`46`		`- if (!AddTimeError.empty()) {`
	`47`	`+ if (isAnySet(AddTimeError)) {`
`47`	`48`	`str += " AddTimeError:";`
`48`	`49`	`for (unsigned int i : AddTimeError) {`
`49`	`50`	`str += std::format("{} ", i);`
`50`	`51`	`}`
`51`	`52`	`}`
	`53`	`+ if (SharedMaxClusters) {`
	`54`	`+ str += std::format(" ShaMaxCls:{} ", SharedMaxClusters);`
	`55`	`+ }`
	`56`	`+ if (AllowSharingFirstCluster) {`
	`57`	`+ str += std::format(" ShaClsDPhi:{} ShaClsDEta:{} ShaClsSign:{}", SharedClusterMaxDeltaPhi, SharedClusterMaxDeltaEta, SharedClusterOppositeSign);`
	`58`	`+ }`
	`59`	`+ if (MaxHoles) {`
	`60`	`+ str += std::format(" MaxHoles:{} HoleMask:{}", MaxHoles, HoleLayerMask.asString());`
	`61`	`+ }`
`52`	`62`	`if (std::numeric_limits<size_t>::max() != MaxMemory) {`
`53`	`63`	`str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);`
`54`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -681,8 +681,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)`
`681`	`681`	`bounded_vector<TrackSeedN> trackSeeds(mMemoryPool.get());`
`682`	`682`	`for (int startCellTopologyId{0}; startCellTopologyId < topology.nCells; ++startCellTopologyId) {`
`683`	`683`	`const int startLayer = topology.getCell(startCellTopologyId).hitLayerMask.last();`
`684`		`- if ((mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 \|\|`
`685`		`- mTimeFrame->getCells()[startCellTopologyId].empty()) {`
	`684`	`+ if (!(mTrkParams[iteration].StartLayerMask.has(startLayer)) \|\| mTimeFrame->getCells()[startCellTopologyId].empty()) {`
`686`	`685`	`continue;`
`687`	`686`	`}`
`688`	`687`
`@@ -814,7 +813,7 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS`
`814`	`813`	`}`
`815`	`814`
`816`	`815`	`/// do not account for the first cluster in the shared clusters number if it is allowed`
`817`		`- if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].ClusterSharing) {`
	`816`	`+ if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].SharedMaxClusters) {`
`818`	`817`	`continue;`
`819`	`818`	`}`
`820`	`819`
Original file line number	Diff line number	Diff line change
`@@ -113,8 +113,8 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon`
`113`	`113`	`if (paramConfig.contains("PhiBins")) {`
`114`	`114`	`params.PhiBins = paramConfig["PhiBins"].get<int>();`
`115`	`115`	`}`
`116`		`- if (paramConfig.contains("ClusterSharing")) {`
`117`		`- params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();`
	`116`	`+ if (paramConfig.contains("SharedMaxClusters")) {`
	`117`	`+ params.SharedMaxClusters = paramConfig["SharedMaxClusters"].get<int>();`
`118`	`118`	`}`
`119`	`119`	`if (paramConfig.contains("MinTrackLength")) {`
`120`	`120`	`params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();`