6세대 극초음속 폭격기 공탄성 가변 날개 마하 6 천음속/초음속 플러터 억제 압전 제트 플랩 서보 C# SIMD 엔진

3. C# .NET 9.0 초고속 공탄성 플러터 억제 서보 엔진 소스 코드

날개 32개 스팬 스테이션의 굽힘 가속도 및 비틀림 각속도 센서 데이터를 40마이크로초(25,000Hz) 이내에 처리하여 압전 제트 플랩을 구동하는 C# AVX2 SIMD 구현입니다.

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

namespace ZeliDesk.Defense.HypersonicAeroelasticity
{
    public readonly record struct WingStationTelemetry(
        float BendingAccelerationMps2,
        float TorsionAngularVelocityRps,
        float DynamicPressureKpa,
        float SynthesizedJetMomentumFraction
    );

    public ref struct HypersonicFlutterSuppressorServoEngine
    {
        private const float FlutterCriticalThresholdRps = 18.5f; // Torsion divergence alert
        private const float MaxJetCommandVoltage = 250.0f; // High-voltage PZT drive

        private const float Kb = 0.45f;
        private const float Kt = 12.8f;
        private const float Kpiston = 0.0035f;

        private readonly int _stationCount;
        private readonly Span _jetCommandVoltages;
        private readonly Span _filteredTorsionRates;

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

            _stationCount = jetCommandVoltages.Length;
            _jetCommandVoltages = jetCommandVoltages;
            _filteredTorsionRates = filteredTorsionRates;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
        public void ComputeActiveSuppressionBatch(
            ReadOnlySpan bendingAccelerations,
            ReadOnlySpan torsionRates,
            ReadOnlySpan localDynamicPressures)
        {
            int i = 0;
            int vectorSize = Vector256.Count;

            if (Avx2.IsSupported && _stationCount >= vectorSize)
            {
                Vector256 vKb = Vector256.Create(Kb);
                Vector256 vKt = Vector256.Create(Kt);
                Vector256 vKpiston = Vector256.Create(Kpiston);
                Vector256 vMaxVolt = Vector256.Create(MaxJetCommandVoltage);
                Vector256 vNegMaxVolt = Vector256.Create(-MaxJetCommandVoltage);
                Vector256 vAlpha = Vector256.Create(0.85f); // Low-pass smoothing
                Vector256 vOneMinusAlpha = Vector256.Create(0.15f);

                for (; i <= _stationCount - vectorSize; i += vectorSize)
                {
                    Vector256 vBending = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(bendingAccelerations), (nuint)i);
                    Vector256 vTorsion = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(torsionRates), (nuint)i);
                    Vector256 vQ = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(localDynamicPressures), (nuint)i);
                    Vector256 vPrevT = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(_filteredTorsionRates), (nuint)i);

                    // Exponential moving average filter on torsion rate
                    Vector256 vSmoothT = Avx.Add(Avx.Multiply(vTorsion, vOneMinusAlpha), Avx.Multiply(vPrevT, vAlpha));

                    // Control law: V_jet = -(Kb * bending_acc + Kt * torsion_rate * (1 + Kpiston * Q))
                    Vector256 vQScale = Avx.Add(Vector256.Create(1.0f), Avx.Multiply(vQ, vKpiston));
                    Vector256 vTorsionTerm = Avx.Multiply(Avx.Multiply(vSmoothT, vKt), vQScale);
                    Vector256 vBendingTerm = Avx.Multiply(vBending, vKb);

                    Vector256 vCmd = Avx.Subtract(Vector256.Zero, Avx.Add(vBendingTerm, vTorsionTerm));

                    // Clamp to [-MaxVolt, MaxVolt]
                    vCmd = Avx.Min(vMaxVolt, Avx.Max(vNegMaxVolt, vCmd));

                    vCmd.StoreUnsafe(ref MemoryMarshal.GetReference(_jetCommandVoltages), (nuint)i);
                    vSmoothT.StoreUnsafe(ref MemoryMarshal.GetReference(_filteredTorsionRates), (nuint)i);
                }
            }

            for (; i < _stationCount; i++)
            {
                float bending = bendingAccelerations[i];
                float torsion = torsionRates[i];
                float q = localDynamicPressures[i];
                float prevT = _filteredTorsionRates[i];

                float smoothT = 0.15f * torsion + 0.85f * prevT;
                float cmd = -(Kb * bending + Kt * smoothT * (1.0f + Kpiston * q));

                if (cmd > MaxJetCommandVoltage) cmd = MaxJetCommandVoltage;
                if (cmd < -MaxJetCommandVoltage) cmd = -MaxJetCommandVoltage;

                _jetCommandVoltages[i] = cmd;
                _filteredTorsionRates[i] = smoothT;
            }
        }
    }
}