536 {
537 (void)ctx;
538
539 gridCfg.bFieldInZ = bFieldInZ;
540
541 GridType grid(gridCfg,
logger().cloneWithSuffix(
"Grid"));
542
543 std::size_t totalSpacePoints = 0;
546 }
547
548 std::vector<const xAOD::SpacePoint*> selectedXAODSpacePoints;
549 std::vector<float> selectedSpacePointsR;
550 selectedXAODSpacePoints.reserve(totalSpacePoints);
551 selectedSpacePointsR.reserve(totalSpacePoints);
552
553
554 std::vector<float> selectedSpacePointsPhi;
555 std::vector<float> selectedSpacePointsAsinD0OverR;
556 const float dPhiCutD0 =
559 selectedSpacePointsPhi.reserve(totalSpacePoints);
560 selectedSpacePointsAsinD0OverR.reserve(totalSpacePoints);
561 }
562
565 float x =
static_cast<float>(
sp->x() - beamSpotPos[0]);
566 float y =
static_cast<float>(
sp->y() - beamSpotPos[1]);
567 float z =
static_cast<float>(
sp->z());
568 float r = std::hypot(
x,
y);
569 float phi = std::atan2(
y,
x);
570
572 continue;
573 }
574
575
576 SPGridTraits<GridType>::insert(grid, selectedXAODSpacePoints.size(),
phi,
z,
r);
577 selectedXAODSpacePoints.push_back(
sp);
578 selectedSpacePointsR.push_back(
r);
580 selectedSpacePointsPhi.push_back(
phi);
581 selectedSpacePointsAsinD0OverR.push_back(
582 std::asin(std::min(1.f, dPhiCutD0 / std::max(
r, 1.f))));
583 }
584 }
585 }
586
587 for (std::size_t i = 0;
i < grid.numberOfBins(); ++
i) {
588 std::ranges::sort(
589 grid.at(i), [&](Acts::SpacePointIndex
a, Acts::SpacePointIndex b) {
590 return selectedSpacePointsR[a] < selectedSpacePointsR[b];
591 });
592 }
593
594 Acts::SpacePointContainer selectedSpacePoints;
595 selectedSpacePoints.createColumns(
596 Acts::SpacePointColumns::CopiedFromIndex |
597 Acts::SpacePointColumns::PackedXY | Acts::SpacePointColumns::PackedZR |
598 Acts::SpacePointColumns::VarianceZ | Acts::SpacePointColumns::VarianceR);
600 selectedSpacePoints.createColumns(
601 Acts::SpacePointColumns::StripCalibrationDetails);
602 }
603 selectedSpacePoints.reserve(grid.numberOfSpacePoints());
604 std::vector<Acts::SpacePointIndexRange> gridSpacePointRanges;
605 gridSpacePointRanges.reserve(grid.numberOfBins());
606 for (std::size_t i = 0;
i < grid.numberOfBins(); ++
i) {
607 std::uint32_t
begin = selectedSpacePoints.size();
608 for (const Acts::SpacePointIndex spIndex : grid.at(i)) {
610
611 auto newSp = selectedSpacePoints.createSpacePoint();
612 newSp.copiedFromIndex() = spIndex;
613 newSp.xy() =
614 std::array<float, 2>{
static_cast<float>(
sp->x() - beamSpotPos[0]),
615 static_cast<float>(
sp->y() - beamSpotPos[1])};
616 newSp.zr() = std::array<float, 2>{
static_cast<float>(
sp->z()),
617 selectedSpacePointsR[spIndex]};
618 newSp.varianceZ() =
620 newSp.varianceR() =
622
624 const Eigen::Vector3f innerStripHalfVector =
625 sp->bottomHalfStripLength() *
sp->bottomStripDirection();
626 const Eigen::Vector3f outerStripCenter =
sp->topStripCenter();
627 const Eigen::Vector3f outerStripHalfVector =
628 sp->topHalfStripLength() *
sp->topStripDirection();
629 const Eigen::Vector3f stripSeparation =
sp->stripCenterDistance();
630
631 newSp.outerStripCalibrationDetails().outerCenter = std::array<float, 3>{
632 outerStripCenter.x() - beamSpotPos[0],
633 outerStripCenter.y() - beamSpotPos[1], outerStripCenter.z()};
634 newSp.outerStripCalibrationDetails().innerToOuterSeparation =
635 std::array<float, 3>{stripSeparation.x(), stripSeparation.y(),
636 stripSeparation.z()};
637 newSp.outerStripCalibrationDetails().outerHalfVector =
638 std::array<float, 3>{outerStripHalfVector.x(),
639 outerStripHalfVector.y(),
640 outerStripHalfVector.z()};
641 newSp.outerStripCalibrationDetails().innerHalfVector =
642 std::array<float, 3>{innerStripHalfVector.x(),
643 innerStripHalfVector.y(),
644 innerStripHalfVector.z()};
645 }
646 }
647 std::uint32_t
end = selectedSpacePoints.size();
648 gridSpacePointRanges.emplace_back(begin, end);
649 }
650
651
652 selectedSpacePointsR = {};
653
654 ACTS_VERBOSE("Number of space points after selection "
655 << selectedSpacePoints.size() << " out of " << totalSpacePoints);
656
657
658
659 const Acts::Range1D<float> rRange = [&]() -> Acts::Range1D<float> {
660 float minRange = std::numeric_limits<float>::max();
661 float maxRange = std::numeric_limits<float>::lowest();
662 for (const Acts::SpacePointIndexRange& range : gridSpacePointRanges) {
664 continue;
665 }
666 auto first = selectedSpacePoints[
range.first];
667 auto last = selectedSpacePoints[
range.second - 1];
668 minRange = std::min(
first.zr()[1], minRange);
669 maxRange = std::max(last.zr()[1], maxRange);
670 }
671 return {minRange, maxRange};
672 }();
673
676
677
678
679
680 auto doubletSelection =
681 [this, &selectedSpacePointsPhi, &selectedSpacePointsAsinD0OverR](
682 const Acts::ConstSpacePointProxy& middle,
684 bool isBottomCandidate) {
686 selectedSpacePointsAsinD0OverR, middle,
687 other, cotTheta, isBottomCandidate);
688 };
691 bottomDoubletFinderCfg.experimentCuts.connect(doubletSelection);
692 topDoubletFinderCfg.experimentCuts.connect(doubletSelection);
693 }
694
698
699 for(const auto* vtx: *inputHoughVtx)
700 {
702 {
705 break;
706 }
707 }
708
709 }
710
711 auto bottomDoubletFinder =
712 Acts::DoubletSeedFinder::create(Acts::DoubletSeedFinder::DerivedConfig(
713 bottomDoubletFinderCfg, bFieldInZ));
714 auto topDoubletFinder = Acts::DoubletSeedFinder::create(
715 Acts::DoubletSeedFinder::DerivedConfig(topDoubletFinderCfg, bFieldInZ));
716 auto tripletFinder = Acts::TripletSeedFinder::create(
718
719
720 const Acts::Range1D<float> rMiddleSpRange(
723
724 Acts::BroadTripletSeedFilter::State filterState;
725 Acts::BroadTripletSeedFilter::Cache filterCache;
726 Acts::TripletSeeder::Cache
cache;
727
730
731 std::vector<Acts::SpacePointContainer::ConstRange> bottomSpRanges;
732 std::optional<Acts::SpacePointContainer::ConstRange> middleSpRange;
733 std::vector<Acts::SpacePointContainer::ConstRange> topSpRanges;
734
735 Acts::SeedContainer tmpSeedContainer;
736
737 for (const auto [bottom, middle, top] : grid.binnedGroup()) {
738 ACTS_VERBOSE("Process middle bin " << middle);
739 if (middle >= gridSpacePointRanges.size()) {
740 ATH_MSG_ERROR(
"Grid Binned Group returned an unreasonable middle bin");
741 return StatusCode::FAILURE;
742 }
743
744 bottomSpRanges.clear();
745 topSpRanges.clear();
746
747 std::ranges::transform(
748 bottom, std::back_inserter(bottomSpRanges),
749 [&](std::size_t b) -> Acts::SpacePointContainer::ConstRange {
750 return selectedSpacePoints.range(gridSpacePointRanges[b]).asConst();
751 });
752 middleSpRange =
753 selectedSpacePoints.range(gridSpacePointRanges[middle]).asConst();
754 std::ranges::transform(
755 top, std::back_inserter(topSpRanges),
756 [&](std::size_t t) -> Acts::SpacePointContainer::ConstRange {
757 return selectedSpacePoints.range(gridSpacePointRanges[t]).asConst();
758 });
759
760
761
762 auto firstMiddleSp = middleSpRange->front();
763 auto radiusRangeForMiddle =
765
766 ACTS_VERBOSE("Validity range (radius) for the middle space point is ["
767 << radiusRangeForMiddle.first << ", "
768 << radiusRangeForMiddle.second << "]");
769
771 cache, *bottomDoubletFinder, *topDoubletFinder, *tripletFinder, filter,
772 selectedSpacePoints, bottomSpRanges, *middleSpRange, topSpRanges,
773 radiusRangeForMiddle, tmpSeedContainer);
774 }
775
776
777
778
779 auto selectionFunction =
780 [&filterState](
const Acts::MutableSeedProxy&
seed) ->
bool {
781 float seedQuality =
seed.quality();
782 float bottomQuality =
783 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[0]);
784 float middleQuality =
785 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[1]);
786 float topQuality =
787 filterState.bestSeedQualityMap.at(
seed.spacePointIndices()[2]);
788
789 return bottomQuality <= seedQuality || middleQuality <= seedQuality ||
790 topQuality <= seedQuality;
791 };
792
793 seedContainer.
reserve(seedContainer.
size() + tmpSeedContainer.size());
794
795
796 for (Acts::MutableSeedProxy seed : tmpSeedContainer) {
798 continue;
799 }
800
802 Acts::ConstSeedProxy(seed), [&](const Acts::SpacePointIndex spIndex) {
803 const Acts::SpacePointIndex originalIndex =
804 selectedSpacePoints.at(spIndex).copiedFromIndex();
805 return selectedXAODSpacePoints[originalIndex];
806 });
807 }
808
809 return StatusCode::SUCCESS;
810}
Scalar phi() const
phi method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_ERROR(x,...)
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
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.17.0