393 {
394 (void)ctx;
395
397 gridCfg.bFieldInZ = bFieldInZ;
398
399 Acts::CylindricalSpacePointGrid2 grid(gridCfg,
400 logger().cloneWithSuffix(
"Grid"));
401
402 std::size_t totalSpacePoints = 0;
405 }
406
407 std::vector<const xAOD::SpacePoint*> selectedXAODSpacePoints;
408 std::vector<float> selectedSpacePointsR;
409 selectedXAODSpacePoints.reserve(totalSpacePoints);
410 selectedSpacePointsR.reserve(totalSpacePoints);
411
414 float x =
static_cast<float>(
sp->x() - beamSpotPos[0]);
415 float y =
static_cast<float>(
sp->y() - beamSpotPos[1]);
416 float z =
static_cast<float>(
sp->z());
417 float r = std::hypot(
x,
y);
418 float phi = std::atan2(
y,
x);
419
421 continue;
422 }
423
424 grid.insert(selectedXAODSpacePoints.size(),
phi,
z,
r);
425 selectedXAODSpacePoints.push_back(
sp);
426 selectedSpacePointsR.push_back(
r);
427 }
428 }
429
430 for (std::size_t i = 0;
i < grid.numberOfBins(); ++
i) {
431 std::ranges::sort(
432 grid.at(i), [&](Acts::SpacePointIndex2
a, Acts::SpacePointIndex2 b) {
433 return selectedSpacePointsR[a] < selectedSpacePointsR[b];
434 });
435 }
436
437 Acts::SpacePointContainer2 selectedSpacePoints;
438 selectedSpacePoints.createColumns(
439 Acts::SpacePointColumns::CopyFromIndex |
440 Acts::SpacePointColumns::PackedXY | Acts::SpacePointColumns::PackedZR |
441 Acts::SpacePointColumns::VarianceZ | Acts::SpacePointColumns::VarianceR);
443 selectedSpacePoints.createColumns(Acts::SpacePointColumns::Strip);
444 }
445 selectedSpacePoints.reserve(grid.numberOfSpacePoints());
446 std::vector<Acts::SpacePointIndexRange2> gridSpacePointRanges;
447 gridSpacePointRanges.reserve(grid.numberOfBins());
448 for (std::size_t i = 0;
i < grid.numberOfBins(); ++
i) {
449 std::uint32_t
begin = selectedSpacePoints.size();
450 for (const Acts::SpacePointIndex2 spIndex : grid.at(i)) {
452
453 auto newSp = selectedSpacePoints.createSpacePoint();
454 newSp.copyFromIndex() = spIndex;
455 newSp.xy() =
456 std::array<float, 2>{
static_cast<float>(
sp->x() - beamSpotPos[0]),
457 static_cast<float>(
sp->y() - beamSpotPos[1])};
458 newSp.zr() = std::array<float, 2>{
static_cast<float>(
sp->z()),
459 selectedSpacePointsR[spIndex]};
460 newSp.varianceZ() =
static_cast<float>(
sp->varianceZ());
461 newSp.varianceR() =
static_cast<float>(
sp->varianceR());
463 Eigen::Vector3f topStripVector =
464 sp->topHalfStripLength() *
sp->topStripDirection();
465 Eigen::Vector3f bottomStripVector =
466 sp->bottomHalfStripLength() *
sp->bottomStripDirection();
467 Eigen::Vector3f stripCenterDistance =
sp->stripCenterDistance();
468 Eigen::Vector3f topStripCenter =
sp->topStripCenter();
469
470 newSp.topStripVector() = std::array<float, 3>{
471 topStripVector.x(), topStripVector.y(), topStripVector.z()};
472 newSp.bottomStripVector() =
473 std::array<float, 3>{bottomStripVector.x(), bottomStripVector.y(),
474 bottomStripVector.z()};
475 newSp.stripCenterDistance() = std::array<float, 3>{
476 stripCenterDistance.x(), stripCenterDistance.y(),
477 stripCenterDistance.z()};
478 newSp.topStripCenter() = std::array<float, 3>{
479 topStripCenter.x(), topStripCenter.y(), topStripCenter.z()};
480 }
481 }
482 std::uint32_t
end = selectedSpacePoints.size();
483 gridSpacePointRanges.emplace_back(begin, end);
484 }
485
486
487 selectedSpacePointsR = {};
488
489 ACTS_VERBOSE("Number of space points after selection "
490 << selectedSpacePoints.size() << " out of " << totalSpacePoints);
491
492
493
494 const Acts::Range1D<float> rRange = [&]() -> Acts::Range1D<float> {
495 float minRange = std::numeric_limits<float>::max();
496 float maxRange = std::numeric_limits<float>::lowest();
497 for (const Acts::SpacePointIndexRange2& range : gridSpacePointRanges) {
499 continue;
500 }
501 auto first = selectedSpacePoints[
range.first];
502 auto last = selectedSpacePoints[
range.second - 1];
503 minRange = std::min(
first.zr()[1], minRange);
504 maxRange = std::max(last.zr()[1], maxRange);
505 }
506 return {minRange, maxRange};
507 }();
508
509 auto bottomDoubletFinder =
510 Acts::DoubletSeedFinder::create(Acts::DoubletSeedFinder::DerivedConfig(
512 auto topDoubletFinder = Acts::DoubletSeedFinder::create(
514 auto tripletFinder = Acts::TripletSeedFinder::create(
516
517
518 const Acts::Range1D<float> rMiddleSpRange(
521
522 Acts::BroadTripletSeedFilter::State filterState;
523 Acts::BroadTripletSeedFilter::Cache filterCache;
524 Acts::TripletSeeder::Cache
cache;
525
528
529 std::vector<Acts::SpacePointContainer2::ConstRange> bottomSpRanges;
530 std::optional<Acts::SpacePointContainer2::ConstRange> middleSpRange;
531 std::vector<Acts::SpacePointContainer2::ConstRange> topSpRanges;
532
533 Acts::SeedContainer2 tmpSeedContainer;
534
535 for (
const auto [bottom, middle,
top] : grid.binnedGroup()) {
536 ACTS_VERBOSE("Process middle bin " << middle);
537 if (middle >= gridSpacePointRanges.size()) {
538 ATH_MSG_ERROR(
"Grid Binned Group returned an unreasonable middle bin");
539 return StatusCode::FAILURE;
540 }
541
542 bottomSpRanges.clear();
543 topSpRanges.clear();
544
545 std::ranges::transform(
546 bottom, std::back_inserter(bottomSpRanges),
547 [&](std::size_t b) -> Acts::SpacePointContainer2::ConstRange {
548 return selectedSpacePoints.range(gridSpacePointRanges[b]).asConst();
549 });
550 middleSpRange =
551 selectedSpacePoints.range(gridSpacePointRanges[middle]).asConst();
552 std::ranges::transform(
553 top, std::back_inserter(topSpRanges),
554 [&](std::size_t t) -> Acts::SpacePointContainer2::ConstRange {
555 return selectedSpacePoints.range(gridSpacePointRanges[t]).asConst();
556 });
557
558
559
560 auto firstMiddleSp = middleSpRange->front();
561 auto radiusRangeForMiddle =
563
564 ACTS_VERBOSE("Validity range (radius) for the middle space point is ["
565 << radiusRangeForMiddle.first << ", "
566 << radiusRangeForMiddle.second << "]");
567
569 cache, *bottomDoubletFinder, *topDoubletFinder, *tripletFinder, filter,
570 selectedSpacePoints, bottomSpRanges, *middleSpRange, topSpRanges,
571 radiusRangeForMiddle, tmpSeedContainer);
572 }
573
574
575
576
577 auto selectionFunction =
578 [&filterState](
const Acts::MutableSeedProxy2&
seed) ->
bool {
579 float seedQuality =
seed.quality();
580 float bottomQuality =
581 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[0]);
582 float middleQuality =
583 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[1]);
584 float topQuality =
585 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[2]);
586
587 return bottomQuality <= seedQuality || middleQuality <= seedQuality ||
588 topQuality <= seedQuality;
589 };
590
591 seedContainer.
reserve(seedContainer.
size() + tmpSeedContainer.size());
592
593
594 for (Acts::MutableSeedProxy2 seed : tmpSeedContainer) {
596 continue;
597 }
598
600 Acts::ConstSeedProxy2(seed), [&](const Acts::SpacePointIndex2 spIndex) {
601 const Acts::SpacePointIndex2 originalIndex =
602 selectedSpacePoints.at(spIndex).copyFromIndex();
603 return selectedXAODSpacePoints[originalIndex];
604 });
605 }
606
607 return StatusCode::SUCCESS;
608}
Scalar phi() const
phi method
const IIntersectionCache * cache() const
Retrieve the associated cache block, if it exists.
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
Seed push_back(SpacePointRange spacePoints, float quality, float vertexZ)
void reserve(std::size_t size, float averageSpacePoints=3) noexcept
std::size_t size() const noexcept
1.16.1