Project
Loading...
Searching...
No Matches
GPUChainTrackingIO.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#include "GPUChainTracking.h"
16#include "GPUReconstructionIO.h"
17#include "GPUTPCClusterData.h"
19#include "GPUTPCGMMergedTrack.h"
21#include "GPUTPCTrack.h"
22#include "GPUTPCHitId.h"
23#include "GPUTRDTrackletWord.h"
25#include "GPUTPCMCInfo.h"
26#include "GPUTRDTrack.h"
27#include "GPUTRDTracker.h"
28#include "AliHLTTPCRawCluster.h"
30#include "GPUQA.h"
31#include "GPULogging.h"
35#include "TPCZSLinkMapping.h"
36#include "GPUTriggerOutputs.h"
37
42#include "GPUHostDataTypes.h"
44#include "CalibdEdxContainer.h"
45
46#include "TPCFastTransform.h"
48
49#include "utils/linux_helpers.h"
50
51using namespace o2::gpu;
52
53#include "GPUO2DataTypes.h"
54
55using namespace o2::tpc;
56using namespace o2::trd;
57using namespace o2::dataformats;
58
59static constexpr uint32_t DUMP_HEADER_SIZE = 4;
60static constexpr char DUMP_HEADER[DUMP_HEADER_SIZE + 1] = "CAv1";
61
66
68{
69 FILE* fp = fopen(filename, "w+b");
70 if (fp == nullptr) {
71 return;
72 }
73 fwrite(DUMP_HEADER, 1, DUMP_HEADER_SIZE, fp);
75 DumpData(fp, mIOPtrs.clusterData, mIOPtrs.nClusterData, InOutPointerType::CLUSTER_DATA);
76 DumpData(fp, mIOPtrs.rawClusters, mIOPtrs.nRawClusters, InOutPointerType::RAW_CLUSTERS);
78 if (DumpData(fp, &mIOPtrs.clustersNative->clustersLinear, &mIOPtrs.clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
82 std::pair<const char*, size_t> tmp = {buffer.data(), buffer.size()};
83 DumpData(fp, &tmp.first, &tmp.second, InOutPointerType::CLUSTER_NATIVE_MC);
84 }
85 }
86 }
89 const char* ptrs[NSECTORS];
90 size_t sizes[NSECTORS];
91 for (uint32_t i = 0; i < NSECTORS; i++) {
93 const auto& buffer = mIOPtrs.tpcPackedDigits->tpcDigitsMC->v[i]->getBuffer();
94 ptrs[i] = buffer.data();
95 sizes[i] = buffer.size();
96 } else {
97 ptrs[i] = nullptr;
98 sizes[i] = 0;
99 }
100 }
101 DumpData(fp, ptrs, sizes, InOutPointerType::TPC_DIGIT_MC);
102 }
103 }
104 if (mIOPtrs.tpcZS) {
105 size_t total = 0;
106 for (int32_t i = 0; i < NSECTORS; i++) {
107 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
108 for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[i].count[j]; k++) {
109 total += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
110 }
111 }
112 }
113 std::vector<std::array<char, TPCZSHDR::TPC_ZS_PAGE_SIZE>> pages(total);
114 char* ptr = pages[0].data();
116 total = 0;
117 for (int32_t i = 0; i < NSECTORS; i++) {
118 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
119 for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[i].count[j]; k++) {
121 counts.count[i][j] += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
122 total += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
123 }
124 }
125 }
127 if (DumpData(fp, &ptr, &total, InOutPointerType::TPC_ZS)) {
128 fwrite(&counts, sizeof(counts), 1, fp);
129 }
130 }
133 throw std::runtime_error("Cannot dump non-flat compressed clusters");
134 }
135 char* ptr = (char*)mIOPtrs.tpcCompressedClusters;
137 DumpData(fp, &ptr, &size, InOutPointerType::TPC_COMPRESSED_CL);
138 }
139 if (mIOPtrs.settingsTF) {
140 uint32_t n = 1;
141 DumpData(fp, &mIOPtrs.settingsTF, &n, InOutPointerType::TF_SETTINGS);
142 }
143 DumpData(fp, mIOPtrs.sectorTracks, mIOPtrs.nSectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
144 DumpData(fp, mIOPtrs.sectorClusters, mIOPtrs.nSectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
145 DumpData(fp, &mIOPtrs.mcLabelsTPC, &mIOPtrs.nMCLabelsTPC, InOutPointerType::MC_LABEL_TPC);
146 DumpData(fp, &mIOPtrs.mcInfosTPC, &mIOPtrs.nMCInfosTPC, InOutPointerType::MC_INFO_TPC);
147 DumpData(fp, &mIOPtrs.mcInfosTPCCol, &mIOPtrs.nMCInfosTPCCol, InOutPointerType::MC_INFO_TPC);
148 DumpData(fp, &mIOPtrs.mergedTracks, &mIOPtrs.nMergedTracks, InOutPointerType::MERGED_TRACK);
149 DumpData(fp, &mIOPtrs.mergedTrackHits, &mIOPtrs.nMergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
150 DumpData(fp, &mIOPtrs.trdTracks, &mIOPtrs.nTRDTracks, InOutPointerType::TRD_TRACK);
151 DumpData(fp, &mIOPtrs.trdTracklets, &mIOPtrs.nTRDTracklets, InOutPointerType::TRD_TRACKLET);
153 DumpData(fp, &mIOPtrs.trdSpacePoints, &mIOPtrs.nTRDTracklets, InOutPointerType::TRD_SPACEPOINT);
154 }
155 DumpData(fp, &mIOPtrs.trdTriggerTimes, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
156 DumpData(fp, &mIOPtrs.trdTrackletIdxFirst, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
157 DumpData(fp, &mIOPtrs.trdTrigRecMask, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
158 fclose(fp);
159}
160
162{
164 FILE* fp = fopen(filename, "rb");
165 if (fp == nullptr) {
166 return (1);
167 }
168
169 char buf[DUMP_HEADER_SIZE + 1] = "";
170 size_t r = fread(buf, 1, DUMP_HEADER_SIZE, fp);
171 if (strncmp(DUMP_HEADER, buf, DUMP_HEADER_SIZE)) {
172 GPUError("Invalid file header");
173 fclose(fp);
174 return -1;
175 }
176 GeometryType geo;
177 r = fread(&geo, sizeof(geo), 1, fp);
179 GPUError("File has invalid geometry (%s v.s. %s)", GPUReconstruction::GEOMETRY_TYPE_NAMES[(int32_t)geo], GPUReconstruction::GEOMETRY_TYPE_NAMES[(int32_t)GPUReconstruction::geometryType]);
180 fclose(fp);
181 return 1;
182 }
183 GPUTPCClusterData* ptrClusterData[NSECTORS];
184 ReadData(fp, mIOPtrs.clusterData, mIOPtrs.nClusterData, mIOMem.clusterData, InOutPointerType::CLUSTER_DATA, ptrClusterData);
185 AliHLTTPCRawCluster* ptrRawClusters[NSECTORS];
186 ReadData(fp, mIOPtrs.rawClusters, mIOPtrs.nRawClusters, mIOMem.rawClusters, InOutPointerType::RAW_CLUSTERS, ptrRawClusters);
187 int32_t nClustersTotal = 0;
189 if (ReadData<ClusterNative>(fp, &mIOMem.clusterNativeAccess->clustersLinear, &mIOMem.clusterNativeAccess->nClustersTotal, &mIOMem.clustersNative, InOutPointerType::CLUSTERS_NATIVE)) {
190 r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUCA_ROW_COUNT, fp);
191 mIOMem.clusterNativeAccess->setOffsetPtrs();
193 std::pair<const char*, size_t> tmp = {nullptr, 0};
194 if (ReadData(fp, &tmp.first, &tmp.second, &mIOMem.clusterNativeMC, InOutPointerType::CLUSTER_NATIVE_MC)) {
195 mIOMem.clusterNativeMCView = std::make_unique<ConstMCLabelContainerView>(gsl::span<const char>(tmp.first, tmp.first + tmp.second));
196 mIOMem.clusterNativeAccess->clustersMCTruth = mIOMem.clusterNativeMCView.get();
197 }
198 }
200 if (ReadData(fp, mIOMem.digitMap->tpcDigits, mIOMem.digitMap->nTPCDigits, mIOMem.tpcDigits, InOutPointerType::TPC_DIGIT)) {
202 const char* ptrs[NSECTORS];
203 size_t sizes[NSECTORS];
204 if (ReadData(fp, ptrs, sizes, mIOMem.tpcDigitsMC, InOutPointerType::TPC_DIGIT_MC)) {
205 mIOMem.tpcDigitMCMap = std::make_unique<GPUTPCDigitsMCInput>();
207 for (uint32_t i = 0; i < NSECTORS; i++) {
208 if (sizes[i]) {
209 mIOMem.tpcDigitMCView.get()[i] = gsl::span<const char>(ptrs[i], ptrs[i] + sizes[i]);
211 } else {
212 mIOMem.tpcDigitMCMap->v[i] = nullptr;
213 }
214 }
215 mIOMem.digitMap->tpcDigitsMC = mIOMem.tpcDigitMCMap.get();
216 }
217 }
218 const char* ptr;
219 size_t total;
220 char* ptrZSPages;
221 if (ReadData(fp, &ptr, &total, &mIOMem.tpcZSpagesChar, InOutPointerType::TPC_ZS, &ptrZSPages)) {
223 r = fread(&counts, sizeof(counts), 1, fp);
226 total = 0;
227 for (int32_t i = 0; i < NSECTORS; i++) {
228 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
229 mIOMem.tpcZSmeta2->ptr[i][j] = &ptrZSPages[total * TPCZSHDR::TPC_ZS_PAGE_SIZE];
230 mIOMem.tpcZSmeta->sector[i].zsPtr[j] = &mIOMem.tpcZSmeta2->ptr[i][j];
231 mIOMem.tpcZSmeta2->n[i][j] = counts.count[i][j];
232 mIOMem.tpcZSmeta->sector[i].nZSPtr[j] = &mIOMem.tpcZSmeta2->n[i][j];
233 mIOMem.tpcZSmeta->sector[i].count[j] = 1;
234 total += counts.count[i][j];
235 }
236 }
238 }
239 if (ReadData(fp, &ptr, &total, &mIOMem.tpcCompressedClusters, InOutPointerType::TPC_COMPRESSED_CL)) {
241 }
242 uint32_t n;
243 ReadData(fp, &mIOPtrs.settingsTF, &n, &mIOMem.settingsTF, InOutPointerType::TF_SETTINGS);
244 ReadData(fp, mIOPtrs.sectorTracks, mIOPtrs.nSectorTracks, mIOMem.sectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
245 ReadData(fp, mIOPtrs.sectorClusters, mIOPtrs.nSectorClusters, mIOMem.sectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
246 ReadData(fp, &mIOPtrs.mcLabelsTPC, &mIOPtrs.nMCLabelsTPC, &mIOMem.mcLabelsTPC, InOutPointerType::MC_LABEL_TPC);
247 ReadData(fp, &mIOPtrs.mcInfosTPC, &mIOPtrs.nMCInfosTPC, &mIOMem.mcInfosTPC, InOutPointerType::MC_INFO_TPC);
248 ReadData(fp, &mIOPtrs.mcInfosTPCCol, &mIOPtrs.nMCInfosTPCCol, &mIOMem.mcInfosTPCCol, InOutPointerType::MC_INFO_TPC);
249 ReadData(fp, &mIOPtrs.mergedTracks, &mIOPtrs.nMergedTracks, &mIOMem.mergedTracks, InOutPointerType::MERGED_TRACK);
250 ReadData(fp, &mIOPtrs.mergedTrackHits, &mIOPtrs.nMergedTrackHits, &mIOMem.mergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
251 ReadData(fp, &mIOPtrs.trdTracks, &mIOPtrs.nTRDTracks, &mIOMem.trdTracks, InOutPointerType::TRD_TRACK);
252 ReadData(fp, &mIOPtrs.trdTracklets, &mIOPtrs.nTRDTracklets, &mIOMem.trdTracklets, InOutPointerType::TRD_TRACKLET);
253 uint32_t dummy = 0;
254 ReadData(fp, &mIOPtrs.trdSpacePoints, &dummy, &mIOMem.trdSpacePoints, InOutPointerType::TRD_SPACEPOINT);
255 ReadData(fp, &mIOPtrs.trdTriggerTimes, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTriggerTimes, InOutPointerType::TRD_TRIGGERRECORDS);
256 ReadData(fp, &mIOPtrs.trdTrackletIdxFirst, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTrackletIdxFirst, InOutPointerType::TRD_TRIGGERRECORDS);
257 ReadData(fp, &mIOPtrs.trdTrigRecMask, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTrigRecMask, InOutPointerType::TRD_TRIGGERRECORDS);
258
259 size_t fptr = ftell(fp);
260 fseek(fp, 0, SEEK_END);
261 size_t fend = ftell(fp);
262 fclose(fp);
263 if (fptr != fend) {
264 GPUError("Error reading data file, reading incomplete");
265 return 1;
266 }
267 (void)r;
268 for (uint32_t i = 0; i < NSECTORS; i++) {
269 for (uint32_t j = 0; j < mIOPtrs.nClusterData[i]; j++) {
270 ptrClusterData[i][j].id = nClustersTotal++;
271 if ((uint32_t)ptrClusterData[i][j].amp >= 25 * 1024) {
272 GPUError("Invalid cluster charge, truncating (%d >= %d)", (int32_t)ptrClusterData[i][j].amp, 25 * 1024);
273 ptrClusterData[i][j].amp = 25 * 1024 - 1;
274 }
275 }
276 for (uint32_t j = 0; j < mIOPtrs.nRawClusters[i]; j++) {
277 if ((uint32_t)mIOMem.rawClusters[i][j].GetCharge() >= 25 * 1024) {
278 GPUError("Invalid raw cluster charge, truncating (%d >= %d)", (int32_t)ptrRawClusters[i][j].GetCharge(), 25 * 1024);
279 ptrRawClusters[i][j].SetCharge(25 * 1024 - 1);
280 }
281 if ((uint32_t)mIOPtrs.rawClusters[i][j].GetQMax() >= 1024) {
282 GPUError("Invalid raw cluster charge max, truncating (%d >= %d)", (int32_t)ptrRawClusters[i][j].GetQMax(), 1024);
283 ptrRawClusters[i][j].SetQMax(1024 - 1);
284 }
285 }
286 }
287
288 return (0);
289}
290
292{
293 std::string f;
294 if (processors()->calibObjects.fastTransform != nullptr) {
295 f = dir;
296 f += "tpctransform.dump";
297 DumpFlatObjectToFile(processors()->calibObjects.fastTransform, f.c_str());
298 }
299 if (processors()->calibObjects.fastTransformRef != nullptr) {
300 f = dir;
301 f += "tpctransformref.dump";
302 DumpFlatObjectToFile(processors()->calibObjects.fastTransformRef, f.c_str());
303 }
304 if (processors()->calibObjects.fastTransformMShape != nullptr) {
305 f = dir;
306 f += "tpctransformmshape.dump";
307 DumpFlatObjectToFile(processors()->calibObjects.fastTransformMShape, f.c_str());
308 }
309 if (processors()->calibObjects.fastTransformHelper != nullptr) {
310 f = dir;
311 f += "tpctransformhelper.dump";
312 DumpStructToFile(processors()->calibObjects.fastTransformHelper, f.c_str());
313 }
314 if (processors()->calibObjects.tpcPadGain != nullptr) {
315 f = dir;
316 f += "tpcpadgaincalib.dump";
317 DumpStructToFile(processors()->calibObjects.tpcPadGain, f.c_str());
318 }
319 if (processors()->calibObjects.tpcZSLinkMapping != nullptr) {
320 f = dir;
321 f += "tpczslinkmapping.dump";
322 DumpStructToFile(processors()->calibObjects.tpcZSLinkMapping, f.c_str());
323 }
324 if (processors()->calibObjects.dEdxCalibContainer != nullptr) {
325 f = dir;
326 f += "dEdxCalibContainer.dump";
327 DumpFlatObjectToFile(processors()->calibObjects.dEdxCalibContainer, f.c_str());
328 }
329 if (processors()->calibObjects.matLUT != nullptr) {
330 f = dir;
331 f += "matlut.dump";
332 DumpFlatObjectToFile(processors()->calibObjects.matLUT, f.c_str());
333 }
334 if (processors()->calibObjects.trdGeometry != nullptr) {
335 f = dir;
336 f += "trdgeometry.dump";
337 DumpStructToFile(processors()->calibObjects.trdGeometry, f.c_str());
338 }
339}
340
342{
343 std::string f;
344 f = dir;
345 f += "tpctransform.dump";
346 mTPCFastTransformU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
348 f = dir;
349 f += "tpctransformref.dump";
350 mTPCFastTransformRefU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
352 f = dir;
353 f += "tpctransformmshape.dump";
354 mTPCFastTransformMShapeU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
356 f = dir;
357 f += "tpctransformhelper.dump";
358 mTPCFastTransformHelperU = ReadStructFromFile<CorrectionMapsHelper>(f.c_str());
359 if ((processors()->calibObjects.fastTransformHelper = mTPCFastTransformHelperU.get())) {
362 mTPCFastTransformHelperU->setCorrMapMShape(mTPCFastTransformMShapeU.get());
363 }
364 f = dir;
365 f += "tpcpadgaincalib.dump";
366 mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());
368 f = dir;
369 f += "tpczslinkmapping.dump";
370 mTPCZSLinkMappingU = ReadStructFromFile<TPCZSLinkMapping>(f.c_str());
372 f = dir;
373 f += "dEdxCalibContainer.dump";
374 mdEdxCalibContainerU = ReadFlatObjectFromFile<o2::tpc::CalibdEdxContainer>(f.c_str());
376 f = dir;
377 f += "matlut.dump";
378 mMatLUTU = ReadFlatObjectFromFile<o2::base::MatLayerCylSet>(f.c_str());
380 f = dir;
381 f += "trdgeometry.dump";
382 mTRDGeometryU = ReadStructFromFile<o2::trd::GeometryFlat>(f.c_str());
384}
Definition of container class for dE/dx corrections.
Helper class to access correction maps.
Definition of the TPC Digit.
int32_t i
#define GPUCA_ROW_COUNT
Online TRD tracker based on extrapolated TPC tracks.
Used for storing the MC labels for the TRD tracklets.
TRD Tracklet word for GPU tracker - 32bit tracklet info + half chamber ID + index.
Definition of a container to keep Monte Carlo truth external to simulation objects.
uint32_t j
Definition RawData.h:0
Definition of TPCFastTransform class.
TBranch * ptr
Definitions of TPC Zero Suppression Data Headers.
const gsl::span< const char > & getBuffer() const
std::unique_ptr< o2::base::MatLayerCylSet > mMatLUTU
std::unique_ptr< TPCFastTransform > mTPCFastTransformMShapeU
void ReadSettings(const char *dir="") override
std::unique_ptr< CorrectionMapsHelper > mTPCFastTransformHelperU
std::unique_ptr< TPCFastTransform > mTPCFastTransformRefU
void DumpData(const char *filename)
std::unique_ptr< TPCPadGainCalib > mTPCPadGainCalibU
std::unique_ptr< o2::tpc::CalibdEdxContainer > mdEdxCalibContainerU
std::unique_ptr< o2::trd::GeometryFlat > mTRDGeometryU
std::unique_ptr< TPCZSLinkMapping > mTPCZSLinkMappingU
std::unique_ptr< TPCFastTransform > mTPCFastTransformU
GPUTrackingInOutPointers & mIOPtrs
struct o2::gpu::GPUChainTracking::InOutMemory mIOMem
int32_t ReadData(const char *filename)
void DumpSettings(const char *dir="") override
GPUConstantMem * processors()
Definition GPUChain.h:80
void DumpStructToFile(const T *obj, const char *file)
Definition GPUChain.h:159
static constexpr int32_t NSECTORS
Definition GPUChain.h:54
void DumpFlatObjectToFile(const T *obj, const char *file)
Definition GPUChain.h:149
static constexpr GeometryType geometryType
static constexpr const char *const GEOMETRY_TYPE_NAMES[]
GLdouble n
Definition glcorearb.h:1982
GLuint buffer
Definition glcorearb.h:655
GLsizeiptr size
Definition glcorearb.h:659
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
Definition glcorearb.h:2595
GLdouble f
Definition glcorearb.h:310
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
GLboolean r
Definition glcorearb.h:1233
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition glcorearb.h:2514
Definition of a container to keep/associate and arbitrary number of labels associated to an index wit...
Global TPC definitions and constants.
Definition SimTraits.h:167
std::string filename()
void SetQMax(uint16_t qmax)
void SetCharge(uint16_t charge)
S< o2::trd::GeometryFlat >::type * trdGeometry
S< o2::tpc::CalibdEdxContainer >::type * dEdxCalibContainer
S< TPCZSLinkMapping >::type * tpcZSLinkMapping
S< TPCFastTransform >::type * fastTransform
S< TPCPadGainCalib >::type * tpcPadGain
S< o2::base::MatLayerCylSet >::type * matLUT
S< TPCFastTransform >::type * fastTransformRef
S< TPCFastTransform >::type * fastTransformMShape
std::unique_ptr< o2::tpc::Digit[]> tpcDigits[NSECTORS]
std::unique_ptr< char[]> tpcCompressedClusters
std::unique_ptr< GPUTPCMCInfo[]> mcInfosTPC
std::unique_ptr< char[]> tpcDigitsMC[NSECTORS]
std::unique_ptr< GPUTRDTrackletWord[]> trdTracklets
std::unique_ptr< o2::dataformats::ConstMCTruthContainerView< o2::MCCompLabel >[]> tpcDigitMCView
std::unique_ptr< GPUTPCMCInfoCol[]> mcInfosTPCCol
std::unique_ptr< GPUTPCGMMergedTrackHit[]> mergedTrackHits
std::unique_ptr< int32_t[]> trdTrackletIdxFirst
std::unique_ptr< GPUTPCGMMergedTrack[]> mergedTracks
std::unique_ptr< AliHLTTPCClusterMCLabel[]> mcLabelsTPC
std::unique_ptr< o2::dataformats::ConstMCTruthContainerView< o2::MCCompLabel > > clusterNativeMCView
std::unique_ptr< GPUTrackingInOutDigits > digitMap
std::unique_ptr< GPUTPCClusterData[]> clusterData[NSECTORS]
std::unique_ptr< o2::tpc::ClusterNative[]> clustersNative
std::unique_ptr< GPUTPCDigitsMCInput > tpcDigitMCMap
InOutMemory & operator=(InOutMemory &&)
std::unique_ptr< float[]> trdTriggerTimes
std::unique_ptr< GPUTPCTrack[]> sectorTracks[NSECTORS]
std::unique_ptr< GPUTRDSpacePoint[]> trdSpacePoints
std::unique_ptr< GPUTrackingInOutZS > tpcZSmeta
std::unique_ptr< uint8_t[]> trdTrigRecMask
std::unique_ptr< o2::tpc::ClusterNativeAccess > clusterNativeAccess
std::unique_ptr< AliHLTTPCRawCluster[]> rawClusters[NSECTORS]
std::unique_ptr< GPUTPCHitId[]> sectorClusters[NSECTORS]
std::unique_ptr< GPUSettingsTF[]> settingsTF
std::unique_ptr< char[]> tpcZSpagesChar
std::unique_ptr< GPUTRDTrackGPU[]> trdTracks
std::unique_ptr< GPUTrackingInOutZS::GPUTrackingInOutZSMeta > tpcZSmeta2
GPUCalibObjectsConst calibObjects
std::array< const o2::dataformats::ConstMCTruthContainerView< o2::MCCompLabel > *, o2::tpc::constants::MAXSECTOR > v
const o2::tpc::Digit * tpcDigits[NSECTORS]
const GPUTPCDigitsMCInput * tpcDigitsMC
const GPUTPCHitId * sectorClusters[NSECTORS]
const o2::tpc::ClusterNativeAccess * clustersNative
const GPUTPCMCInfo * mcInfosTPC
const o2::tpc::CompressedClustersFlat * tpcCompressedClusters
const AliHLTTPCClusterMCLabel * mcLabelsTPC
const GPUTRDSpacePoint * trdSpacePoints
const GPUTPCTrack * sectorTracks[NSECTORS]
const GPUTRDTrackGPU * trdTracks
const GPUSettingsTF * settingsTF
const GPUTRDTrackletWord * trdTracklets
const GPUTrackingInOutZS * tpcZS
const AliHLTTPCRawCluster * rawClusters[NSECTORS]
const GPUTPCClusterData * clusterData[NSECTORS]
const GPUTPCGMMergedTrackHit * mergedTrackHits
const GPUTrackingInOutDigits * tpcPackedDigits
const GPUTPCMCInfoCol * mcInfosTPCCol
const GPUTPCGMMergedTrack * mergedTracks
GPUTrackingInOutZSSector sector[NSECTORS]
static constexpr uint32_t NENDPOINTS
unsigned int nClusters[constants::MAXSECTOR][constants::MAXGLOBALPADROW]
const o2::dataformats::ConstMCTruthContainerView< o2::MCCompLabel > * clustersMCTruth
const ClusterNative * clustersLinear
const CompressedClusters * ptrForward
static constexpr size_t TPC_ZS_PAGE_SIZE