극저온 방사광 X-선 나노회절 기반 보스-아인슈타인 응축체(BEC, 87Rb) 양자 소용돌이 격자(Vortex Lattice) 광학 핀 포텐셜 능동 서보 아키텍처 (.NET 9 C# SIMD)

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

namespace ZeliDesk.Quantum.BoseEinsteinCondensate
{
    /// <summary>
    /// 보스-아인슈타인 응축체(BEC) 양자 소용돌이 격자 광학 핀 포텐셜 서보
    /// GC 무할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct BecVortexLatticeServo
    {
        private readonly ReadOnlySpan<float> _measuredX;       // 실측 소용돌이 X 좌표 (um)
        private readonly ReadOnlySpan<float> _measuredY;       // 실측 소용돌이 Y 좌표 (um)
        private readonly ReadOnlySpan<float> _gridReferenceX;  // 이상 격자 기준점 X (um)
        private readonly ReadOnlySpan<float> _gridReferenceY;  // 이상 격자 기준점 Y (um)
        private readonly Span<float> _positionErrors;          // 합성 위치 편차 (um)
        private readonly Span<float> _pinningLaserPowers;      // 광학 핀 레이저 파워 (mW)

        private readonly float _trapFrequency;  // 트랩 회전 각속도 Omega
        private readonly float _servoGain;      // 핀 레이저 파워 게인 (mW/um)
        private readonly float _maxPower;       // 최대 핀 레이저 파워 (mW)

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public BecVortexLatticeServo(
            ReadOnlySpan<float> measuredX,
            ReadOnlySpan<float> measuredY,
            ReadOnlySpan<float> gridReferenceX,
            ReadOnlySpan<float> gridReferenceY,
            Span<float> positionErrors,
            Span<float> pinningLaserPowers,
            float trapFrequency = 120.0f,
            float servoGain = 15.0f,
            float maxPower = 50.0f)
        {
            _measuredX = measuredX;
            _measuredY = measuredY;
            _gridReferenceX = gridReferenceX;
            _gridReferenceY = gridReferenceY;
            _positionErrors = positionErrors;
            _pinningLaserPowers = pinningLaserPowers;
            _trapFrequency = trapFrequency;
            _servoGain = servoGain;
            _maxPower = maxPower;
        }

        /// <summary>
        /// 8개 양자 소용돌이 코어의 이탈 오차를 SIMD 병렬 분석하여 광학 핀 파워 연산
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteVortexPinningLoop()
        {
            int length = _measuredX.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vGain = Vector256.Create(_servoGain);
            Vector256<float> vMaxP = Vector256.Create(_maxPower);
            Vector256<float> vBaseP = Vector256.Create(10.0f);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vMx = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_measuredX.Slice(i, 8))[0]);
                    Vector256<float> vMy = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_measuredY.Slice(i, 8))[0]);
                    Vector256<float> vRx = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_gridReferenceX.Slice(i, 8))[0]);
                    Vector256<float> vRy = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_gridReferenceY.Slice(i, 8))[0]);

                    // 편차: Dx = Mx - Rx, Dy = My - Ry
                    Vector256<float> vDx = Avx.Subtract(vMx, vRx);
                    Vector256<float> vDy = Avx.Subtract(vMy, vRy);

                    // 유클리드 오차 Dist = sqrt(Dx^2 + Dy^2)
                    Vector256<float> vDistSq = Avx.Add(Avx.Multiply(vDx, vDx), Avx.Multiply(vDy, vDy));
                    Vector256<float> vDist = Avx.Sqrt(vDistSq);

                    // 핀 레이저 파워 = BaseP + Gain * Dist
                    Vector256<float> vPwr = Avx.Add(vBaseP, Avx.Multiply(vGain, vDist));
                    Vector256<float> vClampedPwr = Avx.Min(vMaxP, vPwr);

                    vDist.CopyTo(_positionErrors.Slice(i, 8));
                    vClampedPwr.CopyTo(_pinningLaserPowers.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float dx = _measuredX[i] - _gridReferenceX[i];
                float dy = _measuredY[i] - _gridReferenceY[i];
                float dist = MathF.Sqrt((dx * dx) + (dy * dy));
                float pwr = Math.Min(_maxPower, 10.0f + (_servoGain * dist));

                _positionErrors[i] = dist;
                _pinningLaserPowers[i] = pwr;
            }
        }
    }
}