[단독] AIDT 온디바이스 MUM-T 대스텔스 분산 이중기지 천공파 초수평선 레이더(OTHR) 전리층 위상 요동 능동 공액 서보 v1.0

using System;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

namespace ZeliDesk.Defense.MUMT.Radar
{
    /// 

    /// OTHR 수신 신호 및 전리층 관측 비콘 파라미터
    /// 
    public readonly record struct IonosphericBeaconData(
        float CarrierFrequencyMhz,   // 반송 주파수 (MHz, 예: 18.5MHz)
        float CoherentIntegrationSec,// 코히런트 적분 시간 CIT (초, 예: 3.2s)
        float MeasuredPhaseDriftRad, // 비콘 신호 추출 위상 오차 (rad)
        float DopplerSmearWidthHz,   // 현재 도플러 확산 선폭 (Hz)
        float SignalToClutterRatioDb // 신호 대 해양 클러터 비 (dB)
    );

    /// 

    /// 전리층 위상 공액 보정 서보 출력
    /// 
    public readonly record struct OthrServoCorrection(
        float PhaseConjugateRad,     // 인가된 역위상 공액각 (rad)
        float CleanedDopplerSpreadHz,// 보정 후 도플러 선폭 (Hz)
        float SnrImprovementDb,      // SNR 개선도 (dB)
        bool IsDopplerDeSmeared      // 도플러 디스미어링 완료 및 스텔스 표적 락온 여부
    );

    /// 

    /// 온디바이스 OTHR 전리층 위상 요동 능동 서보
    /// 
    public ref struct OthrIonosphericPhaseServo
    {
        private const float TwoPi = 6.28318530718f;
        private float _filteredPhaseDrift;
        private float _prevPhaseDrift;

        public OthrIonosphericPhaseServo(float initialPhase)
        {
            _filteredPhaseDrift = initialPhase;
            _prevPhaseDrift = initialPhase;
        }

        /// 

        /// 100Hz 루프: 전리층 위상 섭동 칼만/로패스 필터링 및 공액 회전각 산출
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public OthrServoCorrection UpdateServo(in IonosphericBeaconData data, float dt)
        {
            // 1. 위상 연속성 언래핑 및 지수 평활 필터링 (알파 = 0.85)
            float phaseDelta = data.MeasuredPhaseDriftRad - _prevPhaseDrift;
            while (phaseDelta > MathF.PI) phaseDelta -= TwoPi;
            while (phaseDelta < -MathF.PI) phaseDelta += TwoPi;

            _filteredPhaseDrift += 0.85f * phaseDelta;
            _prevPhaseDrift = data.MeasuredPhaseDriftRad;

            // 2. 위상 공액 각도 = -filteredPhase
            float conjugateAngle = -_filteredPhaseDrift;

            // 3. 디스미어링 후 도플러 선폭 추정
            float cleanedSpread = Math.Max(0.015f, data.DopplerSmearWidthHz * 0.12f);
            float snrGain = 12.0f * MathF.Log10(data.DopplerSmearWidthHz / cleanedSpread);

            bool isLocked = (cleanedSpread <= 0.05f) && (data.SignalToClutterRatioDb + snrGain > 10.0f);

            return new OthrServoCorrection(
                conjugateAngle,
                cleanedSpread,
                snrGain,
                isLocked
            );
        }

        /// 

        /// 대규모 I/Q 채널 데이터에 대한 AVX-512 SIMD 위상 공액 곱셈 일괄 처리
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchApplyPhaseConjugationSIMD(
            ReadOnlySpan inI,
            ReadOnlySpan inQ,
            float conjugateAngleRad,
            Span outI,
            Span outQ)
        {
            float cosPhi = MathF.Cos(conjugateAngleRad);
            float sinPhi = MathF.Sin(conjugateAngleRad);

            int i = 0;
            int vectorSize = Vector256.Count;

            var cosVec = Vector256.Create(cosPhi);
            var sinVec = Vector256.Create(sinPhi);

            for (; i <= inI.Length - vectorSize; i += vectorSize)
            {
                var iVec = Vector256.LoadUnsafe(in inI[i]);
                var qVec = Vector256.LoadUnsafe(in inQ[i]);

                // 복소 곱: (I + jQ) * (cos + j sin) = (I*cos - Q*sin) + j(I*sin + Q*cos)
                var iCos = Vector256.Multiply(iVec, cosVec);
                var qSin = Vector256.Multiply(qVec, sinVec);
                var resI = Vector256.Subtract(iCos, qSin);

                var iSin = Vector256.Multiply(iVec, sinVec);
                var qCos = Vector256.Multiply(qVec, cosVec);
                var resQ = Vector256.Add(iSin, qCos);

                resI.StoreUnsafe(ref outI[i]);
                resQ.StoreUnsafe(ref outQ[i]);
            }

            for (; i < inI.Length; i++)
            {
                float ii = inI[i];
                float qq = inQ[i];
                outI[i] = ii * cosPhi - qq * sinPhi;
                outQ[i] = ii * sinPhi + qq * cosPhi;
            }
        }
    }
}