Project
Loading...
Searching...
No Matches
GPUDisplayImportEvent.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
14
15#ifndef GPUCA_NO_ROOT
16#include "Rtypes.h" // Include ROOT header first, to use ROOT and disable replacements
17#endif
18
19#include "GPUDisplay.h"
20#include "frontend/GPUDisplayInfo.inc"
21#include "GPUO2DataTypes.h"
22#include "GPUTPCClusterData.h"
23#include "GPUTPCConvertImpl.h"
24#include "GPUTRDGeometry.h"
25#include "GPUTRDTrackletWord.h"
26#include "GPUParam.inc"
27
31#include "TOFBase/Geo.h"
33#ifdef GPUCA_O2_LIB
35#endif
36
37#include <oneapi/tbb.h>
38
39using namespace o2::gpu;
40
41void GPUDisplay::DrawGLScene_updateEventData()
42{
43 mTimerDraw.ResetStart();
44 if (mIOPtrs->clustersNative) {
45 mCurrentClusters = mIOPtrs->clustersNative->nClustersTotal;
46 } else {
47 mCurrentClusters = 0;
48 for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
49 mCurrentClusters += mIOPtrs->nClusterData[iSector];
50 }
51 }
52 if (mNMaxClusters < mCurrentClusters) {
53 mNMaxClusters = mCurrentClusters;
54 mGlobalPosPtr.reset(new float4[mNMaxClusters]);
55 mGlobalPos = mGlobalPosPtr.get();
56 }
57
58 mCurrentSpacePointsTRD = mIOPtrs->nTRDTracklets;
59 if (mCurrentSpacePointsTRD > mNMaxSpacePointsTRD) {
60 mNMaxSpacePointsTRD = mCurrentSpacePointsTRD;
61 mGlobalPosPtrTRD.reset(new float4[mNMaxSpacePointsTRD]);
62 mGlobalPosPtrTRD2.reset(new float4[mNMaxSpacePointsTRD]);
63 mGlobalPosTRD = mGlobalPosPtrTRD.get();
64 mGlobalPosTRD2 = mGlobalPosPtrTRD2.get();
65 }
66
67 mCurrentClustersITS = mIOPtrs->itsClusters ? mIOPtrs->nItsClusters : 0;
68 if (mNMaxClustersITS < mCurrentClustersITS) {
69 mNMaxClustersITS = mCurrentClustersITS;
70 mGlobalPosPtrITS.reset(new float4[mNMaxClustersITS]);
71 mGlobalPosITS = mGlobalPosPtrITS.get();
72 }
73
74 mCurrentClustersTOF = mIOPtrs->nTOFClusters;
75 if (mNMaxClustersTOF < mCurrentClustersTOF) {
76 mNMaxClustersTOF = mCurrentClustersTOF;
77 mGlobalPosPtrTOF.reset(new float4[mNMaxClustersTOF]);
78 mGlobalPosTOF = mGlobalPosPtrTOF.get();
79 }
80
81 uint32_t nTpcMergedTracks = mConfig.showTPCTracksFromO2Format ? mIOPtrs->nOutputTracksTPCO2 : mIOPtrs->nMergedTracks;
82 if ((size_t)nTpcMergedTracks > mTRDTrackIds.size()) {
83 mTRDTrackIds.resize(nTpcMergedTracks);
84 }
85 if (mIOPtrs->nItsTracks > mITSStandaloneTracks.size()) {
86 mITSStandaloneTracks.resize(mIOPtrs->nItsTracks);
87 }
88 for (uint32_t i = 0; i < nTpcMergedTracks; i++) {
89 mTRDTrackIds[i] = -1;
90 }
91 auto tmpDoTRDTracklets = [&](auto* trdTracks) {
92 for (uint32_t i = 0; i < mIOPtrs->nTRDTracks; i++) {
93 if (trdTracks[i].getNtracklets()) {
94 mTRDTrackIds[trdTracks[i].getRefGlobalTrackIdRaw()] = i;
95 }
96 }
97 };
98 if (mIOPtrs->trdTracksO2) {
99 tmpDoTRDTracklets(mIOPtrs->trdTracksO2);
100 } else {
101 tmpDoTRDTracklets(mIOPtrs->trdTracks);
102 }
103 if (mIOPtrs->nItsTracks) {
104 std::fill(mITSStandaloneTracks.begin(), mITSStandaloneTracks.end(), true);
105 if (mIOPtrs->tpcLinkITS) {
106 for (uint32_t i = 0; i < nTpcMergedTracks; i++) {
107 if (mIOPtrs->tpcLinkITS[i] != -1) {
108 mITSStandaloneTracks[mIOPtrs->tpcLinkITS[i]] = false;
109 }
110 }
111 }
112 }
113
114 if (mCfgH.trackFilter) {
115 uint32_t nTracks = mConfig.showTPCTracksFromO2Format ? mIOPtrs->nOutputTracksTPCO2 : mIOPtrs->nMergedTracks;
116 mTrackFilter.resize(nTracks);
117 std::fill(mTrackFilter.begin(), mTrackFilter.end(), true);
118 if (buildTrackFilter()) {
119 SetInfo("Error running track filter from %s", mConfig.filterMacros[mCfgH.trackFilter - 1].c_str());
120 } else {
121 uint32_t nFiltered = 0;
122 for (uint32_t i = 0; i < mTrackFilter.size(); i++) {
123 nFiltered += !mTrackFilter[i];
124 }
125 if (mUpdateTrackFilter) {
126 SetInfo("Applied track filter %s - filtered %u / %u", mConfig.filterMacros[mCfgH.trackFilter - 1].c_str(), nFiltered, (uint32_t)mTrackFilter.size());
127 }
128 }
129 }
130 mUpdateTrackFilter = false;
131
132 mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, NSECTORS, 1), float(0.f), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
133 for (int32_t iSector = r.begin(); iSector < r.end(); iSector++) {
134 int32_t row = 0;
135 uint32_t nCls = mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : (mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
136 for (uint32_t i = 0; i < nCls; i++) {
137 int32_t cid;
138 if (mParam->par.earlyTpcTransform) {
139 const auto& cl = mIOPtrs->clusterData[iSector][i];
140 cid = cl.id;
141 row = cl.row;
142 } else {
143 cid = mIOPtrs->clustersNative->clusterOffset[iSector][0] + i;
144 while (row < GPUCA_ROW_COUNT - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
145 row++;
146 }
147 }
148 if (cid >= mNMaxClusters) {
149 throw std::runtime_error("Cluster Buffer Size exceeded");
150 }
151 float4* ptr = &mGlobalPos[cid];
152 if (mParam->par.earlyTpcTransform) {
153 const auto& cl = mIOPtrs->clusterData[iSector][i];
154 mParam->Sector2Global(iSector, (mCfgH.clustersOnNominalRow ? GPUTPCGeometry::Row2X(row) : cl.x) + mCfgH.xAdd, cl.y, cl.z, &ptr->x, &ptr->y, &ptr->z);
155 } else {
156 float x, y, z;
157 const auto& cln = mIOPtrs->clustersNative->clusters[iSector][0][i];
158 GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, iSector, row, cln.getPad(), cln.getTime(), x, y, z);
159 if (mCfgH.clustersOnNominalRow) {
160 x = GPUTPCGeometry::Row2X(row);
161 }
162 mParam->Sector2Global(iSector, x + mCfgH.xAdd, y, z, &ptr->x, &ptr->y, &ptr->z);
163 }
164
165 if (fabsf(ptr->z) > maxClusterZ) {
166 maxClusterZ = fabsf(ptr->z);
167 }
168 ptr->z += iSector < 18 ? mCfgH.zAdd : -mCfgH.zAdd;
169 ptr->x *= GL_SCALE_FACTOR;
170 ptr->y *= GL_SCALE_FACTOR;
171 ptr->z *= GL_SCALE_FACTOR;
172 ptr->w = tCLUSTER;
173 }
174 }
175 return maxClusterZ; // clang-format off
176 }, [](const float a, const float b) { return std::max(a, b); }, tbb::simple_partitioner()); // clang-format on
177
178 mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, mCurrentSpacePointsTRD, 32), float(mMaxClusterZ), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
179 int32_t trdTriggerRecord = -1;
180 float trdZoffset = 0;
181 for (int i = r.begin(); i < r.end(); i++) {
182 while (mParam->par.continuousTracking && trdTriggerRecord < (int32_t)mIOPtrs->nTRDTriggerRecords - 1 && mIOPtrs->trdTrackletIdxFirst[trdTriggerRecord + 1] <= i) {
183 trdTriggerRecord++; // This requires to go through the data in order I believe
184 float trdTime = mIOPtrs->trdTriggerTimes[trdTriggerRecord] * 1e3 / o2::constants::lhc::LHCBunchSpacingNS / o2::tpc::constants::LHCBCPERTIMEBIN;
185 trdZoffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, trdTime, mParam->continuousMaxTimeBin));
186 }
187 const auto& sp = mIOPtrs->trdSpacePoints[i];
188 int32_t iSec = trdGeometry()->GetSector(mIOPtrs->trdTracklets[i].GetDetector());
189 float4* ptr = &mGlobalPosTRD[i];
190 mParam->Sector2Global(iSec, sp.getX() + mCfgH.xAdd, sp.getY(), sp.getZ(), &ptr->x, &ptr->y, &ptr->z);
191 ptr->z += ptr->z > 0 ? trdZoffset : -trdZoffset;
192 if (fabsf(ptr->z) > maxClusterZ) {
193 maxClusterZ = fabsf(ptr->z);
194 }
195 ptr->x *= GL_SCALE_FACTOR;
196 ptr->y *= GL_SCALE_FACTOR;
197 ptr->z *= GL_SCALE_FACTOR;
198 ptr->w = tTRDCLUSTER;
199 ptr = &mGlobalPosTRD2[i];
200 mParam->Sector2Global(iSec, sp.getX() + mCfgH.xAdd + 4.5f, sp.getY() + 1.5f * sp.getDy(), sp.getZ(), &ptr->x, &ptr->y, &ptr->z);
201 ptr->z += ptr->z > 0 ? trdZoffset : -trdZoffset;
202 if (fabsf(ptr->z) > maxClusterZ) {
203 maxClusterZ = fabsf(ptr->z);
204 }
205 ptr->x *= GL_SCALE_FACTOR;
206 ptr->y *= GL_SCALE_FACTOR;
207 ptr->z *= GL_SCALE_FACTOR;
208 ptr->w = tTRDCLUSTER;
209 }
210 return maxClusterZ; // clang-format off
211 }, [](const float a, const float b) { return std::max(a, b); }, tbb::static_partitioner()); // clang-format on
212
213 mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, mCurrentClustersTOF, 32), float(mMaxClusterZ), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
214 for (int32_t i = r.begin(); i < r.end(); i++) {
215 float4* ptr = &mGlobalPosTOF[i];
216 mParam->Sector2Global(mIOPtrs->tofClusters[i].getSector(), mIOPtrs->tofClusters[i].getX() + mCfgH.xAdd, mIOPtrs->tofClusters[i].getY(), mIOPtrs->tofClusters[i].getZ(), &ptr->x, &ptr->y, &ptr->z);
217 float ZOffset = 0;
218 if (mParam->par.continuousTracking) {
220 ZOffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, tofTime, mParam->continuousMaxTimeBin));
221 ptr->z += ptr->z > 0 ? ZOffset : -ZOffset;
222 }
223 if (fabsf(ptr->z) > maxClusterZ) {
224 maxClusterZ = fabsf(ptr->z);
225 }
226 ptr->x *= GL_SCALE_FACTOR;
227 ptr->y *= GL_SCALE_FACTOR;
228 ptr->z *= GL_SCALE_FACTOR;
229 ptr->w = tTOFCLUSTER;
230 }
231 return maxClusterZ; // clang-format off
232 }, [](const float a, const float b) { return std::max(a, b); }); // clang-format on
233
234 if (mCurrentClustersITS) {
235 float itsROFhalfLen = 0;
236#ifdef GPUCA_O2_LIB // Not available in standalone benchmark
237 if (mParam->par.continuousTracking) {
239 itsROFhalfLen = alpParams.roFrameLengthInBC / (float)o2::tpc::constants::LHCBCPERTIMEBIN / 2;
240 }
241#endif
242 int32_t i = 0;
243 for (uint32_t j = 0; j < mIOPtrs->nItsClusterROF; j++) {
244 float ZOffset = 0;
245 if (mParam->par.continuousTracking) {
247 float itsROFtime = mIOPtrs->itsClusterROF[j].getBCData().differenceInBC(startIR) / (float)o2::tpc::constants::LHCBCPERTIMEBIN;
248 ZOffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, itsROFtime + itsROFhalfLen, mParam->continuousMaxTimeBin));
249 }
250 if (i != mIOPtrs->itsClusterROF[j].getFirstEntry()) {
251 throw std::runtime_error("Inconsistent ITS data, number of clusters does not match ROF content");
252 }
253 for (int32_t k = 0; k < mIOPtrs->itsClusterROF[j].getNEntries(); k++) {
254 float4* ptr = &mGlobalPosITS[i];
255 const auto& cl = mIOPtrs->itsClusters[i];
256 auto* itsGeo = o2::its::GeometryTGeo::Instance();
257 auto p = cl.getXYZGlo(*itsGeo);
258 ptr->x = p.X();
259 ptr->y = p.Y();
260 ptr->z = p.Z();
261 ptr->z += ptr->z > 0 ? ZOffset : -ZOffset;
262 if (fabsf(ptr->z) > mMaxClusterZ) {
263 mMaxClusterZ = fabsf(ptr->z);
264 }
265 ptr->x *= GL_SCALE_FACTOR;
266 ptr->y *= GL_SCALE_FACTOR;
267 ptr->z *= GL_SCALE_FACTOR;
268 ptr->w = tITSCLUSTER;
269 i++;
270 }
271 }
272 }
273}
Definition of the TOF cluster.
int32_t i
TRD Tracklet word for GPU tracker - 32bit tracklet info + half chamber ID + index.
Definition of the GeometryTGeo class.
Definition of the ITSMFT ROFrame (trigger) record.
uint32_t j
Definition RawData.h:0
TBranch * ptr
void ResetStart()
Definition timer.cxx:63
T getX() const
Definition BaseCluster.h:62
T getY() const
Definition BaseCluster.h:63
T getZ() const
Definition BaseCluster.h:64
static GeometryTGeo * Instance()
int getNEntries() const
Definition ROFRecord.h:62
const BCData & getBCData() const
Definition ROFRecord.h:58
int getFirstEntry() const
Definition ROFRecord.h:63
std::int8_t getSector() const
Definition Cluster.h:60
double getTime() const
Definition Cluster.h:68
GLint GLenum GLint x
Definition glcorearb.h:403
GLboolean GLboolean GLboolean b
Definition glcorearb.h:1233
GLint y
Definition glcorearb.h:270
GLboolean r
Definition glcorearb.h:1233
GLboolean GLboolean GLboolean GLboolean a
Definition glcorearb.h:1233
GLdouble GLdouble GLdouble z
Definition glcorearb.h:843
constexpr double LHCBunchSpacingNS
constexpr int LHCBCPERTIMEBIN
Definition Constants.h:38
int64_t differenceInBC(const InteractionRecord &other) const
S< TPCFastTransform >::type * fastTransform
S< CorrectionMapsHelper >::type * fastTransformHelper
int32_t float z
Definition GPUParam.h:98
const o2::tpc::ClusterNativeAccess * clustersNative
const GPUTRDSpacePoint * trdSpacePoints
const o2::tof::Cluster * tofClusters
const o2::BaseCluster< float > * itsClusters
const o2::itsmft::ROFRecord * itsClusterROF
const GPUTRDTrackGPU * trdTracks
const GPUSettingsTF * settingsTF
const GPUTRDTrackletWord * trdTracklets
const GPUTPCClusterData * clusterData[NSECTORS]
unsigned int nClustersSector[constants::MAXSECTOR]
const ClusterNative * clusters[constants::MAXSECTOR][constants::MAXGLOBALPADROW]
unsigned int clusterOffset[constants::MAXSECTOR][constants::MAXGLOBALPADROW]
std::vector< int > row