극초음속 비행체 전자광학 적외선(EO/IR) 사파이어 컨포멀 윈도우 공력가열 시야 차단 방지 냉각 제트 서보 C# SIMD 엔진

3. C# .NET 9.0 초고속 극초음속 광학 윈도우 냉각 서보 엔진 소스 코드

윈도우 32개 영역의 표면 온도 센서와 적외선 배경 노이즈를 100마이크로초(10,000Hz) 이내에 SIMD 연산하여 냉각 가스 분사를 조절하는 무할당 C# 구현입니다.

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

namespace ZeliDesk.Defense.HypersonicOptics
{
    public readonly record struct ConformalWindowThermalState(
        float WindowTemperatureKelvin,
        float SelfEmissionNoiseWattsPerSqm,
        float WavefrontErrorRmsMicrons,
        float CoolingGasMassFlowKgPerSec
    );

    public ref struct HypersonicConformalWindowCoolingServoEngine
    {
        private const float TargetMaxTemperatureKelvin = 550.0f; // Self-emission cutoff
        private const float CriticalTemperatureKelvin = 1100.0f;
        private const float MaxCoolingFlowKgPerSec = 0.85f;

        private const float Kp = 0.0018f;
        private const float Kd = 0.000095f;
        private const float Kq = 0.000045f;

        private readonly int _zoneCount;
        private readonly Span _coolingMassFlows;
        private readonly Span _prevTemperatures;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HypersonicConformalWindowCoolingServoEngine(
            Span coolingMassFlows,
            Span prevTemperatures)
        {
            if (coolingMassFlows.Length != prevTemperatures.Length)
            {
                throw new ArgumentException("Lengths must match.");
            }

            _zoneCount = coolingMassFlows.Length;
            _coolingMassFlows = coolingMassFlows;
            _prevTemperatures = prevTemperatures;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
        public void UpdateCoolingJetsBatch(
            ReadOnlySpan measuredTemperatures,
            ReadOnlySpan aeroHeatFluxes,
            float dtSeconds)
        {
            int i = 0;
            int vectorSize = Vector256.Count;
            float invDt = 1.0f / dtSeconds;

            if (Avx2.IsSupported && _zoneCount >= vectorSize)
            {
                Vector256 vTarget = Vector256.Create(TargetMaxTemperatureKelvin);
                Vector256 vKp = Vector256.Create(Kp);
                Vector256 vKd = Vector256.Create(Kd * invDt);
                Vector256 vKq = Vector256.Create(Kq);
                Vector256 vMaxFlow = Vector256.Create(MaxCoolingFlowKgPerSec);
                Vector256 vZero = Vector256.Zero;

                for (; i <= _zoneCount - vectorSize; i += vectorSize)
                {
                    Vector256 vT = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(measuredTemperatures), (nuint)i);
                    Vector256 vPrevT = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(_prevTemperatures), (nuint)i);
                    Vector256 vQ = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(aeroHeatFluxes), (nuint)i);
                    Vector256 vFlow = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(_coolingMassFlows), (nuint)i);

                    // Temperature error
                    Vector256 vErr = Avx.Subtract(vT, vTarget);
                    Vector256 vDeriv = Avx.Multiply(Avx.Subtract(vT, vPrevT), vKd);
                    Vector256 vFF = Avx.Multiply(vQ, vKq);

                    // delta = Kp * err + Kd * deriv + Kq * q
                    Vector256 vDelta = Avx.Add(Avx.Add(Avx.Multiply(vErr, vKp), vDeriv), vFF);
                    Vector256 vNewFlow = Avx.Min(vMaxFlow, Avx.Max(vZero, Avx.Add(vFlow, vDelta)));

                    vNewFlow.StoreUnsafe(ref MemoryMarshal.GetReference(_coolingMassFlows), (nuint)i);
                    vT.StoreUnsafe(ref MemoryMarshal.GetReference(_prevTemperatures), (nuint)i);
                }
            }

            for (; i < _zoneCount; i++)
            {
                float t = measuredTemperatures[i];
                float prevT = _prevTemperatures[i];
                float q = aeroHeatFluxes[i];

                float err = t - TargetMaxTemperatureKelvin;
                float deriv = (t - prevT) * invDt * Kd;
                float ff = q * Kq;

                float delta = err * Kp + deriv + ff;
                float newFlow = _coolingMassFlows[i] + delta;

                if (newFlow > MaxCoolingFlowKgPerSec) newFlow = MaxCoolingFlowKgPerSec;
                if (newFlow < 0.0f) newFlow = 0.0f;

                _coolingMassFlows[i] = newFlow;
                _prevTemperatures[i] = t;
            }
        }
    }
}