[단독] AIDT 온디바이스 STEM 방사광 X선 극저온 헬륨 냉각 루테늄산 스트론튬(Sr2RuO4) 스핀 삼중항 초전도 단축 피에조 변형 서보 v1.0

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

namespace ZeliDesk.Physics.Nanocryo.Sr2RuO4
{
    /// 

    /// 극저온 단축 변형 셀 계측 센서 파라미터
    /// 
    public readonly record struct UniaxialStrainSensorData(
        float MeasuredStrainPercent,   // 커패시턴스 게이지 측정 변형률 (예: -0.58%)
        float TargetStrainPercent,     // 목표 반 호브 특이점 변형률 (예: -0.60%)
        float CriticalTempTcKelvin,    // 계측된 순간 초전도 전이온도 (K)
        float CapacitanceBridgePicoF,  // 브리지 정전용량 (pF)
        float CryoTempKelvin           // 극저온 헬륨 온도 (K, 0.3K ~ 4.2K)
    );

    /// 

    /// 피에조 스택 액추에이터 제어 명령
    /// 
    public readonly record struct PiezoStrainServoCommand(
        float PiezoVoltageV,           // 피에조 스택 구동 전압 (V, -150V ~ +150V)
        float StrainErrorPercent,      // 변형률 오차율 (%)
        float EstimatedDosState,       // 페르미 준위 상태밀도 N(Ef) 추정치 (상대값)
        bool IsAtVanHoveSingularity    // 반 호브 특이점 락온 여부
    );

    /// 

    /// 루테늄산 스트론튬 스핀 삼중항 초전도 단축 피에조 서보
    /// 
    public ref struct Sr2RuO4UniaxialStrainServo
    {
        private const float MaxVoltageLimit = 150.0f;
        private float _integratedStrainError;
        private float _prevStrainPercent;

        public Sr2RuO4UniaxialStrainServo(float initialStrain)
        {
            _integratedStrainError = 0.0f;
            _prevStrainPercent = initialStrain;
        }

        /// 

        /// 1kHz 고속 루프: 정밀 변형률 PID 및 반 호브 상태밀도 최대화 제어
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public PiezoStrainServoCommand UpdateStrainServo(in UniaxialStrainSensorData data, float dt)
        {
            // 1. 변형률 오차 연산
            float error = data.MeasuredStrainPercent - data.TargetStrainPercent;
            _integratedStrainError += error * dt;
            float dError = (data.MeasuredStrainPercent - _prevStrainPercent) / Math.Max(1e-6f, dt);
            _prevStrainPercent = data.MeasuredStrainPercent;

            // 2. 피에조 액추에이터 감도 (1% 변형당 약 200V)
            // PID 계수: Kp = 250.0f, Ki = 40.0f, Kd = 8.0f
            float vOut = -(250.0f * error + 40.0f * _integratedStrainError + 8.0f * dError);

            // 전압 리미터 클램핑 [-150V, +150V]
            vOut = Math.Clamp(vOut, -MaxVoltageLimit, MaxVoltageLimit);

            // 3. 반 호브 특이점 상태밀도 N(E_f) 대수 모델: N = ln(1.0 / (|strain - target| + 0.005))
            float distFromVhs = MathF.Abs(data.MeasuredStrainPercent - data.TargetStrainPercent);
            float estimatedDos = MathF.Log(1.0f / (distFromVhs + 0.005f));

            // 락온 판정: 변형률 오차 0.005% 이내, 전이온도 3.2K 초과
            bool isLocked = (distFromVhs < 0.005f) && (data.CriticalTempTcKelvin > 3.2f);

            return new PiezoStrainServoCommand(
                vOut,
                error,
                estimatedDos,
                isLocked
            );
        }

        /// 

        /// 다채널 변형 셀 배열에 대한 페르미 상태밀도 SIMD 일괄 벡터 산출 커널
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchComputeDensityOfStatesSIMD(
            ReadOnlySpan strains,
            float targetVhsStrain,
            Span outDos)
        {
            int i = 0;
            int vectorSize = Vector256.Count;
            var targetVec = Vector256.Create(targetVhsStrain);
            var epsVec = Vector256.Create(0.005f);
            var oneVec = Vector256.Create(1.0f);

            for (; i <= strains.Length - vectorSize; i += vectorSize)
            {
                var sVec = Vector256.LoadUnsafe(in strains[i]);
                var diffVec = Vector256.Subtract(sVec, targetVec);
                var absDiff = Vector256.Abs(diffVec);
                var denom = Vector256.Add(absDiff, epsVec);

                // AVX-512 간이 근사 (1 / denom)
                var invDenom = Vector256.Divide(oneVec, denom);

                // Store and compute log scalar fallback for element
                invDenom.StoreUnsafe(ref outDos[i]);
                for (int k = 0; k < vectorSize; k++)
                {
                    outDos[i + k] = MathF.Log(outDos[i + k]);
                }
            }

            for (; i < strains.Length; i++)
            {
                float d = MathF.Abs(strains[i] - targetVhsStrain);
                outDos[i] = MathF.Log(1.0f / (d + 0.005f));
            }
        }
    }
}