Merge branch 'AliceO2Group:dev' into fd3_digits

Author: pkurash

.clang-tidy

@@ -1,3 +1,42 @@
+---
+Checks:
+  - -*
+  - modernize-avoid-bind
+  - modernize-deprecated-headers
+  - modernize-make-shared
+  - modernize-raw-string-literal
+  - modernize-redundant-void-arg
+  - modernize-replace-auto-ptr
+  - modernize-replace-random-shuffle
+  - modernize-shrink-to-fit
+  - modernize-unary-static-assert
+  - modernize-use-equals-default
+  - modernize-use-noexcept
+  - modernize-use-nullptr
+  - modernize-use-override
+  - modernize-use-transparent-functors
+  - modernize-use-uncaught-exceptions
+  - readability-braces-around-statements
+  - -clang-diagnostic-vla-cxx-extension
 CheckOptions:
-  - key: CheckPathRegex
-    value: '.*/O2/.*'
+  # Naming conventions
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.ClassMemberPrefix: m
+  readability-identifier-naming.ConceptCase: CamelCase
+  readability-identifier-naming.ConstexprVariableCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.EnumConstantIgnoredRegexp: "^k?[A-Z][a-zA-Z0-9_]*$" # Allow "k" prefix and non-trailing underscores in PDG names.
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.MacroDefinitionIgnoredRegexp: "^[A-Z][A-Z0-9_]*_$" # Allow the trailing underscore in header guards.
+  readability-identifier-naming.MemberCase: camelBack
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.ParameterCase: camelBack
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  readability-identifier-naming.TypeTemplateParameterCase: CamelCase
+  readability-identifier-naming.VariableCase: camelBack
+...

Common/Utils/include/CommonUtils/NameConf.h

@@ -100,6 +100,9 @@ class NameConf : public o2::conf::ConfigurableParamHelper<NameConf>
   // CTF Dictionary
   static std::string getCTFDictFileName();
 
+  // O2 Raw TF Filename
+  static std::string getRawTFFileName(uint32_t run, uint32_t orb, uint32_t id, const std::string& host, const std::string_view prefix = "o2_rawtf_dump");
+
   // Default CCDB server
   static std::string getCCDBServer();
 

Common/Utils/src/NameConf.cxx

@@ -95,6 +95,11 @@ std::string NameConf::getCTFFileName(uint32_t run, uint32_t orb, uint32_t id, co
   return o2::utils::Str::concat_string(prefix, '_', fmt::format("run{:08d}_orbit{:010d}_tf{:010d}_{}", run, orb, id, host), ".root");
 }
 
+std::string NameConf::getRawTFFileName(uint32_t run, uint32_t orb, uint32_t id, const std::string& host, const std::string_view prefix)
+{
+  return o2::utils::Str::concat_string(prefix, '_', fmt::format("run{:08d}_orbit{:010d}_tf{:010d}_{}", run, orb, id, host), ".tf");
+}
+
 std::string NameConf::getCTFDictFileName()
 {
   return o2::utils::Str::concat_string(CTFDICT, ".root");

DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h

@@ -85,11 +85,13 @@ struct Data {
     return positive ? magnitude : -magnitude;
   }
 
-  // Encode from float: clamps magnitude to 15 bits, range ±255.992
+  // Encode from float: truncates magnitude to 15 bits, range ±255.992
   void setCMVFloat(float value)
   {
     const bool positive = (value >= 0.f);
-    const uint16_t magnitude = static_cast<uint16_t>(std::abs(value) * 128.f + 0.5f) & 0x7FFF;
+    const uint16_t magnitude = static_cast<uint16_t>(
+                                 std::lround(std::abs(value) * 128.f)) &
+                               0x7FFF;
     cmv = (positive ? 0x8000 : 0x0000) | magnitude;
   }
 };
@@ -119,4 +121,4 @@ struct Container {
 
 } // namespace o2::tpc::cmv
 
-#endif
+#endif

Detectors/CTF/workflow/src/CTFWriterSpec.cxx

@@ -310,7 +310,7 @@ size_t CTFWriterSpec::processDet(o2::framework::ProcessingContext& pc, DetID det
   if (det == DetID::ITS) {
     nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
   } else if (det == DetID::MFT) {
-    nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+    nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
   }
   for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
     auto binding = getBinding(det.getName(), iLayer);
@@ -431,7 +431,7 @@ size_t CTFWriterSpec::estimateCTFSize(ProcessingContext& pc)
     if (det == DetID::ITS) {
       nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
     } else if (det == DetID::MFT) {
-      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
     }
     for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
       auto binding = getBinding(det.getName(), iLayer);
@@ -818,7 +818,7 @@ DataProcessorSpec getCTFWriterSpec(const o2::ctf::CTFWriterInp& inp)
       if (det == DetID::ITS) {
         nLayers = inp.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
       } else if (det == DetID::MFT) {
-        nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+        nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
       }
       for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
         inputs.emplace_back(CTFWriterSpec::getBinding(det.getName(), iLayer), det.getDataOrigin(), "CTFDATA", iLayer, Lifetime::Timeframe);

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h

@@ -31,7 +31,11 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   using typename TimeFrame<NLayers>::ROFOverlapTableN;
   using typename TimeFrame<NLayers>::ROFVertexLookupTableN;
   using typename TimeFrame<NLayers>::ROFMaskTableN;
+  using typename TimeFrame<NLayers>::TrackingTopologyN;
   using typename TimeFrame<NLayers>::TrackSeedN;
+  static constexpr int MaxTransitions = TrackingTopologyN::MaxTransitions;
+  static constexpr int MaxCells = TrackingTopologyN::MaxCells;
+  static constexpr int MaxStreams = MaxCells > NLayers ? MaxCells : NLayers;
 
  public:
   TimeFrameGPU() = default;
@@ -42,30 +46,32 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void popMemoryStack(const int);
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
-  void initialise(const int, const TrackingParameters&, const int);
-  void loadIndexTableUtils(const int);
-  void loadTrackingFrameInfoDevice(const int, const int);
-  void createTrackingFrameInfoDeviceArray(const int);
-  void loadUnsortedClustersDevice(const int, const int);
-  void createUnsortedClustersDeviceArray(const int, const int = NLayers);
-  void loadClustersDevice(const int, const int);
-  void createClustersDeviceArray(const int, const int = NLayers);
-  void loadClustersIndexTables(const int, const int);
-  void createClustersIndexTablesArray(const int);
-  void createUsedClustersDevice(const int, const int);
-  void createUsedClustersDeviceArray(const int, const int = NLayers);
+  void initialise(const TrackingParameters&, int maxLayers);
+  void initialise(const TrackingParameters&, int maxLayers, int iteration);
+  void loadIndexTableUtils();
+  void loadTrackingTopologies();
+  void loadTrackingFrameInfoDevice(const int);
+  void createTrackingFrameInfoDeviceArray();
+  void loadUnsortedClustersDevice(const int);
+  void createUnsortedClustersDeviceArray(const int = NLayers);
+  void loadClustersDevice(const int);
+  void createClustersDeviceArray(const int = NLayers);
+  void loadClustersIndexTables(const int);
+  void createClustersIndexTablesArray();
+  void createUsedClustersDevice(const int);
+  void createUsedClustersDeviceArray(const int = NLayers);
   void loadUsedClustersDevice();
-  void loadROFrameClustersDevice(const int, const int);
-  void createROFrameClustersDeviceArray(const int);
+  void loadROFrameClustersDevice(const int);
+  void createROFrameClustersDeviceArray();
   void loadROFCutMask(const int);
-  void loadVertices(const int);
-  void loadROFOverlapTable(const int);
-  void loadROFVertexLookupTable(const int);
-  void updateROFVertexLookupTable(const int);
+  void loadVertices();
+  void loadROFOverlapTable();
+  void loadROFVertexLookupTable();
+  void updateROFVertexLookupTable();
 
   ///
-  void createTrackletsLUTDevice(const int, const int);
-  void createTrackletsLUTDeviceArray(const int);
+  void createTrackletsLUTDevice(bool, const int);
+  void createTrackletsLUTDeviceArray();
   void loadTrackletsDevice();
   void loadTrackletsLUTDevice();
   void loadCellsDevice();
@@ -74,18 +80,18 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void loadTrackSeedsChi2Device();
   void loadTrackSeedsDevice(bounded_vector<TrackSeedN>&);
   void createTrackletsBuffers(const int);
-  void createTrackletsBuffersArray(const int);
+  void createTrackletsBuffersArray();
   void createCellsBuffers(const int);
-  void createCellsBuffersArray(const int);
+  void createCellsBuffersArray();
   void createCellsDevice();
   void createCellsLUTDevice(const int);
-  void createCellsLUTDeviceArray(const int);
+  void createCellsLUTDeviceArray();
   void createNeighboursIndexTablesDevice(const int);
   void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
   void createTrackITSExtDevice(const size_t);
   void downloadTrackITSExtDevice();
-  void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
+  void downloadCellsNeighboursDevice(std::vector<bounded_vector<CellNeighbour>>&, const int);
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
@@ -109,6 +115,7 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   const auto getDeviceROFOverlapTableView() { return mDeviceROFOverlapTableView; }
   const auto getDeviceROFVertexLookupTableView() { return mDeviceROFVertexLookupTableView; }
   const auto getDeviceROFMaskTableView() { return mDeviceROFMaskTableView; }
+  const auto getDeviceTrackingTopologyView() const { return mDeviceTrackingTopologyView; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
   auto& getTrackITSExt() { return mTrackITSExt; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
@@ -120,10 +127,9 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   TrackITSExt* getDeviceTrackITSExt() { return mTrackITSExtDevice; }
   int* getDeviceNeighboursLUT(const int layer) { return mNeighboursLUTDevice[layer]; }
   gsl::span<int*> getDeviceNeighboursLUTs() { return mNeighboursLUTDevice; }
-  gpuPair<int, int>* getDeviceNeighbourPairs(const int layer) { return mNeighbourPairsDevice[layer]; }
-  std::array<int*, NLayers - 2>& getDeviceNeighboursAll() { return mNeighboursDevice; }
-  int* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
-  int** getDeviceNeighboursArray() { return mNeighboursDevice.data(); }
+  CellNeighbour** getDeviceArrayNeighbours() { return mNeighboursDeviceArray; }
+  std::array<CellNeighbour*, MaxCells>& getDeviceNeighboursAll() { return mNeighboursDevice; }
+  CellNeighbour* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
   TrackingFrameInfo* getDeviceTrackingFrameInfo(const int);
   const TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() const { return mTrackingFrameInfoDeviceArray; }
   const Cluster** getDeviceArrayClusters() const { return mClustersDeviceArray; }
@@ -147,10 +153,10 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
-  gsl::span<int, NLayers - 1> getNTracklets() { return mNTracklets; }
-  gsl::span<int, NLayers - 2> getNCells() { return mNCells; }
+  gsl::span<int> getNTracklets() { return {mNTracklets.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nTransitions)}; }
+  gsl::span<int> getNCells() { return {mNCells.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nCells)}; }
   auto& getArrayNCells() { return mNCells; }
-  gsl::span<int, NLayers - 3> getNNeighbours() { return mNNeighbours; }
+  gsl::span<int> getNNeighbours() { return {mNNeighbours.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nCells)}; }
   auto& getArrayNNeighbours() { return mNNeighbours; }
 
   // Host-available device getters
@@ -169,16 +175,18 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void allocMem(void**, size_t, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU);               // Abstract owned and unowned memory allocations on default stream
 
   // Host-available device buffer sizes
-  std::array<int, NLayers - 1> mNTracklets;
-  std::array<int, NLayers - 2> mNCells;
-  std::array<int, NLayers - 3> mNNeighbours;
+  std::array<int, MaxTransitions> mNTracklets{};
+  std::array<int, MaxCells> mNCells{};
+  std::array<int, MaxCells> mNNeighbours{};
 
   // Device pointers
   IndexTableUtilsN* mIndexTableUtilsDevice;
   // device navigation views
   ROFOverlapTableN::View mDeviceROFOverlapTableView;
   ROFVertexLookupTableN::View mDeviceROFVertexLookupTableView;
   ROFMaskTableN::View mDeviceROFMaskTableView;
+  std::vector<typename TrackingTopologyN::View> mDeviceTrackerTopologyViews;
+  typename TrackingTopologyN::View mDeviceTrackingTopologyView;
 
   // Hybrid pref
   Vertex* mPrimaryVerticesDevice;
@@ -193,30 +201,29 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   const int** mClustersIndexTablesDeviceArray;
   uint8_t** mUsedClustersDeviceArray;
   const int** mROFramesClustersDeviceArray;
-  std::array<Tracklet*, NLayers - 1> mTrackletsDevice;
-  std::array<int*, NLayers - 1> mTrackletsLUTDevice;
-  std::array<int*, NLayers - 2> mCellsLUTDevice;
-  std::array<int*, NLayers - 3> mNeighboursLUTDevice;
+  std::array<Tracklet*, MaxTransitions> mTrackletsDevice{};
+  std::array<int*, MaxTransitions> mTrackletsLUTDevice{};
+  std::array<int*, MaxCells> mCellsLUTDevice{};
+  std::array<int*, MaxCells> mNeighboursLUTDevice{};
 
   Tracklet** mTrackletsDeviceArray{nullptr};
   int** mCellsLUTDeviceArray{nullptr};
-  int** mNeighboursCellDeviceArray{nullptr};
   int** mNeighboursCellLUTDeviceArray{nullptr};
   int** mTrackletsLUTDeviceArray{nullptr};
-  std::array<CellSeed*, NLayers - 2> mCellsDevice;
+  std::array<CellSeed*, MaxCells> mCellsDevice{};
   CellSeed** mCellsDeviceArray;
-  std::array<int*, NLayers - 3> mNeighboursIndexTablesDevice;
+  std::array<int*, MaxCells> mNeighboursIndexTablesDevice{};
   TrackSeedN* mTrackSeedsDevice{nullptr};
   int* mTrackSeedsLUTDevice{nullptr};
   unsigned int mNTracks{0};
-  std::array<o2::track::TrackParCovF*, NLayers - 2> mCellSeedsDevice;
+  std::array<o2::track::TrackParCovF*, MaxCells> mCellSeedsDevice{};
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
-  std::array<float*, NLayers - 2> mCellSeedsChi2Device;
+  std::array<float*, MaxCells> mCellSeedsChi2Device{};
   float** mCellSeedsChi2DeviceArray;
 
   TrackITSExt* mTrackITSExtDevice;
-  std::array<gpuPair<int, int>*, NLayers - 2> mNeighbourPairsDevice;
-  std::array<int*, NLayers - 2> mNeighboursDevice;
+  std::array<CellNeighbour*, MaxCells> mNeighboursDevice{};
+  CellNeighbour** mNeighboursDeviceArray{nullptr};
   std::array<TrackingFrameInfo*, NLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
@@ -245,19 +252,19 @@ inline std::vector<unsigned int> TimeFrameGPU<NLayers>::getClusterSizes()
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfTracklets() const
 {
-  return std::accumulate(mNTracklets.begin(), mNTracklets.end(), 0);
+  return std::accumulate(mNTracklets.begin(), mNTracklets.begin() + this->mTrackingTopologyView.nTransitions, 0);
 }
 
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfCells() const
 {
-  return std::accumulate(mNCells.begin(), mNCells.end(), 0);
+  return std::accumulate(mNCells.begin(), mNCells.begin() + this->mTrackingTopologyView.nCells, 0);
 }
 
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfNeighbours() const
 {
-  return std::accumulate(mNNeighbours.begin(), mNNeighbours.end(), 0);
+  return std::accumulate(mNNeighbours.begin(), mNNeighbours.begin() + this->mTrackingTopologyView.nCells, 0);
 }
 
 } // namespace o2::its::gpu