45#include <TGeoGlobalMagField.h>
72 constexpr const char* kGPUBackendFunction =
"runALICE3GPUTracking";
77 const std::string& hitRecoConfigFileName,
78 const std::string& clusterRecoConfigFileName,
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();
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();
96 mTrackingThreads = std::max(1, trackingThreads);
105 LOG(info) <<
"Registered automatic ACTS TRK geometry builder";
112 LOGF(info,
"CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
115std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromConfig()
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();
123 if (paramConfig.contains(
name)) {
124 if (paramConfig[
name].get<bool>()) {
125 params.PassFlags.set(step);
127 params.PassFlags.reset(step);
132 if (paramConfig.contains(
"NLayers")) {
133 params.NLayers = paramConfig[
"NLayers"].get<
int>();
135 if (paramConfig.contains(
"ZBins")) {
136 params.ZBins = paramConfig[
"ZBins"].get<
int>();
138 if (paramConfig.contains(
"PhiBins")) {
139 params.PhiBins = paramConfig[
"PhiBins"].get<
int>();
141 if (paramConfig.contains(
"SharedMaxClusters")) {
142 params.SharedMaxClusters = paramConfig[
"SharedMaxClusters"].get<
int>();
144 if (paramConfig.contains(
"MinTrackLength")) {
145 params.MinTrackLength = paramConfig[
"MinTrackLength"].get<
int>();
147 if (paramConfig.contains(
"MaxHoles")) {
148 params.MaxHoles = paramConfig[
"MaxHoles"].get<
int>();
150 if (paramConfig.contains(
"HoleLayerMask")) {
151 params.HoleLayerMask = paramConfig[
"HoleLayerMask"].get<
uint16_t>();
153 if (paramConfig.contains(
"InactiveLayerMask")) {
154 params.InactiveLayerMask = paramConfig[
"InactiveLayerMask"].get<
uint16_t>();
156 if (paramConfig.contains(
"SeedingLayers")) {
157 params.SeedingLayers = paramConfig[
"SeedingLayers"].get<
uint16_t>();
159 if (paramConfig.contains(
"ReseedIfShorter")) {
160 params.ReseedIfShorter = paramConfig[
"ReseedIfShorter"].get<
int>();
162 if (paramConfig.contains(
"StartLayerMask")) {
163 params.StartLayerMask = paramConfig[
"StartLayerMask"].get<
uint16_t>();
165 if (paramConfig.contains(
"NSigmaCut")) {
166 params.NSigmaCut = paramConfig[
"NSigmaCut"].get<
float>();
168 if (paramConfig.contains(
"PVres")) {
169 params.PVres = paramConfig[
"PVres"].get<
float>();
171 if (paramConfig.contains(
"TrackletMinPt")) {
172 params.TrackletMinPt = paramConfig[
"TrackletMinPt"].get<
float>();
174 if (paramConfig.contains(
"CellDeltaTanLambdaSigma")) {
175 params.CellDeltaTanLambdaSigma = paramConfig[
"CellDeltaTanLambdaSigma"].get<
float>();
177 if (paramConfig.contains(
"MaxChi2ClusterAttachment")) {
178 params.MaxChi2ClusterAttachment = paramConfig[
"MaxChi2ClusterAttachment"].get<
float>();
180 if (paramConfig.contains(
"MaxChi2NDF")) {
181 params.MaxChi2NDF = paramConfig[
"MaxChi2NDF"].get<
float>();
183 if (paramConfig.contains(
"UseDiamond")) {
184 params.UseDiamond = paramConfig[
"UseDiamond"].get<
bool>();
186 if (paramConfig.contains(
"AllowSharingFirstCluster")) {
187 params.AllowSharingFirstCluster = paramConfig[
"AllowSharingFirstCluster"].get<
bool>();
189 if (paramConfig.contains(
"RepeatRefitOut")) {
190 params.RepeatRefitOut = paramConfig[
"RepeatRefitOut"].get<
bool>();
192 if (paramConfig.contains(
"ShiftRefToCluster")) {
193 params.ShiftRefToCluster = paramConfig[
"ShiftRefToCluster"].get<
bool>();
195 if (paramConfig.contains(
"PerPrimaryVertexProcessing")) {
196 params.PerPrimaryVertexProcessing = paramConfig[
"PerPrimaryVertexProcessing"].get<
bool>();
198 if (paramConfig.contains(
"SaveTimeBenchmarks")) {
199 params.SaveTimeBenchmarks = paramConfig[
"SaveTimeBenchmarks"].get<
bool>();
201 if (paramConfig.contains(
"DoUPCIteration")) {
202 params.DoUPCIteration = paramConfig[
"DoUPCIteration"].get<
bool>();
204 if (paramConfig.contains(
"FataliseUponFailure")) {
205 params.FataliseUponFailure = paramConfig[
"FataliseUponFailure"].get<
bool>();
207 if (paramConfig.contains(
"CreateArtefactLabels")) {
208 params.CreateArtefactLabels = paramConfig[
"CreateArtefactLabels"].get<
bool>();
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);
223 if (paramConfig.contains(
"TrackFollowerNSigmaCutZ")) {
224 params.TrackFollowerNSigmaCutZ = paramConfig[
"TrackFollowerNSigmaCutZ"].get<
float>();
226 if (paramConfig.contains(
"TrackFollowerNSigmaCutPhi")) {
227 params.TrackFollowerNSigmaCutPhi = paramConfig[
"TrackFollowerNSigmaCutPhi"].get<
float>();
229 if (paramConfig.contains(
"TrackFollowerMaxHypotheses")) {
230 params.TrackFollowerMaxHypotheses = std::max(1, paramConfig[
"TrackFollowerMaxHypotheses"].get<int>());
241 if (paramConfig.contains(
"PrintMemory")) {
242 params.PrintMemory = paramConfig[
"PrintMemory"].get<
bool>();
244 if (paramConfig.contains(
"DropTFUponFailure")) {
245 params.DropTFUponFailure = paramConfig[
"DropTFUponFailure"].get<
bool>();
247 if (paramConfig.contains(
"LayerZ")) {
248 params.LayerZ = paramConfig[
"LayerZ"].get<std::vector<float>>();
250 if (paramConfig.contains(
"LayerRadii")) {
251 params.LayerRadii = paramConfig[
"LayerRadii"].get<std::vector<float>>();
253 if (paramConfig.contains(
"LayerxX0")) {
254 params.LayerxX0 = paramConfig[
"LayerxX0"].get<std::vector<float>>();
256 if (paramConfig.contains(
"LayerResolution")) {
257 params.LayerResolution = paramConfig[
"LayerResolution"].get<std::vector<float>>();
259 if (paramConfig.contains(
"SystErrorY2")) {
260 params.SystErrorY2 = paramConfig[
"SystErrorY2"].get<std::vector<float>>();
262 if (paramConfig.contains(
"SystErrorZ2")) {
263 params.SystErrorZ2 = paramConfig[
"SystErrorZ2"].get<std::vector<float>>();
265 if (paramConfig.contains(
"MinPt")) {
266 params.MinPt = paramConfig[
"MinPt"].get<std::vector<float>>();
268 if (paramConfig.contains(
"AddTimeError")) {
269 params.AddTimeError = paramConfig[
"AddTimeError"].get<std::vector<UInt_t>>();
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>();
278 if (paramConfig.contains(
"MaxMemory")) {
279 params.MaxMemory = paramConfig[
"MaxMemory"].get<
size_t>();
282 if (paramConfig.contains(
"CorrType")) {
283 int corrTypeInt = paramConfig[
"CorrType"].get<
int>();
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();
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();
300 trackingParams.push_back(
params);
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"]);
309 LOGP(fatal,
"No trackingparams field found in configuration or it is not an array. Returning empty vector.");
310 return trackingParams;
313 LOGP(info,
"Loaded {} tracking parameter sets from configuration", trackingParams.size());
314 return trackingParams;
319 if (mMemoryPool.get() ==
nullptr) {
320 mMemoryPool = std::make_shared<itsmft::tracking::BoundedMemoryResource>();
322 if (mTaskArena.get() ==
nullptr) {
323 mTaskArena = std::make_shared<tbb::task_arena>(mTrackingThreads);
326 mTrackingParams = createTrackingParamsFromConfig();
328 auto cput = mTimer.CpuTime();
329 auto realt = mTimer.RealTime();
334 if (useGPU && mUseACTS) {
335 LOG(fatal) <<
"ACTS tracking is only supported with the CPU backend";
352 LOGP(info,
"CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
357 auto& loader = ALICE3TrackingBackendLoader::Instance();
358 switch (mDeviceType) {
360#ifdef TRK_HAS_CUDA_TRACKING
361 loader.executeFunctionAlias<int,
TrackerDPL*,
ProcessingContext*>(
"O2ALICE3GlobalReconstructionWorkflowCUDA", kGPUBackendFunction,
this, &pc);
364 LOGP(fatal,
"CUDA TRK GPU tracking was requested but this build has no CUDA TRK GPU tracking backend");
367#ifdef TRK_HAS_HIP_TRACKING
368 loader.executeFunctionAlias<int,
TrackerDPL*,
ProcessingContext*>(
"O2ALICE3GlobalReconstructionWorkflowHIP", kGPUBackendFunction,
this, &pc);
371 LOGP(fatal,
"HIP TRK GPU tracking was requested but this build has no HIP TRK GPU tracking backend");
374 LOGP(fatal,
"Unsupported TRK GPU device type {}",
static_cast<int>(mDeviceType));
380 LOGF(info,
"TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
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,
399 if (!hitRecoConfig.empty()) {
401 outputs.emplace_back(
"TRK",
"TRACKSMCTR", 0, Lifetime::Timeframe);
421 inputs.emplace_back(
"dummy",
"TRK",
"DUMMY", 0, Lifetime::Timeframe);
423 if (!clusterRecoConfig.empty()) {
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);
431 inputs.emplace_back(std::format(
"trkmclabels_{}", iLayer),
"TRK",
"CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
437 outputs.emplace_back(
"TRK",
"TRACKSMCTR", 0, Lifetime::Timeframe);
#define O2DLLoaderDef(classname)
#define O2DLLoaderImpl(classname)
Definition of the GeometryManager class.
CPU TRK TimeFrame wrapper.
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.
T get(const char *key) const
ConfigParamRegistry const & options()
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
GLenum const GLfloat * params
@ 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"