diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h index a178a662b8796..2bed2f9be28be 100644 --- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h +++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h @@ -37,7 +37,7 @@ class TrackITS : public o2::track::TrackParCov public: using o2::track::TrackParCov::TrackParCov; // inherit base constructors - static constexpr int MaxClusters = 7; + static constexpr int MaxClusters = 16; TrackITS() = default; TrackITS(const TrackITS& t) = default; @@ -87,7 +87,7 @@ class TrackITS : public o2::track::TrackParCov o2::track::TrackParCov& getParamOut() { return mParamOut; } const o2::track::TrackParCov& getParamOut() const { return mParamOut; } - void setPattern(uint8_t p) { mPattern = p; } + void setPattern(uint16_t p) { mPattern = p; } int getPattern() const { return mPattern; } bool hasHitOnLayer(int i) { return mPattern & (0x1 << i); } @@ -95,7 +95,7 @@ class TrackITS : public o2::track::TrackParCov o2::track::TrackParCov mParamOut; ///< parameter at largest radius ClusRefs mClusRef; ///< references on clusters float mChi2 = 0.; ///< Chi2 for this track - uint8_t mPattern = 0; ///< layers pattern + uint16_t mPattern = 0; ///< layers pattern ClassDefNV(TrackITS, 4); }; @@ -104,7 +104,7 @@ class TrackITSExt : public TrackITS { ///< heavy version of TrackITS, with clusters embedded public: - static constexpr int MaxClusters = 7; + static constexpr int MaxClusters = 16; /// Prepare for overlaps and new detector configurations using TrackITS::TrackITS; // inherit base constructors TrackITSExt(o2::track::TrackParCov&& parCov, short ncl, float chi2, @@ -132,7 +132,7 @@ class TrackITSExt : public TrackITS } private: - std::array mIndex = {-1}; ///< Indices of associated clusters + std::array mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; ///< Indices of associated clusters ClassDefNV(TrackITSExt, 2); }; } // namespace its diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt index 5465d25b3ab33..7315b166edf54 100644 --- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt +++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt @@ -19,7 +19,7 @@ o2_add_library(ITStracking src/Label.cxx src/PrimaryVertexContext.cxx src/Road.cxx - src/StandaloneDebugger.cxx + # src/StandaloneDebugger.cxx src/Tracker.cxx src/TrackerTraitsCPU.cxx src/TrackingConfigParam.cxx diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreNV.h b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreNV.h index d5e38ff3b6319..32485259f7980 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreNV.h +++ b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreNV.h @@ -29,6 +29,7 @@ namespace o2 { namespace its { + namespace GPU { @@ -38,83 +39,83 @@ class DeviceStoreNV final DeviceStoreNV(); UniquePointer initialise(const float3&, - const std::array, constants::its::LayersNumber>&, - const std::array, constants::its::TrackletsPerRoad>&, - const std::array, constants::its::CellsPerRoad>&, - const std::array, constants::its::CellsPerRoad - 1>&, - const std::array&, - const std::array&); + const std::array, constants::its2::LayersNumber>&, + const std::array, constants::its2::TrackletsPerRoad>&, + const std::array, constants::its2::CellsPerRoad>&, + const std::array, constants::its2::CellsPerRoad - 1>&, + const std::array&, + const std::array&); GPU_DEVICE const float3& getPrimaryVertex(); - GPU_HOST_DEVICE Array, constants::its::LayersNumber>& getClusters(); - GPU_DEVICE Array, - constants::its::TrackletsPerRoad>& + GPU_HOST_DEVICE Array, constants::its2::LayersNumber>& getClusters(); + GPU_DEVICE Array, + constants::its2::TrackletsPerRoad>& getIndexTables(); - GPU_HOST_DEVICE Array, constants::its::TrackletsPerRoad>& getTracklets(); - GPU_HOST_DEVICE Array, constants::its::CellsPerRoad>& getTrackletsLookupTable(); - GPU_HOST_DEVICE Array, constants::its::CellsPerRoad>& getTrackletsPerClusterTable(); - GPU_HOST_DEVICE Array, constants::its::CellsPerRoad>& getCells(); - GPU_HOST_DEVICE Array, constants::its::CellsPerRoad - 1>& getCellsLookupTable(); - GPU_HOST_DEVICE Array, constants::its::CellsPerRoad - 1>& getCellsPerTrackletTable(); - Array, constants::its::CellsPerRoad>& getTempTableArray(); + GPU_HOST_DEVICE Array, constants::its2::TrackletsPerRoad>& getTracklets(); + GPU_HOST_DEVICE Array, constants::its2::CellsPerRoad>& getTrackletsLookupTable(); + GPU_HOST_DEVICE Array, constants::its2::CellsPerRoad>& getTrackletsPerClusterTable(); + GPU_HOST_DEVICE Array, constants::its2::CellsPerRoad>& getCells(); + GPU_HOST_DEVICE Array, constants::its2::CellsPerRoad - 1>& getCellsLookupTable(); + GPU_HOST_DEVICE Array, constants::its2::CellsPerRoad - 1>& getCellsPerTrackletTable(); + Array, constants::its2::CellsPerRoad>& getTempTableArray(); GPU_HOST_DEVICE float getRmin(int layer); GPU_HOST_DEVICE float getRmax(int layer); private: UniquePointer mPrimaryVertex; - Array, constants::its::LayersNumber> mClusters; - Array mRmin; - Array mRmax; - Array, constants::its::TrackletsPerRoad> + Array, constants::its2::LayersNumber> mClusters; + Array mRmin; + Array mRmax; + Array, constants::its2::TrackletsPerRoad> mIndexTables; - Array, constants::its::TrackletsPerRoad> mTracklets; - Array, constants::its::CellsPerRoad> mTrackletsLookupTable; - Array, constants::its::CellsPerRoad> mTrackletsPerClusterTable; - Array, constants::its::CellsPerRoad> mCells; - Array, constants::its::CellsPerRoad - 1> mCellsLookupTable; - Array, constants::its::CellsPerRoad - 1> mCellsPerTrackletTable; + Array, constants::its2::TrackletsPerRoad> mTracklets; + Array, constants::its2::CellsPerRoad> mTrackletsLookupTable; + Array, constants::its2::CellsPerRoad> mTrackletsPerClusterTable; + Array, constants::its2::CellsPerRoad> mCells; + Array, constants::its2::CellsPerRoad - 1> mCellsLookupTable; + Array, constants::its2::CellsPerRoad - 1> mCellsPerTrackletTable; }; GPU_DEVICE inline const float3& DeviceStoreNV::getPrimaryVertex() { return *mPrimaryVertex; } -GPU_HOST_DEVICE inline Array, constants::its::LayersNumber>& DeviceStoreNV::getClusters() +GPU_HOST_DEVICE inline Array, constants::its2::LayersNumber>& DeviceStoreNV::getClusters() { return mClusters; } -GPU_DEVICE inline Array, - constants::its::TrackletsPerRoad>& +GPU_DEVICE inline Array, + constants::its2::TrackletsPerRoad>& DeviceStoreNV::getIndexTables() { return mIndexTables; } -GPU_DEVICE inline Array, constants::its::TrackletsPerRoad>& DeviceStoreNV::getTracklets() +GPU_DEVICE inline Array, constants::its2::TrackletsPerRoad>& DeviceStoreNV::getTracklets() { return mTracklets; } -GPU_DEVICE inline Array, constants::its::CellsPerRoad>& DeviceStoreNV::getTrackletsLookupTable() +GPU_DEVICE inline Array, constants::its2::CellsPerRoad>& DeviceStoreNV::getTrackletsLookupTable() { return mTrackletsLookupTable; } -GPU_DEVICE inline Array, constants::its::CellsPerRoad>& DeviceStoreNV::getTrackletsPerClusterTable() +GPU_DEVICE inline Array, constants::its2::CellsPerRoad>& DeviceStoreNV::getTrackletsPerClusterTable() { return mTrackletsPerClusterTable; } -GPU_HOST_DEVICE inline Array, constants::its::CellsPerRoad>& DeviceStoreNV::getCells() +GPU_HOST_DEVICE inline Array, constants::its2::CellsPerRoad>& DeviceStoreNV::getCells() { return mCells; } -GPU_HOST_DEVICE inline Array, constants::its::CellsPerRoad - 1>& DeviceStoreNV::getCellsLookupTable() +GPU_HOST_DEVICE inline Array, constants::its2::CellsPerRoad - 1>& DeviceStoreNV::getCellsLookupTable() { return mCellsLookupTable; } -GPU_HOST_DEVICE inline Array, constants::its::CellsPerRoad - 1>& +GPU_HOST_DEVICE inline Array, constants::its2::CellsPerRoad - 1>& DeviceStoreNV::getCellsPerTrackletTable() { return mCellsPerTrackletTable; diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreVertexerGPU.h b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreVertexerGPU.h index 6bf180fcb93ad..255eb952e96ff 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreVertexerGPU.h +++ b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/DeviceStoreVertexerGPU.h @@ -57,7 +57,7 @@ class DeviceStoreVertexerGPU final ~DeviceStoreVertexerGPU() = default; UniquePointer initialise(const std::array, constants::its::LayersNumberVertexer>&, - const std::array, + const std::array, constants::its::LayersNumberVertexer>&); // RO APIs diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/PrimaryVertexContextNV.h b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/PrimaryVertexContextNV.h index d5d3493a52292..dac80e224b7b8 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/PrimaryVertexContextNV.h +++ b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/PrimaryVertexContextNV.h @@ -38,28 +38,28 @@ class PrimaryVertexContextNV final : public PrimaryVertexContext PrimaryVertexContextNV() = default; virtual ~PrimaryVertexContextNV() = default; - virtual void initialise(const MemoryParameters& memParam, const std::array, constants::its::LayersNumber>& cl, - const std::array& pv, const int iteration); + void initialise(const MemoryParameters& memParam, const std::array, constants::its2::LayersNumber>& cl, + const std::array& pv, const int iteration); GPU::DeviceStoreNV& getDeviceContext(); - GPU::Array, constants::its::LayersNumber>& getDeviceClusters(); - GPU::Array, constants::its::TrackletsPerRoad>& getDeviceTracklets(); - GPU::Array, constants::its::CellsPerRoad>& getDeviceTrackletsLookupTable(); - GPU::Array, constants::its::CellsPerRoad>& getDeviceTrackletsPerClustersTable(); - GPU::Array, constants::its::CellsPerRoad>& getDeviceCells(); - GPU::Array, constants::its::CellsPerRoad - 1>& getDeviceCellsLookupTable(); - GPU::Array, constants::its::CellsPerRoad - 1>& getDeviceCellsPerTrackletTable(); - std::array, constants::its::CellsPerRoad>& getTempTableArray(); - std::array, constants::its::CellsPerRoad>& getTempTrackletArray(); - std::array, constants::its::CellsPerRoad - 1>& getTempCellArray(); + GPU::Array, constants::its2::LayersNumber>& getDeviceClusters(); + GPU::Array, constants::its2::TrackletsPerRoad>& getDeviceTracklets(); + GPU::Array, constants::its2::CellsPerRoad>& getDeviceTrackletsLookupTable(); + GPU::Array, constants::its2::CellsPerRoad>& getDeviceTrackletsPerClustersTable(); + GPU::Array, constants::its2::CellsPerRoad>& getDeviceCells(); + GPU::Array, constants::its2::CellsPerRoad - 1>& getDeviceCellsLookupTable(); + GPU::Array, constants::its2::CellsPerRoad - 1>& getDeviceCellsPerTrackletTable(); + std::array, constants::its2::CellsPerRoad>& getTempTableArray(); + std::array, constants::its2::CellsPerRoad>& getTempTrackletArray(); + std::array, constants::its2::CellsPerRoad - 1>& getTempCellArray(); void updateDeviceContext(); private: GPU::DeviceStoreNV mGPUContext; GPU::UniquePointer mGPUContextDevicePointer; - std::array, constants::its::CellsPerRoad> mTempTableArray; - std::array, constants::its::CellsPerRoad> mTempTrackletArray; - std::array, constants::its::CellsPerRoad - 1> mTempCellArray; + std::array, constants::its2::CellsPerRoad> mTempTableArray; + std::array, constants::its2::CellsPerRoad> mTempTrackletArray; + std::array, constants::its2::CellsPerRoad - 1> mTempCellArray; }; inline GPU::DeviceStoreNV& PrimaryVertexContextNV::getDeviceContext() @@ -67,54 +67,54 @@ inline GPU::DeviceStoreNV& PrimaryVertexContextNV::getDeviceContext() return *mGPUContextDevicePointer; } -inline GPU::Array, constants::its::LayersNumber>& PrimaryVertexContextNV::getDeviceClusters() +inline GPU::Array, constants::its2::LayersNumber>& PrimaryVertexContextNV::getDeviceClusters() { return mGPUContext.getClusters(); } -inline GPU::Array, constants::its::TrackletsPerRoad>& PrimaryVertexContextNV::getDeviceTracklets() +inline GPU::Array, constants::its2::TrackletsPerRoad>& PrimaryVertexContextNV::getDeviceTracklets() { return mGPUContext.getTracklets(); } -inline GPU::Array, constants::its::CellsPerRoad>& PrimaryVertexContextNV::getDeviceTrackletsLookupTable() +inline GPU::Array, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getDeviceTrackletsLookupTable() { return mGPUContext.getTrackletsLookupTable(); } -inline GPU::Array, constants::its::CellsPerRoad>& +inline GPU::Array, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getDeviceTrackletsPerClustersTable() { return mGPUContext.getTrackletsPerClusterTable(); } -inline GPU::Array, constants::its::CellsPerRoad>& PrimaryVertexContextNV::getDeviceCells() +inline GPU::Array, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getDeviceCells() { return mGPUContext.getCells(); } -inline GPU::Array, constants::its::CellsPerRoad - 1>& PrimaryVertexContextNV::getDeviceCellsLookupTable() +inline GPU::Array, constants::its2::CellsPerRoad - 1>& PrimaryVertexContextNV::getDeviceCellsLookupTable() { return mGPUContext.getCellsLookupTable(); } -inline GPU::Array, constants::its::CellsPerRoad - 1>& +inline GPU::Array, constants::its2::CellsPerRoad - 1>& PrimaryVertexContextNV::getDeviceCellsPerTrackletTable() { return mGPUContext.getCellsPerTrackletTable(); } -inline std::array, constants::its::CellsPerRoad>& PrimaryVertexContextNV::getTempTableArray() +inline std::array, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getTempTableArray() { return mTempTableArray; } -inline std::array, constants::its::CellsPerRoad>& PrimaryVertexContextNV::getTempTrackletArray() +inline std::array, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getTempTrackletArray() { return mTempTrackletArray; } -inline std::array, constants::its::CellsPerRoad - 1>& PrimaryVertexContextNV::getTempCellArray() +inline std::array, constants::its2::CellsPerRoad - 1>& PrimaryVertexContextNV::getTempCellArray() { return mTempCellArray; } @@ -124,11 +124,12 @@ inline void PrimaryVertexContextNV::updateDeviceContext() mGPUContextDevicePointer = GPU::UniquePointer{mGPUContext}; } -inline void PrimaryVertexContextNV::initialise(const MemoryParameters& memParam, const std::array, constants::its::LayersNumber>& cl, +inline void PrimaryVertexContextNV::initialise(const MemoryParameters& memParam, const std::array, constants::its2::LayersNumber>& cl, const std::array& pv, const int iteration) { - this->PrimaryVertexContext::initialise(memParam, cl, pv, iteration); - mGPUContextDevicePointer = mGPUContext.initialise(mPrimaryVertex, mClusters, mTracklets, mCells, mCellsLookupTable, mMinR, mMaxR); + ///TODO: to be re-enabled in the future + // this->PrimaryVertexContext::initialise(memParam, cl, pv, iteration); + // mGPUContextDevicePointer = mGPUContext.initialise(mPrimaryVertex, mClusters, mTracklets, mCells, mCellsLookupTable, mMinR, mMaxR); } } // namespace its diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/TrackerTraitsNV.h b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/TrackerTraitsNV.h index ea90e52114428..e3dbd233c7d96 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/TrackerTraitsNV.h +++ b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/TrackerTraitsNV.h @@ -34,7 +34,7 @@ class TrackerTraitsNV : public TrackerTraits void computeLayerCells() final; void computeLayerTracklets() final; - void refitTracks(const std::array, 7>& tf, std::vector& tracks) final; + void refitTracks(const std::array, 7>& tf, std::vector& tracks); }; extern "C" TrackerTraits* createTrackerTraitsNV(); diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/VertexerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/VertexerTraitsGPU.h index a3447e55c586f..4f218e9ada8d4 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/VertexerTraitsGPU.h +++ b/Detectors/ITSMFT/ITS/tracking/cuda/include/ITStrackingCUDA/VertexerTraitsGPU.h @@ -37,7 +37,7 @@ namespace its { class ROframe; -using constants::index_table::InversePhiBinSize; +using constants::its2::InversePhiBinSize; class VertexerTraitsGPU : public VertexerTraits { @@ -69,7 +69,7 @@ class VertexerTraitsGPU : public VertexerTraits inline GPUd() const int2 VertexerTraitsGPU::getBinsPhiRectWindow(const Cluster& currentCluster, float phiCut) { // This function returns the lowest PhiBin and the number of phi bins to be spanned, In the form int2{phiBinLow, PhiBinSpan} - const int phiBinMin{index_table_utils::getPhiBinIndex( + const int phiBinMin{constants::its2::getPhiBinIndex( math_utils::getNormalizedPhiCoordinate(currentCluster.phiCoordinate - phiCut))}; const int phiBinSpan{static_cast(MATH_CEIL(phiCut * InversePhiBinSize))}; return int2{phiBinMin, phiBinSpan}; diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreNV.cu b/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreNV.cu index 14eb74ff41bde..c0152ab12a8bc 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreNV.cu +++ b/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreNV.cu @@ -57,7 +57,7 @@ __device__ void fillIndexTables(GPU::DeviceStoreNV& primaryVertexContext, const if (currentClusterIndex == nextLayerClustersNum - 1) { - for (int iBin{currentBinIndex + 1}; iBin <= o2::its::constants::index_table::ZBins * o2::its::constants::index_table::PhiBins; + for (int iBin{currentBinIndex + 1}; iBin <= o2::its::constants::its2::ZBins * o2::its::constants::its2::PhiBins; iBin++) { primaryVertexContext.getIndexTables()[layerIndex][iBin] = nextLayerClustersNum; @@ -96,12 +96,12 @@ __global__ void fillDeviceStructures(GPU::DeviceStoreNV& primaryVertexContext, c { fillIndexTables(primaryVertexContext, layerIndex); - if (layerIndex < o2::its::constants::its::CellsPerRoad) { + if (layerIndex < o2::its::constants::its2::CellsPerRoad) { fillTrackletsPerClusterTables(primaryVertexContext, layerIndex); } - if (layerIndex < o2::its::constants::its::CellsPerRoad - 1) { + if (layerIndex < o2::its::constants::its2::CellsPerRoad - 1) { fillCellsPerClusterTables(primaryVertexContext, layerIndex); } @@ -121,34 +121,34 @@ DeviceStoreNV::DeviceStoreNV() } UniquePointer DeviceStoreNV::initialise(const float3& primaryVertex, - const std::array, constants::its::LayersNumber>& clusters, - const std::array, constants::its::TrackletsPerRoad>& tracklets, - const std::array, constants::its::CellsPerRoad>& cells, - const std::array, constants::its::CellsPerRoad - 1>& cellsLookupTable, - const std::array& rmin, - const std::array& rmax) + const std::array, constants::its2::LayersNumber>& clusters, + const std::array, constants::its2::TrackletsPerRoad>& tracklets, + const std::array, constants::its2::CellsPerRoad>& cells, + const std::array, constants::its2::CellsPerRoad - 1>& cellsLookupTable, + const std::array& rmin, + const std::array& rmax) { mPrimaryVertex = UniquePointer{primaryVertex}; - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::LayersNumber; ++iLayer) { this->mRmin[iLayer] = rmin[iLayer]; this->mRmax[iLayer] = rmax[iLayer]; this->mClusters[iLayer] = Vector{&clusters[iLayer][0], static_cast(clusters[iLayer].size())}; - if (iLayer < constants::its::TrackletsPerRoad) { + if (iLayer < constants::its2::TrackletsPerRoad) { this->mTracklets[iLayer].reset(tracklets[iLayer].capacity()); } - if (iLayer < constants::its::CellsPerRoad) { + if (iLayer < constants::its2::CellsPerRoad) { this->mTrackletsLookupTable[iLayer].reset(static_cast(clusters[iLayer + 1].size())); this->mTrackletsPerClusterTable[iLayer].reset(static_cast(clusters[iLayer + 1].size())); this->mCells[iLayer].reset(static_cast(cells[iLayer].capacity())); } - if (iLayer < constants::its::CellsPerRoad - 1) { + if (iLayer < constants::its2::CellsPerRoad - 1) { this->mCellsLookupTable[iLayer].reset(static_cast(cellsLookupTable[iLayer].size())); this->mCellsPerTrackletTable[iLayer].reset(static_cast(cellsLookupTable[iLayer].size())); @@ -157,9 +157,9 @@ UniquePointer DeviceStoreNV::initialise(const float3& primaryVert UniquePointer gpuContextDevicePointer{*this}; - std::array streamArray; + std::array streamArray; - for (int iLayer{0}; iLayer < constants::its::TrackletsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::TrackletsPerRoad; ++iLayer) { const int nextLayerClustersNum = static_cast(clusters[iLayer + 1].size()); diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreVertexerGPU.cu b/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreVertexerGPU.cu index cdcec77a16029..4c113d77e0ffd 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreVertexerGPU.cu +++ b/Detectors/ITSMFT/ITS/tracking/cuda/src/DeviceStoreVertexerGPU.cu @@ -47,7 +47,7 @@ DeviceStoreVertexerGPU::DeviceStoreVertexerGPU() mBeamPosition = Vector{2, 2}; for (int iTable{0}; iTable < 2; ++iTable) { - mIndexTables[iTable] = Vector{constants::index_table::ZBins * constants::index_table::PhiBins + 1}; // 2*20*20+1 * sizeof(int) = 802B + mIndexTables[iTable] = Vector{constants::its2::ZBins * constants::its2::PhiBins + 1}; // 2*20*20+1 * sizeof(int) = 802B } for (int iLayer{0}; iLayer < constants::its::LayersNumberVertexer; ++iLayer) { // 4e4 * 3 * sizof(Cluster) = 3.36MB mClusters[iLayer] = Vector{mGPUConf.clustersPerLayerCapacity, mGPUConf.clustersPerLayerCapacity}; @@ -68,7 +68,7 @@ DeviceStoreVertexerGPU::DeviceStoreVertexerGPU() } // namespace GPU UniquePointer DeviceStoreVertexerGPU::initialise(const std::array, constants::its::LayersNumberVertexer>& clusters, - const std::array, + const std::array, constants::its::LayersNumberVertexer>& indexTables) { #ifdef _ALLOW_DEBUG_TREES_ITS_ diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/src/TrackerTraitsNV.cu b/Detectors/ITSMFT/ITS/tracking/cuda/src/TrackerTraitsNV.cu index 186f0b25ead9a..c81a2c149b37c 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/src/TrackerTraitsNV.cu +++ b/Detectors/ITSMFT/ITS/tracking/cuda/src/TrackerTraitsNV.cu @@ -37,10 +37,52 @@ namespace o2 { namespace its { + +using namespace constants::its2; +GPU_DEVICE const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex, + const float z1, const float z2, float maxdeltaz, float maxdeltaphi) +{ + const float zRangeMin = gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz; + const float phiRangeMin = currentCluster.phiCoordinate - maxdeltaphi; + const float zRangeMax = gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz; + const float phiRangeMax = currentCluster.phiCoordinate + maxdeltaphi; + + if (zRangeMax < -LayersZCoordinate()[layerIndex + 1] || + zRangeMin > LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) { + + return getEmptyBinsRect(); + } + + return int4{gpu::GPUCommonMath::Max(0, getZBinIndex(layerIndex + 1, zRangeMin)), + getPhiBinIndex(phiRangeMin), + gpu::GPUCommonMath::Min(ZBins - 1, getZBinIndex(layerIndex + 1, zRangeMax)), + getPhiBinIndex(phiRangeMax)}; +} + namespace GPU { -__constant__ TrackingParameters kTrkPar; +struct StaticTrackingParameters { + StaticTrackingParameters& operator=(const StaticTrackingParameters& t); + + int CellMinimumLevel(); + + /// General parameters + int ClusterSharing = 0; + int MinTrackLength = 7; + /// Trackleting cuts + float TrackletMaxDeltaPhi = 0.3f; + float TrackletMaxDeltaZ[constants::its2::TrackletsPerRoad] = {0.1f, 0.1f, 0.3f, 0.3f, 0.3f, 0.3f}; + /// Cell finding cuts + float CellMaxDeltaTanLambda = 0.025f; + float CellMaxDCA[constants::its2::CellsPerRoad] = {0.05f, 0.04f, 0.05f, 0.2f, 0.4f}; + float CellMaxDeltaPhi = 0.14f; + float CellMaxDeltaZ[constants::its2::CellsPerRoad] = {0.2f, 0.4f, 0.5f, 0.6f, 3.0f}; + /// Neighbour finding cuts + float NeighbourMaxDeltaCurvature[constants::its2::CellsPerRoad - 1] = {0.008f, 0.0025f, 0.003f, 0.0035f}; + float NeighbourMaxDeltaN[constants::its2::CellsPerRoad - 1] = {0.002f, 0.0090f, 0.002f, 0.005f}; +}; +__constant__ StaticTrackingParameters kTrkPar; __device__ void computeLayerTracklets(DeviceStoreNV& devStore, const int layerIndex, Vector& trackletsVector) @@ -62,8 +104,8 @@ __device__ void computeLayerTracklets(DeviceStoreNV& devStore, const int layerIn const float zAtRmin{tanLambda * (devStore.getRmin(layerIndex + 1) - currentCluster.rCoordinate) + currentCluster.zCoordinate}; const float zAtRmax{tanLambda * (devStore.getRmax(layerIndex + 1) - currentCluster.rCoordinate) + currentCluster.zCoordinate}; - const int4 selectedBinsRect{TrackerTraits::getBinsRect(currentCluster, layerIndex, zAtRmin, zAtRmax, - kTrkPar.TrackletMaxDeltaZ[layerIndex], kTrkPar.TrackletMaxDeltaPhi)}; + const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex, zAtRmin, zAtRmax, + kTrkPar.TrackletMaxDeltaZ[layerIndex], kTrkPar.TrackletMaxDeltaPhi)}; if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) { @@ -72,13 +114,13 @@ __device__ void computeLayerTracklets(DeviceStoreNV& devStore, const int layerIn if (phiBinsNum < 0) { - phiBinsNum += constants::index_table::PhiBins; + phiBinsNum += constants::its2::PhiBins; } for (int iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; - iPhiBin = ++iPhiBin == constants::index_table::PhiBins ? 0 : iPhiBin, iPhiCount++) { + iPhiBin = ++iPhiBin == constants::its2::PhiBins ? 0 : iPhiBin, iPhiCount++) { - const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect.x, iPhiBin)}; + const int firstBinIndex{constants::its2::getBinIndex(selectedBinsRect.x, iPhiBin)}; const int firstRowClusterIndex = devStore.getIndexTables()[layerIndex][firstBinIndex]; const int maxRowClusterIndex = devStore.getIndexTables()[layerIndex][{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1}]; @@ -282,12 +324,12 @@ void TrackerTraitsNV::computeLayerTracklets() { PrimaryVertexContextNV* primaryVertexContext = static_cast(mPrimaryVertexContext); - cudaMemcpyToSymbol(GPU::kTrkPar, &mTrkParams, sizeof(TrackingParameters)); - std::array tempSize; - std::array trackletsNum; - std::array streamArray; + // cudaMemcpyToSymbol(GPU::kTrkPar, &mTrkParams, sizeof(TrackingParameters)); + std::array tempSize; + std::array trackletsNum; + std::array streamArray; - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad; ++iLayer) { tempSize[iLayer] = 0; primaryVertexContext->getTempTrackletArray()[iLayer].reset( @@ -303,7 +345,7 @@ void TrackerTraitsNV::computeLayerTracklets() cudaDeviceSynchronize(); - for (int iLayer{0}; iLayer < constants::its::TrackletsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::TrackletsPerRoad; ++iLayer) { const GPU::DeviceProperties& deviceProperties = GPU::Context::getInstance().getDeviceProperties(); const int clustersNum{static_cast(primaryVertexContext->getClusters()[iLayer].size())}; @@ -335,7 +377,7 @@ void TrackerTraitsNV::computeLayerTracklets() cudaDeviceSynchronize(); - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad; ++iLayer) { trackletsNum[iLayer] = primaryVertexContext->getTempTrackletArray()[iLayer].getSizeFromDevice(); if (trackletsNum[iLayer] == 0) { @@ -371,12 +413,12 @@ void TrackerTraitsNV::computeLayerCells() { PrimaryVertexContextNV* primaryVertexContext = static_cast(mPrimaryVertexContext); - std::array tempSize; - std::array trackletsNum; - std::array cellsNum; - std::array streamArray; + std::array tempSize; + std::array trackletsNum; + std::array cellsNum; + std::array streamArray; - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad - 1; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad - 1; ++iLayer) { tempSize[iLayer] = 0; trackletsNum[iLayer] = primaryVertexContext->getDeviceTracklets()[iLayer + 1].getSizeFromDevice(); @@ -394,7 +436,7 @@ void TrackerTraitsNV::computeLayerCells() cudaDeviceSynchronize(); - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad; ++iLayer) { const GPU::DeviceProperties& deviceProperties = GPU::Context::getInstance().getDeviceProperties(); const int trackletsSize = primaryVertexContext->getDeviceTracklets()[iLayer].getSizeFromDevice(); if (trackletsSize == 0) { @@ -428,7 +470,7 @@ void TrackerTraitsNV::computeLayerCells() cudaDeviceSynchronize(); - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad - 1; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad - 1; ++iLayer) { cellsNum[iLayer] = primaryVertexContext->getTempCellArray()[iLayer].getSizeFromDevice(); if (cellsNum[iLayer] == 0) { continue; @@ -460,7 +502,7 @@ void TrackerTraitsNV::computeLayerCells() cudaDeviceSynchronize(); - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < constants::its2::CellsPerRoad; ++iLayer) { int cellsSize = 0; if (iLayer == 0) { @@ -493,7 +535,8 @@ void TrackerTraitsNV::refitTracks(const std::arraygetDeviceClusters()[iLayer].get(); } - mChainRunITSTrackFit(*mChain, mPrimaryVertexContext->getRoads(), clusters, cells, tf, tracks); + //TODO: restore this + // mChainRunITSTrackFit(*mChain, mPrimaryVertexContext->getRoads(), clusters, cells, tf, tracks); } } // namespace its } // namespace o2 diff --git a/Detectors/ITSMFT/ITS/tracking/cuda/src/VertexerTraitsGPU.cu b/Detectors/ITSMFT/ITS/tracking/cuda/src/VertexerTraitsGPU.cu index 790a7b9f5b3bb..9b34edeecd800 100644 --- a/Detectors/ITSMFT/ITS/tracking/cuda/src/VertexerTraitsGPU.cu +++ b/Detectors/ITSMFT/ITS/tracking/cuda/src/VertexerTraitsGPU.cu @@ -37,16 +37,31 @@ namespace o2 namespace its { -using constants::index_table::PhiBins; -using constants::index_table::ZBins; -using constants::its::LayersRCoordinate; -using constants::its::LayersZCoordinate; using constants::its::VertexerHistogramVolume; using constants::math::TwoPi; -using index_table_utils::getPhiBinIndex; -using index_table_utils::getZBinIndex; using math_utils::getNormalizedPhiCoordinate; +using namespace constants::its2; +GPU_DEVICE const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex, + const float z1, float maxdeltaz, float maxdeltaphi) +{ + const float zRangeMin = z1 - maxdeltaz; + const float phiRangeMin = currentCluster.phiCoordinate - maxdeltaphi; + const float zRangeMax = z1 + maxdeltaz; + const float phiRangeMax = currentCluster.phiCoordinate + maxdeltaphi; + + if (zRangeMax < -LayersZCoordinate()[layerIndex + 1] || + zRangeMin > LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) { + + return getEmptyBinsRect(); + } + + return int4{gpu::GPUCommonMath::Max(0, getZBinIndex(layerIndex + 1, zRangeMin)), + getPhiBinIndex(phiRangeMin), + gpu::GPUCommonMath::Min(ZBins - 1, getZBinIndex(layerIndex + 1, zRangeMax)), + getPhiBinIndex(phiRangeMax)}; +} + GPUh() void gpuThrowOnError() { cudaError_t error = cudaGetLastError(); @@ -82,7 +97,8 @@ void VertexerTraitsGPU::initialise(ROframe* event) { reset(); arrangeClusters(event); - mStoreVertexerGPUPtr = mStoreVertexerGPU.initialise(mClusters, mIndexTables); + //TODO: restore this + // mStoreVertexerGPUPtr = mStoreVertexerGPU.initialise(mClusters, mIndexTables); } namespace GPU @@ -147,7 +163,7 @@ GPUg() void trackleterKernel( const size_t stride{currentClusterIndex * store.getConfig().maxTrackletsPerCluster}; const Cluster& currentCluster = store.getClusters()[1][currentClusterIndex]; // assign-constructor may be a problem, check const VertexerLayerName adjacentLayerIndex{layerOrder == TrackletingLayerOrder::fromInnermostToMiddleLayer ? VertexerLayerName::innermostLayer : VertexerLayerName::outerLayer}; - const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, static_cast(adjacentLayerIndex), 0.f, 50.f, phiCut / 2)}; + const int4 selectedBinsRect{getBinsRect(currentCluster, static_cast(adjacentLayerIndex), 0.f, 50.f, phiCut / 2)}; if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) { int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1}; if (phiBinsNum < 0) { @@ -155,7 +171,7 @@ GPUg() void trackleterKernel( } const size_t nClustersAdjacentLayer = store.getClusters()[static_cast(adjacentLayerIndex)].size(); for (size_t iPhiBin{(size_t)selectedBinsRect.y}, iPhiCount{0}; iPhiCount < (size_t)phiBinsNum; iPhiBin = ++iPhiBin == PhiBins ? 0 : iPhiBin, iPhiCount++) { - const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect.x, iPhiBin)}; + const int firstBinIndex{constants::its2::getBinIndex(selectedBinsRect.x, iPhiBin)}; const int firstRowClusterIndex{store.getIndexTable(adjacentLayerIndex)[firstBinIndex]}; const int maxRowClusterIndex{store.getIndexTable(adjacentLayerIndex)[firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1]}; for (size_t iAdjacentCluster{(size_t)firstRowClusterIndex}; iAdjacentCluster < (size_t)maxRowClusterIndex && iAdjacentCluster < nClustersAdjacentLayer; ++iAdjacentCluster) { diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h index 68c09dc52f5a5..9c2d7b7fe9f40 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h @@ -21,19 +21,20 @@ #include "ITStracking/Definitions.h" #include "ITStracking/MathUtils.h" -#include "ITStracking/IndexTableUtils.h" namespace o2 { namespace its { +class IndexTableUtils; + struct Cluster final { Cluster() = default; Cluster(const float x, const float y, const float z, const int idx); - Cluster(const int, const Cluster&); - Cluster(const int, const float3&, const Cluster&); - void Init(const int, const float3&, const Cluster&); + Cluster(const int, const IndexTableUtils& utils, const Cluster&); + Cluster(const int, const float3&, const IndexTableUtils& utils, const Cluster&); + void Init(const int, const float3&, const IndexTableUtils& utils, const Cluster&); float xCoordinate; // = -999.f; float yCoordinate; // = -999.f; diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h index 2951da3b81ae3..671804e39b3b2 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h @@ -15,10 +15,12 @@ #ifndef TRACKINGITSU_INCLUDE_CONFIGURATION_H_ #define TRACKINGITSU_INCLUDE_CONFIGURATION_H_ +#ifndef GPUCA_GPUCODE_DEVICE #include #include #include #include +#endif #include "ITStracking/Constants.h" @@ -44,32 +46,40 @@ class Configuration : public Param }; struct TrackingParameters { - TrackingParameters& operator=(const TrackingParameters& t); + TrackingParameters& operator=(const TrackingParameters& t) = default; int CellMinimumLevel(); + int CellsPerRoad() const { return NLayers - 2; } + int TrackletsPerRoad() const { return NLayers - 1; } + + int NLayers = 7; + std::vector LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1}; + std::vector LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}; + int ZBins{256}; + int PhiBins{128}; /// General parameters int ClusterSharing = 0; int MinTrackLength = 7; /// Trackleting cuts float TrackletMaxDeltaPhi = 0.3f; - float TrackletMaxDeltaZ[constants::its::TrackletsPerRoad] = {0.1f, 0.1f, 0.3f, 0.3f, 0.3f, 0.3f}; + std::vector TrackletMaxDeltaZ = {0.1f, 0.1f, 0.3f, 0.3f, 0.3f, 0.3f}; /// Cell finding cuts float CellMaxDeltaTanLambda = 0.025f; - float CellMaxDCA[constants::its::CellsPerRoad] = {0.05f, 0.04f, 0.05f, 0.2f, 0.4f}; + std::vector CellMaxDCA = {0.05f, 0.04f, 0.05f, 0.2f, 0.4f}; float CellMaxDeltaPhi = 0.14f; - float CellMaxDeltaZ[constants::its::CellsPerRoad] = {0.2f, 0.4f, 0.5f, 0.6f, 3.0f}; + std::vector CellMaxDeltaZ = {0.2f, 0.4f, 0.5f, 0.6f, 3.0f}; /// Neighbour finding cuts - float NeighbourMaxDeltaCurvature[constants::its::CellsPerRoad - 1] = {0.008f, 0.0025f, 0.003f, 0.0035f}; - float NeighbourMaxDeltaN[constants::its::CellsPerRoad - 1] = {0.002f, 0.0090f, 0.002f, 0.005f}; + std::vector NeighbourMaxDeltaCurvature = {0.008f, 0.0025f, 0.003f, 0.0035f}; + std::vector NeighbourMaxDeltaN = {0.002f, 0.0090f, 0.002f, 0.005f}; }; struct MemoryParameters { /// Memory coefficients - MemoryParameters& operator=(const MemoryParameters& t); + MemoryParameters& operator=(const MemoryParameters& t) = default; int MemoryOffset = 256; - float CellsMemoryCoefficients[constants::its::CellsPerRoad] = {2.3208e-08f, 2.104e-08f, 1.6432e-08f, 1.2412e-08f, 1.3543e-08f}; - float TrackletsMemoryCoefficients[constants::its::TrackletsPerRoad] = {0.0016353f, 0.0013627f, 0.000984f, 0.00078135f, 0.00057934f, 0.00052217f}; + std::vector CellsMemoryCoefficients = {2.3208e-08f, 2.104e-08f, 1.6432e-08f, 1.2412e-08f, 1.3543e-08f}; + std::vector TrackletsMemoryCoefficients = {0.0016353f, 0.0013627f, 0.000984f, 0.00078135f, 0.00057934f, 0.00052217f}; }; inline int TrackingParameters::CellMinimumLevel() @@ -77,43 +87,12 @@ inline int TrackingParameters::CellMinimumLevel() return MinTrackLength - constants::its::ClustersPerCell + 1; } -inline TrackingParameters& TrackingParameters::operator=(const TrackingParameters& t) -{ - this->ClusterSharing = t.ClusterSharing; - this->MinTrackLength = t.MinTrackLength; - /// Trackleting cuts - this->TrackletMaxDeltaPhi = t.TrackletMaxDeltaPhi; - for (int iT = 0; iT < constants::its::TrackletsPerRoad; ++iT) { - this->TrackletMaxDeltaZ[iT] = t.TrackletMaxDeltaZ[iT]; - } - /// Cell finding cuts - this->CellMaxDeltaTanLambda = t.CellMaxDeltaTanLambda; - this->CellMaxDeltaPhi = t.CellMaxDeltaPhi; - for (int iC = 0; iC < constants::its::CellsPerRoad; ++iC) { - this->CellMaxDCA[iC] = t.CellMaxDCA[iC]; - this->CellMaxDeltaZ[iC] = t.CellMaxDeltaZ[iC]; - } - /// Neighbour finding cuts - for (int iC = 0; iC < constants::its::CellsPerRoad - 1; ++iC) { - this->NeighbourMaxDeltaCurvature[iC] = t.NeighbourMaxDeltaCurvature[iC]; - this->NeighbourMaxDeltaN[iC] = t.NeighbourMaxDeltaN[iC]; - } - return *this; -} - -inline MemoryParameters& MemoryParameters::operator=(const MemoryParameters& t) -{ - this->MemoryOffset = t.MemoryOffset; - for (int iC = 0; iC < constants::its::CellsPerRoad; ++iC) { - this->CellsMemoryCoefficients[iC] = t.CellsMemoryCoefficients[iC]; - } - for (int iT = 0; iT < constants::its::TrackletsPerRoad; ++iT) { - this->TrackletsMemoryCoefficients[iT] = t.TrackletsMemoryCoefficients[iT]; - } - return *this; -} - struct VertexingParameters { + std::vector LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1}; + std::vector LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}; + int ZBins{256}; + int PhiBins{128}; + float zCut = 0.002f; //0.002f float phiCut = 0.005f; //0.005f float pairCut = 0.04f; diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h index e6353c9cae8af..40cdc77f185c5 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h @@ -21,6 +21,7 @@ #endif #include "ITStracking/Definitions.h" +#include "GPUCommonMath.h" namespace o2 { @@ -41,14 +42,23 @@ constexpr float FloatMinThreshold{1e-20f}; namespace its { -constexpr int LayersNumber{7}; constexpr int LayersNumberVertexer{3}; -constexpr int TrackletsPerRoad{LayersNumber - 1}; -constexpr int CellsPerRoad{LayersNumber - 2}; constexpr int ClustersPerCell{3}; constexpr int UnusedIndex{-1}; constexpr float Resolution{0.0005f}; +GPU_HOST_DEVICE constexpr GPUArray VertexerHistogramVolume() +{ + return GPUArray{{1.98, 1.98, 40.f}}; +} +} // namespace its + +namespace its2 +{ +constexpr int LayersNumber{7}; +constexpr int TrackletsPerRoad{LayersNumber - 1}; +constexpr int CellsPerRoad{LayersNumber - 2}; + GPU_HOST_DEVICE constexpr GPUArray LayersZCoordinate() { constexpr double s = 1.; // safety margin @@ -58,25 +68,42 @@ GPU_HOST_DEVICE constexpr GPUArray LayersRCoordinate() { return GPUArray{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}}; } -GPU_HOST_DEVICE constexpr GPUArray VertexerHistogramVolume() + +constexpr int ZBins{256}; +constexpr int PhiBins{128}; +constexpr float InversePhiBinSize{PhiBins / constants::math::TwoPi}; +GPU_HOST_DEVICE constexpr GPUArray InverseZBinSize() { - return GPUArray{{1.98, 1.98, 40.f}}; + constexpr auto zSize = LayersZCoordinate(); + return GPUArray{{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]), + 0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]), + 0.5f * ZBins / (zSize[6])}}; +} +inline float getInverseZCoordinate(const int layerIndex) +{ + return 0.5f * ZBins / LayersZCoordinate()[layerIndex]; } -} // namespace its -namespace index_table +GPU_HOST_DEVICE inline int getZBinIndex(const int layerIndex, const float zCoordinate) { -constexpr int ZBins{256}; -constexpr int PhiBins{128}; -constexpr float InversePhiBinSize{constants::index_table::PhiBins / constants::math::TwoPi}; -GPU_HOST_DEVICE constexpr GPUArray InverseZBinSize() + return (zCoordinate + LayersZCoordinate()[layerIndex]) * + InverseZBinSize()[layerIndex]; +} + +GPU_HOST_DEVICE inline int getPhiBinIndex(const float currentPhi) { - constexpr auto zSize = its::LayersZCoordinate(); - return GPUArray{{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]), - 0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]), - 0.5f * ZBins / (zSize[6])}}; + return (currentPhi * InversePhiBinSize); } -} // namespace index_table + +GPU_HOST_DEVICE inline int getBinIndex(const int zIndex, const int phiIndex) +{ + return gpu::GPUCommonMath::Min(phiIndex * ZBins + zIndex, + ZBins * PhiBins - 1); +} + +GPU_HOST_DEVICE constexpr int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; } + +} // namespace its2 namespace pdgcodes { diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h index 8afe8dbbe4b78..621052f088f91 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h @@ -55,7 +55,6 @@ constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow; constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol; -void loadConfigurations(const std::string&); std::vector loadEventData(const std::string&); void loadEventData(ROframe& events, gsl::span clusters, gsl::span::iterator& pattIt, const itsmft::TopologyDictionary& dict, @@ -63,7 +62,7 @@ void loadEventData(ROframe& events, gsl::span clus int loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& events, gsl::span clusters, gsl::span::iterator& pattIt, const itsmft::TopologyDictionary& dict, const dataformats::MCTruthContainer* mClsLabels = nullptr); -void generateSimpleData(ROframe& event, const int phiDivs, const int zDivs); +// void generateSimpleData(ROframe& event, const int phiDivs, const int zDivs); void convertCompactClusters(gsl::span clusters, gsl::span::iterator& pattIt, diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h index 228defce3b650..034994ca898f5 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h @@ -22,6 +22,7 @@ #endif #include "ITStracking/Constants.h" +#include "ITStracking/Configuration.h" #include "ITStracking/Definitions.h" #include "GPUCommonMath.h" #include "GPUCommonDef.h" @@ -31,42 +32,64 @@ namespace o2 namespace its { -namespace index_table_utils +class IndexTableUtils { -float getInverseZBinSize(const int); -GPUhdi() int getZBinIndex(const int, const float); -GPUhdi() int getPhiBinIndex(const float); -GPUhdi() int getBinIndex(const int, const int); -GPUhdi() int countRowSelectedBins( - const GPUArray&, const int, const int, - const int); -} // namespace index_table_utils + public: + template + void setTrackingParameters(const T& params); + float getInverseZCoordinate(const int layerIndex) const; + GPUhdi() int getZBinIndex(const int, const float) const; + GPUhdi() int getPhiBinIndex(const float) const; + GPUhdi() int getBinIndex(const int, const int) const; + GPUhdi() int countRowSelectedBins(const int*, const int, const int, const int) const; -inline float getInverseZCoordinate(const int layerIndex) + GPUhdi() int getNzBins() const { return mNzBins; } + GPUhdi() int getNphiBins() const { return mNphiBins; } + GPUhdi() float getLayerZ(int i) const { return mLayerZ[i]; } + + private: + int mNzBins = 0; + int mNphiBins = 0; + float mInversePhiBinSize = 0.f; + std::vector mLayerZ; + std::vector mInverseZBinSize; +}; + +template +inline void IndexTableUtils::setTrackingParameters(const T& params) +{ + mInversePhiBinSize = params.PhiBins / constants::math::TwoPi; + mInverseZBinSize.resize(params.LayerZ.size()); + mNzBins = params.ZBins; + mNphiBins = params.PhiBins; + mLayerZ = params.LayerZ; + for (unsigned int iL{0}; iL < mInverseZBinSize.size(); ++iL) { + mInverseZBinSize[iL] = 0.5f * params.ZBins / params.LayerZ[iL]; + } +} + +inline float IndexTableUtils::getInverseZCoordinate(const int layerIndex) const { - return 0.5f * constants::index_table::ZBins / constants::its::LayersZCoordinate()[layerIndex]; + return 0.5f * mNzBins / mLayerZ[layerIndex]; } -GPUhdi() int index_table_utils::getZBinIndex(const int layerIndex, const float zCoordinate) +GPUhdi() int IndexTableUtils::getZBinIndex(const int layerIndex, const float zCoordinate) const { - return (zCoordinate + constants::its::LayersZCoordinate()[layerIndex]) * - constants::index_table::InverseZBinSize()[layerIndex]; + return (zCoordinate + mLayerZ[layerIndex]) * mInverseZBinSize[layerIndex]; } -GPUhdi() int index_table_utils::getPhiBinIndex(const float currentPhi) +GPUhdi() int IndexTableUtils::getPhiBinIndex(const float currentPhi) const { - return (currentPhi * constants::index_table::InversePhiBinSize); + return (currentPhi * mInversePhiBinSize); } -GPUhdi() int index_table_utils::getBinIndex(const int zIndex, const int phiIndex) +GPUhdi() int IndexTableUtils::getBinIndex(const int zIndex, const int phiIndex) const { - return gpu::GPUCommonMath::Min(phiIndex * constants::index_table::ZBins + zIndex, - constants::index_table::ZBins * constants::index_table::PhiBins - 1); + return gpu::GPUCommonMath::Min(phiIndex * mNzBins + zIndex, mNzBins * mNphiBins - 1); } -GPUhdi() int index_table_utils::countRowSelectedBins( - const GPUArray& indexTable, - const int phiBinIndex, const int minZBinIndex, const int maxZBinIndex) +GPUhdi() int IndexTableUtils::countRowSelectedBins(const int* indexTable, const int phiBinIndex, + const int minZBinIndex, const int maxZBinIndex) const { const int firstBinIndex{getBinIndex(minZBinIndex, phiBinIndex)}; const int maxBinIndex{firstBinIndex + maxZBinIndex - minZBinIndex + 1}; diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/PrimaryVertexContext.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/PrimaryVertexContext.h index 3c363c4d7219f..112c3fe77d3dd 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/PrimaryVertexContext.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/PrimaryVertexContext.h @@ -24,6 +24,7 @@ #include "ITStracking/Configuration.h" #include "ITStracking/Constants.h" #include "ITStracking/Definitions.h" +#include "ITStracking/IndexTableUtils.h" #include "ITStracking/Road.h" #include "ITStracking/Tracklet.h" @@ -42,99 +43,55 @@ class PrimaryVertexContext PrimaryVertexContext(const PrimaryVertexContext&) = delete; PrimaryVertexContext& operator=(const PrimaryVertexContext&) = delete; - virtual void initialise(const MemoryParameters& memParam, const std::array, constants::its::LayersNumber>& cl, - const std::array& pv, const int iteration); - const float3& getPrimaryVertex() const; - std::array, constants::its::LayersNumber>& getClusters(); - std::array, constants::its::CellsPerRoad>& getCells(); - std::array, constants::its::CellsPerRoad - 1>& getCellsLookupTable(); - std::array>, constants::its::CellsPerRoad - 1>& getCellsNeighbours(); - std::vector& getRoads(); + virtual void initialise(const MemoryParameters& memParam, const TrackingParameters& trkParam, + const std::vector>& cl, const std::array& pv, const int iteration); + const float3& getPrimaryVertex() const { return mPrimaryVertex; } + auto& getClusters() { return mClusters; } + auto& getCells() { return mCells; } + auto& getCellsLookupTable() { return mCellsLookupTable; } + auto& getCellsNeighbours() { return mCellsNeighbours; } + auto& getRoads() { return mRoads; } float getMinR(int layer) { return mMinR[layer]; } float getMaxR(int layer) { return mMaxR[layer]; } - bool isClusterUsed(int layer, int clusterId) const; + bool isClusterUsed(int layer, int clusterId) const { return mUsedClusters[layer][clusterId]; } void markUsedCluster(int layer, int clusterId); - std::array, - constants::its::TrackletsPerRoad>& - getIndexTables(); - std::array, constants::its::TrackletsPerRoad>& getTracklets(); - std::array, constants::its::CellsPerRoad>& getTrackletsLookupTable(); + auto& getIndexTables() { return mIndexTables; } + auto& getTracklets() { return mTracklets; } + auto& getTrackletsLookupTable() { return mTrackletsLookupTable; } void initialiseRoadLabels(); void setRoadLabel(int i, const unsigned long long& lab, bool fake); const unsigned long long& getRoadLabel(int i) const; bool isRoadFake(int i) const; + IndexTableUtils mIndexTableUtils; + protected: float3 mPrimaryVertex; - std::array mMinR; - std::array mMaxR; - std::array, constants::its::LayersNumber> mUnsortedClusters; - std::array, constants::its::LayersNumber> mClusters; - std::array, constants::its::LayersNumber> mUsedClusters; - std::array, constants::its::CellsPerRoad> mCells; - std::array, constants::its::CellsPerRoad - 1> mCellsLookupTable; - std::array>, constants::its::CellsPerRoad - 1> mCellsNeighbours; + std::vector mMinR; + std::vector mMaxR; + std::vector> mClusters; + std::vector> mUsedClusters; + std::vector> mCells; + std::vector> mCellsLookupTable; + std::vector>> mCellsNeighbours; std::vector mRoads; - std::array, - constants::its::TrackletsPerRoad> - mIndexTables; - std::array, constants::its::TrackletsPerRoad> mTracklets; - std::array, constants::its::CellsPerRoad> mTrackletsLookupTable; + // std::array, + // constants::its::TrackletsPerRoad> + std::vector> mIndexTables; + std::vector> mTracklets; + std::vector> mTrackletsLookupTable; std::vector> mRoadLabels; }; -inline const float3& PrimaryVertexContext::getPrimaryVertex() const { return mPrimaryVertex; } - -inline std::array, constants::its::LayersNumber>& PrimaryVertexContext::getClusters() -{ - return mClusters; -} - -inline std::array, constants::its::CellsPerRoad>& PrimaryVertexContext::getCells() { return mCells; } - -inline std::array, constants::its::CellsPerRoad - 1>& PrimaryVertexContext::getCellsLookupTable() -{ - return mCellsLookupTable; -} - -inline std::array>, constants::its::CellsPerRoad - 1>& - PrimaryVertexContext::getCellsNeighbours() -{ - return mCellsNeighbours; -} - -inline std::vector& PrimaryVertexContext::getRoads() { return mRoads; } - -inline bool PrimaryVertexContext::isClusterUsed(int layer, int clusterId) const -{ - return mUsedClusters[layer][clusterId]; -} inline void PrimaryVertexContext::markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; } -inline std::array, - constants::its::TrackletsPerRoad>& - PrimaryVertexContext::getIndexTables() -{ - return mIndexTables; -} - -inline std::array, constants::its::TrackletsPerRoad>& PrimaryVertexContext::getTracklets() -{ - return mTracklets; -} - -inline std::array, constants::its::CellsPerRoad>& PrimaryVertexContext::getTrackletsLookupTable() -{ - return mTrackletsLookupTable; -} - inline void PrimaryVertexContext::initialiseRoadLabels() { mRoadLabels.clear(); diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h index 99c1578540e4d..45ba3e4498ce3 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h @@ -38,7 +38,7 @@ using Vertex = o2::dataformats::Vertex>; class ROframe final { public: - ROframe(int ROframeId); + ROframe(int ROframeId, int nLayers); int getROFrameId() const; const float3& getPrimaryVertex(const int) const; int getPrimaryVerticesNum() const; @@ -49,10 +49,10 @@ class ROframe final int getTotalClusters() const; bool empty() const; - const std::array, constants::its::LayersNumber>& getClusters() const; + const auto& getClusters() const { return mClusters; } const std::vector& getClustersOnLayer(int layerId) const; const std::vector& getTrackingFrameInfoOnLayer(int layerId) const; - const std::array, constants::its::LayersNumber>& getTrackingFrameInfo() const; + const auto& getTrackingFrameInfo() const { return mTrackingFrameInfo; } const TrackingFrameInfo& getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const; const MCCompLabel& getClusterLabels(int layerId, const Cluster& cl) const; @@ -73,10 +73,10 @@ class ROframe final private: const int mROframeId; std::vector mPrimaryVertices; - std::array, constants::its::LayersNumber> mClusters; - std::array, constants::its::LayersNumber> mTrackingFrameInfo; - std::array, constants::its::LayersNumber> mClusterLabels; - std::array, constants::its::LayersNumber> mClusterExternalIndices; + std::vector> mClusters; + std::vector> mTrackingFrameInfo; + std::vector> mClusterLabels; + std::vector> mClusterExternalIndices; }; inline int ROframe::getROFrameId() const { return mROframeId; } @@ -87,11 +87,6 @@ inline int ROframe::getPrimaryVerticesNum() const { return mPrimaryVertices.size inline bool ROframe::empty() const { return getTotalClusters() == 0; } -inline const std::array, constants::its::LayersNumber>& ROframe::getClusters() const -{ - return mClusters; -} - inline const std::vector& ROframe::getClustersOnLayer(int layerId) const { return mClusters[layerId]; @@ -102,11 +97,6 @@ inline const std::vector& ROframe::getTrackingFrameInfoOnLaye return mTrackingFrameInfo[layerId]; } -inline const std::array, constants::its::LayersNumber>& ROframe::getTrackingFrameInfo() const -{ - return mTrackingFrameInfo; -} - inline const TrackingFrameInfo& ROframe::getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const { return mTrackingFrameInfo[layerId][cl.clusterId]; @@ -157,7 +147,7 @@ inline void ROframe::addClusterExternalIndexToLayer(int layer, const int idx) inline void ROframe::clear() { - for (int iL = 0; iL < constants::its::LayersNumber; ++iL) { + for (unsigned int iL = 0; iL < mClusters.size(); ++iL) { mClusters[iL].clear(); mTrackingFrameInfo[iL].clear(); mClusterLabels[iL].clear(); diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h index 9650eb9fa9ab7..04946fad243e7 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h @@ -43,8 +43,10 @@ class Road final void resetRoad(); void addCell(int, int); + static constexpr int mMaxRoadSize = 13; + private: - int mCellIds[constants::its::CellsPerRoad]; + int mCellIds[mMaxRoadSize]; int mRoadSize; int mLabel; bool mIsFakeRoad; diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h index 65500276c3374..913cc5dc805ac 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h @@ -41,7 +41,7 @@ namespace its { class TrackITSExt; -typedef std::function& roads, std::array, std::array, const std::array, 7>&, std::vector&)> FuncRunITSTrackFit_t; +typedef std::function& roads, std::vector&, std::vector&, const std::vector>&, std::vector&)> FuncRunITSTrackFit_t; class TrackerTraits { @@ -49,7 +49,7 @@ class TrackerTraits virtual ~TrackerTraits() = default; GPU_HOST_DEVICE static constexpr int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; } - GPU_DEVICE static const int4 getBinsRect(const Cluster&, const int, const float, const float, float maxdeltaz, float maxdeltaphi); + GPU_DEVICE const int4 getBinsRect(const Cluster&, const int, const float, const float, float maxdeltaz, float maxdeltaphi); void SetRecoChain(o2::gpu::GPUChainITS* chain, FuncRunITSTrackFit_t&& funcRunITSTrackFit) { @@ -59,7 +59,7 @@ class TrackerTraits virtual void computeLayerTracklets(){}; virtual void computeLayerCells(){}; - virtual void refitTracks(const std::array, 7>&, std::vector&){}; + virtual void refitTracks(const std::vector>&, std::vector&){}; void UpdateTrackingParameters(const TrackingParameters& trkPar); PrimaryVertexContext* getPrimaryVertexContext() { return mPrimaryVertexContext; } @@ -85,16 +85,17 @@ inline GPU_DEVICE const int4 TrackerTraits::getBinsRect(const Cluster& currentCl const float zRangeMax = gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz; const float phiRangeMax = currentCluster.phiCoordinate + maxdeltaphi; - if (zRangeMax < -constants::its::LayersZCoordinate()[layerIndex + 1] || - zRangeMin > constants::its::LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) { + if (zRangeMax < -mTrkParams.LayerZ[layerIndex + 1] || + zRangeMin > mTrkParams.LayerZ[layerIndex + 1] || zRangeMin > zRangeMax) { return getEmptyBinsRect(); } - return int4{gpu::GPUCommonMath::Max(0, index_table_utils::getZBinIndex(layerIndex + 1, zRangeMin)), - index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMin)), - gpu::GPUCommonMath::Min(constants::index_table::ZBins - 1, index_table_utils::getZBinIndex(layerIndex + 1, zRangeMax)), - index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMax))}; + const IndexTableUtils& utils{mPrimaryVertexContext->mIndexTableUtils}; + return int4{gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex + 1, zRangeMin)), + utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMin)), + gpu::GPUCommonMath::Min(mTrkParams.ZBins - 1, utils.getZBinIndex(layerIndex + 1, zRangeMax)), + utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMax))}; } } // namespace its } // namespace o2 diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraitsCPU.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraitsCPU.h index 865ae121abe04..a43fc44b28ef1 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraitsCPU.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraitsCPU.h @@ -44,7 +44,7 @@ class TrackerTraitsCPU : public TrackerTraits void computeLayerCells() final; void computeLayerTracklets() final; - void refitTracks(const std::array, 7>& tf, std::vector& tracks) final; + void refitTracks(const std::vector>& tf, std::vector& tracks) final; protected: std::vector> mTracklets; diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h index be341b69a39a3..97e1dcde9cf52 100644 --- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h +++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h @@ -23,6 +23,7 @@ #include "ITStracking/Configuration.h" #include "ITStracking/ClusterLines.h" #include "ITStracking/Definitions.h" +#include "ITStracking/IndexTableUtils.h" #ifdef _ALLOW_DEBUG_TREES_ITS_ #include "ITStracking/StandaloneDebugger.h" #endif @@ -45,8 +46,6 @@ namespace its class ROframe; -using constants::index_table::PhiBins; -using constants::index_table::ZBins; using constants::its::LayersNumberVertexer; struct lightVertex { @@ -106,8 +105,11 @@ class VertexerTraits { return int4{0, 0, 0, 0}; } - GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi); - GPUhd() static const int2 getPhiBins(float phi, float deltaPhi); + GPUhd() const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi); + GPUhd() const int2 getPhiBins(float phi, float deltaPhi); + + GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi, const IndexTableUtils&); + GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtils&); // virtual vertexer interface virtual void reset(); @@ -128,8 +130,9 @@ class VertexerTraits void updateVertexingParameters(const VertexingParameters& vrtPar); VertexingParameters getVertexingParameters() const { return mVrtParams; } - static const std::vector> selectClusters(const std::array& indexTable, - const std::array& selectedBinsRect); + static const std::vector> selectClusters(const int* indexTable, + const std::array& selectedBinsRect, + const IndexTableUtils& utils); std::vector getVertices() const { return mVertices; } // utils @@ -160,7 +163,8 @@ class VertexerTraits #endif VertexingParameters mVrtParams; - std::array, LayersNumberVertexer> mIndexTables; + IndexTableUtils mIndexTableUtils; + std::array, LayersNumberVertexer> mIndexTables; std::vector mVertices; // Frame related quantities @@ -177,6 +181,9 @@ class VertexerTraits inline void VertexerTraits::initialise(ROframe* event) { reset(); + if (!mIndexTableUtils.getNzBins()) { + updateVertexingParameters(mVrtParams); + } arrangeClusters(event); setIsGPU(false); } @@ -189,32 +196,51 @@ inline void VertexerTraits::setIsGPU(const unsigned char isgpu) inline void VertexerTraits::updateVertexingParameters(const VertexingParameters& vrtPar) { mVrtParams = vrtPar; + mIndexTableUtils.setTrackingParameters(vrtPar); + mVrtParams.phiSpan = static_cast(std::ceil(mIndexTableUtils.getNphiBins() * mVrtParams.phiCut / + constants::math::TwoPi)); + mVrtParams.zSpan = static_cast(std::ceil(mVrtParams.zCut * mIndexTableUtils.getInverseZCoordinate(0))); + for (auto& table : mIndexTables) { + table.resize(mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1, 0); + } } GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi) { - return int2{index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phi - dPhi)), - index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phi + dPhi))}; + return VertexerTraits::getPhiBins(phi, dPhi, mIndexTableUtils); +} + +GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi, const IndexTableUtils& utils) +{ + return int2{utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phi - dPhi)), + utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phi + dPhi))}; } GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, const int layerIndex, - const float directionZIntersection, float maxdeltaz, float maxdeltaphi) + const float directionZIntersection, float maxdeltaz, float maxdeltaphi, + const IndexTableUtils& utils) { const float zRangeMin = directionZIntersection - 2 * maxdeltaz; const float phiRangeMin = currentCluster.phiCoordinate - maxdeltaphi; const float zRangeMax = directionZIntersection + 2 * maxdeltaz; const float phiRangeMax = currentCluster.phiCoordinate + maxdeltaphi; - if (zRangeMax < -constants::its::LayersZCoordinate()[layerIndex + 1] || - zRangeMin > constants::its::LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) { + if (zRangeMax < -utils.getLayerZ(layerIndex + 1) || + zRangeMin > utils.getLayerZ(layerIndex + 1) || zRangeMin > zRangeMax) { return getEmptyBinsRect(); } - return int4{gpu::GPUCommonMath::Max(0, index_table_utils::getZBinIndex(layerIndex + 1, zRangeMin)), - index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMin)), - gpu::GPUCommonMath::Min(constants::index_table::ZBins - 1, index_table_utils::getZBinIndex(layerIndex + 1, zRangeMax)), - index_table_utils::getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMax))}; + return int4{gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex + 1, zRangeMin)), + utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMin)), + gpu::GPUCommonMath::Min(utils.getNzBins() - 1, utils.getZBinIndex(layerIndex + 1, zRangeMax)), + utils.getPhiBinIndex(math_utils::getNormalizedPhiCoordinate(phiRangeMax))}; +} + +GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, const int layerIndex, + const float directionZIntersection, float maxdeltaz, float maxdeltaphi) +{ + return VertexerTraits::getBinsRect(currentCluster, layerIndex, directionZIntersection, maxdeltaz, maxdeltaphi, mIndexTableUtils); } // debug diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx index ed96496fcfb6e..7f6b4e49d2c79 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx @@ -13,9 +13,8 @@ /// #include "ITStracking/Cluster.h" - -#include "ITStracking/IndexTableUtils.h" #include "ITStracking/MathUtils.h" +#include "ITStracking/IndexTableUtils.h" namespace o2 { @@ -38,21 +37,21 @@ Cluster::Cluster(const float x, const float y, const float z, const int index) // Nothing to do } -Cluster::Cluster(const int layerIndex, const Cluster& other) +Cluster::Cluster(const int layerIndex, const IndexTableUtils& utils, const Cluster& other) : xCoordinate{other.xCoordinate}, yCoordinate{other.yCoordinate}, zCoordinate{other.zCoordinate}, phiCoordinate{getNormalizedPhiCoordinate(calculatePhiCoordinate(other.xCoordinate, other.yCoordinate))}, rCoordinate{calculateRCoordinate(other.xCoordinate, other.yCoordinate)}, clusterId{other.clusterId}, - indexTableBinIndex{index_table_utils::getBinIndex(index_table_utils::getZBinIndex(layerIndex, zCoordinate), - index_table_utils::getPhiBinIndex(phiCoordinate))} + indexTableBinIndex{utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate), + utils.getPhiBinIndex(phiCoordinate))} //, montecarloId{ other.montecarloId } { // Nothing to do } -Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const Cluster& other) +Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexTableUtils& utils, const Cluster& other) : xCoordinate{other.xCoordinate}, yCoordinate{other.yCoordinate}, zCoordinate{other.zCoordinate}, @@ -60,13 +59,13 @@ Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const Cluste calculatePhiCoordinate(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y))}, rCoordinate{calculateRCoordinate(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y)}, clusterId{other.clusterId}, - indexTableBinIndex{index_table_utils::getBinIndex(index_table_utils::getZBinIndex(layerIndex, zCoordinate), - index_table_utils::getPhiBinIndex(phiCoordinate))} + indexTableBinIndex{utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate), + utils.getPhiBinIndex(phiCoordinate))} { // Nothing to do } -void Cluster::Init(const int layerIndex, const float3& primaryVertex, const Cluster& other) +void Cluster::Init(const int layerIndex, const float3& primaryVertex, const IndexTableUtils& utils, const Cluster& other) { xCoordinate = other.xCoordinate; yCoordinate = other.yCoordinate; @@ -75,8 +74,8 @@ void Cluster::Init(const int layerIndex, const float3& primaryVertex, const Clus calculatePhiCoordinate(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y)); rCoordinate = calculateRCoordinate(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y); clusterId = other.clusterId; - indexTableBinIndex = index_table_utils::getBinIndex(index_table_utils::getZBinIndex(layerIndex, zCoordinate), - index_table_utils::getPhiBinIndex(phiCoordinate)); + indexTableBinIndex = utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate), + utils.getPhiBinIndex(phiCoordinate)); } TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, GPUArray&& posTF, diff --git a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx index f3cecb7c53944..e21d75cf2adb2 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx @@ -38,9 +38,6 @@ constexpr int PrimaryVertexLayerId{-1}; constexpr int EventLabelsSeparator{-1}; } // namespace -using o2::its::constants::its::LayersRCoordinate; -using o2::its::constants::its::LayersZCoordinate; - namespace o2 { namespace its @@ -80,18 +77,6 @@ void ioutils::convertCompactClusters(gsl::span clu } } -void ioutils::loadConfigurations(const std::string& fileName) -{ - if (!fileName.empty()) { - std::ifstream inputStream; - inputStream.open(fileName); - nlohmann::json j; - inputStream >> j; - static_cast(Configuration::getInstance()) = j.at("TrackingParameters").get(); - //static_cast(Configuration::getInstance()) = j.at("IndexTableParameters").get(); - } -} - std::vector ioutils::loadEventData(const std::string& fileName) { std::vector events{}; @@ -114,7 +99,7 @@ std::vector ioutils::loadEventData(const std::string& fileName) if (layerId == PrimaryVertexLayerId) { if (clusterId != 0) { - events.emplace_back(events.size()); + events.emplace_back(events.size(), 7); } events.back().addPrimaryVertex(xCoordinate, yCoordinate, zCoordinate); @@ -244,33 +229,33 @@ int ioutils::loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& event, g return clusters_in_frame.size(); } -void ioutils::generateSimpleData(ROframe& event, const int phiDivs, const int zDivs = 1) -{ - const float angleOffset = constants::math::TwoPi / static_cast(phiDivs); - // Maximum z allowed on innermost layer should be: ~9,75 - const float zOffsetFirstLayer = (zDivs == 1) ? 0 : 1.5 * (LayersZCoordinate()[6] * LayersRCoordinate()[0]) / (LayersRCoordinate()[6] * (static_cast(zDivs) - 1)); - std::vector x, y; - std::array, 7> z; - for (size_t j{0}; j < zDivs; ++j) { - for (size_t i{0}; i < phiDivs; ++i) { - x.emplace_back(cos(i * angleOffset + 0.001)); // put an epsilon to move from periods (e.g. 20 clusters vs 20 cells) - y.emplace_back(sin(i * angleOffset + 0.001)); - const float zFirstLayer{-static_cast((zDivs - 1.) / 2.) * zOffsetFirstLayer + zOffsetFirstLayer * static_cast(j)}; - z[0].emplace_back(zFirstLayer); - for (size_t iLayer{1}; iLayer < constants::its::LayersNumber; ++iLayer) { - z[iLayer].emplace_back(zFirstLayer * LayersRCoordinate()[iLayer] / LayersRCoordinate()[0]); - } - } - } - - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { - for (int i = 0; i < phiDivs * zDivs; i++) { - o2::MCCompLabel label{i, 0, 0, false}; - event.addClusterLabelToLayer(iLayer, label); //last argument : label, goes into mClustersLabel - event.addClusterToLayer(iLayer, LayersRCoordinate()[iLayer] * x[i], LayersRCoordinate()[iLayer] * y[i], z[iLayer][i], i); //uses 1st constructor for clusters - } - } -} +// void ioutils::generateSimpleData(ROframe& event, const int phiDivs, const int zDivs = 1) +// { +// const float angleOffset = constants::math::TwoPi / static_cast(phiDivs); +// // Maximum z allowed on innermost layer should be: ~9,75 +// const float zOffsetFirstLayer = (zDivs == 1) ? 0 : 1.5 * (LayersZCoordinate()[6] * LayersRCoordinate()[0]) / (LayersRCoordinate()[6] * (static_cast(zDivs) - 1)); +// std::vector x, y; +// std::array, 7> z; +// for (size_t j{0}; j < zDivs; ++j) { +// for (size_t i{0}; i < phiDivs; ++i) { +// x.emplace_back(cos(i * angleOffset + 0.001)); // put an epsilon to move from periods (e.g. 20 clusters vs 20 cells) +// y.emplace_back(sin(i * angleOffset + 0.001)); +// const float zFirstLayer{-static_cast((zDivs - 1.) / 2.) * zOffsetFirstLayer + zOffsetFirstLayer * static_cast(j)}; +// z[0].emplace_back(zFirstLayer); +// for (size_t iLayer{1}; iLayer < 7; ++iLayer) { +// z[iLayer].emplace_back(zFirstLayer * LayersRCoordinate()[iLayer] / LayersRCoordinate()[0]); +// } +// } +// } + +// for (int iLayer{0}; iLayer < 7; ++iLayer) { +// for (int i = 0; i < phiDivs * zDivs; i++) { +// o2::MCCompLabel label{i, 0, 0, false}; +// event.addClusterLabelToLayer(iLayer, label); //last argument : label, goes into mClustersLabel +// event.addClusterToLayer(iLayer, LayersRCoordinate()[iLayer] * x[i], LayersRCoordinate()[iLayer] * y[i], z[iLayer][i], i); //uses 1st constructor for clusters +// } +// } +// } std::vector> ioutils::loadLabels(const int eventsNum, const std::string& fileName) { @@ -364,70 +349,7 @@ void ioutils::writeRoadsReport(std::ofstream& correctRoadsOutputStream, std::ofs } } -void to_json(nlohmann::json& j, const TrackingParameters& par) -{ - std::array tmpTrackletMaxDeltaZ; - std::copy(par.TrackletMaxDeltaZ, par.TrackletMaxDeltaZ + tmpTrackletMaxDeltaZ.size(), tmpTrackletMaxDeltaZ.begin()); - std::array tmpCellMaxDCA; - std::copy(par.CellMaxDCA, par.CellMaxDCA + tmpCellMaxDCA.size(), tmpCellMaxDCA.begin()); - std::array tmpCellMaxDeltaZ; - std::copy(par.CellMaxDeltaZ, par.CellMaxDeltaZ + tmpCellMaxDeltaZ.size(), tmpCellMaxDeltaZ.begin()); - std::array tmpNeighbourMaxDeltaCurvature; - std::copy(par.NeighbourMaxDeltaCurvature, par.NeighbourMaxDeltaCurvature + tmpNeighbourMaxDeltaCurvature.size(), tmpNeighbourMaxDeltaCurvature.begin()); - std::array tmpNeighbourMaxDeltaN; - std::copy(par.NeighbourMaxDeltaN, par.NeighbourMaxDeltaN + tmpNeighbourMaxDeltaN.size(), tmpNeighbourMaxDeltaN.begin()); - j = nlohmann::json{ - {"ClusterSharing", par.ClusterSharing}, - {"MinTrackLength", par.MinTrackLength}, - {"TrackletMaxDeltaPhi", par.TrackletMaxDeltaPhi}, - {"TrackletMaxDeltaZ", tmpTrackletMaxDeltaZ}, - {"CellMaxDeltaTanLambda", par.CellMaxDeltaTanLambda}, - {"CellMaxDCA", tmpCellMaxDCA}, - {"CellMaxDeltaPhi", par.CellMaxDeltaPhi}, - {"CellMaxDeltaZ", tmpCellMaxDeltaZ}, - {"NeighbourMaxDeltaCurvature", tmpNeighbourMaxDeltaCurvature}, - {"NeighbourMaxDeltaN", tmpNeighbourMaxDeltaN}}; -} - -void from_json(const nlohmann::json& j, TrackingParameters& par) -{ - par.ClusterSharing = j.at("ClusterSharing").get(); - par.MinTrackLength = j.at("MinTrackLength").get(); - par.TrackletMaxDeltaPhi = j.at("TrackletMaxDeltaPhi").get(); - par.CellMaxDeltaTanLambda = j.at("CellMaxDeltaTanLambda").get(); - par.CellMaxDeltaPhi = j.at("CellMaxDeltaPhi").get(); - auto tmpTrackletMaxDeltaZ = j.at("TrackletMaxDeltaZ").get>(); - std::copy(tmpTrackletMaxDeltaZ.begin(), tmpTrackletMaxDeltaZ.end(), par.TrackletMaxDeltaZ); - auto tmpCellMaxDCA = j.at("CellMaxDCA").get>(); - std::copy(tmpCellMaxDCA.begin(), tmpCellMaxDCA.end(), par.CellMaxDCA); - auto tmpCellMaxDeltaZ = j.at("CellMaxDeltaZ").get>(); - std::copy(tmpCellMaxDCA.begin(), tmpCellMaxDeltaZ.end(), par.CellMaxDeltaZ); - auto tmpNeighbourMaxDeltaCurvature = j.at("NeighbourMaxDeltaCurvature").get>(); - std::copy(tmpNeighbourMaxDeltaCurvature.begin(), tmpNeighbourMaxDeltaCurvature.end(), par.NeighbourMaxDeltaCurvature); - auto tmpNeighbourMaxDeltaN = j.at("NeighbourMaxDeltaN").get>(); - std::copy(tmpNeighbourMaxDeltaN.begin(), tmpNeighbourMaxDeltaN.end(), par.NeighbourMaxDeltaN); -} -void to_json(nlohmann::json& j, const MemoryParameters& par) -{ - std::array tmpCellsMemoryCoefficients; - std::copy(par.CellsMemoryCoefficients, par.CellsMemoryCoefficients + tmpCellsMemoryCoefficients.size(), tmpCellsMemoryCoefficients.begin()); - std::array tmpTrackletsMemoryCoefficients; - std::copy(par.TrackletsMemoryCoefficients, par.TrackletsMemoryCoefficients + tmpTrackletsMemoryCoefficients.size(), tmpTrackletsMemoryCoefficients.begin()); - j = nlohmann::json{ - {"MemoryOffset", par.MemoryOffset}, - {"CellsMemoryCoefficients", tmpCellsMemoryCoefficients}, - {"TrackletsMemoryCoefficients", tmpTrackletsMemoryCoefficients}}; -} - -void from_json(const nlohmann::json& j, MemoryParameters& par) -{ - par.MemoryOffset = j.at("MemoryOffset").get(); - auto tmpCellsMemoryCoefficients = j.at("CellsMemoryCoefficients").get>(); - std::copy(tmpCellsMemoryCoefficients.begin(), tmpCellsMemoryCoefficients.end(), par.CellsMemoryCoefficients); - auto tmpTrackletsMemoryCoefficients = j.at("TrackletsMemoryCoefficients").get>(); - std::copy(tmpTrackletsMemoryCoefficients.begin(), tmpTrackletsMemoryCoefficients.end(), par.TrackletsMemoryCoefficients); -} } // namespace its } // namespace o2 diff --git a/Detectors/ITSMFT/ITS/tracking/src/PrimaryVertexContext.cxx b/Detectors/ITSMFT/ITS/tracking/src/PrimaryVertexContext.cxx index d4dcbe5f36fc9..c984d560588ac 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/PrimaryVertexContext.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/PrimaryVertexContext.cxx @@ -21,8 +21,8 @@ namespace o2 namespace its { -void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const std::array, constants::its::LayersNumber>& cl, - const std::array& pVtx, const int iteration) +void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const TrackingParameters& trkParam, + const std::vector>& cl, const std::array& pVtx, const int iteration) { struct ClusterHelper { @@ -38,7 +38,20 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st std::vector cHelper; - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { + mMinR.resize(trkParam.NLayers, 10000.); + mMaxR.resize(trkParam.NLayers, -1.); + mClusters.resize(trkParam.NLayers); + mUsedClusters.resize(trkParam.NLayers); + mCells.resize(trkParam.CellsPerRoad()); + mCellsLookupTable.resize(trkParam.CellsPerRoad() - 1); + mCellsNeighbours.resize(trkParam.CellsPerRoad() - 1); + mIndexTables.resize(trkParam.TrackletsPerRoad(), std::vector(trkParam.ZBins * trkParam.PhiBins + 1, 0)); + mTracklets.resize(trkParam.TrackletsPerRoad()); + mTrackletsLookupTable.resize(trkParam.CellsPerRoad()); + mIndexTableUtils.setTrackingParameters(trkParam); + + std::vector clsPerBin(trkParam.PhiBins * trkParam.ZBins, 0); + for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) { const auto& currentLayer{cl[iLayer]}; const int clustersNum{static_cast(currentLayer.size())}; @@ -48,11 +61,7 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st mUsedClusters[iLayer].clear(); mUsedClusters[iLayer].resize(clustersNum, false); - constexpr int _size = constants::index_table::PhiBins * constants::index_table::ZBins; - std::array clsPerBin; - for (int iB{0}; iB < _size; ++iB) { - clsPerBin[iB] = 0; - } + std::fill(clsPerBin.begin(), clsPerBin.end(), 0); cHelper.clear(); cHelper.resize(clustersNum); @@ -66,8 +75,9 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st float x = c.xCoordinate - mPrimaryVertex.x; float y = c.yCoordinate - mPrimaryVertex.y; float phi = math_utils::calculatePhiCoordinate(x, y); - int bin = index_table_utils::getBinIndex(index_table_utils::getZBinIndex(iLayer, c.zCoordinate), - index_table_utils::getPhiBinIndex(phi)); + const int zBin{mIndexTableUtils.getZBinIndex(iLayer, c.zCoordinate)}; + int bin = mIndexTableUtils.getBinIndex(zBin, mIndexTableUtils.getPhiBinIndex(phi)); + CA_DEBUGGER(assert(zBin > 0)); h.phi = phi; h.r = math_utils::calculateRCoordinate(x, y); mMinR[iLayer] = gpu::GPUCommonMath::Min(h.r, mMinR[iLayer]); @@ -76,9 +86,9 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st h.ind = clsPerBin[bin]++; } - std::array lutPerBin; + std::vector lutPerBin(clsPerBin.size()); lutPerBin[0] = 0; - for (int iB{1}; iB < _size; ++iB) { + for (unsigned int iB{1}; iB < lutPerBin.size(); ++iB) { lutPerBin[iB] = lutPerBin[iB - 1] + clsPerBin[iB - 1]; } @@ -92,10 +102,10 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st } if (iLayer > 0) { - for (int iB{0}; iB < _size; ++iB) { + for (unsigned int iB{0}; iB < clsPerBin.size(); ++iB) { mIndexTables[iLayer - 1][iB] = lutPerBin[iB]; } - for (int iB{_size}; iB < (int)mIndexTables[iLayer - 1].size(); iB++) { + for (auto iB{clsPerBin.size()}; iB < (int)mIndexTables[iLayer - 1].size(); iB++) { mIndexTables[iLayer - 1][iB] = clustersNum; } } @@ -104,8 +114,8 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st mRoads.clear(); - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { - if (iLayer < constants::its::CellsPerRoad) { + for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) { + if (iLayer < mCells.size()) { mCells[iLayer].clear(); float cellsMemorySize = memParam.MemoryOffset + @@ -118,32 +128,32 @@ void PrimaryVertexContext::initialise(const MemoryParameters& memParam, const st } } - if (iLayer < constants::its::CellsPerRoad - 1) { + if (iLayer < mCells.size() - 1) { mCellsLookupTable[iLayer].clear(); - mCellsLookupTable[iLayer].resize( - std::max(cl[iLayer + 1].size(), cl[iLayer + 2].size()) + - std::ceil((memParam.TrackletsMemoryCoefficients[iLayer + 1] * - cl[iLayer + 1].size()) * - cl[iLayer + 2].size()), - constants::its::UnusedIndex); + mCellsLookupTable[iLayer].resize(memParam.MemoryOffset + + std::max(cl[iLayer + 1].size(), cl[iLayer + 2].size()) + + std::ceil((memParam.TrackletsMemoryCoefficients[iLayer + 1] * + cl[iLayer + 1].size()) * + cl[iLayer + 2].size()), + constants::its::UnusedIndex); mCellsNeighbours[iLayer].clear(); } } - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { - if (iLayer < constants::its::TrackletsPerRoad) { + for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) { + if (iLayer < mTracklets.size()) { mTracklets[iLayer].clear(); - float trackletsMemorySize = - std::max(cl[iLayer].size(), cl[iLayer + 1].size()) + - std::ceil((memParam.TrackletsMemoryCoefficients[iLayer] * cl[iLayer].size()) * - cl[iLayer + 1].size()); + float trackletsMemorySize = memParam.MemoryOffset + + std::max(cl[iLayer].size(), cl[iLayer + 1].size()) + + std::ceil((memParam.TrackletsMemoryCoefficients[iLayer] * cl[iLayer].size()) * + cl[iLayer + 1].size()); if (trackletsMemorySize > mTracklets[iLayer].capacity()) { mTracklets[iLayer].reserve(trackletsMemorySize); } } - if (iLayer < constants::its::CellsPerRoad) { + if (iLayer < mCells.size()) { mTrackletsLookupTable[iLayer].clear(); mTrackletsLookupTable[iLayer].resize(cl[iLayer + 1].size(), constants::its::UnusedIndex); } diff --git a/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx b/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx index e4375d1caafb9..76ba90171c3cf 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx @@ -21,8 +21,12 @@ namespace o2 namespace its { -ROframe::ROframe(const int ROframeId) : mROframeId{ROframeId} +ROframe::ROframe(int ROframeId, int nLayers) : mROframeId{ROframeId} { + mClusters.resize(nLayers); + mTrackingFrameInfo.resize(nLayers); + mClusterLabels.resize(nLayers); + mClusterExternalIndices.resize(nLayers); } void ROframe::addPrimaryVertex(const float xCoordinate, const float yCoordinate, const float zCoordinate) diff --git a/Detectors/ITSMFT/ITS/tracking/src/Road.cxx b/Detectors/ITSMFT/ITS/tracking/src/Road.cxx index da5748bbcd75a..facb1f43fa1e2 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/Road.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/Road.cxx @@ -13,6 +13,8 @@ /// #include "ITStracking/Road.h" +#include +#include namespace o2 { @@ -25,7 +27,7 @@ Road::Road(int cellLayer, int cellId) : Road() { addCell(cellLayer, cellId); } void Road::resetRoad() { - for (int i = 0; i < constants::its::CellsPerRoad; i++) { + for (int i = 0; i < mMaxRoadSize; i++) { mCellIds[i] = constants::its::UnusedIndex; } mRoadSize = 0; diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx index 1aa9483d6f84b..721fa617051b5 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx @@ -57,12 +57,21 @@ void Tracker::clustersToTracks(const ROframe& event, std::ostream& timeBenchmark float total{0.f}; for (int iteration = 0; iteration < mTrkParams.size(); ++iteration) { + + int numCls = 0; + for (unsigned int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) { + numCls += event.getClusters()[iLayer].size(); + } + if (numCls < mTrkParams[iteration].MinTrackLength) { + continue; + } + mTraits->UpdateTrackingParameters(mTrkParams[iteration]); /// Ugly hack -> Unifiy float3 definition in CPU and CUDA/HIP code int pass = iteration + iVertex; /// Do not reinitialise the context if we analyse pile-up events std::array pV = {event.getPrimaryVertex(iVertex).x, event.getPrimaryVertex(iVertex).y, event.getPrimaryVertex(iVertex).z}; total += evaluateTask(&Tracker::initialisePrimaryVertexContext, "Context initialisation", - timeBenchmarkOutputStream, mMemParams[iteration], event.getClusters(), pV, pass); + timeBenchmarkOutputStream, mMemParams[iteration], mTrkParams[iteration], event.getClusters(), pV, pass); total += evaluateTask(&Tracker::computeTracklets, "Tracklet finding", timeBenchmarkOutputStream); total += evaluateTask(&Tracker::computeCells, "Cell finding", timeBenchmarkOutputStream); total += evaluateTask(&Tracker::findCellsNeighbours, "Neighbour finding", timeBenchmarkOutputStream, iteration); @@ -93,7 +102,7 @@ void Tracker::computeCells() void Tracker::findCellsNeighbours(int& iteration) { - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad - 1; ++iLayer) { + for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) { if (mPrimaryVertexContext->getCells()[iLayer + 1].empty() || mPrimaryVertexContext->getCellsLookupTable()[iLayer].empty()) { @@ -101,6 +110,8 @@ void Tracker::findCellsNeighbours(int& iteration) } int layerCellsNum{static_cast(mPrimaryVertexContext->getCells()[iLayer].size())}; + const int nextLayerCellsNum{static_cast(mPrimaryVertexContext->getCells()[iLayer + 1].size())}; + mPrimaryVertexContext->getCellsNeighbours()[iLayer].resize(nextLayerCellsNum); for (int iCell{0}; iCell < layerCellsNum; ++iCell) { @@ -111,16 +122,13 @@ void Tracker::findCellsNeighbours(int& iteration) mPrimaryVertexContext->getCells()[iLayer + 1][nextLayerFirstCellIndex].getFirstTrackletIndex() == nextLayerTrackletIndex) { - const int nextLayerCellsNum{static_cast(mPrimaryVertexContext->getCells()[iLayer + 1].size())}; - mPrimaryVertexContext->getCellsNeighbours()[iLayer].resize(nextLayerCellsNum); - - for (int iNextLayerCell{nextLayerFirstCellIndex}; - iNextLayerCell < nextLayerCellsNum && - mPrimaryVertexContext->getCells()[iLayer + 1][iNextLayerCell].getFirstTrackletIndex() == - nextLayerTrackletIndex; - ++iNextLayerCell) { + for (int iNextLayerCell{nextLayerFirstCellIndex}; iNextLayerCell < nextLayerCellsNum; ++iNextLayerCell) { Cell& nextCell{mPrimaryVertexContext->getCells()[iLayer + 1][iNextLayerCell]}; + if (nextCell.getFirstTrackletIndex() != nextLayerTrackletIndex) { + break; + } + const float3 currentCellNormalVector{currentCell.getNormalVectorCoordinates()}; const float3 nextCellNormalVector{nextCell.getNormalVectorCoordinates()}; const float3 normalVectorsDeltaVector{currentCellNormalVector.x - nextCellNormalVector.x, @@ -152,11 +160,11 @@ void Tracker::findCellsNeighbours(int& iteration) void Tracker::findRoads(int& iteration) { - for (int iLevel{constants::its::CellsPerRoad}; iLevel >= mTrkParams[iteration].CellMinimumLevel(); --iLevel) { + for (int iLevel{mTrkParams[iteration].CellsPerRoad()}; iLevel >= mTrkParams[iteration].CellMinimumLevel(); --iLevel) { CA_DEBUGGER(int nRoads = -mPrimaryVertexContext->getRoads().size()); const int minimumLevel{iLevel - 1}; - for (int iLayer{constants::its::CellsPerRoad - 1}; iLayer >= minimumLevel; --iLayer) { + for (int iLayer{mTrkParams[iteration].CellsPerRoad() - 1}; iLayer >= minimumLevel; --iLayer) { const int levelCellsNum{static_cast(mPrimaryVertexContext->getCells()[iLayer].size())}; @@ -218,19 +226,19 @@ void Tracker::findTracks(const ROframe& event) std::vector tracks; tracks.reserve(mPrimaryVertexContext->getRoads().size()); #ifdef CA_DEBUG - std::array roadCounters{0, 0, 0, 0}; - std::array fitCounters{0, 0, 0, 0}; - std::array backpropagatedCounters{0, 0, 0, 0}; - std::array refitCounters{0, 0, 0, 0}; - std::array nonsharingCounters{0, 0, 0, 0}; + std::vector roadCounters(mTrkParams[0].NLayers - 3, 0); + std::vector fitCounters(mTrkParams[0].NLayers - 3, 0); + std::vector backpropagatedCounters(mTrkParams[0].NLayers - 3, 0); + std::vector refitCounters(mTrkParams[0].NLayers - 3, 0); + std::vector nonsharingCounters(mTrkParams[0].NLayers - 3, 0); #endif for (auto& road : mPrimaryVertexContext->getRoads()) { - std::array clusters{constants::its::UnusedIndex, constants::its::UnusedIndex, constants::its::UnusedIndex, constants::its::UnusedIndex, constants::its::UnusedIndex, constants::its::UnusedIndex, constants::its::UnusedIndex}; + std::vector clusters(mTrkParams[0].NLayers, constants::its::UnusedIndex); int lastCellLevel = constants::its::UnusedIndex; CA_DEBUGGER(int nClusters = 2); - for (int iCell{0}; iCell < constants::its::CellsPerRoad; ++iCell) { + for (int iCell{0}; iCell < mTrkParams[0].CellsPerRoad(); ++iCell) { const int cellIndex = road[iCell]; if (cellIndex == constants::its::UnusedIndex) { continue; @@ -271,20 +279,20 @@ void Tracker::findTracks(const ROframe& event) for (size_t iC = 0; iC < clusters.size(); ++iC) { temporaryTrack.setExternalClusterIndex(iC, clusters[iC], clusters[iC] != constants::its::UnusedIndex); } - bool fitSuccess = fitTrack(event, temporaryTrack, constants::its::LayersNumber - 4, -1, -1); + bool fitSuccess = fitTrack(event, temporaryTrack, mTrkParams[0].NLayers - 4, -1, -1); if (!fitSuccess) { continue; } CA_DEBUGGER(fitCounters[nClusters - 4]++); temporaryTrack.resetCovariance(); - fitSuccess = fitTrack(event, temporaryTrack, 0, constants::its::LayersNumber, 1); + fitSuccess = fitTrack(event, temporaryTrack, 0, mTrkParams[0].NLayers, 1); if (!fitSuccess) { continue; } CA_DEBUGGER(backpropagatedCounters[nClusters - 4]++); temporaryTrack.getParamOut() = temporaryTrack; temporaryTrack.resetCovariance(); - fitSuccess = fitTrack(event, temporaryTrack, constants::its::LayersNumber - 1, -1, -1); + fitSuccess = fitTrack(event, temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1); if (!fitSuccess) { continue; } @@ -298,19 +306,19 @@ void Tracker::findTracks(const ROframe& event) [](TrackITSExt& track1, TrackITSExt& track2) { return track1.isBetter(track2, 1.e6f); }); #ifdef CA_DEBUG - std::array sharingMatrix{0}; - int prevNclusters = 7; - auto cumulativeIndex = [](int ncl) -> int { - constexpr int idx[5] = {0, 5, 11, 18, 26}; - return idx[ncl - 4]; - }; - std::array xcheckCounters{0}; + // std::array sharingMatrix{0}; + // int prevNclusters = 7; + // auto cumulativeIndex = [](int ncl) -> int { + // constexpr int idx[5] = {0, 5, 11, 18, 26}; + // return idx[ncl - 4]; + // }; + // std::array xcheckCounters{0}; #endif for (auto& track : tracks) { CA_DEBUGGER(int nClusters = 0); int nShared = 0; - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { + for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) { if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) { continue; } @@ -318,24 +326,24 @@ void Tracker::findTracks(const ROframe& event) CA_DEBUGGER(nClusters++); } -#ifdef CA_DEBUG - assert(nClusters == track.getNumberOfClusters()); - xcheckCounters[nClusters - 4]++; - assert(nShared <= nClusters); - sharingMatrix[cumulativeIndex(nClusters) + nShared]++; -#endif + // #ifdef CA_DEBUG + // assert(nClusters == track.getNumberOfClusters()); + // xcheckCounters[nClusters - 4]++; + // assert(nShared <= nClusters); + // sharingMatrix[cumulativeIndex(nClusters) + nShared]++; + // #endif if (nShared > mTrkParams[0].ClusterSharing) { continue; } -#ifdef CA_DEBUG - nonsharingCounters[nClusters - 4]++; - assert(nClusters <= prevNclusters); - prevNclusters = nClusters; -#endif + // #ifdef CA_DEBUG + // nonsharingCounters[nClusters - 4]++; + // assert(nClusters <= prevNclusters); + // prevNclusters = nClusters; + // #endif - for (int iLayer{0}; iLayer < constants::its::LayersNumber; ++iLayer) { + for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) { if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) { continue; } @@ -365,26 +373,26 @@ void Tracker::findTracks(const ROframe& event) std::cout << count << "\t"; std::cout << std::endl; - std::cout << "+++ Cross check counters for 4, 5, 6 and 7 clusters:\t"; - for (size_t iCount = 0; iCount < refitCounters.size(); ++iCount) { - std::cout << xcheckCounters[iCount] << "\t"; - //assert(refitCounters[iCount] == xcheckCounters[iCount]); - } - std::cout << std::endl; - - std::cout << "+++ Nonsharing candidates with 4, 5, 6 and 7 clusters:\t"; - for (int count : nonsharingCounters) - std::cout << count << "\t"; - std::cout << std::endl; - - std::cout << "+++ Sharing matrix:\n"; - for (int iCl = 4; iCl <= 7; ++iCl) { - std::cout << "+++ "; - for (int iSh = cumulativeIndex(iCl); iSh < cumulativeIndex(iCl + 1); ++iSh) { - std::cout << sharingMatrix[iSh] << "\t"; - } - std::cout << std::endl; - } + // std::cout << "+++ Cross check counters for 4, 5, 6 and 7 clusters:\t"; + // for (size_t iCount = 0; iCount < refitCounters.size(); ++iCount) { + // std::cout << xcheckCounters[iCount] << "\t"; + // //assert(refitCounters[iCount] == xcheckCounters[iCount]); + // } + // std::cout << std::endl; + + // std::cout << "+++ Nonsharing candidates with 4, 5, 6 and 7 clusters:\t"; + // for (int count : nonsharingCounters) + // std::cout << count << "\t"; + // std::cout << std::endl; + + // std::cout << "+++ Sharing matrix:\n"; + // for (int iCl = 4; iCl <= 7; ++iCl) { + // std::cout << "+++ "; + // for (int iSh = cumulativeIndex(iCl); iSh < cumulativeIndex(iCl + 1); ++iSh) { + // std::cout << sharingMatrix[iSh] << "\t"; + // } + // std::cout << std::endl; + // } #endif } @@ -477,7 +485,7 @@ void Tracker::computeRoadsMClabels(const ROframe& event) bool isFakeRoad{false}; bool isFirstRoadCell{true}; - for (int iCell{0}; iCell < constants::its::CellsPerRoad; ++iCell) { + for (int iCell{0}; iCell < mTrkParams[0].CellsPerRoad(); ++iCell) { const int currentCellIndex{currentRoad[iCell]}; if (currentCellIndex == constants::its::UnusedIndex) { @@ -554,7 +562,6 @@ void Tracker::computeTracksMClabels(const ROframe& event) if (index == constants::its::UnusedIndex) { continue; } - const MCCompLabel& currentLabel = event.getClusterLabels(iCluster, index); if (currentLabel == maxOccurrencesValue) { ++count; diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraitsCPU.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraitsCPU.cxx index 5925a66c7a204..b8c7299134bcf 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraitsCPU.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraitsCPU.cxx @@ -34,9 +34,9 @@ namespace its void TrackerTraitsCPU::computeLayerTracklets() { PrimaryVertexContext* primaryVertexContext = mPrimaryVertexContext; - for (int iLayer{0}; iLayer < constants::its::TrackletsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < mTrkParams.TrackletsPerRoad(); ++iLayer) { if (primaryVertexContext->getClusters()[iLayer].empty() || primaryVertexContext->getClusters()[iLayer + 1].empty()) { - return; + continue; } const float3& primaryVertex = primaryVertexContext->getPrimaryVertex(); @@ -67,12 +67,12 @@ void TrackerTraitsCPU::computeLayerTracklets() int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1}; if (phiBinsNum < 0) { - phiBinsNum += constants::index_table::PhiBins; + phiBinsNum += mTrkParams.PhiBins; } for (int iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; - iPhiBin = ++iPhiBin == constants::index_table::PhiBins ? 0 : iPhiBin, iPhiCount++) { - const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect.x, iPhiBin)}; + iPhiBin = ++iPhiBin == mTrkParams.PhiBins ? 0 : iPhiBin, iPhiCount++) { + const int firstBinIndex{primaryVertexContext->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)}; const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1}; const int firstRowClusterIndex = primaryVertexContext->getIndexTables()[iLayer][firstBinIndex]; const int maxRowClusterIndex = primaryVertexContext->getIndexTables()[iLayer][maxBinIndex]; @@ -80,6 +80,10 @@ void TrackerTraitsCPU::computeLayerTracklets() for (int iNextLayerCluster{firstRowClusterIndex}; iNextLayerCluster < maxRowClusterIndex; ++iNextLayerCluster) { + if (iNextLayerCluster >= primaryVertexContext->getClusters()[iLayer + 1].size()) { + break; + } + const Cluster& nextCluster{primaryVertexContext->getClusters()[iLayer + 1][iNextLayerCluster]}; if (primaryVertexContext->isClusterUsed(iLayer + 1, nextCluster.clusterId)) { @@ -107,13 +111,25 @@ void TrackerTraitsCPU::computeLayerTracklets() } } } + if (iLayer > 0 && iLayer < mTrkParams.TrackletsPerRoad() - 1 && + primaryVertexContext->getTracklets()[iLayer].size() > primaryVertexContext->getCellsLookupTable()[iLayer - 1].size()) { + std::cout << "**** FATAL: not enough memory in the CellsLookupTable, increase the tracklet memory coefficients ****" << std::endl; + exit(1); + } + } +#ifdef CA_DEBUG + std::cout << "+++ Number of tracklets per layer: "; + for (int iLayer{0}; iLayer < mTrkParams.TrackletsPerRoad(); ++iLayer) { + std::cout << primaryVertexContext->getTracklets()[iLayer].size() << "\t"; } + std::cout << std::endl; +#endif } void TrackerTraitsCPU::computeLayerCells() { PrimaryVertexContext* primaryVertexContext = mPrimaryVertexContext; - for (int iLayer{0}; iLayer < constants::its::CellsPerRoad; ++iLayer) { + for (int iLayer{0}; iLayer < mTrkParams.CellsPerRoad(); ++iLayer) { if (primaryVertexContext->getTracklets()[iLayer + 1].empty() || primaryVertexContext->getTracklets()[iLayer].empty()) { @@ -229,17 +245,24 @@ void TrackerTraitsCPU::computeLayerCells() } } } +#ifdef CA_DEBUG + std::cout << "+++ Number of cells per layer: "; + for (int iLayer{0}; iLayer < mTrkParams.CellsPerRoad(); ++iLayer) { + std::cout << primaryVertexContext->getCells()[iLayer].size() << "\t"; + } + std::cout << std::endl; +#endif } -void TrackerTraitsCPU::refitTracks(const std::array, 7>& tf, std::vector& tracks) +void TrackerTraitsCPU::refitTracks(const std::vector>& tf, std::vector& tracks) { - std::array cells; - for (int iLayer = 0; iLayer < 5; iLayer++) { - cells[iLayer] = mPrimaryVertexContext->getCells()[iLayer].data(); + std::vector cells; + for (int iLayer = 0; iLayer < mTrkParams.CellsPerRoad(); iLayer++) { + cells.push_back(mPrimaryVertexContext->getCells()[iLayer].data()); } - std::array clusters; - for (int iLayer = 0; iLayer < 7; iLayer++) { - clusters[iLayer] = mPrimaryVertexContext->getClusters()[iLayer].data(); + std::vector clusters; + for (int iLayer = 0; iLayer < mTrkParams.NLayers; iLayer++) { + clusters.push_back(mPrimaryVertexContext->getClusters()[iLayer].data()); } mChainRunITSTrackFit(*mChain, mPrimaryVertexContext->getRoads(), clusters, cells, tf, tracks); } diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx index b5b843f33e24e..b407d2059acaf 100644 --- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx +++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx @@ -37,31 +37,30 @@ namespace o2 namespace its { using boost::histogram::indexed; -using constants::index_table::PhiBins; -using constants::index_table::ZBins; -using constants::its::LayersRCoordinate; -using constants::its::LayersZCoordinate; using constants::math::TwoPi; -using index_table_utils::getZBinIndex; void trackleterKernelSerial( const std::vector& clustersNextLayer, // 0 2 const std::vector& clustersCurrentLayer, // 1 1 - const std::array& indexTableNext, + const int* indexTableNext, const unsigned char pairOfLayers, const float phiCut, std::vector& Tracklets, std::vector& foundTracklets, + const IndexTableUtils& utils, // const ROframe* evt = nullptr, const int maxTrackletsPerCluster = static_cast(2e3)) { + const int PhiBins{utils.getNphiBins()}; + const int ZBins{utils.getNzBins()}; + foundTracklets.resize(clustersCurrentLayer.size(), 0); // loop on layer1 clusters for (unsigned int iCurrentLayerClusterIndex{0}; iCurrentLayerClusterIndex < clustersCurrentLayer.size(); ++iCurrentLayerClusterIndex) { int storedTracklets{0}; const Cluster currentCluster{clustersCurrentLayer[iCurrentLayerClusterIndex]}; const int layerIndex{pairOfLayers == LAYER0_TO_LAYER1 ? 0 : 2}; - const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, layerIndex, 0.f, 50.f, phiCut / 2)}; + const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, layerIndex, 0.f, 50.f, phiCut / 2, utils)}; if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) { int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1}; if (phiBinsNum < 0) { @@ -69,7 +68,7 @@ void trackleterKernelSerial( } // loop on phi bins next layer for (int iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; iPhiBin = ++iPhiBin == PhiBins ? 0 : iPhiBin, iPhiCount++) { - const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect.x, iPhiBin)}; + const int firstBinIndex{utils.getBinIndex(selectedBinsRect.x, iPhiBin)}; const int firstRowClusterIndex{indexTableNext[firstBinIndex]}; const int maxRowClusterIndex{indexTableNext[firstBinIndex + ZBins]}; // loop on clusters next layer @@ -150,9 +149,6 @@ VertexerTraits::VertexerTraits() : mAverageClustersRadii{std::array{0. VertexerTraits::VertexerTraits() : mAverageClustersRadii{std::array{0.f, 0.f, 0.f}}, mMaxDirectorCosine3{0.f} { - mVrtParams.phiSpan = static_cast(std::ceil(constants::index_table::PhiBins * mVrtParams.phiCut / - constants::math::TwoPi)); - mVrtParams.zSpan = static_cast(std::ceil(mVrtParams.zCut * constants::index_table::InverseZBinSize()[0])); } #endif @@ -169,7 +165,7 @@ void VertexerTraits::reset() { for (int iLayer{0}; iLayer < constants::its::LayersNumberVertexer; ++iLayer) { mClusters[iLayer].clear(); - mIndexTables[iLayer].fill(0); + std::fill(mIndexTables[iLayer].begin(), mIndexTables[iLayer].end(), 0); } mTracklets.clear(); @@ -193,6 +189,7 @@ std::vector VertexerTraits::getMClabelsLayer(const int layer) const void VertexerTraits::arrangeClusters(ROframe* event) { + const auto& LayersZCoordinate = mVrtParams.LayerZ; mEvent = event; for (int iLayer{0}; iLayer < constants::its::LayersNumberVertexer; ++iLayer) { const auto& currentLayer{event->getClustersOnLayer(iLayer)}; @@ -202,7 +199,7 @@ void VertexerTraits::arrangeClusters(ROframe* event) mClusters[iLayer].reserve(clustersNum); } for (unsigned int iCluster{0}; iCluster < clustersNum; ++iCluster) { - mClusters[iLayer].emplace_back(iLayer, currentLayer.at(iCluster)); + mClusters[iLayer].emplace_back(iLayer, mIndexTableUtils, currentLayer.at(iCluster)); mAverageClustersRadii[iLayer] += mClusters[iLayer].back().rCoordinate; } mAverageClustersRadii[iLayer] *= 1.f / clustersNum; @@ -221,7 +218,7 @@ void VertexerTraits::arrangeClusters(ROframe* event) previousBinIndex = currentBinIndex; } } - for (int iBin{previousBinIndex + 1}; iBin <= ZBins * PhiBins; iBin++) { + for (int iBin{previousBinIndex + 1}; iBin <= mIndexTableUtils.getNzBins() * mIndexTableUtils.getNphiBins(); iBin++) { mIndexTables[iLayer][iBin] = static_cast(clustersNum); } } @@ -229,25 +226,25 @@ void VertexerTraits::arrangeClusters(ROframe* event) mDeltaRadii10 = mAverageClustersRadii[1] - mAverageClustersRadii[0]; mDeltaRadii21 = mAverageClustersRadii[2] - mAverageClustersRadii[1]; mMaxDirectorCosine3 = - LayersZCoordinate()[2] / std::sqrt(LayersZCoordinate()[2] * LayersZCoordinate()[2] + - (mDeltaRadii10 + mDeltaRadii21) * (mDeltaRadii10 + mDeltaRadii21)); + LayersZCoordinate[2] / std::hypot(LayersZCoordinate[2], mDeltaRadii10 + mDeltaRadii21); } -const std::vector> VertexerTraits::selectClusters(const std::array& indexTable, - const std::array& selectedBinsRect) +const std::vector> VertexerTraits::selectClusters(const int* indexTable, + const std::array& selectedBinsRect, + const IndexTableUtils& utils) { std::vector> filteredBins{}; int phiBinsNum{selectedBinsRect[3] - selectedBinsRect[1] + 1}; if (phiBinsNum < 0) { - phiBinsNum += PhiBins; + phiBinsNum += utils.getNphiBins(); } filteredBins.reserve(phiBinsNum); for (int iPhiBin{selectedBinsRect[1]}, iPhiCount{0}; iPhiCount < phiBinsNum; - iPhiBin = ++iPhiBin == PhiBins ? 0 : iPhiBin, iPhiCount++) { - const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect[0], iPhiBin)}; + iPhiBin = ++iPhiBin == utils.getNphiBins() ? 0 : iPhiBin, iPhiCount++) { + const int firstBinIndex{utils.getBinIndex(selectedBinsRect[0], iPhiBin)}; filteredBins.emplace_back( indexTable[firstBinIndex], - index_table_utils::countRowSelectedBins(indexTable, iPhiBin, selectedBinsRect[0], selectedBinsRect[2])); + utils.countRowSelectedBins(indexTable, iPhiBin, selectedBinsRect[0], selectedBinsRect[2])); } return filteredBins; } @@ -312,20 +309,22 @@ void VertexerTraits::computeTracklets() trackleterKernelSerial( mClusters[0], mClusters[1], - mIndexTables[0], + mIndexTables[0].data(), LAYER0_TO_LAYER1, mVrtParams.phiCut, mComb01, - mFoundTracklets01); + mFoundTracklets01, + mIndexTableUtils); trackleterKernelSerial( mClusters[2], mClusters[1], - mIndexTables[2], + mIndexTables[2].data(), LAYER1_TO_LAYER2, mVrtParams.phiCut, mComb12, - mFoundTracklets12); + mFoundTracklets12, + mIndexTableUtils); #ifdef _ALLOW_DEBUG_TREES_ITS_ if (isDebugFlag(VertexerDebug::CombinatoricsTreeAll)) { diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx index c27ac26b4a6cf..1103157c3adbf 100644 --- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx +++ b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx @@ -119,7 +119,7 @@ void CookedTrackerDPL::run(ProcessingContext& pc) o2::its::VertexerTraits vertexerTraits; o2::its::Vertexer vertexer(&vertexerTraits); - o2::its::ROframe event(0); + o2::its::ROframe event(0, 7); auto& vertROFvec = pc.outputs().make>(Output{"ITS", "VERTICESROF", 0, Lifetime::Timeframe}); auto& vertices = pc.outputs().make>(Output{"ITS", "VERTICES", 0, Lifetime::Timeframe}); diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx index 47bfbdc8c93de..7f29a4bb0e0cb 100644 --- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx +++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx @@ -130,7 +130,7 @@ void TrackerDPL::run(ProcessingContext& pc) auto& vertices = pc.outputs().make>(Output{"ITS", "VERTICES", 0, Lifetime::Timeframe}); std::uint32_t roFrame = 0; - ROframe event(0); + ROframe event(0, 7); bool continuous = mGRP->isDetContinuousReadOut("ITS"); LOG(INFO) << "ITSTracker RO: continuous=" << continuous; diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx index c828884b69328..a6db94b02b007 100644 --- a/GPU/GPUTracking/Global/GPUChainITS.cxx +++ b/GPU/GPUTracking/Global/GPUChainITS.cxx @@ -70,13 +70,13 @@ int GPUChainITS::Finalize() { return 0; } int GPUChainITS::RunChain() { return 0; } -int GPUChainITS::PrepareAndRunITSTrackFit(std::vector& roads, std::array clusters, std::array cells, const std::array, 7>& tf, std::vector& tracks) +int GPUChainITS::PrepareAndRunITSTrackFit(std::vector& roads, std::vector& clusters, std::vector& cells, const std::vector>& tf, std::vector& tracks) { mRec->PrepareEvent(); return RunITSTrackFit(roads, clusters, cells, tf, tracks); } -int GPUChainITS::RunITSTrackFit(std::vector& roads, std::array clusters, std::array cells, const std::array, 7>& tf, std::vector& tracks) +int GPUChainITS::RunITSTrackFit(std::vector& roads, std::vector& clusters, std::vector& cells, const std::vector>& tf, std::vector& tracks) { auto threadContext = GetThreadContext(); bool doGPU = GetRecoStepsGPU() & RecoStep::ITSTracking; @@ -85,7 +85,7 @@ int GPUChainITS::RunITSTrackFit(std::vector& roads, std::arrayioPtrs); @@ -93,7 +93,7 @@ int GPUChainITS::RunITSTrackFit(std::vector& roads, std::array& roads, std::array clusters, std::array cells, const std::array, 7>& tf, std::vector& tracks); - int RunITSTrackFit(std::vector& roads, std::array clusters, std::array cells, const std::array, 7>& tf, std::vector& tracks); + int PrepareAndRunITSTrackFit(std::vector& roads, std::vector& clusters, std::vector& cells, const std::vector>& tf, std::vector& tracks); + int RunITSTrackFit(std::vector& roads, std::vector& clusters, std::vector& cells, const std::vector>& tf, std::vector& tracks); o2::its::TrackerTraits* GetITSTrackerTraits(); o2::its::VertexerTraits* GetITSVertexerTraits(); diff --git a/GPU/GPUTracking/ITS/GPUITSFitter.h b/GPU/GPUTracking/ITS/GPUITSFitter.h index c45efa0048adf..fc27cc985808a 100644 --- a/GPU/GPUTracking/ITS/GPUITSFitter.h +++ b/GPU/GPUTracking/ITS/GPUITSFitter.h @@ -56,6 +56,8 @@ class GPUITSFitter : public GPUProcessor { return mMemory->mNumberOfTracks; } + GPUd() void SetNumberOfLayers(int i) { mNumberOfLayers = i; } + GPUd() int NumberOfLayers() { return mNumberOfLayers; } GPUd() void SetNumberTF(int i, int v) { mNTF[i] = v; } GPUd() o2::its::TrackingFrameInfo** trackingFrame() { @@ -77,16 +79,17 @@ class GPUITSFitter : public GPUProcessor }; protected: + int mNumberOfLayers; int mNumberOfRoads = 0; int mNMaxTracks = 0; - int mNTF[7] = {}; + int* mNTF = nullptr; Memory* mMemory = nullptr; o2::its::Road* mRoads = nullptr; - o2::its::TrackingFrameInfo* mTF[7] = {}; + o2::its::TrackingFrameInfo** mTF = {nullptr}; GPUITSTrack* mTracks = nullptr; - const o2::its::Cluster* mClusterPtrs[7]; - const o2::its::Cell* mCellPtrs[5]; + const o2::its::Cluster** mClusterPtrs; + const o2::its::Cell** mCellPtrs; short mMemoryResInput = -1; short mMemoryResTracks = -1; diff --git a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx index 0e3fba8649e41..67360fbb49ed9 100644 --- a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx +++ b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx @@ -78,7 +78,7 @@ GPUdii() void GPUITSFitterKernel::Thread<0>(int nBlocks, int nThreads, int iBloc int lastCellLevel = o2::its::constants::its::UnusedIndex; CA_DEBUGGER(int nClusters = 2); - for (int iCell{0}; iCell < o2::its::constants::its::CellsPerRoad; ++iCell) { + for (int iCell{0}; iCell < Fitter.NumberOfLayers() - 2; ++iCell) { const int cellIndex = road[iCell]; if (cellIndex == o2::its::constants::its::UnusedIndex) { continue; @@ -164,13 +164,13 @@ GPUdii() void GPUITSFitterKernel::Thread<0>(int nBlocks, int nThreads, int iBloc for (size_t iC = 0; iC < 7; ++iC) { temporaryTrack.mClusters[iC] = clusters[iC]; } - bool fitSuccess = fitTrack(Fitter, prop, temporaryTrack, o2::its::constants::its::LayersNumber - 4, -1, -1); + bool fitSuccess = fitTrack(Fitter, prop, temporaryTrack, Fitter.NumberOfLayers() - 4, -1, -1); if (!fitSuccess) { continue; } CA_DEBUGGER(fitCounters[nClusters - 4]++); temporaryTrack.ResetCovariance(); - fitSuccess = fitTrack(Fitter, prop, temporaryTrack, 0, o2::its::constants::its::LayersNumber, 1); + fitSuccess = fitTrack(Fitter, prop, temporaryTrack, 0, Fitter.NumberOfLayers(), 1); if (!fitSuccess) { continue; } @@ -184,7 +184,7 @@ GPUdii() void GPUITSFitterKernel::Thread<0>(int nBlocks, int nThreads, int iBloc temporaryTrack.mOuterParam.X = temporaryTrack.X(); temporaryTrack.mOuterParam.alpha = prop.GetAlpha(); temporaryTrack.ResetCovariance(); - fitSuccess = fitTrack(Fitter, prop, temporaryTrack, o2::its::constants::its::LayersNumber - 1, -1, -1); + fitSuccess = fitTrack(Fitter, prop, temporaryTrack, Fitter.NumberOfLayers() - 1, -1, -1); if (!fitSuccess) { continue; } diff --git a/macro/CMakeLists.txt b/macro/CMakeLists.txt index b98d5319126c6..7baa6029f5a2f 100644 --- a/macro/CMakeLists.txt +++ b/macro/CMakeLists.txt @@ -53,6 +53,7 @@ install(FILES CheckDigits_mft.C run_rawdecoding_mft.C run_trac_ca_its.C run_trac_its.C + run_trac_alice3.C CreateBCPattern.C DESTINATION share/macro/) @@ -380,6 +381,11 @@ o2_add_test_root_macro(run_trac_its.C O2::SimulationDataFormat LABELS its) +# FIXME: move to subsystem dir +o2_add_test_root_macro(run_trac_alice3.C + PUBLIC_LINK_LIBRARIES O2::GPUTracking + LABELS its COMPILE_ONLY) + # # NOTE: commented out until unit testing reenabled FIXME : re-enable or delete ? # diff --git a/macro/run_primary_vertexer_ITS.C b/macro/run_primary_vertexer_ITS.C index 1a9e8f122f7fc..fc0599a84ae91 100644 --- a/macro/run_primary_vertexer_ITS.C +++ b/macro/run_primary_vertexer_ITS.C @@ -170,7 +170,7 @@ int run_primary_vertexer_ITS(const GPUDataTypes::DeviceType dtype = GPUDataTypes for (size_t iROfCount{static_cast(startAt)}; iROfCount < static_cast(stopAt); ++iROfCount) { auto& rof = (*rofs)[iROfCount]; - o2::its::ROframe frame(iROfCount); // to get meaningful roframeId + o2::its::ROframe frame(iROfCount, 7); // to get meaningful roframeId std::cout << "ROframe: " << iROfCount << std::endl; auto it = pattIt; diff --git a/macro/run_trac_alice3.C b/macro/run_trac_alice3.C new file mode 100644 index 0000000000000..b38c9c2918e1e --- /dev/null +++ b/macro/run_trac_alice3.C @@ -0,0 +1,263 @@ +#if !defined(__CLING__) || defined(__ROOTCLING__) +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "DataFormatsITSMFT/ROFRecord.h" +#include "ITSMFTSimulation/Hit.h" +#include "ITStracking/Configuration.h" +#include "ITStracking/IOUtils.h" +#include "ITStracking/Tracker.h" +#include "ITStracking/TrackerTraitsCPU.h" +#include "ITStracking/Vertexer.h" +#include "DataFormatsITSMFT/Cluster.h" +#include "DataFormatsITSMFT/TopologyDictionary.h" +#include "DataFormatsITSMFT/CompCluster.h" +#include "DetectorsCommonDataFormats/DetID.h" +#include "SimulationDataFormat/MCTrack.h" +#include "MathUtils/Cartesian3D.h" +#include "ReconstructionDataFormats/DCA.h" +#include "ReconstructionDataFormats/Vertex.h" + +#endif + +using o2::its::MemoryParameters; +using o2::its::TrackingParameters; +using o2::itsmft::Hit; +using std::string; + +constexpr bool kUseSmearing{false}; + +struct particle { + int pdg = 0; + int nLayers = 0; + float pt; + float eta; + float phi; + float recoPt; + float recoEta; + float energyFirst; + float energyLast; + int isReco = 0; // 0 = no, 1 = good, 2 = fake +}; + +float getDetLengthFromEta(const float eta, const float radius) +{ + return 10. * (10. + radius * std::cos(2 * std::atan(std::exp(-eta)))); +} + +void run_trac_alice3(const string hitsFileName = "o2sim_HitsIT4.root") +{ + + TChain mcTree("o2sim"); + mcTree.AddFile("o2sim_Kine.root"); + mcTree.SetBranchStatus("*", 0); //disable all branches + mcTree.SetBranchStatus("MCTrack*", 1); + + std::vector* mcArr = nullptr; + mcTree.SetBranchAddress("MCTrack", &mcArr); + + o2::its::Vertexer vertexer(new o2::its::VertexerTraits()); + TChain itsHits("o2sim"); + + itsHits.AddFile(hitsFileName.data()); + + o2::its::Tracker tracker(new o2::its::TrackerTraitsCPU()); + tracker.setBz(5.f); + + std::uint32_t roFrame; + std::vector* hits = nullptr; + itsHits.SetBranchAddress("IT4Hit", &hits); + + std::vector trackParams(4); + trackParams[0].NLayers = 10; + trackParams[0].MinTrackLength = 10; + + std::vector LayerRadii = {1.8f, 2.4f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f}; + std::vector LayerZ(10); + for (int i{0}; i < 10; ++i) + LayerZ[i] = getDetLengthFromEta(1.44, LayerRadii[i]) + 1.; + std::vector TrackletMaxDeltaZ = {0.1f, 0.1f, 0.3f, 0.3f, 0.3f, 0.3f, 0.5f, 0.5f, 0.5f}; + std::vector CellMaxDCA = {0.05f, 0.04f, 0.05f, 0.2f, 0.4f, 0.5f, 0.5f, 0.5f}; + std::vector CellMaxDeltaZ = {0.2f, 0.4f, 0.5f, 0.6f, 3.0f, 3.0f, 3.0f, 3.0f}; + std::vector NeighbourMaxDeltaCurvature = {0.008f, 0.0025f, 0.003f, 0.0035f, 0.004f, 0.004f, 0.005f}; + std::vector NeighbourMaxDeltaN = {0.002f, 0.0090f, 0.002f, 0.005f, 0.005f, 0.005f, 0.005f}; + + trackParams[0].LayerRadii = LayerRadii; + trackParams[0].LayerZ = LayerZ; + trackParams[0].TrackletMaxDeltaPhi = 0.3; + trackParams[0].CellMaxDeltaPhi = 0.15; + trackParams[0].CellMaxDeltaTanLambda = 0.03; + trackParams[0].TrackletMaxDeltaZ = TrackletMaxDeltaZ; + trackParams[0].CellMaxDCA = CellMaxDCA; + trackParams[0].CellMaxDeltaZ = CellMaxDeltaZ; + trackParams[0].NeighbourMaxDeltaCurvature = NeighbourMaxDeltaCurvature; + trackParams[0].NeighbourMaxDeltaN = NeighbourMaxDeltaN; + + std::vector memParams(4); + std::vector CellsMemoryCoefficients = {2.3208e-08f * 20, 2.104e-08f * 20, 1.6432e-08f * 20, 1.2412e-08f * 20, 1.3543e-08f * 20, 1.5e-08f * 20, 1.6e-08f * 20, 1.7e-08f * 20}; + std::vector TrackletsMemoryCoefficients = {0.0016353f * 1000, 0.0013627f * 1000, 0.000984f * 1000, 0.00078135f * 1000, 0.00057934f * 1000, 0.00052217f * 1000, 0.00052217f * 1000, 0.00052217f * 1000, 0.00052217f * 1000}; + memParams[0].CellsMemoryCoefficients = CellsMemoryCoefficients; + memParams[0].TrackletsMemoryCoefficients = TrackletsMemoryCoefficients; + memParams[0].MemoryOffset = 8000; + + for (int i = 1; i < 4; ++i) { + memParams[i] = memParams[i - 1]; + trackParams[i] = trackParams[i - 1]; + // trackParams[i].MinTrackLength -= 2; + trackParams[i].TrackletMaxDeltaPhi *= 3; + trackParams[i].CellMaxDeltaPhi *= 3; + trackParams[i].CellMaxDeltaTanLambda *= 3; + for (auto& val : trackParams[i].TrackletMaxDeltaZ) + val *= 3; + for (auto& val : trackParams[i].CellMaxDCA) + val *= 3; + for (auto& val : trackParams[i].CellMaxDeltaZ) + val *= 3; + for (auto& val : trackParams[i].NeighbourMaxDeltaCurvature) + val *= 3; + for (auto& val : trackParams[i].NeighbourMaxDeltaN) + val *= 3; + } + + tracker.setParameters(memParams, trackParams); + + constexpr int nBins = 100; + constexpr float minPt = 0.01; + constexpr float maxPt = 10; + double newBins[nBins + 1]; + newBins[0] = minPt; + double factor = pow(maxPt / minPt, 1. / nBins); + for (int i = 1; i <= nBins; i++) { + newBins[i] = factor * newBins[i - 1]; + } + + TH1D genH("gen", ";#it{p}_{T} (GeV/#it{c});", nBins, newBins); + TH1D recH("rec", "Efficiency;#it{p}_{T} (GeV/#it{c});", nBins, newBins); + TH1D fakH("fak", "Fake rate;#it{p}_{T} (GeV/#it{c});", nBins, newBins); + TH2D deltaPt("deltapt", ";#it{p}_{T} (GeV/#it{c});#Delta#it{p}_{T} (GeV/#it{c});", nBins, newBins, 100, -0.1, 0.1); + TH2D dcaxy("dcaxy", ";#it{p}_{T} (GeV/#it{c});DCA_{xy} (#mum);", nBins, newBins, 200, -200, 200); + TH2D dcaz("dcaz", ";#it{p}_{T} (GeV/#it{c});DCA_{z} (#mum);", nBins, newBins, 200, -200, 200); + TH2D deltaE("deltaE", ";#it{p}_{T} (GeV/#it{c});#DeltaE (MeV);", nBins, newBins, 200, 0, 100); + + Point3D pos{0.f, 0.f, 0.f}; + const std::array cov{1.e-4, 0., 0., 1.e-4, 0., 1.e-4}; + o2::dataformats::VertexBase vtx(pos, cov); + o2::dataformats::DCA dca; + + for (int iEvent{0}; iEvent < itsHits.GetEntriesFast(); ++iEvent) { + std::cout << "*************** Event " << iEvent << " ***************" << std::endl; + itsHits.GetEntry(iEvent); + mcTree.GetEvent(iEvent); + o2::its::ROframe event{iEvent, 10}; + + int id{0}; + std::map mapPDG; + for (auto& hit : *hits) { + const int layer{hit.GetDetectorID()}; + float xyz[3]{hit.GetX(), hit.GetY(), hit.GetZ()}; + float r{std::hypot(xyz[0], xyz[1])}; + float phi{std::atan2(-xyz[1], -xyz[0]) + o2::its::constants::math::Pi}; + + if (kUseSmearing) { + phi = gRandom->Gaus(phi, std::asin(0.0005f / r)); + xyz[0] = r * std::cos(phi); + xyz[1] = r * std::sin(phi); + xyz[2] = gRandom->Gaus(xyz[2], 0.0005f); + } + + event.addTrackingFrameInfoToLayer(layer, xyz[0], xyz[1], xyz[2], r, phi, std::array{0.f, xyz[2]}, + std::array{0.0005f * 0.0005f, 0.f, 0.0005f * 0.0005f}); + event.addClusterToLayer(layer, xyz[0], xyz[1], xyz[2], event.getClustersOnLayer(layer).size()); + event.addClusterLabelToLayer(layer, o2::MCCompLabel(hit.GetTrackID(), iEvent, iEvent, false)); + event.addClusterExternalIndexToLayer(layer, id++); + if (mapPDG.find(hit.GetTrackID()) == mapPDG.end()) { + mapPDG[hit.GetTrackID()] = particle(); + mapPDG[hit.GetTrackID()].nLayers |= 1 << layer; + mapPDG[hit.GetTrackID()].pt = std::hypot(hit.GetPx(), hit.GetPy()); + if (hit.GetTrackID() < mcArr->size()) { + auto part = mcArr->at(hit.GetTrackID()); + mapPDG[hit.GetTrackID()].energyFirst = part.GetEnergy(); + mapPDG[hit.GetTrackID()].pdg = part.GetPdgCode(); + mapPDG[hit.GetTrackID()].pt = part.GetPt(); + mapPDG[hit.GetTrackID()].eta = part.GetEta(); + mapPDG[hit.GetTrackID()].phi = part.GetPhi(); + } + } else { + mapPDG[hit.GetTrackID()].nLayers |= 1 << layer; + mapPDG[hit.GetTrackID()].energyLast = hit.GetE(); + } + } + roFrame = iEvent; + + vertexer.clustersToVertices(event); + int nPart10layers{0}; + for (auto& part : mapPDG) { + if (part.second.nLayers == 0x3FF) { + nPart10layers++; + genH.Fill(part.second.pt); + deltaE.Fill(part.second.pt, 1000 * (part.second.energyFirst - part.second.energyLast)); + } + } + tracker.clustersToTracks(event); + auto& tracks = tracker.getTracks(); + auto& tracksLabels = tracker.getTrackLabels(); + std::cout << "**** " << nPart10layers << " particles with 10 layers " << tracks.size() << " tracks" << std::endl; + int good{0}; + for (unsigned int i{0}; i < tracks.size(); ++i) { + auto& lab = tracksLabels[i]; + auto& track = tracks[i]; + int trackID = std::abs(lab.getTrackID()); + if (mapPDG.find(trackID) != mapPDG.end()) { + if (!mapPDG[trackID].pdg) + std::cout << "strange" << std::endl; + mapPDG[trackID].isReco = lab.isFake() ? 2 : 1; + mapPDG[trackID].recoPt = track.getPt(); + mapPDG[trackID].recoEta = track.getEta(); + (lab.isFake() ? fakH : recH).Fill(mapPDG[trackID].pt); + deltaPt.Fill(mapPDG[trackID].pt, (mapPDG[trackID].pt - mapPDG[trackID].recoPt) / mapPDG[trackID].pt); + if (!track.propagateToDCA(vtx, tracker.getBz(), &dca)) { + std::cout << "Propagation failed." << std::endl; + } else { + dcaxy.Fill(mapPDG[trackID].pt, dca.getY() * 1.e4); + dcaz.Fill(mapPDG[trackID].pt, dca.getZ() * 1.e4); + } + } + } + } + + TH1D dcaxy_res(recH); + dcaxy_res.Reset(); + dcaxy_res.SetNameTitle("dcaxy_res", ";#it{p}_{T} (GeV/#it{c});#sigma(DCA_{xy}) (#mum);"); + TH1D dcaz_res(recH); + dcaz_res.Reset(); + dcaz_res.SetNameTitle("dcaz_res", ";#it{p}_{T} (GeV/#it{c});#sigma(DCA_{z}) (#mum);"); + for (int i = 1; i <= nBins; ++i) { + auto proj = dcaxy.ProjectionY(Form("xy%i", i), i, i); + dcaxy_res.SetBinContent(i, proj->GetStdDev()); + dcaxy_res.SetBinError(i, proj->GetStdDevError()); + proj = dcaz.ProjectionY(Form("z%i", i), i, i); + dcaz_res.SetBinContent(i, proj->GetStdDev()); + dcaz_res.SetBinError(i, proj->GetStdDevError()); + } + + TFile output("output.root", "recreate"); + recH.Divide(&genH); + fakH.Divide(&genH); + recH.Write(); + fakH.SetLineColor(kRed); + fakH.Write(); + genH.Write(); + deltaPt.Write(); + dcaxy.Write(); + dcaz.Write(); + dcaz_res.Write(); + dcaxy_res.Write(); + deltaE.Write(); +} diff --git a/macro/run_trac_ca_its.C b/macro/run_trac_ca_its.C index b29671c2772b7..04213bbb1946f 100644 --- a/macro/run_trac_ca_its.C +++ b/macro/run_trac_ca_its.C @@ -63,13 +63,13 @@ void run_trac_ca_its(std::string path = "./", gSystem->Load("libO2ITStracking.so"); //std::unique_ptr rec(GPUReconstruction::CreateInstance()); - std::unique_ptr rec(GPUReconstruction::CreateInstance("CUDA", true)); // for GPU with CUDA - auto* chainITS = rec->AddChain(); - rec->Init(); + // std::unique_ptr rec(GPUReconstruction::CreateInstance("CUDA", true)); // for GPU with CUDA + // auto* chainITS = rec->AddChain(); + // rec->Init(); - o2::its::Tracker tracker(chainITS->GetITSTrackerTraits()); - //o2::its::Tracker tracker(new o2::its::TrackerTraitsCPU()); - o2::its::ROframe event(0); + // o2::its::Tracker tracker(chainITS->GetITSTrackerTraits()); + o2::its::Tracker tracker(new o2::its::TrackerTraitsCPU()); + o2::its::ROframe event(0, 7); if (path.back() != '/') { path += '/'; diff --git a/macro/run_trac_its.C b/macro/run_trac_its.C index d1272e1df3445..252db1a899072 100644 --- a/macro/run_trac_its.C +++ b/macro/run_trac_its.C @@ -166,7 +166,7 @@ void run_trac_its(std::string path = "./", std::string outputfile = "o2trac_its. o2::its::VertexerTraits vertexerTraits; o2::its::Vertexer vertexer(&vertexerTraits); - o2::its::ROframe event(0); + o2::its::ROframe event(0, 7); gsl::span patt(patterns->data(), patterns->size()); auto pattIt = patt.begin();