MUM-T 대드론(C-UAS) 지향성에너지 고출력 레이저(HEL) 대기 난류 빔 지터 보정 및 초점 추적 적응광학 서보 아키텍처 (.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.DirectedEnergy
{
    /// <summary>
    /// 고출력 레이저(HEL) 대기 난류 빔 지터 보정 적응광학 파면 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct HelLaserAdaptiveOpticsServo
    {
        private readonly ReadOnlySpan<float> _wavefrontSlopesX;  // 파면 X 구배 (urad)
        private readonly ReadOnlySpan<float> _wavefrontSlopesY;  // 파면 Y 구배 (urad)
        private readonly Span<float> _reconstructedPhases;      // 복원된 위상 수차 (nm)
        private readonly Span<float> _deformableMirrorVolts;    // 변형 거울 구동 전압 (V)

        private readonly float _slopeToPhaseScale; // 구배 -> 위상 환산 계수
        private readonly float _actuatorGain;      // 액추에이터 전압 게인 (V/nm)
        private readonly float _maxVoltage;        // 최대 허용 전압 (V)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HelLaserAdaptiveOpticsServo(
            ReadOnlySpan<float> wavefrontSlopesX,
            ReadOnlySpan<float> wavefrontSlopesY,
            Span<float> reconstructedPhases,
            Span<float> deformableMirrorVolts,
            float slopeToPhaseScale = 12.5f,
            float actuatorGain = 0.45f,
            float maxVoltage = 150.0f)
        {
            _wavefrontSlopesX = wavefrontSlopesX;
            _wavefrontSlopesY = wavefrontSlopesY;
            _reconstructedPhases = reconstructedPhases;
            _deformableMirrorVolts = deformableMirrorVolts;
            _slopeToPhaseScale = slopeToPhaseScale;
            _actuatorGain = actuatorGain;
            _maxVoltage = maxVoltage;
        }

        /// <summary>
        /// 8채널 서브애퍼처 슬로프 벡터를 SIMD 병렬 분석하여 거울 구동 전압 산출
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteWavefrontCorrectionLoop()
        {
            int length = _wavefrontSlopesX.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vScale = Vector256.Create(_slopeToPhaseScale);
            Vector256<float> vGain = Vector256.Create(_actuatorGain);
            Vector256<float> vMaxV = Vector256.Create(_maxVoltage);
            Vector256<float> vMinV = Vector256.Create(-_maxVoltage);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vSx = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_wavefrontSlopesX.Slice(i, 8))[0]);
                    Vector256<float> vSy = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_wavefrontSlopesY.Slice(i, 8))[0]);

                    // 국소 파면 수차: Phase = Scale * sqrt(Sx^2 + Sy^2)
                    Vector256<float> vSlopeMagSq = Avx.Add(Avx.Multiply(vSx, vSx), Avx.Multiply(vSy, vSy));
                    Vector256<float> vPhase = Avx.Multiply(vScale, Avx.Sqrt(vSlopeMagSq));

                    // 거울 전압 = -Gain * Phase
                    Vector256<float> vRawVolts = Avx.Multiply(Avx.Subtract(Vector256<float>.Zero, vPhase), vGain);
                    Vector256<float> vClampedVolts = Avx.Min(vMaxV, Avx.Max(vMinV, vRawVolts));

                    vPhase.CopyTo(_reconstructedPhases.Slice(i, 8));
                    vClampedVolts.CopyTo(_deformableMirrorVolts.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float mag = MathF.Sqrt((_wavefrontSlopesX[i] * _wavefrontSlopesX[i]) + (_wavefrontSlopesY[i] * _wavefrontSlopesY[i]));
                float phase = _slopeToPhaseScale * mag;
                float volts = Math.Clamp(-_actuatorGain * phase, -_maxVoltage, _maxVoltage);

                _reconstructedPhases[i] = phase;
                _deformableMirrorVolts[i] = volts;
            }
        }
    }
}