AIDT 온디바이스 국방 MUM-T 안티드론 고출력 극초단파(HPM) 지향성 위상배열 안테나 빔 지향 추적 서보 엔진

using System;
using System.Runtime.CompilerServices;

namespace ZeliDesk.Defense.MumT.CounterUasHpm
{
    /// <summary>
    /// 단일 드론 표적 레이더 좌표
    /// </summary>
    public readonly struct DroneTargetCoordinate
    {
        public readonly double PosXMeters;
        public readonly double PosYMeters;
        public readonly double PosZMeters;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public DroneTargetCoordinate(double x, double y, double z)
        {
            PosXMeters = x;
            PosYMeters = y;
            PosZMeters = z;
        }
    }

    /// <summary>
    /// HPM 빔 지향 및 방사 지령
    /// </summary>
    public readonly ref struct HpmBeamSteeringOutput
    {
        public readonly double AzimuthCommandRad;    // 빔 지향 방위각 [rad]
        public readonly double ElevationCommandRad;  // 빔 지향 고각 [rad]
        public readonly double PeakPowerDensityKwM2; // 표적 도달 전력 밀도 [kW/m^2]
        public readonly bool IsKillThresholdAchieved;// 전자회로 파괴 임계(>10kW/m^2) 달성 플래그

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HpmBeamSteeringOutput(double az, double el, double pDensity, bool killAchieved)
        {
            AzimuthCommandRad = az;
            ElevationCommandRad = el;
            PeakPowerDensityKwM2 = pDensity;
            IsKillThresholdAchieved = killAchieved;
        }
    }

    /// <summary>
    /// 10,000Hz 안티드론 HPM 지향성 위상배열 빔 서보 엔진
    /// </summary>
    public ref struct HpmPhasedArrayBeamServoEngine
    {
        private readonly double _rfFrequencyGhz;
        private readonly double _peakPowerMegaWatts;
        private readonly double _antennaGainDbi;
        private readonly int _elementsM;
        private readonly int _elementsN;

        // 위상 천이기 갱신 버퍼
        private readonly Span<double> _phaseShifterBuffer;

        public HpmPhasedArrayBeamServoEngine(
            double rfFrequencyGhz,
            double peakPowerMegaWatts,
            double antennaGainDbi,
            int elementsM,
            int elementsN,
            Span<double> phaseBuffer)
        {
            _rfFrequencyGhz = rfFrequencyGhz;
            _peakPowerMegaWatts = peakPowerMegaWatts;
            _antennaGainDbi = antennaGainDbi;
            _elementsM = elementsM;
            _elementsN = elementsN;
            _phaseShifterBuffer = phaseBuffer;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HpmBeamSteeringOutput ComputeBeamCycle(
            ReadOnlySpan<DroneTargetCoordinate> swarmTargets)
        {
            if (swarmTargets.IsEmpty)
            {
                return new HpmBeamSteeringOutput(0.0, 0.0, 0.0, false);
            }

            // 1. 군집 드론 기하학적 중심(Centroid) 계산
            double sumX = 0.0;
            double sumY = 0.0;
            double sumZ = 0.0;
            int count = swarmTargets.Length;

            for (int i = 0; i < count; i++)
            {
                sumX += swarmTargets[i].PosXMeters;
                sumY += swarmTargets[i].PosYMeters;
                sumZ += swarmTargets[i].PosZMeters;
            }

            double cX = sumX / count;
            double cY = sumY / count;
            double cZ = sumZ / count;

            double rangeTarget = Math.Sqrt(cX * cX + cY * cY + cZ * cZ);
            rangeTarget = Math.Max(10.0, rangeTarget); // 10m 이상 안전

            // 2. 조준 방위각 및 고각 계산
            double targetAzimuth = Math.Atan2(cY, cX);
            double groundDist = Math.Sqrt(cX * cX + cY * cY);
            double targetElevation = Math.Atan2(cZ, groundDist);

            // 3. 파장 lambda 및 위상차 deltaPhi 계산
            double lambda = 0.299792458 / _rfFrequencyGhz; // 파장 [m]
            double k = (2.0 * Math.PI) / lambda;
            double dx = lambda * 0.5;
            double dy = lambda * 0.5;

            double dPhiX = k * dx * Math.Cos(targetElevation) * Math.Cos(targetAzimuth);
            double dPhiY = k * dy * Math.Cos(targetElevation) * Math.Sin(targetAzimuth);

            // 4. 위상 천이기 어레이 버퍼 갱신
            int idx = 0;
            for (int m = 0; m < _elementsM; m++)
            {
                for (int n = 0; n < _elementsN; n++)
                {
                    double phi = (m * dPhiX + n * dPhiY) % (2.0 * Math.PI);
                    if (idx < _phaseShifterBuffer.Length)
                    {
                        _phaseShifterBuffer[idx++] = phi;
                    }
                }
            }

            // 5. 표적 도달 전력 밀도 계산
            double linGain = Math.Pow(10.0, _antennaGainDbi / 10.0);
            double eirpWatts = (_peakPowerMegaWatts * 1e6) * linGain;
            double powerDensityWattsM2 = eirpWatts / (4.0 * Math.PI * rangeTarget * rangeTarget);
            double powerDensityKwM2 = powerDensityWattsM2 / 1000.0;

            bool isKillAchieved = powerDensityKwM2 >= 10.0; // 10 kW/m^2 파괴 임계

            return new HpmBeamSteeringOutput(
                targetAzimuth,
                targetElevation,
                powerDensityKwM2,
                isKillAchieved);
        }
    }
}