Project
Loading...
Searching...
No Matches
TrackerSpecImpl.h
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#ifndef O2_TRK_TRACKERSPECIMPL_H
13#define O2_TRK_TRACKERSPECIMPL_H
14
16
21#include "Field/MagFieldParam.h"
22#include "Field/MagneticField.h"
24#include "ITStracking/Tracker.h"
25#ifdef O2_WITH_ACTS
27#endif
33
34#include <TFile.h>
35#include <TGeoGlobalMagField.h>
36#include <TTree.h>
37
38#include <algorithm>
39#include <array>
40#include <chrono>
41#include <format>
42#include <numeric>
43#include <vector>
44
45namespace o2::trk
46{
47
48template <typename TimeFrameT, typename TrackerTraitsT>
49void TrackerDPL::runTracking(framework::ProcessingContext& pc, TimeFrameT& timeFrame, TrackerTraitsT& trackerTraits)
50{
51 o2::its::Tracker<11> itsTracker(&trackerTraits);
52 timeFrame.setMemoryPool(mMemoryPool);
53 trackerTraits.setMemoryPool(mMemoryPool);
54 trackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
55 trackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
56 itsTracker.adoptTimeFrame(timeFrame);
57 trackerTraits.updateTrackingParameters(mTrackingParams);
58 timeFrame.initTrackerTopologies(mTrackingParams, 11);
59
60 int nRofs{0};
61 if (!mHitRecoConfig.empty()) {
62 TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
63 TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
64 TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
65 std::vector<o2::trkft3::Hit>* trkHit = nullptr;
66 hitsTree->SetBranchAddress("TRKHit", &trkHit);
67
68 TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
69 auto mcheader = new o2::dataformats::MCEventHeader;
70 mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
71
72 o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
74
75 const Long64_t nEvents{hitsTree->GetEntries()};
76 LOGP(info, "Starting {} reconstruction from hits for {} events", trackerTraits.getName(), nEvents);
77
78 trackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
79 auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
80 TGeoGlobalMagField::Instance()->SetField(field);
81 TGeoGlobalMagField::Instance()->Lock();
82
83 nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
84 const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
85 timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
86 } else if (!mClusterRecoConfig.empty()) {
87 LOGP(info, "Starting {} reconstruction from clusters", trackerTraits.getName());
88
89 o2::base::GeometryManager::loadGeometry(mClusterRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
91
92 trackerTraits.setBz(mClusterRecoConfig["geometry"]["bz"].get<float>());
93 auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mClusterRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
94 TGeoGlobalMagField::Instance()->SetField(field);
95 TGeoGlobalMagField::Instance()->Lock();
96
97 constexpr int nLayers{11};
98 std::array<gsl::span<const o2::trkft3::TRKCluster>, nLayers> layerClusters;
99 std::array<gsl::span<const unsigned char>, nLayers> layerPatterns;
100 std::array<gsl::span<const o2::trkft3::ROFRecord>, nLayers> layerROFs;
101 std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers> layerLabels{};
102
103 size_t nInputRofs{0};
104 for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
105 layerClusters[iLayer] = pc.inputs().get<gsl::span<o2::trkft3::TRKCluster>>(std::format("compClusters_{}", iLayer));
106 layerPatterns[iLayer] = pc.inputs().get<gsl::span<unsigned char>>(std::format("patterns_{}", iLayer));
107 layerROFs[iLayer] = pc.inputs().get<gsl::span<o2::trkft3::ROFRecord>>(std::format("ROframes_{}", iLayer));
108 nInputRofs = std::max(nInputRofs, layerROFs[iLayer].size());
109 if (mIsMC) {
110 layerLabels[iLayer] = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>(std::format("trkmclabels_{}", iLayer)).release();
111 }
112 }
113
114 timeFrame.deriveAndInitTiming(layerROFs);
115
116 const float yPlaneMLOT = 0.0010f;
117 nRofs = timeFrame.loadROFrameData(layerROFs, layerClusters, layerPatterns, mIsMC ? &layerLabels : nullptr, yPlaneMLOT);
118 timeFrame.addTruthSeedingVertices();
119 }
120 const auto trackingLoopStart = std::chrono::steady_clock::now();
121#ifdef O2_WITH_ACTS
122 if (mUseACTS) {
123 LOG(info) << "Running ACTS tracking";
124 o2::trk::TrackerACTS<11> actsTracker;
125 actsTracker.adoptTimeFrame(timeFrame);
126 actsTracker.adoptSensorIDs(timeFrame.getClusterSensorIDs());
127
128 actsTracker.clustersToTracks(); // This will run the full tracking chain: space point building, seeding, and track finding.
129 actsTracker.printSummary();
130 } else
131#endif
132 {
133 for (size_t iter{0}; iter < mTrackingParams.size(); ++iter) {
134 LOGP(info, "{}", mTrackingParams[iter].asString());
135 trackerTraits.initialiseTimeFrame(iter);
136 trackerTraits.computeLayerTracklets(iter, -1);
137 LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
138 trackerTraits.computeLayerCells(iter);
139 LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
140 trackerTraits.findCellsNeighbours(iter);
141 LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
142 trackerTraits.findRoads(iter);
143 LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
144 }
145 if (mIsMC) {
146 itsTracker.computeTracksMClabels();
147 }
148 }
149 const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
150 LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
151
152 const auto& tracks = timeFrame.getTracks();
153 const auto& labels = timeFrame.getTracksLabel();
154 if (mIsMC && tracks.size() != labels.size()) {
155 LOGP(fatal, "TRK: {} reconstructed tracks but {} MC labels", tracks.size(), labels.size());
156 }
157 std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
158 std::vector<o2::MCCompLabel> allLabels;
159
160 const int totalTracks = allTracks.size();
161 int goodTracks = 0;
162 int fakeTracks = 0;
163
164 if (mIsMC) {
165 allLabels.assign(labels.begin(), labels.end());
166 for (const auto& label : allLabels) {
167 if (label.isFake()) {
168 ++fakeTracks;
169 } else {
170 ++goodTracks;
171 }
172 }
173 }
174
175 LOGP(info, "=== Tracking Summary ===");
176 LOGP(info, "Total tracks reconstructed: {}", totalTracks);
177 LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
178 LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
179
180 const auto& rofView = timeFrame.getROFOverlapTableView();
181 const auto& clockLayer = rofView.getClockLayer();
182 const int clockLayerId = rofView.getClock();
183 const int64_t anchorBC = timeFrame.getTFAnchorIR().toLong();
184
185 int highestROF = static_cast<int>(clockLayer.mNROFsTF);
186 for (const auto& trc : allTracks) {
187 highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(trc.getTimeStamp())));
188 }
189 for (const auto& vtx : timeFrame.getPrimaryVertices()) {
190 highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(vtx.getTimeStamp().lower())));
191 }
192
193 std::vector<o2::trkft3::ROFRecord> allTrackROFs(highestROF);
194 for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
195 auto& rof = allTrackROFs[iROF];
197 ir.setFromLong(anchorBC + static_cast<int64_t>(clockLayer.getROFStartInBC(iROF)));
198 rof.setBCData(ir);
199 rof.setROFrame(iROF);
200 rof.setFirstEntry(0);
201 rof.setNEntries(0);
202 }
203
204 std::vector<int> rofEntries(highestROF + 1, 0);
205 for (const auto& trc : allTracks) {
206 const int rof = static_cast<int>(clockLayer.getROF(trc.getTimeStamp()));
207 if (rof >= 0 && rof < highestROF) {
208 ++rofEntries[rof];
209 }
210 }
211 std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
212
213 std::vector<o2::dataformats::IRFrame> irFrames;
214 irFrames.reserve(allTrackROFs.size());
215 const auto& maskView = timeFrame.getROFMaskView();
216 const auto rofLenMinus1 = clockLayer.mROFLength > 0 ? clockLayer.mROFLength - 1 : 0;
217 for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
218 allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
219 allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
220 if (maskView.isROFEnabled(clockLayerId, static_cast<int>(iROF))) {
221 const auto& bcStart = allTrackROFs[iROF].getBCData();
222 auto& irFrame = irFrames.emplace_back(bcStart, bcStart + rofLenMinus1);
223 irFrame.info = allTrackROFs[iROF].getNEntries();
224 }
225 }
226
227 pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
228 pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSROF", 0}, allTrackROFs);
229 pc.outputs().snapshot(o2::framework::Output{"TRK", "IRFRAMES", 0}, irFrames);
230 if (mIsMC) {
231 pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
232 }
233
234 LOGP(info, "TRK pushed {} tracks in {} ROFs and {} IR frames{}",
235 allTracks.size(), allTrackROFs.size(), irFrames.size(),
236 mIsMC ? " (with MC labels)" : "");
237
238 timeFrame.wipe();
239}
240
241} // namespace o2::trk
242
243#endif // O2_TRK_TRACKERSPECIMPL_H
std::string asString(TDataMember const &dm, char *pointer)
Definition of the GeometryManager class.
Class to delimit start and end IR of certain time period.
std::vector< o2::MCCompLabel > labels
std::vector< o2::its::TrackITS > tracks
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.
TRK tracker using ACTS seeding algorithm.
static void loadGeometry(std::string_view geomFilePath="", bool applyMisalignment=false, bool preferAlignedFile=true)
A container to hold and manage MC truth information/labels.
void snapshot(const Output &spec, T const &object)
decltype(auto) get(R binding, int part=0) const
DataAllocator & outputs()
The data allocator is used to allocate memory for the output data.
InputRecord & inputs()
The inputs associated with this processing context.
void adoptTimeFrame(TimeFrame< NLayers > &tf)
Definition Tracker.cxx:314
void computeTracksMClabels()
Definition Tracker.cxx:210
static GeometryTGeo * Instance()
void adoptSensorIDs(const std::array< std::vector< int >, nLayers > &sensorIDs)
void clustersToTracks()
Build space points, find tracks, and publish accepted tracks in the TimeFrame.
void adoptTimeFrame(o2::its::TimeFrame< nLayers > &tf)
void printSummary() const
Print the accumulated tracking timing and processing summary.
void runTracking(framework::ProcessingContext &pc, TimeFrameT &timeFrame, TrackerTraitsT &trackerTraits)
GLsizeiptr size
Definition glcorearb.h:659
GLuint GLsizei const GLchar * label
Definition glcorearb.h:2519
template std::string ConfigParamRegistry::get< std::string >(const char *key) const
void setFromLong(int64_t l)
const int nEvents
Definition test_Fifo.cxx:27
LOG(info)<< "Compressed in "<< sw.CpuTime()<< " s"
o2::InteractionRecord ir(0, 0)