차세대 항공모함 유무인 함재기 전자기식 사출장치(EMALS) 선형유도전동기(LIM) 단부효과 누설자속 보정 서보 아키텍처 (.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.NavalAviation
{
    /// <summary>
    /// EMALS 선형유도전동기(LIM) 단부효과 누설자속 보정 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct EmalsLimFluxBarrierServo
    {
        private readonly ReadOnlySpan<float> _shuttleVelocities; // 셔틀 구간 속도 v (m/s)
        private readonly ReadOnlySpan<float> _targetThrusts;      // 목표 추력 명령 F_target (kN)
        private readonly Span<float> _endEffectFactors;          // 연산된 단부 감쇠 계수 f_end
        private readonly Span<float> _compensatedIds;            // d축 여자 전류 보정 명령 (A)
        private readonly Span<float> _compensatedIqs;            // q축 토크 전류 보정 명령 (A)

        private readonly float _polePitch;    // 극피치 tau_p (m)
        private readonly float _statorLength; // 섹션 길이 L (m)
        private readonly float _nominalIds;   // 기준 d축 전류 (A)
        private readonly float _thrustConstant;// 추력 환산 상수 (A/kN)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public EmalsLimFluxBarrierServo(
            ReadOnlySpan<float> shuttleVelocities,
            ReadOnlySpan<float> targetThrusts,
            Span<float> endEffectFactors,
            Span<float> compensatedIds,
            Span<float> compensatedIqs,
            float polePitch = 0.25f,
            float statorLength = 12.0f,
            float nominalIds = 350.0f,
            float thrustConstant = 4.2f)
        {
            _shuttleVelocities = shuttleVelocities;
            _targetThrusts = targetThrusts;
            _endEffectFactors = endEffectFactors;
            _compensatedIds = compensatedIds;
            _compensatedIqs = compensatedIqs;
            _polePitch = polePitch;
            _statorLength = statorLength;
            _nominalIds = nominalIds;
            _thrustConstant = thrustConstant;
        }

        /// <summary>
        /// 8개 인버터 모듈의 속도 의존 단부 손실을 SIMD 병렬 연산하여 전류 지령 보정
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteFluxCompensationLoop()
        {
            int length = _shuttleVelocities.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vNomIds = Vector256.Create(_nominalIds);
            Vector256<float> vKt = Vector256.Create(_thrustConstant);
            Vector256<float> vOne = Vector256.Create(1.0f);
            Vector256<float> vAlpha = Vector256.Create(0.0045f); // 속도 비례 감쇠 계수

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vVel = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_shuttleVelocities.Slice(i, 8))[0]);
                    Vector256<float> vThrust = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_targetThrusts.Slice(i, 8))[0]);

                    // 단부 감쇠율: f_end = alpha * v
                    Vector256<float> vFend = Avx.Multiply(vVel, vAlpha);
                    Vector256<float> vThrustFactor = Avx.Subtract(vOne, vFend);
                    vThrustFactor = Avx.Max(Vector256.Create(0.5f), vThrustFactor);

                    // d축 자속 보상: Ids_comp = NomIds * (1.0 + f_end * 1.5)
                    Vector256<float> vIdsComp = Avx.Multiply(vNomIds, Avx.Add(vOne, Avx.Multiply(vFend, Vector256.Create(1.5f))));

                    // q축 토크 보상: Iqs_comp = (Thrust * Kt) / ThrustFactor
                    Vector256<float> vNomIqs = Avx.Multiply(vThrust, vKt);
                    Vector256<float> vIqsComp = Avx.Divide(vNomIqs, vThrustFactor);

                    vFend.CopyTo(_endEffectFactors.Slice(i, 8));
                    vIdsComp.CopyTo(_compensatedIds.Slice(i, 8));
                    vIqsComp.CopyTo(_compensatedIqs.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float fend = _shuttleVelocities[i] * 0.0045f;
                float thrustFactor = MathF.Max(0.5f, 1.0f - fend);
                _endEffectFactors[i] = fend;
                _compensatedIds[i] = _nominalIds * (1.0f + (fend * 1.5f));
                _compensatedIqs[i] = (_targetThrusts[i] * _thrustConstant) / thrustFactor;
            }
        }
    }
}