MUM-T 유무인복합 AESA 레이다 T/R 모듈 위상배열 열팽창 보정 및 서멀 쓰로틀링 능동 이득 밸런싱 서보 아키텍처 (.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.Avionics
{
    /// <summary>
    /// AESA T/R 모듈 위상배열 열팽창 및 서멀 쓰로틀링 능동 이득 밸런싱 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct AesatrModuleThermalServo
    {
        private readonly ReadOnlySpan<float> _temperatures;     // 채널별 온도 (deg C)
        private readonly ReadOnlySpan<float> _nominalPhases;     // 목표 조향 위상 (rad)
        private readonly ReadOnlySpan<float> _taylorWeights;     // 테일러 가중치
        private readonly Span<float> _commandAmplitudes;         // 출력 보정 진폭
        private readonly Span<float> _commandPhases;             // 출력 보정 위상

        private readonly float _alphaGain;     // dB/deg C
        private readonly float _alphaPhase;    // rad/deg C
        private readonly float _refTemp;       // 기준 온도 (25 deg C)
        private readonly float _maxTemp;       // 임계 온도 (85 deg C)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public AesatrModuleThermalServo(
            ReadOnlySpan<float> temperatures,
            ReadOnlySpan<float> nominalPhases,
            ReadOnlySpan<float> taylorWeights,
            Span<float> commandAmplitudes,
            Span<float> commandPhases,
            float alphaGain = 0.015f,
            float alphaPhase = 0.008f,
            float refTemp = 25.0f,
            float maxTemp = 85.0f)
        {
            _temperatures = temperatures;
            _nominalPhases = nominalPhases;
            _taylorWeights = taylorWeights;
            _commandAmplitudes = commandAmplitudes;
            _commandPhases = commandPhases;
            _alphaGain = alphaGain;
            _alphaPhase = alphaPhase;
            _refTemp = refTemp;
            _maxTemp = maxTemp;
        }

        /// <summary>
        /// 수천 채널의 T/R 모듈 열 보정을 SIMD 8개 병렬 단위로 실시간 연산
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteCorrectionLoop()
        {
            int length = _temperatures.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vRefTemp = Vector256.Create(_refTemp);
            Vector256<float> vMaxTemp = Vector256.Create(_maxTemp);
            Vector256<float> vAlphaG = Vector256.Create(_alphaGain);
            Vector256<float> vAlphaP = Vector256.Create(_alphaPhase);
            Vector256<float> vZero = Vector256<float>.Zero;
            Vector256<float> vOne = Vector256.Create(1.0f);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vTemp = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_temperatures.Slice(i, 8))[0]);
                    Vector256<float> vNomPhase = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_nominalPhases.Slice(i, 8))[0]);
                    Vector256<float> vTaylor = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_taylorWeights.Slice(i, 8))[0]);

                    // Delta T = T - T_ref
                    Vector256<float> vDeltaT = Avx.Subtract(vTemp, vRefTemp);

                    // 위상 보정: Psi_cmd = Psi_nom - alpha_phase * DeltaT
                    Vector256<float> vDeltaPhase = Avx.Multiply(vDeltaT, vAlphaP);
                    Vector256<float> vCmdPhase = Avx.Subtract(vNomPhase, vDeltaPhase);

                    // 서멀 쓰로틀링 계수 계산: OverTemp = max(0, T - maxTemp)
                    Vector256<float> vOverTemp = Avx.Max(vZero, Avx.Subtract(vTemp, vMaxTemp));
                    Vector256<float> vThrottle = Avx.Subtract(vOne, Avx.Multiply(vOverTemp, Vector256.Create(0.025f)));
                    vThrottle = Avx.Max(Vector256.Create(0.2f), Avx.Min(vOne, vThrottle));

                    // 이득 열화 보정 인자 (근사 스케일링)
                    Vector256<float> vGainFactor = Avx.Add(vOne, Avx.Multiply(vDeltaT, vAlphaG));
                    Vector256<float> vCmdAmp = Avx.Multiply(Avx.Multiply(vTaylor, vGainFactor), vThrottle);

                    // 결과 벡터 저장
                    vCmdPhase.CopyTo(_commandPhases.Slice(i, 8));
                    vCmdAmp.CopyTo(_commandAmplitudes.Slice(i, 8));
                }
            }

            // SIMD 잔여 채널 스칼라 처리
            for (; i < length; i++)
            {
                float deltaT = _temperatures[i] - _refTemp;
                _commandPhases[i] = _nominalPhases[i] - (_alphaPhase * deltaT);

                float overTemp = MathF.Max(0.0f, _temperatures[i] - _maxTemp);
                float throttle = MathF.Max(0.2f, MathF.Min(1.0f, 1.0f - (overTemp * 0.025f)));
                float gainFactor = 1.0f + (_alphaGain * deltaT);
                _commandAmplitudes[i] = _taylorWeights[i] * gainFactor * throttle;
            }
        }
    }
}