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"
18#include "GPUTPCGMMergedTrack.h"
20#include "GPUTPCTrack.h"
21#include "GPUTPCHitId.h"
22#include "GPUTRDTrackletWord.h"
23#include "GPUTRDRecoParam.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#include "GPUConstantMem.h"
38
43#include "GPUHostDataTypes.h"
45#include "CalibdEdxContainer.h"
46
47#include "TPCFastTransformPOD.h"
48
49using namespace o2::gpu;
50
51#include "GPUO2DataTypes.h"
52
53using namespace o2::tpc;
54using namespace o2::trd;
55using namespace o2::dataformats;
56
57static constexpr uint32_t DUMP_HEADER_SIZE = 4;
58static constexpr char DUMP_HEADER[DUMP_HEADER_SIZE + 1] = "CAv1";
59
64
66{
67 FILE* fp = fopen(filename, "w+b");
68 if (fp == nullptr) {
69 return;
70 }
71 if (ioPtrs == nullptr) {
72 ioPtrs = &mIOPtrs;
73 }
74 fwrite(DUMP_HEADER, 1, DUMP_HEADER_SIZE, fp);
76 DumpData(fp, ioPtrs->clusterData, ioPtrs->nClusterData, InOutPointerType::CLUSTER_DATA);
77 DumpData(fp, ioPtrs->rawClusters, ioPtrs->nRawClusters, InOutPointerType::RAW_CLUSTERS);
78 if (ioPtrs->clustersNative) {
79 if (DumpData(fp, &ioPtrs->clustersNative->clustersLinear, &ioPtrs->clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
80 fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUTPCGeometry::NROWS, fp);
81 if (ioPtrs->clustersNative->clustersMCTruth) {
82 const auto& buffer = ioPtrs->clustersNative->clustersMCTruth->getBuffer();
83 std::pair<const char*, size_t> tmp = {buffer.data(), buffer.size()};
84 DumpData(fp, &tmp.first, &tmp.second, InOutPointerType::CLUSTER_NATIVE_MC);
85 }
86 }
87 }
88 if (ioPtrs->tpcPackedDigits) {
89 if (DumpData(fp, ioPtrs->tpcPackedDigits->tpcDigits, ioPtrs->tpcPackedDigits->nTPCDigits, InOutPointerType::TPC_DIGIT) && ioPtrs->tpcPackedDigits->tpcDigitsMC) {
90 const char* ptrs[NSECTORS];
91 size_t sizes[NSECTORS];
92 for (uint32_t i = 0; i < NSECTORS; i++) {
93 if (ioPtrs->tpcPackedDigits->tpcDigitsMC->v[i]) {
94 const auto& buffer = ioPtrs->tpcPackedDigits->tpcDigitsMC->v[i]->getBuffer();
95 ptrs[i] = buffer.data();
96 sizes[i] = buffer.size();
97 } else {
98 ptrs[i] = nullptr;
99 sizes[i] = 0;
100 }
101 }
102 DumpData(fp, ptrs, sizes, InOutPointerType::TPC_DIGIT_MC);
103 }
104 }
105 if (ioPtrs->tpcZS) {
106 size_t total = 0;
107 for (int32_t i = 0; i < NSECTORS; i++) {
108 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
109 for (uint32_t k = 0; k < ioPtrs->tpcZS->sector[i].count[j]; k++) {
110 total += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
111 }
112 }
113 }
114 std::vector<std::array<char, TPCZSHDR::TPC_ZS_PAGE_SIZE>> pages(total);
115 char* ptr = pages[0].data();
117 total = 0;
118 for (int32_t i = 0; i < NSECTORS; i++) {
119 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
120 for (uint32_t k = 0; k < ioPtrs->tpcZS->sector[i].count[j]; k++) {
121 memcpy(&ptr[total * TPCZSHDR::TPC_ZS_PAGE_SIZE], ioPtrs->tpcZS->sector[i].zsPtr[j][k], ioPtrs->tpcZS->sector[i].nZSPtr[j][k] * TPCZSHDR::TPC_ZS_PAGE_SIZE);
122 counts.count[i][j] += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
123 total += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
124 }
125 }
126 }
127 total *= TPCZSHDR::TPC_ZS_PAGE_SIZE;
128 if (DumpData(fp, &ptr, &total, InOutPointerType::TPC_ZS)) {
129 fwrite(&counts, sizeof(counts), 1, fp);
130 }
131 }
132 if (ioPtrs->tpcCompressedClusters) {
133 if (ioPtrs->tpcCompressedClusters->ptrForward) {
134 throw std::runtime_error("Cannot dump non-flat compressed clusters");
135 }
136 char* ptr = (char*)ioPtrs->tpcCompressedClusters;
137 size_t size = ioPtrs->tpcCompressedClusters->totalDataSize;
138 DumpData(fp, &ptr, &size, InOutPointerType::TPC_COMPRESSED_CL);
139 }
140 if (ioPtrs->settingsTF) {
141 uint32_t n = 1;
142 DumpData(fp, &ioPtrs->settingsTF, &n, InOutPointerType::TF_SETTINGS);
143 }
144 DumpData(fp, ioPtrs->sectorTracks, ioPtrs->nSectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
145 DumpData(fp, ioPtrs->sectorClusters, ioPtrs->nSectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
146 DumpData(fp, &ioPtrs->mcLabelsTPC, &ioPtrs->nMCLabelsTPC, InOutPointerType::MC_LABEL_TPC);
147 DumpData(fp, &ioPtrs->mcInfosTPC, &ioPtrs->nMCInfosTPC, InOutPointerType::MC_INFO_TPC);
148 DumpData(fp, &ioPtrs->mcInfosTPCCol, &ioPtrs->nMCInfosTPCCol, InOutPointerType::MC_INFO_TPC);
149 DumpData(fp, &ioPtrs->mergedTracks, &ioPtrs->nMergedTracks, InOutPointerType::MERGED_TRACK);
150 DumpData(fp, &ioPtrs->mergedTrackHits, &ioPtrs->nMergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
151 DumpData(fp, &ioPtrs->trdTracks, &ioPtrs->nTRDTracks, InOutPointerType::TRD_TRACK);
152 DumpData(fp, &ioPtrs->trdTracklets, &ioPtrs->nTRDTracklets, InOutPointerType::TRD_TRACKLET);
153 if (ioPtrs->trdSpacePoints) {
154 DumpData(fp, &ioPtrs->trdSpacePoints, &ioPtrs->nTRDTracklets, InOutPointerType::TRD_SPACEPOINT);
155 }
156 DumpData(fp, &ioPtrs->trdTriggerTimes, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
157 DumpData(fp, &ioPtrs->trdTrackletIdxFirst, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
158 DumpData(fp, &ioPtrs->trdTrigRecMask, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
159 fclose(fp);
160}
161
163{
165 FILE* fp = fopen(filename, "rb");
166 if (fp == nullptr) {
167 return (1);
168 }
169
170 char buf[DUMP_HEADER_SIZE + 1] = "";
171 size_t r = fread(buf, 1, DUMP_HEADER_SIZE, fp);
172 if (strncmp(DUMP_HEADER, buf, DUMP_HEADER_SIZE)) {
173 GPUError("Invalid file header");
174 fclose(fp);
175 return -1;
176 }
177 GeometryType geo;
178 r = fread(&geo, sizeof(geo), 1, fp);
181 fclose(fp);
182 return 1;
183 }
184 GPUTPCClusterData* ptrClusterData[NSECTORS];
185 ReadData(fp, mIOPtrs.clusterData, mIOPtrs.nClusterData, mIOMem.clusterData, InOutPointerType::CLUSTER_DATA, ptrClusterData);
186 AliHLTTPCRawCluster* ptrRawClusters[NSECTORS];
187 ReadData(fp, mIOPtrs.rawClusters, mIOPtrs.nRawClusters, mIOMem.rawClusters, InOutPointerType::RAW_CLUSTERS, ptrRawClusters);
188 int32_t nClustersTotal = 0;
190 if (ReadData<ClusterNative>(fp, &mIOMem.clusterNativeAccess->clustersLinear, &mIOMem.clusterNativeAccess->nClustersTotal, &mIOMem.clustersNative, InOutPointerType::CLUSTERS_NATIVE)) {
191 r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUTPCGeometry::NROWS, fp);
192 mIOMem.clusterNativeAccess->setOffsetPtrs();
194 std::pair<const char*, size_t> tmp = {nullptr, 0};
195 if (ReadData(fp, &tmp.first, &tmp.second, &mIOMem.clusterNativeMC, InOutPointerType::CLUSTER_NATIVE_MC)) {
196 mIOMem.clusterNativeMCView = std::make_unique<ConstMCLabelContainerView>(gsl::span<const char>(tmp.first, tmp.first + tmp.second));
197 mIOMem.clusterNativeAccess->clustersMCTruth = mIOMem.clusterNativeMCView.get();
198 }
199 }
201 if (ReadData(fp, mIOMem.digitMap->tpcDigits, mIOMem.digitMap->nTPCDigits, mIOMem.tpcDigits, InOutPointerType::TPC_DIGIT)) {
203 const char* ptrs[NSECTORS];
204 size_t sizes[NSECTORS];
205 if (ReadData(fp, ptrs, sizes, mIOMem.tpcDigitsMC, InOutPointerType::TPC_DIGIT_MC)) {
206 mIOMem.tpcDigitMCMap = std::make_unique<GPUTPCDigitsMCInput>();
208 for (uint32_t i = 0; i < NSECTORS; i++) {
209 if (sizes[i]) {
210 mIOMem.tpcDigitMCView.get()[i] = gsl::span<const char>(ptrs[i], ptrs[i] + sizes[i]);
212 } else {
213 mIOMem.tpcDigitMCMap->v[i] = nullptr;
214 }
215 }
216 mIOMem.digitMap->tpcDigitsMC = mIOMem.tpcDigitMCMap.get();
217 }
218 }
219 const char* ptr;
220 size_t total;
221 char* ptrZSPages;
222 if (ReadData(fp, &ptr, &total, &mIOMem.tpcZSpagesChar, InOutPointerType::TPC_ZS, &ptrZSPages)) {
224 r = fread(&counts, sizeof(counts), 1, fp);
227 total = 0;
228 for (int32_t i = 0; i < NSECTORS; i++) {
229 for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
230 mIOMem.tpcZSmeta2->ptr[i][j] = &ptrZSPages[total * TPCZSHDR::TPC_ZS_PAGE_SIZE];
231 mIOMem.tpcZSmeta->sector[i].zsPtr[j] = &mIOMem.tpcZSmeta2->ptr[i][j];
232 mIOMem.tpcZSmeta2->n[i][j] = counts.count[i][j];
233 mIOMem.tpcZSmeta->sector[i].nZSPtr[j] = &mIOMem.tpcZSmeta2->n[i][j];
234 mIOMem.tpcZSmeta->sector[i].count[j] = 1;
235 total += counts.count[i][j];
236 }
237 }
239 }
240 if (ReadData(fp, &ptr, &total, &mIOMem.tpcCompressedClusters, InOutPointerType::TPC_COMPRESSED_CL)) {
242 }
243 uint32_t n;
244 ReadData(fp, &mIOPtrs.settingsTF, &n, &mIOMem.settingsTF, InOutPointerType::TF_SETTINGS);
245 ReadData(fp, mIOPtrs.sectorTracks, mIOPtrs.nSectorTracks, mIOMem.sectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
246 ReadData(fp, mIOPtrs.sectorClusters, mIOPtrs.nSectorClusters, mIOMem.sectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
247 ReadData(fp, &mIOPtrs.mcLabelsTPC, &mIOPtrs.nMCLabelsTPC, &mIOMem.mcLabelsTPC, InOutPointerType::MC_LABEL_TPC);
248 ReadData(fp, &mIOPtrs.mcInfosTPC, &mIOPtrs.nMCInfosTPC, &mIOMem.mcInfosTPC, InOutPointerType::MC_INFO_TPC);
249 ReadData(fp, &mIOPtrs.mcInfosTPCCol, &mIOPtrs.nMCInfosTPCCol, &mIOMem.mcInfosTPCCol, InOutPointerType::MC_INFO_TPC);
250 ReadData(fp, &mIOPtrs.mergedTracks, &mIOPtrs.nMergedTracks, &mIOMem.mergedTracks, InOutPointerType::MERGED_TRACK);
251 ReadData(fp, &mIOPtrs.mergedTrackHits, &mIOPtrs.nMergedTrackHits, &mIOMem.mergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
252 ReadData(fp, &mIOPtrs.trdTracks, &mIOPtrs.nTRDTracks, &mIOMem.trdTracks, InOutPointerType::TRD_TRACK);
253 ReadData(fp, &mIOPtrs.trdTracklets, &mIOPtrs.nTRDTracklets, &mIOMem.trdTracklets, InOutPointerType::TRD_TRACKLET);
254 uint32_t dummy = 0;
255 ReadData(fp, &mIOPtrs.trdSpacePoints, &dummy, &mIOMem.trdSpacePoints, InOutPointerType::TRD_SPACEPOINT);
256 ReadData(fp, &mIOPtrs.trdTriggerTimes, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTriggerTimes, InOutPointerType::TRD_TRIGGERRECORDS);
257 ReadData(fp, &mIOPtrs.trdTrackletIdxFirst, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTrackletIdxFirst, InOutPointerType::TRD_TRIGGERRECORDS);
258 ReadData(fp, &mIOPtrs.trdTrigRecMask, &mIOPtrs.nTRDTriggerRecords, &mIOMem.trdTrigRecMask, InOutPointerType::TRD_TRIGGERRECORDS);
259
260 size_t fptr = ftell(fp);
261 fseek(fp, 0, SEEK_END);
262 size_t fend = ftell(fp);
263 fclose(fp);
264 if (fptr != fend) {
265 GPUError("Error reading data file, reading incomplete");
266 return 1;
267 }
268 (void)r;
269 for (uint32_t i = 0; i < NSECTORS; i++) {
270 for (uint32_t j = 0; j < mIOPtrs.nClusterData[i]; j++) {
271 ptrClusterData[i][j].id = nClustersTotal++;
272 if ((uint32_t)ptrClusterData[i][j].amp >= 25 * 1024) {
273 GPUError("Invalid cluster charge, truncating (%d >= %d)", (int32_t)ptrClusterData[i][j].amp, 25 * 1024);
274 ptrClusterData[i][j].amp = 25 * 1024 - 1;
275 }
276 }
277 for (uint32_t j = 0; j < mIOPtrs.nRawClusters[i]; j++) {
278 if ((uint32_t)mIOMem.rawClusters[i][j].GetCharge() >= 25 * 1024) {
279 GPUError("Invalid raw cluster charge, truncating (%d >= %d)", (int32_t)ptrRawClusters[i][j].GetCharge(), 25 * 1024);
280 ptrRawClusters[i][j].SetCharge(25 * 1024 - 1);
281 }
282 if ((uint32_t)mIOPtrs.rawClusters[i][j].GetQMax() >= 1024) {
283 GPUError("Invalid raw cluster charge max, truncating (%d >= %d)", (int32_t)ptrRawClusters[i][j].GetQMax(), 1024);
284 ptrRawClusters[i][j].SetQMax(1024 - 1);
285 }
286 }
287 }
288
289 return (0);
290}
291
293{
294 std::string f;
295 if (processors()->calibObjects.fastTransform != nullptr) {
296 f = dir;
297 f += "tpctransform.dump";
298 DumpDynamicStructToFile(processors()->calibObjects.fastTransform, processors()->calibObjects.fastTransform->size(), f.c_str());
299 }
300 if (processors()->calibObjects.tpcPadGain != nullptr) {
301 f = dir;
302 f += "tpcpadgaincalib.dump";
303 DumpStructToFile(processors()->calibObjects.tpcPadGain, f.c_str());
304 }
305 if (processors()->calibObjects.tpcZSLinkMapping != nullptr) {
306 f = dir;
307 f += "tpczslinkmapping.dump";
308 DumpStructToFile(processors()->calibObjects.tpcZSLinkMapping, f.c_str());
309 }
310 if (processors()->calibObjects.dEdxCalibContainer != nullptr) {
311 f = dir;
312 f += "dEdxCalibContainer.dump";
313 DumpFlatObjectToFile(processors()->calibObjects.dEdxCalibContainer, f.c_str());
314 }
315 if (processors()->calibObjects.matLUT != nullptr) {
316 f = dir;
317 f += "matlut.dump";
318 DumpFlatObjectToFile(processors()->calibObjects.matLUT, f.c_str());
319 }
320 if (processors()->calibObjects.trdGeometry != nullptr) {
321 f = dir;
322 f += "trdgeometry.dump";
323 DumpStructToFile(processors()->calibObjects.trdGeometry, f.c_str());
324 }
325 if (processors()->calibObjects.trdRecoParam != nullptr) {
326 f = dir;
327 f += "trdrecoparam.dump";
328 DumpStructToFile(processors()->calibObjects.trdRecoParam, f.c_str());
329 }
330}
331
333{
334 std::string f;
335 f = dir;
336 f += "tpctransform.dump";
337 mTPCFastTransformU = ReadDynamicStructFromFile<TPCFastTransformPOD, &TPCFastTransformPOD::size>(f.c_str());
339 f = dir;
340 f += "tpcpadgaincalib.dump";
341 mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());
343 f = dir;
344 f += "tpczslinkmapping.dump";
345 mTPCZSLinkMappingU = ReadStructFromFile<TPCZSLinkMapping>(f.c_str());
347 f = dir;
348 f += "dEdxCalibContainer.dump";
349 mdEdxCalibContainerU = ReadFlatObjectFromFile<o2::tpc::CalibdEdxContainer>(f.c_str());
351 f = dir;
352 f += "matlut.dump";
353 mMatLUTU = ReadFlatObjectFromFile<o2::base::MatLayerCylSet>(f.c_str());
355 f = dir;
356 f += "trdgeometry.dump";
357 mTRDGeometryU = ReadStructFromFile<o2::trd::GeometryFlat>(f.c_str());
359 f = dir;
360 f += "trdrecoparam.dump";
361 mTRDRecoParamU = ReadStructFromFile<GPUTRDRecoParam>(f.c_str());
363}
Definition of container class for dE/dx corrections.
Definition of the TPC Digit.
unsigned int uint32_t
int32_t i
configStandalone Reconstruction rec_tpc multiplier for the combined cluster track error during track following area in cm for the search of for z only used if decrease removal by when above this local occupancy rowx Shift of TPC revert cluster flag edge bit distance to edge exceeds this ZOffset for secondary multiple of radius max P of electron K BB bands crossing max P of electron p BB bands crossing max P of electron d BB bands crossing max P of electron t BB bands crossing min accepted dEdxMaxTPC of the track Additive extra cluster error for Y2 if edge flag set Additive extra cluster error for Y2 if single set Additive extra cluster error for Y2 if or single set Additive extra cluster error for Z2 if or single set Extra errors to add to track when crossing depending on addErrorsCECrossing Inner portion of y range in sector that is not used in searching for extrapolated track candidates factor2YS for track merging factor2K for track merging Margin in cm of Y position when rejecting edge clusters based on uncorrected track Y Max fraction of shared clusters for tracklet Except pad from cluster finding if total number of charges in a fragment is above this Except pad from cluster finding if number of consecutive charges in a fragment is above this Threshold where a timebin is considered disabling the noisy pad check for that pad Treat signal above this minimum as saturated Smoothing factor for the exponential Highly Ionising Particle tail filter Number of timebins to use for the averaging Add additional custom track errors when crossing relative as fraction of Do N fit passes in final fit of< 0:reject at max -n hits") AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit") AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128") AddOptionRTC(dEdxTruncHigh, uint8_t, 77, "", 0, "High truncation threshold, fraction of 128") AddOptionRTC(extrapolationTracking, int8_t, 1, "", 0, "Enable Extrapolation Tracking(prolong tracks to adjacent sectors to find short segments)") AddOptionRTC(disableRefitAttachment, uint8_t, 0, "", 0, "Bitmask to disable certain attachment steps during refit(1:attachment, 2:propagation, 4:loop following, 8:mirroring)") AddOptionRTC(rejectionStrategy, uint8_t, o2::gpu::GPUSettings::RejectionStrategyA, "", 0, "Enable rejection of TPC clusters for compression(0=no, 1=strategy A, 2=strategy B)") AddOptionRTC(mergeLoopersAfterburner, uint8_t, 1, "", 0, "Run afterburner for additional looper merging") AddOptionRTC(compressionTypeMask, uint8_t, o2::gpu::GPUSettings::CompressionFull, "", 0, "TPC Compression mode bits(1=truncate charge/width LSB, 2=differences, 4=track-model)") AddOptionRTC(compressionSortOrder, uint8_t, o2::gpu::GPUSettings::SortTime, "", 0, "Sort order of TPC compression(0=time, 1=pad, 2=Z-time-pad, 3=Z-pad-time, 4=no sorting(use incoming order))") AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for TPC cluster charge in compression mode 1") AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1") AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop") AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection") AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > mergerNonInterpolateRejectMinNDF Merge tracks accross the central electrode Enable PID response Add sub threshold clusters in TPC dEdx computation OR mask of TPC flags that will reject the cluster in alternative dEdx Reject edge clusters based on uncorrected track Y during track fit Increase decrease removal by when on this number of pads from the edge h configStandalone Reconstruction rec_trd Max chi2 for TRD tracklets to be matched to a track Chi2 cut for strict matching mode Number of sigmas for ITS TPC track time error estimate Addition to search road around track prolongation along Y in cm Optimal tracklet rphi resolution in maximum chi2 per attached tracklet for TRD tracks take into account the full likelihood of the slope including exponential tails Tracks with less attached tracklets are discarded after the tracking Post trigger Pile up integration time in BCs fits all iterations but the last one in projections Use material lookup table for TPC refit Apply workarounds to avoid cyclic merge should not be needed tpc dyn configStandalone Processing proc_rtc Replace constant variables static by constexpr expressions Compile RTC in deterministic with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define Use RTC to optimize GPU code h configStandalone Processing proc_rtctech Use a file lock to serialize access to the cache folder int32_t
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
POD correction map.
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< GPUTRDRecoParam > mTRDRecoParamU
void ReadSettings(const char *dir="") override
std::unique_ptr< TPCPadGainCalib > mTPCPadGainCalibU
std::unique_ptr< o2::tpc::CalibdEdxContainer > mdEdxCalibContainerU
std::unique_ptr< o2::trd::GeometryFlat > mTRDGeometryU
std::unique_ptr< TPCZSLinkMapping > mTPCZSLinkMappingU
void DumpData(const char *filename, const GPUTrackingInOutPointers *ioPtrs=nullptr)
GPUTrackingInOutPointers & mIOPtrs
struct o2::gpu::GPUChainTracking::InOutMemory mIOMem
int32_t ReadData(const char *filename)
void DumpSettings(const char *dir="") override
aligned_unique_buffer_ptr< TPCFastTransformPOD > mTPCFastTransformU
GPUConstantMem * processors()
Definition GPUChain.h:84
void DumpStructToFile(const T *obj, const char *file)
Definition GPUChain.h:165
void DumpDynamicStructToFile(const T *obj, size_t dynamicSize, const char *file)
Definition GPUChain.h:180
static constexpr int32_t NSECTORS
Definition GPUChain.h:58
void DumpFlatObjectToFile(const T *obj, const char *file)
Definition GPUChain.h:155
static constexpr GeometryType geometryType
static constexpr const char *const GEOMETRY_TYPE_NAMES[]
GLdouble n
Definition glcorearb.h:1982
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)
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.
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< TPCFastTransformPOD >::type * fastTransform
S< GPUTRDRecoParam >::type * trdRecoParam
S< TPCPadGainCalib >::type * tpcPadGain
S< o2::base::MatLayerCylSet >::type * matLUT
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< 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 o2::tpc::CompressedClustersFlat * tpcCompressedClusters
const AliHLTTPCClusterMCLabel * mcLabelsTPC
const GPUTRDSpacePoint * trdSpacePoints
const GPUTPCTrack * sectorTracks[NSECTORS]
const GPUTRDTrackGPU * trdTracks
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]
unsigned int nClusters[constants::MAXSECTOR][constants::MAXGLOBALPADROW]
const o2::dataformats::ConstMCTruthContainerView< o2::MCCompLabel > * clustersMCTruth
const ClusterNative * clustersLinear
const CompressedClusters * ptrForward