초·중·고 정보 과학(양자 암호·단일 광자 검출·비트 오류율)·물리(대기 요동·광자 편광 보존·회절 한계) 교육과 국방 기무/우주사령부 및 방위사업청 초소형 위성군 저궤도(LEO)-지상국 간 양자 키 분배(Satellite-to-Ground QKD) 및 자유 공간 양자 통신(FSQC): ZeliDesk의 온디바이스 순수 C# 실시간 대기 난류 유도 광자 편광 회전(Polarization Rotation) 수치 보정, 0-Alloc SIMD 가속 나노라디안(nrad)급 고속 조향 거울(FSM) 능동 빔 지향-획득-추적(PAT) 및 단일 광자 눈사태 다이오드(SPAD) 펄스 지터 동기화 엔진 아키텍처

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

namespace ZeliDesk.Core.QuantumSpace
{
    /// <summary>
    /// 단일 광자 수신 이벤트 타임스탬프 (8바이트 압축 구조체)
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 8, Size = 8)]
    public readonly struct PhotonArrivalEvent
    {
        public readonly ulong PicosecondTimestamp; // 50ps 단위 절대 시각
        public byte DetectionChannel;             // 0: H, 1: V, 2: D, 3: A
        public byte QualityFlag;

        public PhotonArrivalEvent(ulong timestamp, byte channel)
        {
            PicosecondTimestamp = timestamp;
            DetectionChannel = channel;
            QualityFlag = 0;
        }
    }

    /// <summary>
    /// 5,000Hz PZT 고속 조향 거울(FSM) 능동 빔 지향-추적(PAT) 제어기
    /// 나노라디안(nrad)급 광축 안정화 엔진
    /// </summary>
    public sealed class FastSteeringMirrorController
    {
        private float _fsmX, _fsmY; // FSM 각도 (nrad)
        private float _errIntX, _errIntY;
        private readonly float _kp, _ki, _kd;
        private float _prevErrX, _prevErrY;

        public FastSteeringMirrorController(float kp = 0.85f, float ki = 0.15f, float kd = 0.05f)
        {
            _kp = kp; _ki = ki; _kd = kd;
            _fsmX = 0.0f; _fsmY = 0.0f;
            _errIntX = 0.0f; _errIntY = 0.0f;
            _prevErrX = 0.0f; _prevErrY = 0.0f;
        }

        /// <summary>
        /// 4분할 포토다이오드(QPD) 신호로부터 나노라디안 오차 보정 사령 산출 (0-Alloc 루프)
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void UpdateTrackingLoop(float qpdA, float qpdB, float qpdC, float qpdD, float dtSeconds, out float outPztVoltageX, out float outPztVoltageY)
        {
            float total = qpdA + qpdB + qpdC + qpdD + 1e-6f;
            // 수평 및 수직 오차 정규화 (-1.0 ~ +1.0)
            float normErrX = ((qpdA + qpdD) - (qpdB + qpdC)) / total;
            float normErrY = ((qpdA + qpdB) - (qpdC + qpdD)) / total;

            // 라디안 변환 (검출기 FOV 500 urad 기준)
            float errRadX = normErrX * 250.0e-6f;
            float errRadY = normErrY * 250.0e-6f;

            // PID 수치 적분
            _errIntX += errRadX * dtSeconds;
            _errIntY += errRadY * dtSeconds;
            float derivX = (errRadX - _prevErrX) / dtSeconds;
            float derivY = (errRadY - _prevErrY) / dtSeconds;
            _prevErrX = errRadX;
            _prevErrY = errRadY;

            float cmdX = _kp * errRadX + _ki * _errIntX + _kd * derivX;
            float cmdY = _kp * errRadY + _ki * _errIntY + _kd * derivY;

            _fsmX += cmdX;
            _fsmY += cmdY;

            // 피에조 전압 출력 변환 (0~100V -> -50~+50 urad)
            outPztVoltageX = Math.Clamp(50.0f + (_fsmX * 1e6f), 0.0f, 100.0f);
            outPztVoltageY = Math.Clamp(50.0f + (_fsmY * 1e6f), 0.0f, 100.0f);
        }
    }

    /// <summary>
    /// 0-Alloc SIMD 기반 단일 광자 이벤트 시프팅(Sifting) 및 QBER 실시간 평가기
    /// </summary>
    public sealed class QuantumSiftingEngine
    {
        private const int MaxBatchSize = 1024;
        private readonly PhotonArrivalEvent[] _aliceEvents;
        private readonly PhotonArrivalEvent[] _bobEvents;

        public QuantumSiftingEngine()
        {
            _aliceEvents = new PhotonArrivalEvent[MaxBatchSize];
            _bobEvents = new PhotonArrivalEvent[MaxBatchSize];
        }

        /// <summary>
        /// 동기화된 시간 게이트 윈도우(dtGate = 500ps) 내 일치 검출 광자 Sifting
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public float SiftAndCalculateQber(ReadOnlySpan<PhotonArrivalEvent> alice, ReadOnlySpan<PhotonArrivalEvent> bob, ulong dtGatePs, out int siftedCount)
        {
            int errorBits = 0;
            siftedCount = 0;

            int bIdx = 0;
            for (int a = 0; a < alice.Length; a++)
            {
                ulong aTime = alice[a].PicosecondTimestamp;

                while (bIdx < bob.Length && bob[bIdx].PicosecondTimestamp + dtGatePs < aTime)
                {
                    bIdx++;
                }

                if (bIdx < bob.Length)
                {
                    long timeDiff = (long)(bob[bIdx].PicosecondTimestamp - aTime);
                    if (Math.Abs(timeDiff) <= (long)dtGatePs)
                    {
                        byte aChan = alice[a].DetectionChannel;
                        byte bChan = bob[bIdx].DetectionChannel;

                        // 동일 기저(Basis)에서 송수신된 경우 Sifting
                        bool sameBasis = (aChan / 2) == (bChan / 2);
                        if (sameBasis)
                        {
                            siftedCount++;
                            if (aChan != bChan)
                            {
                                errorBits++; // 비트 반전 오류
                            }
                        }
                    }
                }
            }

            if (siftedCount == 0) return 0.0f;
            return (float)errorBits / siftedCount * 100.0f; // QBER (%)
        }
    }
}