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>
 
#include "Acts/Seeding/CompositeSpacePointLineSeeder.hpp"
namespace MuonR4{
    class ISpacePointCalibrator;
    class CalibratedSpacePoint;
}
 
namespace MuonR4::SegmentFit {
    class MdtSegmentSeedGenerator: public AthMessaging {
        public:
            using LineSeeder_t = Acts::Experimental::CompositeSpacePointLineSeeder;
            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{};
                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 TangentLine = LineSeeder_t::TwoCircleTangentPars;
            using TangentAmbi = LineSeeder_t::TangentAmbi;
            static constexpr std::array<TangentAmbi, 4> s_signCombos{TangentAmbi::LL, TangentAmbi::RR,
                                                                     TangentAmbi::LR, TangentAmbi::RL};

            struct SeedSolution : public TangentLine {
                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;
            };
            
            bool isValidLine(const TangentLine& solution) 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 TangentAmbi ambi); 
            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};
        
    };
}
#endif