MdtSegmentSeedGenerator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
#define MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
 
#include <AthenaBaseComps/AthMessaging.h>
#include <ActsInterop/Logger.h>
#include <MuonSpacePoint/SpacePointPerLayerSplitter.h>
#include <MuonPatternEvent/SegmentSeed.h>
 
#include <vector>
#include <array>
 
namespace MuonR4{
    class ISpacePointCalibrator;
    class CalibratedSpacePoint;
}
 
namespace MuonR4::SegmentFit {
    class MdtSegmentSeedGenerator: public AthMessaging {
        public:
            using HitVec = SpacePointPerLayerSplitter::HitVec;
            struct Config{
                std::array<double, 2> thetaRange{0, 180.*Gaudi::Units::deg};
                std::array<double, 2> interceptRange{-20.*Gaudi::Units::m, 20.*Gaudi::Units::m};
                double hitPullCut{5.};
                bool startWithPattern{false};
                unsigned int busyLayerLimit{2};
                unsigned int nMdtHitCut{3};
                double nMdtLayHitCut{2./3.};
                bool tightenHitCut{true};
                bool overlapCorridor{true};
                bool recalibSeedCircles{false};
                const MuonR4::ISpacePointCalibrator* calibrator{nullptr};
                unsigned int nMaxIter{100};
                double precCutOff{1.e-6};
            };
            struct DriftCircleSeed{
                Parameters parameters{Parameters::Zero()};
                std::vector<std::unique_ptr<CalibratedSpacePoint>> measurements{};
                unsigned int nIter{0};
                double chi2{0.};
                const SpacePointBucket* parentBucket{nullptr};
                unsigned int nMdt{0};
            };
        
        MdtSegmentSeedGenerator(const std::string& name,
                                const SegmentSeed* segmentSeed, 
                                const Config& configuration);
 
        ~MdtSegmentSeedGenerator();
        std::optional<DriftCircleSeed> nextSeed(const EventContext& ctx);
        unsigned int numGenerated() const;
        const Config& config() const;
        private:
            using SignComboType = std::array<int, 2>;
            constexpr static std::array<SignComboType,4> s_signCombos{
                std::array{ 1, 1}, std::array{ 1,-1}, 
                std::array{-1,-1}, std::array{-1, 1},  
            };
            struct SeedSolution{
                double theta{0.};
                double y0{0.};
                double dTheta{0.};
                double dY0{0.};
                HitVec seedHits{};
                std::vector<int> solutionSigns{};
                bool isValid{true};
                friend std::ostream& operator<<(std::ostream& ostr, const SeedSolution& sol) {
                    return sol.print(ostr);
                }
                std::ostream& print(std::ostream& ostr) const;
            };
            template <Acts::Experimental::CompositeSpacePoint SpacePoint_t>
                SeedSolution estimateTangentLine(const SpacePoint_t& topHit, const SpacePoint_t& bottomHit,
                                                 const SignComboType& signs) const;
            Line_t::ParamVector constructLinePars(const double theta, const double y0) const;
            std::optional<DriftCircleSeed> buildSeed(const EventContext& ctx,
                                                     const HoughHitType& topHit, 
                                                     const HoughHitType& bottomHit, 
                                                     const SignComboType& signs); 
            void moveToNextCandidate();
            static SeedingAux::Config translate(const Config& cfg); 
            Config m_cfg{};
 
            Line_t m_line{};
            const SegmentSeed* m_segmentSeed{nullptr};
            SpacePointPerLayerSplitter m_hitLayers{m_segmentSeed->getHitsInMax()};
            
            std::size_t m_upperLayer{0};
            std::size_t m_lowerLayer{0}; 
            std::size_t m_lowerHitIndex{0};
            std::size_t m_upperHitIndex{0};
            std::size_t m_signComboIndex{0};
            std::vector<SeedSolution> m_seenSolutions{};
            unsigned int m_nGenSeeds{0};
        
    };
}
#include <MuonPatternHelpers/MdtSegmentSeedGenerator.icc>
 
#endif