390 {
391 (void)ctx;
392
394 gridCfg.bFieldInZ = bFieldInZ;
395
396 Acts::CylindricalSpacePointGrid2 grid(gridCfg,
397 logger().cloneWithSuffix(
"Grid"));
398
399 std::size_t totalSpacePoints = 0;
402 }
403
404 std::vector<const xAOD::SpacePoint*> selectedXAODSpacePoints;
405 std::vector<float> selectedSpacePointsR;
406 selectedXAODSpacePoints.reserve(totalSpacePoints);
407 selectedSpacePointsR.reserve(totalSpacePoints);
408
411 float x =
static_cast<float>(
sp->x() - beamSpotPos[0]);
412 float y =
static_cast<float>(
sp->y() - beamSpotPos[1]);
413 float z =
static_cast<float>(
sp->z());
414 float r = std::hypot(
x,
y);
415 float phi = std::atan2(
y,
x);
416
418 continue;
419 }
420
421 grid.insert(selectedXAODSpacePoints.size(),
phi,
z,
r);
422 selectedXAODSpacePoints.push_back(
sp);
423 selectedSpacePointsR.push_back(
r);
424 }
425 }
426
427 for (std::size_t i = 0;
i < grid.numberOfBins(); ++
i) {
428 std::ranges::sort(grid.at(i), [&](
const Acts::SpacePointIndex2&
a,
429 const Acts::SpacePointIndex2& b) {
430 return selectedSpacePointsR[a] < selectedSpacePointsR[b];
431 });
432 }
433
434 Acts::SpacePointContainer2 selectedSpacePoints;
435 selectedSpacePoints.createColumns(
436 Acts::SpacePointColumns::XY |
437 Acts::SpacePointColumns::ZR | Acts::SpacePointColumns::VarianceZ |
438 Acts::SpacePointColumns::VarianceR);
440 selectedSpacePoints.createColumns(Acts::SpacePointColumns::Strip);
441 }
442 selectedSpacePoints.reserve(grid.numberOfSpacePoints());
443 seedContainer.
spacePoints().reserve(grid.numberOfSpacePoints());
444 std::vector<Acts::SpacePointIndex2> copyFromIndices;
445 copyFromIndices.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
454 auto newSp = selectedSpacePoints.createSpacePoint();
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 copyFromIndices.push_back(spIndex);
483 }
484 std::uint32_t
end = selectedSpacePoints.size();
485 gridSpacePointRanges.emplace_back(begin, end);
486 }
487
488
489 selectedXAODSpacePoints = {};
490 selectedSpacePointsR = {};
491
492 ACTS_VERBOSE("Number of space points after selection "
493 << selectedSpacePoints.size() << " out of " << totalSpacePoints);
494
495
496
497 const Acts::Range1D<float> rRange = [&]() -> Acts::Range1D<float> {
498 float minRange = std::numeric_limits<float>::max();
499 float maxRange = std::numeric_limits<float>::lowest();
500 for (const Acts::SpacePointIndexRange2& range : gridSpacePointRanges) {
502 continue;
503 }
504 auto first = selectedSpacePoints[
range.first];
505 auto last = selectedSpacePoints[
range.second - 1];
506 minRange = std::min(
first.zr()[1], minRange);
507 maxRange = std::max(last.zr()[1], maxRange);
508 }
509 return {minRange, maxRange};
510 }();
511
512 auto bottomDoubletFinder =
513 Acts::DoubletSeedFinder::create(Acts::DoubletSeedFinder::DerivedConfig(
515 auto topDoubletFinder = Acts::DoubletSeedFinder::create(
517 auto tripletFinder = Acts::TripletSeedFinder::create(
519
520
521 const Acts::Range1D<float> rMiddleSpRange(
524
525 Acts::BroadTripletSeedFilter::State filterState;
526 Acts::BroadTripletSeedFilter::Cache filterCache;
527 Acts::TripletSeeder::Cache cache;
528
531
532 std::vector<Acts::SpacePointContainer2::ConstRange> bottomSpRanges;
533 std::optional<Acts::SpacePointContainer2::ConstRange> middleSpRange;
534 std::vector<Acts::SpacePointContainer2::ConstRange> topSpRanges;
535
536 Acts::SeedContainer2 tmpSeedContainer;
537
538 for (
const auto [bottom, middle,
top] : grid.binnedGroup()) {
539 ACTS_VERBOSE("Process middle bin " << middle);
540 if (middle >= gridSpacePointRanges.size()) {
541 ATH_MSG_ERROR(
"Grid Binned Group returned an unreasonable middle bin");
542 return StatusCode::FAILURE;
543 }
544
545 bottomSpRanges.clear();
546 topSpRanges.clear();
547
548 std::ranges::transform(
549 bottom, std::back_inserter(bottomSpRanges),
550 [&](std::size_t b) -> Acts::SpacePointContainer2::ConstRange {
551 return selectedSpacePoints.range(gridSpacePointRanges[b]).asConst();
552 });
553 middleSpRange =
554 selectedSpacePoints.range(gridSpacePointRanges[middle]).asConst();
555 std::ranges::transform(
556 top, std::back_inserter(topSpRanges),
557 [&](std::size_t t) -> Acts::SpacePointContainer2::ConstRange {
558 return selectedSpacePoints.range(gridSpacePointRanges[t]).asConst();
559 });
560
561
562
563 auto firstMiddleSp = middleSpRange->front();
564 auto radiusRangeForMiddle =
566
567 ACTS_VERBOSE("Validity range (radius) for the middle space point is ["
568 << radiusRangeForMiddle.first << ", "
569 << radiusRangeForMiddle.second << "]");
570
572 cache, *bottomDoubletFinder, *topDoubletFinder, *tripletFinder, filter,
573 selectedSpacePoints, bottomSpRanges, *middleSpRange, topSpRanges,
574 radiusRangeForMiddle, tmpSeedContainer);
575 }
576
577
578
579
580 auto selectionFunction =
581 [&filterState](
const Acts::MutableSeedProxy2&
seed) ->
bool {
582 float seedQuality =
seed.quality();
583 float bottomQuality =
584 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[0]);
585 float middleQuality =
586 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[1]);
587 float topQuality =
588 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[2]);
589
590 return bottomQuality <= seedQuality || middleQuality <= seedQuality ||
591 topQuality <= seedQuality;
592 };
593
594 seedContainer.reserve(tmpSeedContainer.size());
595
596
597 for (Acts::MutableSeedProxy2 seed : tmpSeedContainer) {
599 continue;
600 }
601
603 }
604
605 return StatusCode::SUCCESS;
606}
Scalar phi() const
phi method
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
Acts::MutableSeedProxy2 push_back(Acts::SpacePointIndexSubset2 sp)
const SpacePointContainer & spacePoints() const noexcept
1.14.0