178 constexpr std::array<int, 2> startLayer{0, 3};
179 const Long64_t
nEvents = hitsTree->GetEntries();
180 this->setIsStaggered(
true);
182 gman->
fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
184 std::vector<o2::trkft3::Hit>* trkHit =
nullptr;
185 hitsTree->SetBranchAddress(
"TRKHit", &trkHit);
187 const int inROFpileup{config.contains(
"inROFpileup") ? config[
"inROFpileup"].get<
int>() : 1};
189 const int nRofs = (
nEvents + inROFpileup - 1) / inROFpileup;
190 std::array<o2::its::LayerTiming, nLayers> timings{};
191 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
193 timings[iLayer].mROFLength = 1;
195 this->initTimingTables(timings);
196 const auto& timing = this->getROFOverlapTableView().getLayer(0);
198 LOGP(fatal,
"TRK: inconsistent number of ROFs across TFs: timing has {}, hit-tree path produced {}", timing.mNROFsTF, nRofs);
201 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
202 this->mMinR[iLayer] = std::numeric_limits<float>::max();
203 this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
204 this->mROFramesClusters[iLayer].clear();
205 this->mROFramesClusters[iLayer].resize(nRofs + 1, 0);
206 this->mUnsortedClusters[iLayer].clear();
207 this->mTrackingFrameInfo[iLayer].clear();
208 this->mClusterExternalIndices[iLayer].clear();
209 mClusterSensorIDs[iLayer].clear();
210 this->mClusterSize[iLayer].clear();
213 std::array<int, nLayers> clusterCountPerLayer{};
214 for (Long64_t iEvent = 0; iEvent <
nEvents; ++iEvent) {
215 hitsTree->GetEntry(iEvent);
216 for (
const auto& hit : *trkHit) {
217 if (gman->
getDisk(hit.GetDetectorID()) != -1) {
220 int subDetID = gman->
getSubDetID(hit.GetDetectorID());
221 const int layer = startLayer[subDetID] + gman->
getLayer(hit.GetDetectorID());
222 if (
layer >= nLayers) {
225 ++clusterCountPerLayer[
layer];
229 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
230 this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
231 this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
232 this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
233 mClusterSensorIDs[iLayer].reserve(clusterCountPerLayer[iLayer]);
234 this->mClusterSize[iLayer].reserve(clusterCountPerLayer[iLayer]);
237 std::array<float, 11> resolution{0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004};
238 if (config[
"geometry"][
"pitch"].
size() == nLayers) {
239 for (
int iLayer{0}; iLayer < config[
"geometry"][
"pitch"].size(); ++iLayer) {
240 LOGP(info,
"Setting resolution for layer {} from config", iLayer);
241 LOGP(info,
"Layer {} pitch {} cm", iLayer, config[
"geometry"][
"pitch"][iLayer].get<float>());
242 resolution[iLayer] = config[
"geometry"][
"pitch"][iLayer].get<
float>() / std::sqrt(12.f);
247 std::array<int, nLayers> hitCounterPerLayer{};
248 std::array<dataformats::MCTruthContainer<MCCompLabel>*, nLayers>
labels{};
249 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
251 this->mClusterLabels[iLayer] =
labels[iLayer];
255 for (Long64_t iEvent = 0; iEvent <
nEvents; ++iEvent) {
256 hitsTree->GetEntry(iEvent);
258 for (
auto& hit : *trkHit) {
259 if (gman->
getDisk(hit.GetDetectorID()) != -1) {
262 int subDetID = gman->
getSubDetID(hit.GetDetectorID());
263 const int layer = startLayer[subDetID] + gman->
getLayer(hit.GetDetectorID());
269 if (
layer >= nLayers) {
273 int chipID = hit.GetDetectorID();
276 auto locXYZ = l2g ^ (hit.GetPos());
277 locXYZ.SetX(locXYZ.X() + gRandom->Gaus(0.0, resolution[
layer]));
278 locXYZ.SetZ(locXYZ.Z() + gRandom->Gaus(0.0, resolution[
layer]));
281 r = std::hypot(gloXYZ.X(), gloXYZ.Y());
283 const auto& hitPos = hit.GetPos();
284 r = std::hypot(hitPos.X(), hitPos.Y());
285 alpha = std::atan2(hitPos.Y(), hitPos.X()) + gRandom->Gaus(0.0, resolution[
layer] /
r);
286 o2::math_utils::bringTo02Pi(
alpha);
287 gloXYZ.SetX(
r * std::cos(
alpha));
288 gloXYZ.SetY(
r * std::sin(
alpha));
289 gloXYZ.SetZ(hitPos.Z() + gRandom->Gaus(0.0, resolution[
layer]));
292 trkXYZ.SetZ(gloXYZ.Z());
294 this->mMinR[
layer] = std::min(this->mMinR[
layer],
r);
295 this->mMaxR[
layer] = std::max(this->mMaxR[
layer],
r);
296 this->addTrackingFrameInfoToLayer(
layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(),
alpha,
297 std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
298 std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
299 this->addClusterToLayer(
layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[
layer].size());
300 mClusterSensorIDs[
layer].push_back(hit.GetDetectorID());
301 const int layerHitCounter = hitCounterPerLayer[
layer]++;
302 this->addClusterExternalIndexToLayer(
layer, layerHitCounter);
303 this->mClusterSize[
layer].push_back(1);
309 if ((iEvent + 1) % inROFpileup == 0 || iEvent ==
nEvents - 1) {
311 for (
unsigned int iLayer{0}; iLayer < this->mUnsortedClusters.size(); ++iLayer) {
312 this->mROFramesClusters[iLayer][iRof] = this->mUnsortedClusters[iLayer].size();
321 const std::array<gsl::span<const o2::trkft3::TRKCluster>, nLayers>& layerClusters,
322 const std::array<gsl::span<const unsigned char>, nLayers>& layerPatterns,
326 constexpr std::array<int, 2> startLayer{0, 3};
327 this->setIsStaggered(
true);
329 geom->
fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
331 if (!mTimingTablesInitialised) {
332 LOGP(fatal,
"TRK::loadROFrameData: timing tables not initialised — call deriveAndInitTiming() first");
335 for (
const auto& rofs : layerROFs) {
336 nRofs = std::max(nRofs,
static_cast<int>(rofs.size()));
339 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
340 const auto& timing = this->getROFOverlapTableView().getLayer(iLayer);
342 LOGP(fatal,
"TRK: inconsistent number of ROFs on layer {}: timing has {}, cluster path received {}", iLayer, timing.mNROFsTF, layerROFs[iLayer].size());
344 this->mMinR[iLayer] = std::numeric_limits<float>::max();
345 this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
346 this->mROFramesClusters[iLayer].clear();
347 this->mROFramesClusters[iLayer].resize(layerROFs[iLayer].
size() + 1, 0);
348 this->mUnsortedClusters[iLayer].clear();
349 this->mTrackingFrameInfo[iLayer].clear();
350 this->mClusterExternalIndices[iLayer].clear();
351 mClusterSensorIDs[iLayer].clear();
352 this->mClusterSize[iLayer].clear();
353 this->mUnsortedClusters[iLayer].reserve(layerClusters[iLayer].
size());
354 this->mTrackingFrameInfo[iLayer].reserve(layerClusters[iLayer].
size());
355 this->mClusterExternalIndices[iLayer].reserve(layerClusters[iLayer].
size());
356 mClusterSensorIDs[iLayer].reserve(layerClusters[iLayer].
size());
357 this->mClusterSize[iLayer].reserve(layerClusters[iLayer].
size());
360 std::array<std::vector<size_t>, nLayers> patternOffsetsPerLayer;
361 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
362 auto&
offsets = patternOffsetsPerLayer[iLayer];
363 offsets.resize(layerClusters[iLayer].
size(), std::numeric_limits<size_t>::max());
365 bool validPatterns =
true;
366 for (
size_t clusterId{0}; clusterId < layerClusters[iLayer].size(); ++clusterId) {
367 if (pattPos + 2 > layerPatterns[iLayer].
size()) {
368 validPatterns =
false;
372 const uint8_t rowSpan = layerPatterns[iLayer][pattPos];
373 const uint8_t colSpan = layerPatterns[iLayer][pattPos + 1];
374 const size_t nBytes = (size_t(rowSpan) * colSpan + 7) / 8;
375 if (pattPos + 2 + nBytes > layerPatterns[iLayer].
size()) {
376 validPatterns =
false;
379 pattPos += 2 + nBytes;
381 if (!validPatterns || pattPos != layerPatterns[iLayer].
size()) {
382 LOGP(fatal,
"Malformed TRK pattern stream for layer {}: {} bytes for {} clusters",
383 iLayer, layerPatterns[iLayer].
size(), layerClusters[iLayer].
size());
387 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
388 for (
size_t iRof{0}; iRof < layerROFs[iLayer].size(); ++iRof) {
389 const auto& rof = layerROFs[iLayer][iRof];
390 const int first = rof.getFirstEntry();
391 const int last =
first + rof.getNEntries();
393 for (
int clusterId{
first}; clusterId < last; ++clusterId) {
394 if (clusterId < 0 || clusterId >=
static_cast<int>(layerClusters[iLayer].
size())) {
395 LOGP(warning,
"Skipping out-of-range TRK cluster {} on layer {}", clusterId, iLayer);
399 const auto&
c = layerClusters[iLayer][clusterId];
400 if (
c.subDetID < 0 ||
c.subDetID > 1) {
404 const int clusterLayer = startLayer[
c.subDetID] +
c.layer;
405 if (clusterLayer != iLayer) {
406 LOGP(
error,
"Skipping cluster from layer {} found in TRK layer stream {}", clusterLayer, iLayer);
410 const auto pattOffset = patternOffsetsPerLayer[iLayer][clusterId];
411 const uint8_t* pattForCluster = layerPatterns[iLayer].data() + pattOffset;
418 if (
c.subDetID == 1) {
422 const float r = std::hypot(gloXYZ.X(), gloXYZ.Y());
423 alpha = std::atan2(gloXYZ.Y(), gloXYZ.X());
424 o2::math_utils::bringTo02Pi(
alpha);
427 trkXYZ.SetZ(gloXYZ.Z());
430 const float r = std::hypot(gloXYZ.X(), gloXYZ.Y());
431 this->mMinR[iLayer] = std::min(this->mMinR[iLayer],
r);
432 this->mMaxR[iLayer] = std::max(this->mMaxR[iLayer],
r);
434 const float sigmaY2 = (
c.subDetID == 0)
437 const float sigmaZ2 = (
c.subDetID == 0)
441 this->addTrackingFrameInfoToLayer(iLayer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(),
alpha,
442 std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
443 std::array<float, 3>{sigmaY2, 0.f, sigmaZ2});
444 this->addClusterToLayer(iLayer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[iLayer].size());
445 mClusterSensorIDs[iLayer].push_back(
c.chipID);
446 this->addClusterExternalIndexToLayer(iLayer, clusterId);
447 this->mClusterSize[iLayer].push_back(std::clamp(
static_cast<unsigned int>(
c.size), 0u, 255u));
450 this->mROFramesClusters[iLayer][iRof + 1] = this->mUnsortedClusters[iLayer].size();
454 for (
auto i = 0;
i < this->mNTrackletsPerCluster.size(); ++
i) {
455 this->mNTrackletsPerCluster[
i].resize(this->mUnsortedClusters[1].
size());
456 this->mNTrackletsPerClusterSum[
i].resize(this->mUnsortedClusters[1].
size() + 1);
459 if (mcLabels !=
nullptr) {
460 for (
int iLayer{0}; iLayer < nLayers; ++iLayer) {
461 this->mClusterLabels[iLayer] = (*mcLabels)[iLayer];
503 LOGP(info,
"TRK: using truth seeds as vertices from DigitizationContext");
504 this->mPrimaryVertices.clear();
505 this->mPrimaryVerticesLabels.clear();
508 const auto irs = dc->getEventRecords();
511 const int64_t anchorBC = mTFAnchorIR.toLong();
512 const auto& clockLayer = this->getROFOverlapTableView().getClockLayer();
513 const auto rofLength = clockLayer.mROFLength;
521 std::vector<VertEntry>
entries;
524 auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
525 for (
int iEve{0}; iEve < mcReader.
getNEvents(iSrc); ++iEve) {
526 const auto&
ir = irs[eveId2colId[iEve]];
535 vert.setNContributors(std::max(1L, std::ranges::count_if(
537 [](
const auto& trk) {
538 return trk.isPrimary() && trk.GetPt() > 0.05 && std::abs(trk.GetEta()) < 1.1;
540 vert.setXYZ((
float)eve.GetX(), (
float)eve.GetY(), (
float)eve.GetZ());
542 constexpr float cov = 50e-9f;
543 vert.setCov(cov, cov, cov, cov, cov, cov);
544 entries.push_back({evBC, vert, iEve});
551 std::ranges::sort(
entries, {}, &VertEntry::bc);
554 this->addPrimaryVertex(
e.vertex);
556 this->addPrimaryVertexLabel({lbl, 1.f});
558 updateHostROFVertexLookupTable();
559 LOGP(info,
"TRK truth seeding: added {} vertices",
entries.size());