[단독] AIDT 온디바이스 STEM 방사광 X선 극저온 헬륨 냉각 크롬(Cr) 불공존 스핀밀도파(SDW) 자성 도메인 벽 피에조 피닝 서보 v1.0

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

namespace ZeliDesk.Physics.Nanocryo.Chromium
{
    /// 

    /// 크롬 단결정 방사광 XRMS 계측 데이터
    /// 
    public readonly record struct ChromiumSdwSensorData(
        float PeakIntensityQx,       // Q_x 위성 피크 자성 산란 강도 (cps)
        float PeakIntensityQy,       // Q_y 위성 피크 자성 산란 강도 (cps)
        float PeakIntensityQz,       // Q_z 위성 피크 자성 산란 강도 (cps)
        float IncommensurabilityDelta,// 불공존 파수 델타 (예: 0.048)
        float SampleTempKelvin       // 극저온 헬륨 온도 (K, 4.2K ~ 300K)
    );

    /// 

    /// 피에조 도메인 피닝 제어 출력
    /// 
    public readonly record struct ChromiumSdwServoResult(
        float PiezoStressVoltageV,   // 단일 Qx 도메인 고정을 위한 피에조 전압 (V)
        float QxDomainPurityPercent, // Q_x 도메인 순도 [0 ~ 100%]
        float HarmonicCdwRatio,      // 2Q 고조파 비율
        bool IsSingleDomainPinned    // 단일 Q 도메인 완전 피닝 여부
    );

    /// 

    /// 크롬 불공존 스핀밀도파 도메인 피에조 피닝 서보
    /// 
    public ref struct ChromiumSdwDomainServo
    {
        private const float PurityThreshold = 99.0f; // 99% 이상 시 단일 도메인 고정
        private float _integratedPurityError;
        private float _prevPurity;

        public ChromiumSdwDomainServo(float initialPurity)
        {
            _integratedPurityError = 0.0f;
            _prevPurity = initialPurity;
        }

        /// 

        /// 10kHz 고속 루프: 3개 위성 피크 강도비 기반 피에조 응력 전압 제어
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ChromiumSdwServoResult UpdateServo(in ChromiumSdwSensorData data, float dt)
        {
            // 1. 총 강도 및 Q_x 도메인 순도 산출
            float totalIntensity = data.PeakIntensityQx + data.PeakIntensityQy + data.PeakIntensityQz;
            float safeTotal = Math.Max(1.0f, totalIntensity);
            float purityPct = (data.PeakIntensityQx / safeTotal) * 100.0f;

            // 2. 도메인 순도 오차 미적분 (목표 100%)
            float purityError = 100.0f - purityPct;
            _integratedPurityError += purityError * dt;
            float dPurity = (purityPct - _prevPurity) / Math.Max(1e-6f, dt);
            _prevPurity = purityPct;

            // 3. 피에조 액추에이터 전압 (Kp = 1.5, Ki = 0.2, Kd = 0.05)
            float vOut = (1.5f * purityError + 0.2f * _integratedPurityError - 0.05f * dPurity);
            vOut = Math.Clamp(vOut, 0.0f, 150.0f); // 양의 압축 응력 인가

            // 4. 2차 고조파 결합 비율 추정: 4 * delta^2
            float cdwRatio = 4.0f * (data.IncommensurabilityDelta * data.IncommensurabilityDelta);

            bool isPinned = purityPct >= PurityThreshold;

            return new ChromiumSdwServoResult(
                vOut,
                purityPct,
                cdwRatio,
                isPinned
            );
        }

        /// 

        /// 다채널 브래그 회절 피크 강도 배열에 대한 SIMD 정규화 도메인 분율 연산
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void BatchNormalizeDomainPuritySIMD(
            ReadOnlySpan qxArray,
            ReadOnlySpan qyArray,
            ReadOnlySpan qzArray,
            Span outPurityPcts)
        {
            int i = 0;
            int vectorSize = Vector256.Count;
            var hundredVec = Vector256.Create(100.0f);
            var oneVec = Vector256.Create(1.0f);

            for (; i <= qxArray.Length - vectorSize; i += vectorSize)
            {
                var xVec = Vector256.LoadUnsafe(in qxArray[i]);
                var yVec = Vector256.LoadUnsafe(in qyArray[i]);
                var zVec = Vector256.LoadUnsafe(in qzArray[i]);

                var sumXY = Vector256.Add(xVec, yVec);
                var total = Vector256.Add(sumXY, zVec);
                var safeTot = Vector256.Max(total, oneVec);

                var ratio = Vector256.Divide(xVec, safeTot);
                var pct = Vector256.Multiply(ratio, hundredVec);

                pct.StoreUnsafe(ref outPurityPcts[i]);
            }

            for (; i < qxArray.Length; i++)
            {
                float tot = qxArray[i] + qyArray[i] + qzArray[i];
                float safe = Math.Max(1.0f, tot);
                outPurityPcts[i] = (qxArray[i] / safe) * 100.0f;
            }
        }
    }
}