[단독] AIDT 온디바이스 MUM-T 함재기 전자기 강제착함 어레스팅 기어(EMALS/AAG) 선형 동기 전동기 인장력 능동 서보 제어기 v1.0

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

namespace ZeliDesk.Defense.MUMT.CarrierArrestingGear
{
    /// 

    /// 항공기 착함 파라미터 및 계측 상태
    /// 
    public readonly record struct AircraftArrestingState(
        float MassKg,            // 기체 질량 (유인 25,000kg, 무인 4,500kg 등)
        float VelocityX,         // 종방향 속도 (m/s)
        float PositionX,         // 정지 목표점 대비 착함 진행거리 (m)
        float SheaveHalfSpan,    // 갑판 시브 반폭 W (m, 통상 20m)
        float MaxAllowableG,     // 최대 허용 감속도 (G단위, 예: 3.2G)
        float TargetRunoutDist   // 목표 정지 런아웃 거리 (m, 통상 95m)
    );

    /// 

    /// 전자기 선형 전동기(AAG PMLSM) 인장력 제어 출력
    /// 
    public readonly record struct ArrestingServoOutput(
        float DesiredTensionNewton, // 와이어 편측 요구 인장력 (N)
        float DecelerationG,        // 현재 순간 감속도 (G)
        float WireDeflectionAngle,  // 와이어 전단 편향각 (rad)
        float RemainingDistance,    // 잔여 제동 거리 (m)
        bool IsSafelyStopped        // 완전 정지 여부
    );

    /// 

    /// 온디바이스 MUM-T 전자기 강제착함 능동 인장력 서보 제어기
    /// 
    public ref struct CarrierArrestingGearServo
    {
        private const float GravityAcc = 9.80665f;
        private float _accumulatedBrakeEnergyJ;
        private float _prevPositionX;

        public CarrierArrestingGearServo(float initialPositionX)
        {
            _accumulatedBrakeEnergyJ = 0.0f;
            _prevPositionX = initialPositionX;
        }

        /// 

        /// 100kHz 인장력 루프: 기체 감속도 및 와이어 인장력 최적 분배 연산
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ArrestingServoOutput ComputeActiveTension(in AircraftArrestingState state, float deltaTimeSec)
        {
            if (state.VelocityX <= 0.1f)
            {
                return new ArrestingServoOutput(0.0f, 0.0f, 0.0f, Math.Max(0.0f, state.TargetRunoutDist - state.PositionX), true);
            }

            // 1. 와이어 기하각 계산: sin(theta) = x / sqrt(W^2 + x^2)
            float x = Math.Max(0.1f, state.PositionX);
            float w = state.SheaveHalfSpan;
            float hypotenuse = MathF.Sqrt(x * x + w * w);
            float sinTheta = x / hypotenuse;
            float thetaRad = MathF.Asin(sinTheta);

            // 2. 남은 목표 거리 기반 요구 감속도 연산: v^2 = 2 * a_req * (S_target - x)
            float remDist = Math.Max(0.5f, state.TargetRunoutDist - x);
            float requiredDecel = (state.VelocityX * state.VelocityX) / (2.0f * remDist);

            // 3. 기체 허용 G-load 한계 클램핑
            float maxDecel = state.MaxAllowableG * GravityAcc;
            float targetDecel = Math.Min(requiredDecel, maxDecel);

            // 4. 총 소요 제동력 = M * a
            float totalDragForce = state.MassKg * targetDecel;

            // 5. 공기저항 기여분 차감 (C_D=0.08, A=25m^2 가정 간이식)
            float aeroDrag = 0.5f * 1.225f * 0.08f * 25.0f * (state.VelocityX * state.VelocityX);
            float netWireDragForce = Math.Max(0.0f, totalDragForce - aeroDrag);

            // 6. 편측 와이어 장력 T = NetDrag / (2 * sin(theta))
            // 초기 x->0 부근에서 특이점 방지를 위한 sinTheta 하한치 0.05 설정
            float effectiveSinTheta = Math.Max(0.05f, sinTheta);
            float tensionPerSide = netWireDragForce / (2.0f * effectiveSinTheta);

            // 감속도 G 계산
            float actualG = totalDragForce / (state.MassKg * GravityAcc);

            // 에너지 적분
            float displacement = x - _prevPositionX;
            _prevPositionX = x;
            _accumulatedBrakeEnergyJ += totalDragForce * displacement;

            return new ArrestingServoOutput(
                tensionPerSide,
                actualG,
                thetaRad,
                remDist,
                false
            );
        }

        /// 

        /// 멀티 채널 무인 편대 동시 착함 배열에 대한 SIMD 배치 장력 유효성 검사
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchEvaluateTensionSIMD(
            ReadOnlySpan masses,
            ReadOnlySpan velocities,
            ReadOnlySpan sinThetas,
            Span outTensions)
        {
            int i = 0;
            int vectorSize = Vector256.Count;

            var halfVec = Vector256.Create(0.5f);
            var minSinVec = Vector256.Create(0.05f);
            var constAeroVec = Vector256.Create(1.225f);

            for (; i <= masses.Length - vectorSize; i += vectorSize)
            {
                var massVec = Vector256.LoadUnsafe(in masses[i]);
                var velVec = Vector256.LoadUnsafe(in velocities[i]);
                var sinVec = Vector256.LoadUnsafe(in sinThetas[i]);

                // sinTheta 클램핑 (하한 0.05)
                var clampedSin = Vector256.Max(sinVec, minSinVec);

                // 간이 감속 소요 가속도 a = v^2 / 200.0f
                var velSq = Vector256.Multiply(velVec, velVec);
                var aVec = Vector256.Divide(velSq, Vector256.Create(200.0f));

                // F_drag = Mass * a
                var dragVec = Vector256.Multiply(massVec, aVec);

                // T = F_drag / (2 * sinTheta)
                var denom = Vector256.Multiply(Vector256.Create(2.0f), clampedSin);
                var tensionVec = Vector256.Divide(dragVec, denom);

                tensionVec.StoreUnsafe(ref outTensions[i]);
            }

            // 잔여 스칼라 연산 루프
            for (; i < masses.Length; i++)
            {
                float sinTh = Math.Max(0.05f, sinThetas[i]);
                float reqA = (velocities[i] * velocities[i]) / 200.0f;
                float drag = masses[i] * reqA;
                outTensions[i] = drag / (2.0f * sinTh);
            }
        }
    }
}