[단독] AIDT 온디바이스 MUM-T 자율 수중 글라이더 중규모 해양 소용돌이(Mesoscale Eddy) 에너지 하베스팅 및 활공 서보 v1.0

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

namespace ZeliDesk.Defense.MUMT.Glider
{
    /// 

    /// 수중 글라이더 센서 및 국소 소용돌이 유속 파라미터
    /// 
    public readonly record struct OceanEddyTelemetry(
        float RelativeAirspeedMps,   // 수중 상대 속도 (m/s, 통상 0.35m/s)
        float DepthM,                // 현재 수심 (m, 0 ~ 1000m)
        float CurrentVelocityNorthMps,// 북향 해류 유속 (m/s)
        float CurrentVelocityEastMps, // 동향 해류 유속 (m/s)
        float VerticalShearDuDz,     // 연직 유속 전단 du/dz (1/s)
        float EstimatedCoreDistanceKm // 추정 에디 중심 거리 (km)
    );

    /// 

    /// 동적 활공 및 부력 제어 명령
    /// 
    public readonly record struct EddyHarvestingCommand(
        float CommandedBankAngleDeg, // 롤 뱅크각 제어 명령 (도, -45도 ~ +45도)
        float BuoyancyEngineCc,      // 부력 피스톤 볼륨 명령 (cc, -350cc ~ +350cc)
        float NetEnergyHarvestRateW, // 추출되는 순 역학적 일률 (Watts)
        bool IsHarvestingActive      // 에너지 하베스팅 활공 상태 여부
    );

    /// 

    /// 온디바이스 MUM-T 해양 소용돌이 에너지 하베스팅 능동 서보
    /// 
    public ref struct MesoscaleEddyHarvestingServo
    {
        private const float GliderMassKg = 55.0f; // 55kg 글라이더
        private float _accumulatedHarvestJoules;
        private float _prevShear;

        public MesoscaleEddyHarvestingServo(float initialJoules)
        {
            _accumulatedHarvestJoules = initialJoules;
            _prevShear = 0.0f;
        }

        /// 

        /// 10Hz 루프: 전단류 구배 기반 롤 뱅크각 및 부력 엔진 위상 정합
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public EddyHarvestingCommand UpdateServo(in OceanEddyTelemetry data, float dt)
        {
            // 1. 유속 벡터 크기 산출
            float currentSpeed = MathF.Sqrt(data.CurrentVelocityNorthMps * data.CurrentVelocityNorthMps + 
                                            data.CurrentVelocityEastMps * data.CurrentVelocityEastMps);

            // 2. 동적 활공 에너지 흡수율 추정: P = m * V_r * (du/dz) * sin(glide_angle)
            // 전단류가 클수록 에너지 흡수 잠재력 극대화
            float harvestPowerW = GliderMassKg * data.RelativeAirspeedMps * MathF.Abs(data.VerticalShearDuDz) * 0.35f;

            // 항력 소모 일률 차감 (약 0.8W 항력 손실 가정)
            float netPowerW = harvestPowerW - 0.8f;

            // 3. 최적 뱅크각 산출: 소용돌이 접선 방향으로 선회 유지
            // Kp = 35.0f
            float bankDeg = 35.0f * (currentSpeed / Math.Max(0.1f, data.RelativeAirspeedMps));
            bankDeg = Math.Clamp(bankDeg, -40.0f, 40.0f);

            // 4. 부력 엔진 피스톤 볼륨 명령: 에너지 흡수 모드에서는 펌핑 횟수 최소화
            float buoyancyCc = (data.DepthM > 800.0f) ? 250.0f : ((data.DepthM < 50.0f) ? -250.0f : 0.0f);

            if (netPowerW > 0.0f)
            {
                _accumulatedHarvestJoules += netPowerW * dt;
            }

            _prevShear = data.VerticalShearDuDz;
            bool isHarvesting = netPowerW > 0.2f && currentSpeed > 0.25f;

            return new EddyHarvestingCommand(
                bankDeg,
                buoyancyCc,
                netPowerW,
                isHarvesting
            );
        }

        /// 

        /// 다중 글라이더 센서 배열에 대한 SIMD 전단 속도 일괄 벡터 연산 커널
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchComputeEddyShearVectorSIMD(
            ReadOnlySpan vUpper,
            ReadOnlySpan vLower,
            float deltaZM,
            Span outShear)
        {
            int i = 0;
            int vectorSize = Vector256.Count;
            var invDzVec = Vector256.Create(1.0f / Math.Max(0.1f, deltaZM));

            for (; i <= vUpper.Length - vectorSize; i += vectorSize)
            {
                var upVec = Vector256.LoadUnsafe(in vUpper[i]);
                var lowVec = Vector256.LoadUnsafe(in vLower[i]);

                var diffVec = Vector256.Subtract(upVec, lowVec);
                var shearVec = Vector256.Multiply(diffVec, invDzVec);

                shearVec.StoreUnsafe(ref outShear[i]);
            }

            for (; i < vUpper.Length; i++)
            {
                outShear[i] = (vUpper[i] - vLower[i]) / deltaZM;
            }
        }
    }
}