제임스 웹 우주망원경(JWST) 파면 감지(Wavefront Sensing) & 1,000Hz 0-Alloc C# 18개 주경 피코미터 위상 정렬 서보 제어기

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

namespace ZeliDesk.Defense.AstroOptics
{
    /// <summary>
    /// 단일 거울 세그먼트 파면 수차 및 변위 센서 프레임
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 8)]
    public readonly struct MirrorSegmentSensorFrame
    {
        public readonly double TimestampSeconds;
        public readonly int SegmentId;             // 세그먼트 ID (1 ~ 18)
        public readonly double PistonErrorNm;      // 피스톤 단차 오차 (nm)
        public readonly double TipErrorUrad;       // Tip 각도 오차 (urad)
        public readonly double TiltErrorUrad;      // Tilt 각도 오차 (urad)
        public readonly double RocErrorNm;         // 곡률 반경 오차 (nm)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public MirrorSegmentSensorFrame(double timestamp, int id, double piston, double tip, double tilt, double roc)
        {
            TimestampSeconds = timestamp;
            SegmentId = id;
            PistonErrorNm = piston;
            TipErrorUrad = tip;
            TiltErrorUrad = tilt;
            RocErrorNm = roc;
        }
    }

    /// <summary>
    /// 헥사포드 6축 액추에이터 스텝 지령 출력
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 8)]
    public readonly struct MirrorActuatorCommandOutput
    {
        public readonly int SegmentId;
        public readonly double DeltaPistonNm;       // 보정 피스톤 변위 (nm)
        public readonly double DeltaTipUrad;        // 보정 Tip 각도 (urad)
        public readonly double DeltaTiltUrad;       // 보정 Tilt 각도 (urad)
        public readonly double RmsWavefrontErrorNm; // 잔여 RMS 파면 오차 (nm)
        public readonly bool IsDiffractionLimited;  // 회절 한계 달성 플래그 (RMS < 150nm)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public MirrorActuatorCommandOutput(int id, double dPiston, double dTip, double dTilt, double rms, bool isDiffLimited)
        {
            SegmentId = id;
            DeltaPistonNm = dPiston;
            DeltaTipUrad = dTip;
            DeltaTiltUrad = dTilt;
            RmsWavefrontErrorNm = rms;
            IsDiffractionLimited = isDiffLimited;
        }
    }

    /// <summary>
    /// 1,000Hz 0-Alloc C# JWST 주경 파면 감지 및 피코미터 정렬 서보 엔진
    /// </summary>
    public ref struct JwstWavefrontServoEngine
    {
        private const double TargetMaxRmsWfeNm = 150.0; // 회절 한계 기준 150nm
        private const double ActuatorStepResolutionNm = 7.5; // 액추에이터 최소 스텝 7.5nm

        private double _accumulatedPiston;
        private double _accumulatedTip;
        private double _accumulatedTilt;
        private double _lastTimestamp;
        private bool _isInitialized;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Initialize()
        {
            _accumulatedPiston = 0.0;
            _accumulatedTip = 0.0;
            _accumulatedTilt = 0.0;
            _lastTimestamp = 0.0;
            _isInitialized = true;
        }

        /// <summary>
        /// 1,000Hz(1ms 주기) 단일 세그먼트 센서 입력 기반 액추에이터 미세 스텝 틱
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public MirrorActuatorCommandOutput ProcessTick(in MirrorSegmentSensorFrame frame)
        {
            if (!_isInitialized)
            {
                Initialize();
            }

            double dt = frame.TimestampSeconds - _lastTimestamp;
            if (dt <= 0.0 || dt > 0.01) dt = 0.001; // 1ms 기본 주기
            _lastTimestamp = frame.TimestampSeconds;

            // 1. RMS 합성 파면 오차(WFE) 산출
            double rmsWfe = Math.Sqrt(frame.PistonErrorNm * frame.PistonErrorNm +
                                      frame.TipErrorUrad * frame.TipErrorUrad * 100.0 +
                                      frame.TiltErrorUrad * frame.TiltErrorUrad * 100.0 +
                                      frame.RocErrorNm * frame.RocErrorNm);

            // 2. 피스톤, 팁, 틸트 PI 제어량 산출
            _accumulatedPiston += frame.PistonErrorNm * dt;
            _accumulatedTip += frame.TipErrorUrad * dt;
            _accumulatedTilt += frame.TiltErrorUrad * dt;

            _accumulatedPiston = Math.Clamp(_accumulatedPiston, -50.0, 50.0);
            _accumulatedTip = Math.Clamp(_accumulatedTip, -5.0, 5.0);
            _accumulatedTilt = Math.Clamp(_accumulatedTilt, -5.0, 5.0);

            // 게인 적용
            double cmdPiston = -(0.65 * frame.PistonErrorNm + 0.12 * _accumulatedPiston);
            double cmdTip = -(0.55 * frame.TipErrorUrad + 0.08 * _accumulatedTip);
            double cmdTilt = -(0.55 * frame.TiltErrorUrad + 0.08 * _accumulatedTilt);

            // 기계적 액추에이터 최소 스텝 양자화 (7.5nm 단위)
            cmdPiston = Math.Round(cmdPiston / ActuatorStepResolutionNm) * ActuatorStepResolutionNm;

            // 3. 회절 한계 기준 판정
            bool isDiffractionLimited = rmsWfe < TargetMaxRmsWfeNm;

            return new MirrorActuatorCommandOutput(
                id: frame.SegmentId,
                dPiston: cmdPiston,
                dTip: cmdTip,
                dTilt: cmdTilt,
                rms: rmsWfe,
                isDiffLimited: isDiffractionLimited
            );
        }
    }
}