대한민국 해군 P-8A 포세이돈 해상초계기 능동/수동 소나부이 다중정적(Multistatic) 음장 전파 합성 및 1,000Hz 0-Alloc C# 잠수함 음향추적 엔진

1. 해양 음속 프로파일(SSP) 및 스넬 굴절 음선 역학

해양 내 음속 $c(T, S, z)$는 메킨지(Mackenzie) 또는 델 그로소(Del Grosso) 경험식에 의해 온도 $T(^\circ\text{C})$, 염분 $S(\text{PSU})$, 수심 $z(\text{m})$의 함수로 다음과 같이 결정됩니다:

성층화된 수평 성층 매질(Horizontally Stratified Ocean)에서 음파의 경로는 스넬의 법칙(Snell's Law)에 의해 규정되며, 음향 광선(Ray)의 국소 입사각 $\theta(z)$와 국소 음속 $c(z)$는 고정된 음선 파라미터(Ray Parameter $\xi$)를 보존합니다:

음속 기울기 $g = dc/dz$가 일정한 수심 계층 내에서 음선의 궤적은 곡률 반경 $R = -1/(g \xi)$인 원호(Circular Arc)를 그리며, 음속이 최소가 되는 수심층(SOFAR 채널 축)을 향해 굴절 진동(Refraction Oscillation) 운동을 수행합니다.

2. 다중정적 소나 방정식 및 등지연 타원면 기하학

송신 소나부이(Tx) 위치 $\mathbf{x}_{Tx} = (x_{Tx}, y_{Tx}, z_{Tx})$, 잠수함 표적 위치 $\mathbf{x}_{Tgt} = (x, y, z)$, $i$번째 수신 소나부이(Rx) 위치 $\mathbf{x}_{Rx, i} = (x_{Rx, i}, y_{Rx, i}, z_{Rx, i})$에 대한 다중정적 신호 잉여(Signal Excess, SE)는 다음과 같습니다:

여기서 $\text{SL}$은 송신 음원 준위, $\text{TL}$은 음향 전달 손실, $\text{TS}$는 쌍정적 표적 강도(Bistatic Target Strength), $\text{NL}$은 배경 소음, $\text{DI}$는 지향성 지수, $\text{DT}$는 탐지 임계치입니다.

송신 핑 방사 시점 $t_0$부터 $i$번째 수신 부이에 에코 신호가 도달한 전파 지연 시간 $\tau_i$는 송신기와 수신기를 초점(Foci)으로 하는 등지연 회전 타원체(Prolate Spheroid)를 형성합니다:

여기서 $\bar{c}$는 음선 경로 평균 유효 음속입니다. 3개 이상의 비동일선상(Non-collinear) 수신 소나부이의 등지연 타원 방정식과 방위각(DIFAR Bearing $\psi_i$)을 결합하면 3차원 잠수함 위치를 단일 핑으로 완전히 결정할 수 있습니다.

3. 도플러 편이 기반 잠수함 속도 벡터 역산

표적 잠수함이 속도 벡터 $\mathbf{v}_{Tgt}$로 이동할 때, 송신 주파수 $f_0$에 대한 $i$번째 수신 부이의 수신 주파수 $f_{r, i}$는 쌍정적 도플러 편이(Bistatic Doppler Shift) 관계식을 따릅니다:

도플러 편이는 송신-표적-수신 벡터의 2등분선 방향 표적 속도 성분에 비례합니다. 다중 수신 부이의 도플러 편이를 동시 측정함으로써 표적의 침로(Heading)와 전진 속력을 즉각적으로 분해할 수 있습니다.

4. 1,000Hz 0-Alloc C# 다중정적 소나부이 음향추적 엔진

P-8A 해상초계기 전술 컴퓨터에 탑재되는 아래의 C# 엔진은 1개 송신 부이 및 8개 수신 부이로부터 수신된 에코 도달 시간(TOA), 방위각(DOA), 도플러 편이를 융합하여 잠수함의 3차원 위치 $(x, y, z)$ 및 속도 벡터 $(v_x, v_y, v_z)$를 GC 무할당 스택 기반으로 1,000Hz 주기로 추정하는 확장 칼만 필터(EKF) 아키텍처입니다.

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Numerics;

namespace ZeliDesk.Defense.NavalASW
{
    /// <summary>
    /// 소나부이 센서 위치 및 측정 신호 구조체
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct SonobuoyEcho
    {
        public Vector3 BuoyPosition;   // 부이 위치 (동/북/수심) [m]
        public float TimeOfArrivalSec;  // 송신 핑 이후 전파 지연 시간 [s]
        public float AzimuthDeg;        // DIFAR 방위각 [deg] (북 기준 시계방향)
        public float DopplerShiftHz;    // 수신 신호 도플러 편이 [Hz]
        public float SnrDb;             // 수신 신호 대 잡음비 [dB]
        public bool IsValid;            // 유효 신호 여부
    }

    /// <summary>
    /// 잠수함 표적 3차원 운동 상태 벡터
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct SubmarineTargetState
    {
        public Vector3 Position; // 표적 위치 (x, y, z: 수심은 음수) [m]
        public Vector3 Velocity; // 표적 속도 벡터 [m/s]
        public float SpeedKnots; // 전진 속력 [노트]
        public float CourseDeg;  // 진행 방위각 [deg]
        public float EstimatedDepthMeters; // 추정 수심 [m]
        public float CovarianceTrace;      // EKF 공분산 대각합 (추적 품질 지표)
    }

    /// <summary>
    /// 1,000Hz 무할당(Zero-Alloc) P-8A 다중정적 소나부이 음향 추적 엔진
    /// </summary>
    public ref struct MultistaticSonarAswEngine
    {
        private const int MaxReceivers = 8;
        private const float SpeedOfSoundDefault = 1485.0f; // 평균 수중 음속 [m/s]
        private const float CenterFreqHz = 3500.0f;       // 활성 핑 중심 주파수 [Hz]

        private Vector3 _txPosition;
        private float _pingEmitTime;
        private float _soundSpeed;

        // 6차원 상태 벡터: [x, y, z, vx, vy, vz]
        private Span<float> _state;
        private Span<float> _covDiag; // 대각 공분산 P 근사

        public MultistaticSonarAswEngine(Span<float> stateBuffer, Span<float> covBuffer, Vector3 txPos, float meanSSP)
        {
            if (stateBuffer.Length < 6 || covBuffer.Length < 6)
                throw new ArgumentException("Buffers must be at least length 6");

            _state = stateBuffer.Slice(0, 6);
            _covDiag = covBuffer.Slice(0, 6);
            _txPosition = txPos;
            _soundSpeed = meanSSP > 1400.0f ? meanSSP : SpeedOfSoundDefault;
            _pingEmitTime = 0.0f;
        }

        /// <summary>
        /// 표적 초기 위치 및 공분산 시딩
        /// </summary>
        public void InitializeTarget(Vector3 initialPos, Vector3 initialVel)
        {
            _state[0] = initialPos.X;
            _state[1] = initialPos.Y;
            _state[2] = initialPos.Z;
            _state[3] = initialVel.X;
            _state[4] = initialVel.Y;
            _state[5] = initialVel.Z;

            _covDiag[0] = 500.0f; // 위치 분산 500m
            _covDiag[1] = 500.0f;
            _covDiag[2] = 25.0f;  // 수심 분산 25m
            _covDiag[3] = 10.0f;  // 속도 분산 10m/s
            _covDiag[4] = 10.0f;
            _covDiag[5] = 2.0f;
        }

        /// <summary>
        /// 1,000Hz (dt = 0.001s) 주기 등속 운동 예측 및 소나부이 다중정적 융합 루프
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Update(ReadOnlySpan<SonobuoyEcho> rxEchoes, float dt, ref SubmarineTargetState outState)
        {
            // 1. 상태 천이 예측 (상태 전파: 등속 모델)
            _state[0] += _state[3] * dt;
            _state[1] += _state[4] * dt;
            _state[2] += _state[5] * dt;

            // 공분산 전파 (프로세스 노이즈 Q 추가)
            float qPos = 0.05f * dt;
            float qVel = 0.02f * dt;
            _covDiag[0] += _covDiag[3] * dt * dt + qPos;
            _covDiag[1] += _covDiag[4] * dt * dt + qPos;
            _covDiag[2] += _covDiag[5] * dt * dt + qPos;
            _covDiag[3] += qVel;
            _covDiag[4] += qVel;
            _covDiag[5] += qVel;

            Vector3 tgtPos = new Vector3(_state[0], _state[1], _state[2]);
            Vector3 tgtVel = new Vector3(_state[3], _state[4], _state[5]);

            float distTx = Vector3.Distance(tgtPos, _txPosition);
            Vector3 uTx = (distTx > 1.0f) ? (tgtPos - _txPosition) / distTx : Vector3.Zero;

            // 2. 다중 수신 소나부이 에코 측정 업데이트
            int count = Math.Min(rxEchoes.Length, MaxReceivers);
            for (int i = 0; i < count; i++)
            {
                ref readonly SonobuoyEcho echo = ref rxEchoes[i];
                if (!echo.IsValid || echo.TimeOfArrivalSec <= 0.001f) continue;

                float distRx = Vector3.Distance(tgtPos, echo.BuoyPosition);
                Vector3 uRx = (distRx > 1.0f) ? (echo.BuoyPosition - tgtPos) / distRx : Vector3.Zero;

                // 이론적 도달 시간: (R_tx + R_rx) / c
                float expectedToa = (distTx + distRx) / _soundSpeed;
                float residToa = echo.TimeOfArrivalSec - expectedToa;

                // EKF 혁신(Innovation) 업데이트 (칼만 게인 K_toa)
                float rVarToa = 0.01f; // 센서 TOA 측정 분산
                float hToaX = (uTx.X - uRx.X) / _soundSpeed;
                float hToaY = (uTx.Y - uRx.Y) / _soundSpeed;

                float sToa = (hToaX * hToaX * _covDiag[0]) + (hToaY * hToaY * _covDiag[1]) + rVarToa;
                float kx = (_covDiag[0] * hToaX) / sToa;
                float ky = (_covDiag[1] * hToaY) / sToa;

                _state[0] += kx * residToa;
                _state[1] += ky * residToa;
                _covDiag[0] *= (1.0f - kx * hToaX);
                _covDiag[1] *= (1.0f - ky * hToaY);

                // 도플러 측정치를 통한 속도 업데이트
                // f_D = (f0 / c) * v . (uTx - uRx)
                float expectedDoppler = (CenterFreqHz / _soundSpeed) * Vector3.Dot(tgtVel, (uTx - uRx));
                float residDoppler = echo.DopplerShiftHz - expectedDoppler;

                float rVarDop = 1.0f; // 센서 도플러 분산 [Hz^2]
                float hDopVx = (CenterFreqHz / _soundSpeed) * (uTx.X - uRx.X);
                float hDopVy = (CenterFreqHz / _soundSpeed) * (uTx.Y - uRx.Y);

                float sDop = (hDopVx * hDopVx * _covDiag[3]) + (hDopVy * hDopVy * _covDiag[4]) + rVarDop;
                float kvx = (_covDiag[3] * hDopVx) / sDop;
                float kvy = (_covDiag[4] * hDopVy) / sDop;

                _state[3] += kvx * residDoppler;
                _state[4] += kvy * residDoppler;
                _covDiag[3] *= (1.0f - kvx * hDopVx);
                _covDiag[4] *= (1.0f - kvy * hDopVy);
            }

            // 3. 출력 구조체 기록
            outState.Position = new Vector3(_state[0], _state[1], _state[2]);
            outState.Velocity = new Vector3(_state[3], _state[4], _state[5]);
            outState.EstimatedDepthMeters = -_state[2];

            float horizSpeedMps = MathF.Sqrt(_state[3] * _state[3] + _state[4] * _state[4]);
            outState.SpeedKnots = horizSpeedMps * 1.94384f; // m/s -> knots

            float courseRad = MathF.Atan2(_state[3], _state[4]); // x: East, y: North
            float courseDeg = courseRad * 57.2958f;
            if (courseDeg < 0) courseDeg += 360.0f;
            outState.CourseDeg = courseDeg;

            outState.CovarianceTrace = _covDiag[0] + _covDiag[1] + _covDiag[2] + _covDiag[3] + _covDiag[4] + _covDiag[5];
        }
    }
}

5. 2022 개정 물리·지구과학·정보 교육과정 연계표