전투기 지향성 적외선 방해장비(DIRCM) 2색(Dual-Color) 적외선 미사일 탐색기 요란 레이저 지향 추적 서보 C# SIMD 엔진

3. Zero-Allocation C# .NET 9.0 AVX-512 SIMD DIRCM 초고속 지향 서보

25,000Hz 주기로 전투기 기동 지터(Jitter)를 관성 센서로 측정하여 2축 보이스코일 모터 미러를 피드포워드 상쇄하는 실시간 서보 엔진입니다.

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

namespace ZeliDesk.Defense.Dircm
{
    public readonly record struct MissileTrackingTelemetry(
        float LosErrorAzimuthMicroRad,
        float LosErrorElevationMicroRad,
        float AircraftRollRateRadPerSec,
        float AircraftPitchRateRadPerSec,
        float TargetRangeMeters
    );

    public readonly record struct DircmServoCommand(
        float VoiceCoilCurrentAzAmps,
        float VoiceCoilCurrentElAmps,
        float LaserOutputPowerWatts,
        bool LaserOnTargetLocked
    );

    public ref struct FighterLaserDircmServo
    {
        private const float MAX_CURRENT_A = 4.5f;
        private const float TORQUE_CONSTANT_N_PER_A = 0.85f;
        private const float MIRROR_INERTIA = 1.2e-4f; // kg * m^2
        private const float LOCK_THRESHOLD_URAD = 120.0f; // 120 urad 이내 시 타격 록인

        private readonly float _kp;
        private readonly float _kd;
        private readonly float _kff;

        private float _prevAzErr;
        private float _prevElErr;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public FighterLaserDircmServo(float kp, float kd, float kff)
        {
            _kp = kp;
            _kd = kd;
            _kff = kff;
            _prevAzErr = 0.0f;
            _prevElErr = 0.0f;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public DircmServoCommand StepServo(ref readonly MissileTrackingTelemetry telem, float dt)
        {
            // 1. LOS 오차 미분 연산
            float dAz = (telem.LosErrorAzimuthMicroRad - _prevAzErr) / dt;
            _prevAzErr = telem.LosErrorAzimuthMicroRad;

            float dEl = (telem.LosErrorElevationMicroRad - _prevElErr) / dt;
            _prevElErr = telem.LosErrorElevationMicroRad;

            // 2. 항공기 급기동 지터 피드포워드 상쇄 토크
            float ffTorqueAz = _kff * telem.AircraftRollRateRadPerSec * MIRROR_INERTIA * 1e6f;
            float ffTorqueEl = _kff * telem.AircraftPitchRateRadPerSec * MIRROR_INERTIA * 1e6f;

            // 3. PD 피드백 + 피드포워드 보이스코일 전류 지령
            float cmdAzUr = (_kp * telem.LosErrorAzimuthMicroRad + _kd * dAz) + ffTorqueAz;
            float cmdElUr = (_kp * telem.LosErrorElevationMicroRad + _kd * dEl) + ffTorqueEl;

            float currentAz = Math.Clamp(cmdAzUr * 1e-6f / TORQUE_CONSTANT_N_PER_A, -MAX_CURRENT_A, MAX_CURRENT_A);
            float currentEl = Math.Clamp(cmdElUr * 1e-6f / TORQUE_CONSTANT_N_PER_A, -MAX_CURRENT_A, MAX_CURRENT_A);

            // 4. 레이저 방사 판정
            float totalErrorUr = MathF.Sqrt(telem.LosErrorAzimuthMicroRad * telem.LosErrorAzimuthMicroRad +
                                            telem.LosErrorElevationMicroRad * telem.LosErrorElevationMicroRad);
            bool locked = totalErrorUr < LOCK_THRESHOLD_URAD;
            float laserWatts = locked ? 5.5f : 1.0f; // 조준 완료 시 최대 5.5W 중적외선 펄스 방사

            return new DircmServoCommand(currentAz, currentEl, laserWatts, locked);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchComputeLosErrorsSimd(ReadOnlySpan azErrors, ReadOnlySpan elErrors, Span outTotalErrors)
        {
            int i = 0;
            for (; i <= azErrors.Length - 8; i += 8)
            {
                var vAz = Vector256.LoadUnsafe(in azErrors[i]);
                var vEl = Vector256.LoadUnsafe(in elErrors[i]);
                var vAzSq = Vector256.Multiply(vAz, vAz);
                var vElSq = Vector256.Multiply(vEl, vEl);
                var vSum = Vector256.Add(vAzSq, vElSq);
                var vSqrt = Vector256.Sqrt(vSum);
                vSqrt.StoreUnsafe(ref outTotalErrors[i]);
            }
            for (; i < azErrors.Length; i++)
            {
                outTotalErrors[i] = MathF.Sqrt(azErrors[i] * azErrors[i] + elErrors[i] * elErrors[i]);
            }
        }
    }
}