52 timeFrame.setMemoryPool(mMemoryPool);
53 trackerTraits.setMemoryPool(mMemoryPool);
54 trackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
57 trackerTraits.updateTrackingParameters(mTrackingParams);
58 timeFrame.initTrackerTopologies(mTrackingParams, 11);
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);
68 TTree* mcHeaderTree = mcHeaderFile.Get<TTree>(
"o2sim");
70 mcHeaderTree->SetBranchAddress(
"MCEventHeader.", &mcheader);
75 const Long64_t
nEvents{hitsTree->GetEntries()};
76 LOGP(info,
"Starting {} reconstruction from hits for {} events", trackerTraits.getName(),
nEvents);
78 trackerTraits.setBz(mHitRecoConfig[
"geometry"][
"bz"].get<float>());
80 TGeoGlobalMagField::Instance()->SetField(field);
81 TGeoGlobalMagField::Instance()->Lock();
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());
92 trackerTraits.setBz(mClusterRecoConfig[
"geometry"][
"bz"].get<float>());
94 TGeoGlobalMagField::Instance()->SetField(field);
95 TGeoGlobalMagField::Instance()->Lock();
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{};
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());
114 timeFrame.deriveAndInitTiming(layerROFs);
116 const float yPlaneMLOT = 0.0010f;
117 nRofs = timeFrame.loadROFrameData(layerROFs, layerClusters, layerPatterns, mIsMC ? &layerLabels :
nullptr, yPlaneMLOT);
118 timeFrame.addTruthSeedingVertices();
120 const auto trackingLoopStart = std::chrono::steady_clock::now();
123 LOG(info) <<
"Running ACTS tracking";
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());
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);
152 const auto&
tracks = timeFrame.getTracks();
153 const auto&
labels = timeFrame.getTracksLabel();
155 LOGP(fatal,
"TRK: {} reconstructed tracks but {} MC labels",
tracks.size(),
labels.size());
157 std::vector<o2::its::TrackITS> allTracks(
tracks.begin(),
tracks.end());
158 std::vector<o2::MCCompLabel> allLabels;
160 const int totalTracks = allTracks.size();
166 for (
const auto&
label : allLabels) {
167 if (
label.isFake()) {
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);
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();
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())));
189 for (
const auto& vtx : timeFrame.getPrimaryVertices()) {
190 highestROF = std::max(highestROF,
static_cast<int>(clockLayer.getROF(vtx.getTimeStamp().lower())));
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)));
199 rof.setROFrame(iROF);
200 rof.setFirstEntry(0);
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) {
211 std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
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();
234 LOGP(info,
"TRK pushed {} tracks in {} ROFs and {} IR frames{}",
235 allTracks.size(), allTrackROFs.size(), irFrames.size(),
236 mIsMC ?
" (with MC labels)" :
"");