MUM-T 해상초계 무인기 광펌핑 원자자기계(OPM) 기반 자기이상탐지기(MAD) 잠수함 잔류자화 국소화 서보 아키텍처 (.NET 9 C# SIMD)

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

namespace ZeliDesk.Defense.MaritimePatrol
{
    /// <summary>
    /// 해상초계 무인기 광펌핑 원자자기계(OPM) MAD 잠수함 자기이상 탐지 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct MadSubmarineLocalizationServo
    {
        private readonly ReadOnlySpan<float> _rawOpmMagnitudes;  // OPM 총자장 센서 측정치 B_raw (nT)
        private readonly ReadOnlySpan<float> _earthFieldNorms;   // IGRF 지구자기장 기준치 B_earth (nT)
        private readonly ReadOnlySpan<float> _aircraftManeuvers; // 기동 유도 자기잡음 모델 (nT)
        private readonly Span<float> _cleanAnomalySignals;       // 보정된 순수 자기이상 DeltaB (nT)
        private readonly Span<float> _submarineRangeEstimates;   // 추정된 잠수함 상대거리 (m)

        private readonly float _dipoleMoment;   // 잠수함 자기모멘트 환산계수
        private readonly float _detectionThresh;// 탐지 임계값 (0.015 nT)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public MadSubmarineLocalizationServo(
            ReadOnlySpan<float> rawOpmMagnitudes,
            ReadOnlySpan<float> earthFieldNorms,
            ReadOnlySpan<float> aircraftManeuvers,
            Span<float> cleanAnomalySignals,
            Span<float> submarineRangeEstimates,
            float dipoleMoment = 450000.0f,
            float detectionThresh = 0.015f)
        {
            _rawOpmMagnitudes = rawOpmMagnitudes;
            _earthFieldNorms = earthFieldNorms;
            _aircraftManeuvers = aircraftManeuvers;
            _cleanAnomalySignals = cleanAnomalySignals;
            _submarineRangeEstimates = submarineRangeEstimates;
            _dipoleMoment = dipoleMoment;
            _detectionThresh = detectionThresh;
        }

        /// <summary>
        /// 8채널 자기장 데이터를 SIMD 병렬 분석하여 항공기 간섭 제거 및 잠수함 거리 추정
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteMadSignalExtraction()
        {
            int length = _rawOpmMagnitudes.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vMom = Vector256.Create(_dipoleMoment);
            Vector256<float> vThresh = Vector256.Create(_detectionThresh);
            Vector256<float> vZero = Vector256<float>.Zero;
            Vector256<float> vInvThree = Vector256.Create(0.333333f);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vRaw = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_rawOpmMagnitudes.Slice(i, 8))[0]);
                    Vector256<float> vEarth = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_earthFieldNorms.Slice(i, 8))[0]);
                    Vector256<float> vNoise = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_aircraftManeuvers.Slice(i, 8))[0]);

                    // 순수 자기이상 DeltaB = Raw - Earth - Noise
                    Vector256<float> vClean = Avx.Subtract(Avx.Subtract(vRaw, vEarth), vNoise);

                    // 절대값: AbsDelta = |DeltaB|
                    Vector256<float> vAbsDelta = Avx.Max(vClean, Avx.Subtract(vZero, vClean));

                    // 임계값 초과 마스크
                    Vector256<float> vValidMask = Avx.CompareGreaterThan(vAbsDelta, vThresh);

                    // 거리 역산 R = (M / AbsDelta)^(1/3) (근사 지수)
                    Vector256<float> vRatio = Avx.Divide(vMom, Avx.Max(vThresh, vAbsDelta));
                    // 1/3 제곱 근사: sqrt(sqrt(x)) * x^(1/12) 등 대신 cbrt 근사
                    // AVX2는 내장 cbrt가 없으므로 테일러/뉴턴 반복 또는 log2-exp2 근사
                    // 여기서는 1/4 승으로 1차 축소 후 스케일
                    Vector256<float> vSqrt = Avx.Sqrt(vRatio);
                    Vector256<float> vRange = Avx.Multiply(Avx.Sqrt(vSqrt), Vector256.Create(18.5f));
                    vRange = Avx.And(vRange, vValidMask);

                    vClean.CopyTo(_cleanAnomalySignals.Slice(i, 8));
                    vRange.CopyTo(_submarineRangeEstimates.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float clean = _rawOpmMagnitudes[i] - _earthFieldNorms[i] - _aircraftManeuvers[i];
                float absClean = MathF.Abs(clean);
                float range = 0.0f;
                if (absClean > _detectionThresh)
                {
                    range = MathF.Cbrt(_dipoleMoment / absClean) * 1.5f;
                }
                _cleanAnomalySignals[i] = clean;
                _submarineRangeEstimates[i] = range;
            }
        }
    }
}