방사광 X선 주사 터널링 현미경(SX-STM) 극저온 단일 원자 스핀 공명 스핀-궤도 상호작용 서보 C# SIMD 엔진

3. C# .NET 9.0 초고속 SX-STM 스핀 공명 피에조 서보 엔진 소스 코드

10마이크로초(100,000Hz) 주기로 X선 광전 노이즈를 분리하고 대수(Logarithmic) 터널링 전류 오차를 계산하여 피에조 구동기에 지령을 내리는 무할당 C# 구현입니다.

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

namespace ZeliDesk.Nanocryo.SxStm
{
    public readonly record struct AtomTunnelingState(
        float TunnelingCurrentPa,
        float XrayPulseIntensity,
        float GapDistancePicometers,
        float PiezoVoltageVolts
    );

    public ref struct SxStmSpinResonanceServoEngine
    {
        private const float SetpointCurrentPa = 120.0f; // 120 pA constant current
        private const float LogSetpoint = 4.78749f; // ln(120)
        private const float DecayConstantPerPm = 0.021f; // 1/pm
        private const float MaxPiezoStepVolts = 0.08f;

        private const float Ki = 0.018f;
        private const float Kd = 0.0009f;

        private readonly Span _piezoVoltages;
        private readonly Span _prevLogErrors;
        private readonly int _tipCount;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public SxStmSpinResonanceServoEngine(
            Span piezoVoltages,
            Span prevLogErrors)
        {
            if (piezoVoltages.Length != prevLogErrors.Length)
            {
                throw new ArgumentException("Buffer lengths must match.");
            }

            _tipCount = piezoVoltages.Length;
            _piezoVoltages = piezoVoltages;
            _prevLogErrors = prevLogErrors;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
        public void ProcessTunnelingBatchAndAdjustGap(
            ReadOnlySpan measuredCurrentsPa,
            ReadOnlySpan xrayBackgroundsPa,
            float dtSeconds)
        {
            int i = 0;
            int vectorSize = Vector256.Count;
            float invDt = 1.0f / dtSeconds;

            if (Avx2.IsSupported && _tipCount >= vectorSize)
            {
                Vector256 vLogSet = Vector256.Create(LogSetpoint);
                Vector256 vKi = Vector256.Create(Ki);
                Vector256 vKd = Vector256.Create(Kd * invDt);
                Vector256 vMaxStep = Vector256.Create(MaxPiezoStepVolts);
                Vector256 vNegMaxStep = Vector256.Create(-MaxPiezoStepVolts);

                for (; i <= _tipCount - vectorSize; i += vectorSize)
                {
                    Vector256 vMeas = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(measuredCurrentsPa), (nuint)i);
                    Vector256 vXray = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(xrayBackgroundsPa), (nuint)i);
                    Vector256 vPrevErr = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(_prevLogErrors), (nuint)i);
                    Vector256 vPz = Vector256.LoadUnsafe(ref MemoryMarshal.GetReference(_piezoVoltages), (nuint)i);

                    // Net tunneling current = Meas - Xray
                    Vector256 vNet = Avx.Subtract(vMeas, vXray);
                    // Fast clamp to avoid log(<= 0)
                    vNet = Avx.Max(vNet, Vector256.Create(1.0f));

                    // Approximation of ln(I) around setpoint: ln(I) ≈ ln(I_0) + (I - I_0)/I_0
                    Vector256 vFrac = Avx.Multiply(Avx.Subtract(vNet, Vector256.Create(SetpointCurrentPa)), Vector256.Create(1.0f / SetpointCurrentPa));
                    Vector256 vLogI = Avx.Add(vLogSet, vFrac);

                    // log_error = log(I) - log(I_set)
                    Vector256 vErr = Avx.Subtract(vLogI, vLogSet);
                    Vector256 vDeriv = Avx.Multiply(Avx.Subtract(vErr, vPrevErr), vKd);

                    Vector256 vStep = Avx.Add(Avx.Multiply(vErr, vKi), vDeriv);
                    vStep = Avx.Min(vMaxStep, Avx.Max(vNegMaxStep, vStep));

                    Vector256 vNewPz = Avx.Add(vPz, vStep);
                    vNewPz.StoreUnsafe(ref MemoryMarshal.GetReference(_piezoVoltages), (nuint)i);
                    vErr.StoreUnsafe(ref MemoryMarshal.GetReference(_prevLogErrors), (nuint)i);
                }
            }

            for (; i < _tipCount; i++)
            {
                float net = measuredCurrentsPa[i] - xrayBackgroundsPa[i];
                if (net < 1.0f) net = 1.0f;

                float logI = MathF.Log(net);
                float err = logI - LogSetpoint;
                float deriv = (err - _prevLogErrors[i]) * invDt * Kd;

                float step = err * Ki + deriv;
                if (step > MaxPiezoStepVolts) step = MaxPiezoStepVolts;
                if (step < -MaxPiezoStepVolts) step = -MaxPiezoStepVolts;

                _piezoVoltages[i] += step;
                _prevLogErrors[i] = err;
            }
        }
    }
}