MdtSegmentSeedGenerator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
#define MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
 
#include <MuonSpacePoint/SpacePointPerLayerSplitter.h>
#include <MuonSpacePoint/CalibratedSpacePoint.h>
#include <MuonPatternEvent/Segment.h>
 
#include "Acts/Seeding/CompositeSpacePointLineSeeder.hpp"
namespace MuonR4{
    class ISpacePointCalibrator;
    class SegmentSeed;
}
 
namespace MuonR4::SegmentFit {
 
    struct SeederStateBase : public SpacePointPerLayerSplitter {
        protected:
            using SeedSelector_t  = std::function<bool(const Amg::Vector3D& pos,
                                                       const Amg::Vector3D& dir)>;
            explicit SeederStateBase(const SegmentSeed* parentSeed,
                                     const ISpacePointCalibrator* calibrator,
                                     const bool calibratedPull,
                                     SeedSelector_t&& seedSelector = nullptr);

            SeederStateBase(const SegmentSeed* parentSeed,
                            const ISpacePointCalibrator* calibrator,
                            bool calibratePull,
                            const SpacePointPerLayerSplitter::HitVec& hits,
                            SeedSelector_t&& seedSelector = nullptr);
 
        public:
            using CalibCont_t = Segment::MeasVec;
            const SegmentSeed* parent() const;
            bool goodCandidate(const SpacePoint& testMdt) const;
            double candidateChi2(const Acts::CalibrationContext& cctx,
                                    const Amg::Vector3D& seedPos,
                                    const Amg::Vector3D& seedDir,
                                    const double t0,
                                    const SpacePoint& candidate) const;
            double strawRadius(const SpacePoint& testMdt) const;            
            CalibCont_t newContainer(const Acts::CalibrationContext& cctx) const;       
            void append(const Acts::CalibrationContext& cctx,
                        const Amg::Vector3D& pos,
                        const Amg::Vector3D& dir,
                        const double t0,
                        const SpacePoint& appendMe,
                        CalibCont_t& appendTo) const;
            bool stopSeeding(const std::size_t lowerLayer, 
                             const std::size_t upperLayer) const;

            bool goodForSeeding(const Amg::Vector3D& tangentPos,
                                const Amg::Vector3D& tangentDir) const;
        private:    
            const SegmentSeed* m_parent{};
            const ISpacePointCalibrator* m_calibrator{nullptr};
            bool m_calibratePull{false};
            const SeedSelector_t m_selector{nullptr};
    };
    static_assert(Acts::Experimental::detail::CompSpacePointSeederDelegate<SeederStateBase, 
                                                                            SeederStateBase::HitVec, 
                                                                            SeederStateBase::CalibCont_t>);
 
    static_assert(Acts::Experimental::detail::CompositeSpacePointSeedSelector<SeederStateBase>);
    
    class MdtSegmentSeedGenerator: public Acts::Experimental::CompositeSpacePointLineSeeder {
        public:
            using LineSeeder_t = Acts::Experimental::CompositeSpacePointLineSeeder;
            using HitVec_t = SpacePointPerLayerSplitter::HitVec;
 
            using CalibCont_t = SeederStateBase::CalibCont_t;
            using LineSeeder_t::LineSeeder_t;
            using State_t = SeedingState<HitVec_t, CalibCont_t, SeederStateBase>;
            using Seed_t = SegmentSeed<CalibCont_t>;
    };
}
#endif