Project
Loading...
Searching...
No Matches
TrackerSpec.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
12#include <vector>
13#include <algorithm>
14#include <array>
15#include <chrono>
16#include <cstdlib>
17#include <filesystem>
18#include <memory>
19#include <format>
20#include <fstream>
21#include <numeric>
22
30#include "Field/MagneticField.h"
31#include "Field/MagFieldParam.h"
45#include <TGeoGlobalMagField.h>
46
47#ifdef O2_WITH_ACTS
51#endif
52
53#include <TFile.h>
54#include <TTree.h>
55
56namespace o2
57{
58using namespace framework;
59namespace trk
60{
62
63namespace
64{
65class ALICE3TrackingBackendLoader : public o2::utils::DLLoaderBase<ALICE3TrackingBackendLoader>
66{
67 O2DLLoaderDef(ALICE3TrackingBackendLoader)
68};
69
70O2DLLoaderImpl(ALICE3TrackingBackendLoader)
71
72 constexpr const char* kGPUBackendFunction = "runALICE3GPUTracking";
73} // namespace
74
75TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
76 bool isMC,
77 const std::string& hitRecoConfigFileName,
78 const std::string& clusterRecoConfigFileName,
80 int trackingThreads)
81{
82 if (!hitRecoConfigFileName.empty()) {
83 LOG(debug) << "Loading ALICE3 TRK hit reconstruction config from file: " << hitRecoConfigFileName;
84 std::ifstream configFile(hitRecoConfigFileName);
85 mHitRecoConfig = nlohmann::json::parse(configFile);
86 LOG(debug) << "Loaded ALICE3 TRK hit reconstruction config: " << mHitRecoConfig.dump();
87 }
88 if (!clusterRecoConfigFileName.empty()) {
89 LOG(debug) << "Loading ALICE3 TRK cluster reconstruction config from file: " << clusterRecoConfigFileName;
90 std::ifstream configFile(clusterRecoConfigFileName);
91 mClusterRecoConfig = nlohmann::json::parse(configFile);
92 LOG(debug) << "Loaded ALICE3 TRK cluster reconstruction config: " << mClusterRecoConfig.dump();
93 }
94 mIsMC = isMC;
95 mDeviceType = dType;
96 mTrackingThreads = std::max(1, trackingThreads);
97}
98
100{
101#ifdef O2_WITH_ACTS
102 mUseACTS = ic.options().get<bool>("useACTS");
103 if (mUseACTS) {
104 o2::acts::TrackingGeometryManager::instance().setBuilder(std::make_unique<o2::alice3::TrkTGeoBlueprintBuilder>());
105 LOG(info) << "Registered automatic ACTS TRK geometry builder";
106 }
107#endif
108}
109
111{
112 LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
113}
114
115std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromConfig()
116{
117 std::vector<o2::its::TrackingParameters> trackingParams;
118 auto loadTrackingParamsFromJson = [](std::vector<o2::its::TrackingParameters>& trackingParams, const nlohmann::json& paramConfigJson) {
119 for (const auto& paramConfig : paramConfigJson) {
120 LOG(debug) << "Loading ALICE3 TRK tracking parameters from config: " << paramConfig.dump();
122 auto applyPassFlag = [&](const char* name, o2::its::IterationStep step) {
123 if (paramConfig.contains(name)) {
124 if (paramConfig[name].get<bool>()) {
125 params.PassFlags.set(step);
126 } else {
127 params.PassFlags.reset(step);
128 }
129 }
130 };
131
132 if (paramConfig.contains("NLayers")) {
133 params.NLayers = paramConfig["NLayers"].get<int>();
134 }
135 if (paramConfig.contains("ZBins")) {
136 params.ZBins = paramConfig["ZBins"].get<int>();
137 }
138 if (paramConfig.contains("PhiBins")) {
139 params.PhiBins = paramConfig["PhiBins"].get<int>();
140 }
141 if (paramConfig.contains("SharedMaxClusters")) {
142 params.SharedMaxClusters = paramConfig["SharedMaxClusters"].get<int>();
143 }
144 if (paramConfig.contains("MinTrackLength")) {
145 params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();
146 }
147 if (paramConfig.contains("MaxHoles")) {
148 params.MaxHoles = paramConfig["MaxHoles"].get<int>();
149 }
150 if (paramConfig.contains("HoleLayerMask")) {
151 params.HoleLayerMask = paramConfig["HoleLayerMask"].get<uint16_t>();
152 }
153 if (paramConfig.contains("InactiveLayerMask")) {
154 params.InactiveLayerMask = paramConfig["InactiveLayerMask"].get<uint16_t>();
155 }
156 if (paramConfig.contains("SeedingLayers")) {
157 params.SeedingLayers = paramConfig["SeedingLayers"].get<uint16_t>();
158 }
159 if (paramConfig.contains("ReseedIfShorter")) {
160 params.ReseedIfShorter = paramConfig["ReseedIfShorter"].get<int>();
161 }
162 if (paramConfig.contains("StartLayerMask")) {
163 params.StartLayerMask = paramConfig["StartLayerMask"].get<uint16_t>();
164 }
165 if (paramConfig.contains("NSigmaCut")) {
166 params.NSigmaCut = paramConfig["NSigmaCut"].get<float>();
167 }
168 if (paramConfig.contains("PVres")) {
169 params.PVres = paramConfig["PVres"].get<float>();
170 }
171 if (paramConfig.contains("TrackletMinPt")) {
172 params.TrackletMinPt = paramConfig["TrackletMinPt"].get<float>();
173 }
174 if (paramConfig.contains("CellDeltaTanLambdaSigma")) {
175 params.CellDeltaTanLambdaSigma = paramConfig["CellDeltaTanLambdaSigma"].get<float>();
176 }
177 if (paramConfig.contains("MaxChi2ClusterAttachment")) {
178 params.MaxChi2ClusterAttachment = paramConfig["MaxChi2ClusterAttachment"].get<float>();
179 }
180 if (paramConfig.contains("MaxChi2NDF")) {
181 params.MaxChi2NDF = paramConfig["MaxChi2NDF"].get<float>();
182 }
183 if (paramConfig.contains("UseDiamond")) {
184 params.UseDiamond = paramConfig["UseDiamond"].get<bool>();
185 }
186 if (paramConfig.contains("AllowSharingFirstCluster")) {
187 params.AllowSharingFirstCluster = paramConfig["AllowSharingFirstCluster"].get<bool>();
188 }
189 if (paramConfig.contains("RepeatRefitOut")) {
190 params.RepeatRefitOut = paramConfig["RepeatRefitOut"].get<bool>();
191 }
192 if (paramConfig.contains("ShiftRefToCluster")) {
193 params.ShiftRefToCluster = paramConfig["ShiftRefToCluster"].get<bool>();
194 }
195 if (paramConfig.contains("PerPrimaryVertexProcessing")) {
196 params.PerPrimaryVertexProcessing = paramConfig["PerPrimaryVertexProcessing"].get<bool>();
197 }
198 if (paramConfig.contains("SaveTimeBenchmarks")) {
199 params.SaveTimeBenchmarks = paramConfig["SaveTimeBenchmarks"].get<bool>();
200 }
201 if (paramConfig.contains("DoUPCIteration")) {
202 params.DoUPCIteration = paramConfig["DoUPCIteration"].get<bool>();
203 }
204 if (paramConfig.contains("FataliseUponFailure")) {
205 params.FataliseUponFailure = paramConfig["FataliseUponFailure"].get<bool>();
206 }
207 if (paramConfig.contains("CreateArtefactLabels")) {
208 params.CreateArtefactLabels = paramConfig["CreateArtefactLabels"].get<bool>();
209 }
210 if (paramConfig.contains("TrackFollower")) {
211 const auto mode = paramConfig["TrackFollower"].get<std::string>();
212 if (mode == "top" || mode == "outward") {
214 } else if (mode == "bot" || mode == "bottom" || mode == "inward") {
216 } else if (mode == "mix" || mode == "both") {
219 } else if (mode != "off") {
220 LOGP(fatal, "Invalid ALICE3 TRK tracking parameter TrackFollower: {}", mode);
221 }
222 }
223 if (paramConfig.contains("TrackFollowerNSigmaCutZ")) {
224 params.TrackFollowerNSigmaCutZ = paramConfig["TrackFollowerNSigmaCutZ"].get<float>();
225 }
226 if (paramConfig.contains("TrackFollowerNSigmaCutPhi")) {
227 params.TrackFollowerNSigmaCutPhi = paramConfig["TrackFollowerNSigmaCutPhi"].get<float>();
228 }
229 if (paramConfig.contains("TrackFollowerMaxHypotheses")) {
230 params.TrackFollowerMaxHypotheses = std::max(1, paramConfig["TrackFollowerMaxHypotheses"].get<int>());
231 }
232 applyPassFlag("FirstPass", o2::its::IterationStep::FirstPass);
233 applyPassFlag("RebuildClusterLUT", o2::its::IterationStep::RebuildClusterLUT);
234 applyPassFlag("UseUPCMask", o2::its::IterationStep::UseUPCMask);
235 applyPassFlag("SelectUPCVertices", o2::its::IterationStep::SelectUPCVertices);
236 applyPassFlag("ResetVertices", o2::its::IterationStep::ResetVertices);
237 applyPassFlag("SkipROFsAboveThreshold", o2::its::IterationStep::SkipROFsAboveThreshold);
238 applyPassFlag("MarkVerticesAsUPC", o2::its::IterationStep::MarkVerticesAsUPC);
239 applyPassFlag("TrackFollowerTop", o2::its::IterationStep::TrackFollowerTop);
240 applyPassFlag("TrackFollowerBot", o2::its::IterationStep::TrackFollowerBot);
241 if (paramConfig.contains("PrintMemory")) {
242 params.PrintMemory = paramConfig["PrintMemory"].get<bool>();
243 }
244 if (paramConfig.contains("DropTFUponFailure")) {
245 params.DropTFUponFailure = paramConfig["DropTFUponFailure"].get<bool>();
246 }
247 if (paramConfig.contains("LayerZ")) {
248 params.LayerZ = paramConfig["LayerZ"].get<std::vector<float>>();
249 }
250 if (paramConfig.contains("LayerRadii")) {
251 params.LayerRadii = paramConfig["LayerRadii"].get<std::vector<float>>();
252 }
253 if (paramConfig.contains("LayerxX0")) {
254 params.LayerxX0 = paramConfig["LayerxX0"].get<std::vector<float>>();
255 }
256 if (paramConfig.contains("LayerResolution")) {
257 params.LayerResolution = paramConfig["LayerResolution"].get<std::vector<float>>();
258 }
259 if (paramConfig.contains("SystErrorY2")) {
260 params.SystErrorY2 = paramConfig["SystErrorY2"].get<std::vector<float>>();
261 }
262 if (paramConfig.contains("SystErrorZ2")) {
263 params.SystErrorZ2 = paramConfig["SystErrorZ2"].get<std::vector<float>>();
264 }
265 if (paramConfig.contains("MinPt")) {
266 params.MinPt = paramConfig["MinPt"].get<std::vector<float>>();
267 }
268 if (paramConfig.contains("AddTimeError")) {
269 params.AddTimeError = paramConfig["AddTimeError"].get<std::vector<UInt_t>>();
270 }
271
272 if (paramConfig.contains("Diamond") && paramConfig["Diamond"].is_array() && paramConfig["Diamond"].size() == 3) {
273 params.Diamond[0] = paramConfig["Diamond"][0].get<float>();
274 params.Diamond[1] = paramConfig["Diamond"][1].get<float>();
275 params.Diamond[2] = paramConfig["Diamond"][2].get<float>();
276 }
277
278 if (paramConfig.contains("MaxMemory")) {
279 params.MaxMemory = paramConfig["MaxMemory"].get<size_t>();
280 }
281
282 if (paramConfig.contains("CorrType")) {
283 int corrTypeInt = paramConfig["CorrType"].get<int>();
284 params.CorrType = static_cast<o2::base::PropagatorImpl<float>::MatCorrType>(corrTypeInt);
285 }
286
287 const auto nLayers = static_cast<size_t>(params.NLayers);
288 LOG_IF(fatal, params.LayerZ.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerZ: expected " << nLayers << " entries, got " << params.LayerZ.size();
289 LOG_IF(fatal, params.LayerRadii.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerRadii: expected " << nLayers << " entries, got " << params.LayerRadii.size();
290 LOG_IF(fatal, params.LayerxX0.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerxX0: expected " << nLayers << " entries, got " << params.LayerxX0.size();
291 LOG_IF(fatal, params.LayerResolution.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerResolution: expected " << nLayers << " entries, got " << params.LayerResolution.size();
292 LOG_IF(fatal, params.SystErrorY2.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter SystErrorY2: expected " << nLayers << " entries, got " << params.SystErrorY2.size();
293 LOG_IF(fatal, params.SystErrorZ2.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter SystErrorZ2: expected " << nLayers << " entries, got " << params.SystErrorZ2.size();
294 LOG_IF(fatal, params.AddTimeError.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter AddTimeError: expected " << nLayers << " entries, got " << params.AddTimeError.size();
295
296 LOG_IF(fatal, params.MinTrackLength > params.NLayers) << "Invalid ALICE3 TRK tracking parameter MinTrackLength: expected <= NLayers (" << params.NLayers << "), got " << params.MinTrackLength;
297 const auto minPtSize = static_cast<size_t>(params.NLayers - params.MinTrackLength + 1);
298 LOG_IF(fatal, params.MinPt.size() != minPtSize) << "Invalid ALICE3 TRK tracking parameter MinPt: expected " << minPtSize << " entries, got " << params.MinPt.size();
299
300 trackingParams.push_back(params);
301 }
302 };
303
304 if (mHitRecoConfig.contains("trackingparams") && mHitRecoConfig["trackingparams"].is_array()) {
305 loadTrackingParamsFromJson(trackingParams, mHitRecoConfig["trackingparams"]);
306 } else if (mClusterRecoConfig.contains("trackingparams") && mClusterRecoConfig["trackingparams"].is_array()) {
307 loadTrackingParamsFromJson(trackingParams, mClusterRecoConfig["trackingparams"]);
308 } else {
309 LOGP(fatal, "No trackingparams field found in configuration or it is not an array. Returning empty vector.");
310 return trackingParams;
311 }
312
313 LOGP(info, "Loaded {} tracking parameter sets from configuration", trackingParams.size());
314 return trackingParams;
315}
316
318{
319 if (mMemoryPool.get() == nullptr) {
320 mMemoryPool = std::make_shared<itsmft::tracking::BoundedMemoryResource>();
321 }
322 if (mTaskArena.get() == nullptr) {
323 mTaskArena = std::make_shared<tbb::task_arena>(mTrackingThreads);
324 }
325
326 mTrackingParams = createTrackingParamsFromConfig();
327
328 auto cput = mTimer.CpuTime();
329 auto realt = mTimer.RealTime();
330 mTimer.Start(false);
331
332 const bool useGPU = mDeviceType != o2::gpu::gpudatatypes::DeviceType::CPU;
333#ifdef O2_WITH_ACTS
334 if (useGPU && mUseACTS) {
335 LOG(fatal) << "ACTS tracking is only supported with the CPU backend";
336 return;
337 }
338#endif
339
340 if (useGPU) {
341 runGPUTracking(pc);
342 } else {
343 o2::trk::TimeFrame<11> timeFrame;
344 o2::its::TrackerTraits<11> itsTrackerTraits;
345 runTracking(pc, timeFrame, itsTrackerTraits);
346 }
347
350
351 mTimer.Stop();
352 LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
353}
354
355void TrackerDPL::runGPUTracking(ProcessingContext& pc)
356{
357 auto& loader = ALICE3TrackingBackendLoader::Instance();
358 switch (mDeviceType) {
360#ifdef TRK_HAS_CUDA_TRACKING
361 loader.executeFunctionAlias<int, TrackerDPL*, ProcessingContext*>("O2ALICE3GlobalReconstructionWorkflowCUDA", kGPUBackendFunction, this, &pc);
362 return;
363#else
364 LOGP(fatal, "CUDA TRK GPU tracking was requested but this build has no CUDA TRK GPU tracking backend");
365#endif
367#ifdef TRK_HAS_HIP_TRACKING
368 loader.executeFunctionAlias<int, TrackerDPL*, ProcessingContext*>("O2ALICE3GlobalReconstructionWorkflowHIP", kGPUBackendFunction, this, &pc);
369 return;
370#else
371 LOGP(fatal, "HIP TRK GPU tracking was requested but this build has no HIP TRK GPU tracking backend");
372#endif
373 default:
374 LOGP(fatal, "Unsupported TRK GPU device type {}", static_cast<int>(mDeviceType));
375 }
376}
377
379{
380 LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
381}
382
383DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, const std::string& clusterRecoConfig, o2::gpu::gpudatatypes::DeviceType dType, int trackingThreads)
384{
385 std::vector<InputSpec> inputs;
386 std::vector<OutputSpec> outputs;
387 outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
388 outputs.emplace_back("TRK", "TRACKSROF", 0, Lifetime::Timeframe);
389 outputs.emplace_back("TRK", "IRFRAMES", 0, Lifetime::Timeframe);
390 auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, // orbitResetTime
391 false, // GRPECS=true
392 false, // GRPLHCIF
393 false, // GRPMagField
394 false, // askMatLUT
395 o2::base::GRPGeomRequest::None, // geometry, but ignored until it will be put in the CCDB
396 inputs,
397 true);
398
399 if (!hitRecoConfig.empty()) {
400 if (useMC) {
401 outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
402 }
403 return DataProcessorSpec{
404 "trk-hits-tracker",
405 {},
406 outputs,
407 AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
408 useMC,
409 hitRecoConfig,
410 clusterRecoConfig,
411 dType,
412 trackingThreads)},
413 Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}
414#ifdef O2_WITH_ACTS
415 ,
416 {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for tracking"}}
417#endif
418 }};
419 }
420
421 inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);
422
423 if (!clusterRecoConfig.empty()) {
424 inputs.pop_back();
425 constexpr int nLayers{11};
426 for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
427 inputs.emplace_back(std::format("compClusters_{}", iLayer), "TRK", "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
428 inputs.emplace_back(std::format("patterns_{}", iLayer), "TRK", "PATTERNS", iLayer, Lifetime::Timeframe);
429 inputs.emplace_back(std::format("ROframes_{}", iLayer), "TRK", "CLUSTERSROF", iLayer, Lifetime::Timeframe);
430 if (useMC) {
431 inputs.emplace_back(std::format("trkmclabels_{}", iLayer), "TRK", "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
432 }
433 }
434 }
435
436 if (useMC) {
437 outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
438 }
439
440 return DataProcessorSpec{
441 "trk-tracker",
442 inputs,
443 outputs,
444 AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
445 useMC,
446 hitRecoConfig,
447 clusterRecoConfig,
448 dType,
449 trackingThreads)},
450 Options{
451#ifdef O2_WITH_ACTS
452 {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for tracking"}}
453#endif
454 }};
455}
456
457} // namespace trk
458} // namespace o2
#define O2DLLoaderDef(classname)
#define O2DLLoaderImpl(classname)
Definition of the GeometryManager class.
CPU TRK TimeFrame wrapper.
std::ostringstream debug
unsigned short int uint16_t
Class to delimit start and end IR of certain time period.
Definition of a container to keep Monte Carlo truth external to simulation objects.
Definition of the MagFieldParam: ALICE mag. field type enumerations.
Definition of the MagF class.
Definition of the SegmentationChipclass.
TRK tracker using ACTS seeding algorithm.
Process-wide provider of the ACTS tracking geometry.
Build an ACTS TRK tracking geometry from the TGeo geometry already loaded by O2.
static TrackingGeometryManager & instance()
void setBuilder(std::unique_ptr< ITrackingGeometryBuilder > builder)
Install the detector-specific builder. Must be called before the first build.
ConfigParamRegistry const & options()
Definition InitContext.h:33
ServiceRegistryRef services()
The services registry associated with this processing context.
TrackerDPL(std::shared_ptr< o2::base::GRPGeomRequest > gr, bool isMC, const std::string &hitRecoConfig, const std::string &clusterRecoConfig, gpu::gpudatatypes::DeviceType dType=gpu::gpudatatypes::DeviceType::CPU, int trackingThreads=1)
void runTracking(framework::ProcessingContext &pc, TimeFrameT &timeFrame, TrackerTraitsT &trackerTraits)
void endOfStream(framework::EndOfStreamContext &ec) final
This is invoked whenever we have an EndOfStream event.
void run(framework::ProcessingContext &pc) final
void stop() final
This is invoked on stop.
void init(framework::InitContext &ic) final
GLuint const GLchar * name
Definition glcorearb.h:781
GLenum const GLfloat * params
Definition glcorearb.h:272
@ Me
Only quit this data processor.
const bool const int nLayers
framework::DataProcessorSpec getTrackerSpec(bool useMC, const std::string &hitRecoConfig, const std::string &clusterRecoConfig, gpu::gpudatatypes::DeviceType dType=gpu::gpudatatypes::DeviceType::CPU, int trackingThreads=1)
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
LOG(info)<< "Compressed in "<< sw.CpuTime()<< " s"