MdtSegmentSeedGenerator.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
#define MUONR4_MUONPATTERNHELPERS_MDTSEGMENTSEEDGENERATOR_H
 
#include <AthenaBaseComps/AthMessaging.h>
#include <MuonSpacePoint/SpacePointPerLayerSorter.h>
#include <MuonPatternEvent/SegmentSeed.h>
#include <GaudiKernel/SystemOfUnits.h>
 
 
#include <vector>
#include <array>
 
 
namespace MuonR4 {
    class ISpacePointCalibrator;
    class MdtSegmentSeedGenerator: public AthMessaging {
        public:
            using HitVec = SpacePointPerLayerSorter::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 ISpacePointCalibrator* calibrator{nullptr};
                bool fastSeedFit{true};
                bool fastSegFitWithT0{false};
                unsigned int nMaxIter{100};
                double precCutOff{1.e-6};
            };
            struct DriftCircleSeed{
                SegmentFit::Parameters parameters{SegmentFit::Parameters::Zero()};
                std::vector<std::unique_ptr<CalibratedSpacePoint>> measurements{};
                unsigned int nIter{0};
                double chi2{0.};
                const SpacePointBucket* parentBucket{nullptr};
            };
        
        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{};
 
                friend std::ostream& operator<<(std::ostream& ostr, const SeedSolution& sol) {
                    return sol.print(ostr);
                }
                std::ostream& print(std::ostream& ostr) const;
            };
 
 
            std::optional<DriftCircleSeed> buildSeed(const EventContext& ctx,
                                                     const HoughHitType& topHit, 
                                                     const HoughHitType& bottomHit, 
                                                     const SignComboType& signs); 
            struct SeedFitAuxilliaries {
                Amg::Vector3D centerOfGrav{Amg::Vector3D::Zero()};
                std::vector<double> invCovs{};
                std::vector<int> driftSigns{};
                double covNorm{0.};
                double T_zzyy{0.};
                double T_yz{0.}; 
                double T_rz{0.};
                double T_ry{0.};
                double fitY0{0.};
            };
 
            struct SeedFitAuxWithT0: public SeedFitAuxilliaries{
                SeedFitAuxWithT0(SeedFitAuxilliaries&& parent):
                    SeedFitAuxilliaries{std::move(parent)}{}
                    double T_vy{0.};
                    double T_vz{0.};
                    double T_ay{0.};
                    double T_az{0.};
                    double R_vr{0.};
                    double R_vv{0.};
                    double R_va{0.};
                    double fitY0Prime{0.};
                    double fitY0TwoPrime{0.};
            };
 
            SeedFitAuxilliaries estimateAuxillaries(const DriftCircleSeed& seed) const;  
            SeedFitAuxWithT0 estimateAuxillaries(const EventContext& ctx,
                                                 const DriftCircleSeed& seed) const;          
            void fitDriftCircles(DriftCircleSeed& seed) const;
            void fitDriftCirclesWithT0(const EventContext& ctx,
                                       DriftCircleSeed& seed) const;            
            void moveToNextCandidate();
            Config m_cfg{};
            
 
            const SegmentSeed* m_segmentSeed{nullptr};
            SpacePointPerLayerSorter 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