ALICE3: start global tracking directory with TRK tracking (CPU+GPU and ROF staggering)

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

@@ -25,7 +25,7 @@ namespace o2::its::gpu
 {
 
 template <int NLayers>
-class TimeFrameGPU final : public TimeFrame<NLayers>
+class TimeFrameGPU : public TimeFrame<NLayers>
 {
   using typename TimeFrame<NLayers>::IndexTableUtilsN;
   using typename TimeFrame<NLayers>::ROFOverlapTableN;
@@ -35,7 +35,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
 
  public:
   TimeFrameGPU() = default;
-  ~TimeFrameGPU() final = default;
+  ~TimeFrameGPU() override = default;
 
   /// Most relevant operations
   void pushMemoryStack(const int);

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu

@@ -694,4 +694,5 @@ void TimeFrameGPU<NLayers>::wipe()
 }
 
 template class TimeFrameGPU<7>;
+template class TimeFrameGPU<11>;
 } // namespace o2::its::gpu

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx

@@ -380,4 +380,7 @@ void TrackerTraitsGPU<NLayers>::setBz(float bz)
 }
 
 template class TrackerTraitsGPU<7>;
+#ifdef ENABLE_UPGRADES
+template class TrackerTraitsGPU<11>;
+#endif
 } // namespace o2::its

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu

@@ -1258,4 +1258,185 @@ template void computeTrackSeedHandler(TrackSeed<7>* trackSeeds,
                                       const o2::base::PropagatorF::MatCorrType matCorrType,
                                       o2::its::ExternalAllocator* alloc);
 
+/// Explicit instantiation of ALICE3 handlers
+#ifdef ENABLE_UPGRADES
+template void countTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
+                                              const ROFMaskTable<11>::View& rofMask,
+                                              const int layer,
+                                              const ROFOverlapTable<11>::View& rofOverlaps,
+                                              const ROFVertexLookupTable<11>::View& vertexLUT,
+                                              const int vertexId,
+                                              const Vertex* vertices,
+                                              const int* rofPV,
+                                              const Cluster** clusters,
+                                              std::vector<unsigned int> nClusters,
+                                              const int** ROFClusters,
+                                              const unsigned char** usedClusters,
+                                              const int** clustersIndexTables,
+                                              int** trackletsLUTs,
+                                              gsl::span<int*> trackletsLUTsHost,
+                                              const int iteration,
+                                              const float NSigmaCut,
+                                              bounded_vector<float>& phiCuts,
+                                              const float resolutionPV,
+                                              std::array<float, 11>& minRs,
+                                              std::array<float, 11>& maxRs,
+                                              bounded_vector<float>& resolutions,
+                                              std::vector<float>& radii,
+                                              bounded_vector<float>& mulScatAng,
+                                              o2::its::ExternalAllocator* alloc,
+                                              gpu::Streams& streams);
+
+template void computeTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
+                                                const ROFMaskTable<11>::View& rofMask,
+                                                const int layer,
+                                                const ROFOverlapTable<11>::View& rofOverlaps,
+                                                const ROFVertexLookupTable<11>::View& vertexLUT,
+                                                const int vertexId,
+                                                const Vertex* vertices,
+                                                const int* rofPV,
+                                                const Cluster** clusters,
+                                                std::vector<unsigned int> nClusters,
+                                                const int** ROFClusters,
+                                                const unsigned char** usedClusters,
+                                                const int** clustersIndexTables,
+                                                Tracklet** tracklets,
+                                                gsl::span<Tracklet*> spanTracklets,
+                                                gsl::span<int> nTracklets,
+                                                int** trackletsLUTs,
+                                                gsl::span<int*> trackletsLUTsHost,
+                                                const int iteration,
+                                                const float NSigmaCut,
+                                                bounded_vector<float>& phiCuts,
+                                                const float resolutionPV,
+                                                std::array<float, 11>& minRs,
+                                                std::array<float, 11>& maxRs,
+                                                bounded_vector<float>& resolutions,
+                                                std::vector<float>& radii,
+                                                bounded_vector<float>& mulScatAng,
+                                                o2::its::ExternalAllocator* alloc,
+                                                gpu::Streams& streams);
+
+template void countCellsHandler<11>(const Cluster** sortedClusters,
+                                    const Cluster** unsortedClusters,
+                                    const TrackingFrameInfo** tfInfo,
+                                    Tracklet** tracklets,
+                                    int** trackletsLUT,
+                                    const int nTracklets,
+                                    const int layer,
+                                    CellSeed* cells,
+                                    int** cellsLUTsArrayDevice,
+                                    int* cellsLUTsHost,
+                                    const float bz,
+                                    const float maxChi2ClusterAttachment,
+                                    const float cellDeltaTanLambdaSigma,
+                                    const float nSigmaCut,
+                                    const std::vector<float>& layerxX0Host,
+                                    o2::its::ExternalAllocator* alloc,
+                                    gpu::Streams& streams);
+
+template void computeCellsHandler<11>(const Cluster** sortedClusters,
+                                      const Cluster** unsortedClusters,
+                                      const TrackingFrameInfo** tfInfo,
+                                      Tracklet** tracklets,
+                                      int** trackletsLUT,
+                                      const int nTracklets,
+                                      const int layer,
+                                      CellSeed* cells,
+                                      int** cellsLUTsArrayDevice,
+                                      int* cellsLUTsHost,
+                                      const float bz,
+                                      const float maxChi2ClusterAttachment,
+                                      const float cellDeltaTanLambdaSigma,
+                                      const float nSigmaCut,
+                                      const std::vector<float>& layerxX0Host,
+                                      gpu::Streams& streams);
+
+template void countCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
+                                             int* neighboursLUT,
+                                             int** cellsLUTs,
+                                             gpuPair<int, int>* cellNeighbours,
+                                             int* neighboursIndexTable,
+                                             const Tracklet** tracklets,
+                                             const float maxChi2ClusterAttachment,
+                                             const float bz,
+                                             const int layerIndex,
+                                             const unsigned int nCells,
+                                             const unsigned int nCellsNext,
+                                             const int maxCellNeighbours,
+                                             o2::its::ExternalAllocator* alloc,
+                                             gpu::Stream& stream);
+
+template void computeCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
+                                               int* neighboursLUT,
+                                               int** cellsLUTs,
+                                               gpuPair<int, int>* cellNeighbours,
+                                               int* neighboursIndexTable,
+                                               const Tracklet** tracklets,
+                                               const float maxChi2ClusterAttachment,
+                                               const float bz,
+                                               const int layerIndex,
+                                               const unsigned int nCells,
+                                               const unsigned int nCellsNext,
+                                               const int maxCellNeighbours,
+                                               gpu::Stream& stream);
+
+template void processNeighboursHandler<11>(const int startLayer,
+                                           const int startLevel,
+                                           CellSeed** allCellSeeds,
+                                           CellSeed* currentCellSeeds,
+                                           std::array<int, 9>& nCells,
+                                           const unsigned char** usedClusters,
+                                           std::array<int*, 9>& neighbours,
+                                           gsl::span<int*> neighboursDeviceLUTs,
+                                           const TrackingFrameInfo** foundTrackingFrameInfo,
+                                           bounded_vector<TrackSeed<11>>& seedsHost,
+                                           const float bz,
+                                           const float maxChi2ClusterAttachment,
+                                           const float maxChi2NDF,
+                                           const std::vector<float>& layerxX0Host,
+                                           const o2::base::Propagator* propagator,
+                                           const o2::base::PropagatorF::MatCorrType matCorrType,
+                                           o2::its::ExternalAllocator* alloc);
+
+template void countTrackSeedHandler(TrackSeed<11>* trackSeeds,
+                                    const TrackingFrameInfo** foundTrackingFrameInfo,
+                                    const Cluster** unsortedClusters,
+                                    int* seedLUT,
+                                    const std::vector<float>& layerRadiiHost,
+                                    const std::vector<float>& minPtsHost,
+                                    const std::vector<float>& layerxX0Host,
+                                    const unsigned int nSeeds,
+                                    const float bz,
+                                    const int startLevel,
+                                    const float maxChi2ClusterAttachment,
+                                    const float maxChi2NDF,
+                                    const int reseedIfShorter,
+                                    const bool repeatRefitOut,
+                                    const bool shiftRefToCluster,
+                                    const o2::base::Propagator* propagator,
+                                    const o2::base::PropagatorF::MatCorrType matCorrType,
+                                    o2::its::ExternalAllocator* alloc);
+
+template void computeTrackSeedHandler(TrackSeed<11>* trackSeeds,
+                                      const TrackingFrameInfo** foundTrackingFrameInfo,
+                                      const Cluster** unsortedClusters,
+                                      o2::its::TrackITSExt* tracks,
+                                      const int* seedLUT,
+                                      const std::vector<float>& layerRadiiHost,
+                                      const std::vector<float>& minPtsHost,
+                                      const std::vector<float>& layerxX0Host,
+                                      const unsigned int nSeeds,
+                                      const unsigned int nTracks,
+                                      const float bz,
+                                      const int startLevel,
+                                      const float maxChi2ClusterAttachment,
+                                      const float maxChi2NDF,
+                                      const int reseedIfShorter,
+                                      const bool repeatRefitOut,
+                                      const bool shiftRefToCluster,
+                                      const o2::base::Propagator* propagator,
+                                      const o2::base::PropagatorF::MatCorrType matCorrType,
+                                      o2::its::ExternalAllocator* alloc);
+#endif
 } // namespace o2::its

Detectors/Upgrades/ALICE3/CMakeLists.txt

@@ -11,6 +11,7 @@
 
 add_subdirectory(Passive)
 add_subdirectory(TRK)
+add_subdirectory(GlobalReconstruction)
 add_subdirectory(ECal)
 add_subdirectory(FD3)
 add_subdirectory(FT3)

Detectors/Upgrades/ALICE3/GlobalReconstruction/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_subdirectory(reconstruction)
+add_subdirectory(workflow)
+add_subdirectory(macros)

Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test_root_macro(CheckTracksALICE3.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::DataFormatsTRK
+                                             O2::ITStracking
+                                             O2::SimulationDataFormat
+                                             O2::DetectorsBase
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                                             O2::Steer
+                       LABELS trk COMPILE_ONLY)