HeatBuf.cs

using System;
using System.Collections.Generic;
using System.Linq;
using FLY.FeedbackRenZiJia.Common;
using FLY.Thick.RemoteHistory;
using Misc;
using System.IO;
using System.Text;
using System.ComponentModel;
using FLY.FeedbackRenZiJia.IService;
using FObjBase;

namespace FLY.FeedbackRenZiJia.Server
{
    /// <summary>
    /// 存放一堆厚度与加热数据。
    /// 1.用于判断加热是否稳定了；
    /// 2.加热偏移；
    /// 3.加热/厚度
    /// </summary>
    public class HeatBuf: IHeatBuf, Misc.ISaveToXml
    {

        #region 属性，对外接口
        #region 参数


        private List<int> heatEffectCurve = new List<int>();
        /// <summary>
        /// 加热生效曲线,允许为空，则不生效
        /// </summary>
        public List<int> HeatEffectCurve
        {
            get{
                return heatEffectCurve;
            }
            set {
                heatEffectCurve = value;
                NotifyPropertyChanged("HeatEffectCurve");
            }
        }

        private int stablerange = 2;
        /// <summary>
        /// 厚度稳定范围 %， 偏差在范围内，都是稳定的 
        /// </summary>
        public int StableRange
        {
            get { return stablerange; }
            set {
                if (stablerange != value)
                {
                    stablerange = value;
                    NotifyPropertyChanged("StableRange");
                }
            }
        }

        private int stablerange0 = 2;
        /// <summary>
        /// 厚度稳定范围 %， 加热量变化为0时，偏差在范围内，都是稳定的 
        /// </summary>
        public int StableRange0
        {
            get { return stablerange0; }
            set
            {
                if (stablerange0 != value)
                {
                    stablerange0 = value;
                    NotifyPropertyChanged("StableRange0");
                }
            }
        }

        private double thresholdR = 0.7;
        /// <summary>
        /// 对位模式, 加热与厚度相关性阀值, 相关性 >=0.7
        /// </summary>
        public double ThresholdR
        {
            get { return thresholdR; }
            set {
                if (thresholdR != value)
                {
                    thresholdR = value;
                    NotifyPropertyChanged("ThresholdR");
                }
            }
        }

        private int thresholdMaxMin = 8;
        /// <summary>
        /// 对位模式 厚度%差 的极差 >= +4%-4%=8%， 单位%
        /// </summary>
        public int ThresholdMaxMin
        {
            get { return thresholdMaxMin; }
            set
            {
                if (thresholdMaxMin != value)
                {
                    thresholdMaxMin = value;
                    NotifyPropertyChanged("ThresholdMaxMin");
                }
            }
        }

        private int thresholdSigmaMax = 20;
        /// <summary>
        /// ％
        /// 最大sigma, 只有当前的sigma  在 最大sigma 与 最小 sigma 内，才能控制
        /// </summary>
        public int ThresholdSigmaMax
        {
            get { return thresholdSigmaMax; }
            set
            {
                if (thresholdSigmaMax != value)
                {
                    thresholdSigmaMax = value;
                    NotifyPropertyChanged("ThresholdSigmaMax");
                }
            }
        }


        private bool isUsedKp = false;
        /// <summary>
        /// 使用这里独立的Kp， 与 HeatCell 不一样
        /// </summary>
        public bool IsUsedLocalKp
        {
            get { return isUsedKp; }
            set {
                if (isUsedKp != value)
                {
                    isUsedKp = value;
                    NotifyPropertyChanged("IsUsedLocalKp");
                }
            }
        }

        private double localkp = 3;
        /// <summary>
        /// 本地Kp， 用于判断稳定性
        /// </summary>
        public double LocalKp
        {
            get { return localkp; }
            set {
                if (localkp != value)
                {
                    localkp = value;
                    NotifyPropertyChanged("LocalKp");
                }
            }
        }



        #endregion

        #region 状态

        private TimeSpan delay = TimeSpan.FromSeconds(100);
        /// <summary>
        /// 总延时 =Delay+mRenZiJiaService.FilmLength/mRenZiJiaService.Velocity
        /// </summary>
        public TimeSpan Delay
        {
            get { return delay; }
            set
            {
                if (delay != value)
                {
                    delay = value;
                    NotifyPropertyChanged("Delay");
                }
            }
        }


        #region 对位
        private bool isIntoAutoONo = false;
        /// <summary>
        /// 进入了对位模式
        /// </summary>
        public bool IsIntoAutoONo
        {
            get { return isIntoAutoONo; }
            set
            {
                if (isIntoAutoONo != value)
                {
                    isIntoAutoONo = value;
                    NotifyPropertyChanged("IsIntoAutoONo");
                }
            }
        }

        private EAutoONoResult autoONoResult = EAutoONoResult.Idle;
        /// <summary>
        /// 对位模式结果
        /// </summary>
        public EAutoONoResult AutoONoResult
        {
            get { return autoONoResult; }
            set {
                if (autoONoResult != value)
                {
                    autoONoResult = value;
                    NotifyPropertyChanged("AutoONoResult");
                }
            }
        }

        private int bestOrgBoltNo = -1;
        /// <summary>
        /// 计算的最佳复位区号
        /// </summary>
        public int BestOrgBoltNo
        {
            get { return bestOrgBoltNo; }
            set {
                if (bestOrgBoltNo != value)
                {
                    bestOrgBoltNo = value;
                    NotifyPropertyChanged("BestOrgBoltNo");
                }
            }
        }

        private double bestkp = -1;
        /// <summary>
        /// 计算的最佳复位区号 对应的 加热/厚度 
        /// </summary>
        public double BestKp
        {
            get { return bestkp; }
            set
            {
                if (bestkp != value)
                {
                    bestkp = value;
                    NotifyPropertyChanged("BestKp");
                }
            }
        }

        private double maxR = -1;
        /// <summary>
        /// 计算的最佳复位区号 对应的 加热与厚度相关性
        /// </summary>
        public double MaxR
        {
            get { return maxR; }
            set
            {
                if (maxR != value)
                {
                    maxR = value;
                    NotifyPropertyChanged("MaxR");
                }
            }
        }

        private double maxmin = -1;
        /// <summary>
        /// 计算的最佳复位区号 对应的 厚度%变化极差 单位%
        /// </summary>
        public double MaxMin
        {
            get { return maxmin; }
            set {
                if (maxmin != value)
                {
                    maxmin = value;
                    NotifyPropertyChanged("MaxMin");
                }
            }
        }
        #endregion

        #region 稳定性
        private STABILITY stability = STABILITY.IDLE;
        /// <summary>
        /// 当前检测出来的厚度数据 稳定状态
        /// </summary>
        public STABILITY Stability
        {
            get { return stability; }
            protected set {
                if (stability != value)
                {
                    stability = value;
                    NotifyPropertyChanged("Stability");
                }
            }
        }

        private double currR = -1; 
        /// <summary>
        /// 当前检测出来的厚度数据 的稳定性 
        /// </summary>
        public double CurrR
        {
            get { return currR; }
            set {
                if (currR != value)
                {
                    currR = value;
                    NotifyPropertyChanged("CurrR");
                }
            }
        }

        private double curr2Sigma = -1;
        /// <summary>
        /// 当前检测出来的厚度数据 2Sigma
        /// </summary>
        public double Curr2Sigma
        {
            get
            {
                return curr2Sigma;
            }
            set {
                if (curr2Sigma != value)
                {
                    curr2Sigma = value;
                    NotifyPropertyChanged("Curr2Sigma");
                }
            }
        }

        private double currBreakUp = 50;
        /// <summary>
        /// 当前打散程度。 
        /// 连续N点都在平均值同一侧为一个块；
        /// 这些块的长度平均值/总长度， 为打散度；
        /// 打散度越小越好， 最小为 1/NBolts
        /// </summary>
        public double CurrBreakUp
        {
            get
            {
                return currBreakUp;
            }
            protected set
            {
                if (currBreakUp != value)
                {
                    currBreakUp = value;
                    NotifyPropertyChanged("CurrBreakUp");
                }
            }
        }

        DateTime currtime = DateTime.MinValue;
        /// <summary>
        /// 当前检测出来的厚度数据，时间
        /// </summary>
        public DateTime CurrTime
        {
            get
            {
                return currtime;
            }
            set
            {
                if (currtime != value)
                {
                    currtime = value;
                    NotifyPropertyChanged("CurrTime");
                }
            }
        }

        private Misc.DIRECTION currDirection = Misc.DIRECTION.FORWARD;
        /// <summary>
        /// 当前检测出来的厚度数据，方向
        /// </summary>
        public Misc.DIRECTION CurrDirection
        {
            get { return currDirection; }
            protected set
            {
                if (currDirection != value)
                {
                    currDirection = value;
                    NotifyPropertyChanged("CurrDirection ");
                }
            }
        }


        #endregion

        #region 列表
        private int lastbm = 0;
        /// <summary>
        /// 列表最后1个BM
        /// </summary>
        public int LastBM
        {
            get { return lastbm; }
            protected set
            {
                if (lastbm != value)
                {
                    lastbm = value;
                    NotifyPropertyChanged("LastBM");
                }
            }
        }

        private int firstbm = 0;
        /// <summary>
        /// 列表第1个BM
        /// </summary>
        public int FirstBM
        {
            get { return firstbm; }
            protected set
            {
                if (firstbm != value)
                {
                    firstbm = value;
                    NotifyPropertyChanged("FirstBM");
                }
            }
        }
        #endregion

        #region 每个分区状态
        private bool[] boltIsStable;
        public bool[] BoltIsStable
        {
            get { return boltIsStable; }
            set {
                boltIsStable = value;
                NotifyPropertyChanged("BoltIsStable");
            }
        }
        #endregion

        #endregion

        #endregion


        private double kp = 3;
        /// <summary>
        /// HeatCell 的 Kp
        /// </summary>
        public double Kp
        {
            get { return kp; }
            set
            {
                if (kp != value)
                {
                    kp = value;
                    NotifyPropertyChanged("Kp");
                }
            }
        }
        
        /// <summary>
        /// 厚度数量
        /// </summary>
        int BoltCnt = 96;

        /// <summary>
        /// 加热数量
        /// </summary>
        int ChannelCnt = 96;
        
        /// <summary>
        /// 缓存区大小
        /// </summary>
        int BufSize = 60;
        
        /// <summary>
        /// 最后一幅数据的复位区号
        /// </summary>
        int orgBoltNo = 1;
        /// <summary>
        /// 最后一幅数据的旋转角度
        /// </summary>
        double rAngle = 355;

        public History<FlyData_FeedbackHeat> mHistory;
        public RList<FlyData_FeedbackHeat> mData;
        /// <summary>
        /// 当复位区号改变，它应该被清空
        /// </summary>
        public BoltHeat[] mBoltData;
        static HeatBuf()
        {

        }
        public HeatBuf()
        {
            mHistory = new History<Common.FlyData_FeedbackHeat>("history");
            mHistory.SaveRows = 100;

            mData = new RList<FlyData_FeedbackHeat>(BufSize);

            Load();
            checkParamErr();
            PropertyChanged += HeatBuf_PropertyChanged;
        }
        void checkParamErr()
        {
            if (StableRange < 1 || StableRange > 10)
            {
                StableRange = 2;
            }

            if (StableRange0 < 1 || StableRange0 > 10)
            {
                StableRange0 = 2;
            }

            if (ThresholdR < 0.1 || ThresholdR > 0.9)
            {
                ThresholdR = 0.7;
            }

            if (ThresholdMaxMin < 2 || ThresholdMaxMin > 20)
            {
                ThresholdMaxMin = 8;
            }

            if (LocalKp < 1 || LocalKp > 20)
            {
                LocalKp = 3;
            }
        }
        private void HeatBuf_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "IsIntoAutoONo")
            {
                if (IsIntoAutoONo)
                {
                    AutoONoResult = EAutoONoResult.Idle;
                }
                else
                {
                    if (AutoONoResult == EAutoONoResult.Idle)
                    {
                        //被强制关闭
                        AutoONoResult = EAutoONoResult.Err_Break;
                    }
                }
            }
        }

        public void Init(int boltCnt, int channelCnt) 
        {
            BoltCnt = boltCnt;
            ChannelCnt = channelCnt;
            mBoltData = new BoltHeat[BoltCnt];
            for (int i = 0; i < BoltCnt; i++)
            {
                mBoltData[i] = new BoltHeat();
            }
            mData.Clear();
            mHistory.Flush();
            //TODO 测试
            //LoadData();
        }
        


        public bool IsStable()
        {
            if ((int)Stability > 0)
                return true;
            else
                return false;
        }
        public bool IsUnstable()
        {
            if ((int)Stability < 0)
                return true;
            else
                return false;
        }

        public int[] GetThicks() 
        {
            if (mData.Count() == 0)
                return null;
            return mData.Last().Thicks;
        }


        /// <summary>
        /// 1.添加数据到缓冲;
        /// 2.判断是否稳定
        /// 3.根据稳定变化，加热变化，计算偏移
        /// </summary>
        /// <param name="time">测厚的开始时间</param>
        /// <param name="endtime">测厚的结束时间</param>
        /// <param name="direction">方向</param>
        /// <param name="period">旋转时间</param>
        /// <param name="rotateCnt">旋转次数</param>
        /// <param name="orgBoltNo">复位区号</param>
        /// <param name="rAngle">旋转角度</param>
        /// <param name="filmLength">膜距离</param>
        /// <param name="thicks">厚度数据</param>
        /// <param name="htime">加热的时间</param>
        /// <param name="heats">加热量</param>
        /// <returns></returns>
        public bool Add(
            DateTime time, DateTime endtime, Misc.DIRECTION direction, TimeSpan period, int rotateCnt,
            int orgBoltNo, double rAngle, double filmLength,
            int[] thicks,
            DateTime htime, int[] heats)
        {
            //thicks 的数据量一定要是 BoltCnt
            //heats 的数据量一定要是 ChannelCnt
            //不是返回 false
            
            if (thicks.Count() != BoltCnt)//异常
                return false;

            if (heats.Count() != ChannelCnt)//异常
                return false;

            FlyData_FeedbackHeat d = new FlyData_FeedbackHeat()
            {
                Time = time,
                EndTime = endtime,
                Direction = direction,
                RotatePeriod = period,
                RotateCnt = rotateCnt,

                OrgBoltNo = orgBoltNo,
                RAngle = rAngle,
                FilmLength = filmLength,

                Thicks = thicks,

                HTime = htime,
                Heats = heats
            };
            UpdateStable1(d);//判断是否异常数据

           
            //检查，它可能只是因为 复位区号，或旋转角度，膜距离改变了，再重发一次而已
            if (mData.Count() > 0)
            {
                for (int i = 0; i < mData.Count(); i++)
                {
                    int idx = mData.Count() - 1 - i;
                    FlyData_FeedbackHeat f = mData[idx];
                    if (time < f.Time)
                    {
                        //要继续找向前找
                        if (idx == 0)
                        {
                            //已经到头了， 在idx前面插入
                            mData.Insert(0, d);
                            return false;
                        }
                    }
                    else if (f.Time == time)
                    {
                        //只是以前的数据而已，替换掉
                        mData[idx] = d;
                        return false;
                    }
                    else
                    {
                        //找过了，在idx后面插入
                        if (idx == mData.Count() - 1)
                        {
                            //在最后插入数据
                            //mData.RAdd(d);
                            //idx_new = idx;
                        }
                        else
                        {
                            mData.Insert(idx, d);
                            return false;
                        }
                        break;
                    }
                }
            }

            if ((d.RAngle != this.rAngle) || (d.OrgBoltNo != this.orgBoltNo))
            {
                ClearBoltHeat();
                this.rAngle = d.RAngle;
                this.orgBoltNo = d.OrgBoltNo;
            }

            if (d.Stability != STABILITY.IDLE)
            {
                //数据异常
                CurrR = -1;
            }
            else
            {
                //自动对位
                if (IsIntoAutoONo)
                {
                    UpdateAutoONo(d);
                    IsIntoAutoONo = false;
                }
                else
                {
                    //更新每个分区的稳定状态
                    UpdateStable2(d);
                }
            }

            Stability = d.Stability;
            CurrDirection = d.Direction;
            CurrTime = d.Time;

            mHistory.Add(d);
            mData.RAdd(d);

            LastBM = mData.GetLastNo();
            FirstBM = LastBM + 1 - mData.Count();
            //TODO 测试
            //SaveData();

            return true;
        }
        #region 测试用
        string data_path = "heatbuf.csv";
        void SaveData()
        {

            //当文件不存在，重新写入全部
            //当文件存在，只追加
            if (File.Exists(data_path))
            {
                using (StreamWriter sw = new StreamWriter(data_path, true, Encoding.GetEncoding("GB2312")))
                {
                    sw.WriteLine(mData.Last().ToString());
                    sw.Flush();
                    sw.Close();
                }
            }
            else
            {
                using (StreamWriter sw = new StreamWriter(data_path,false, Encoding.GetEncoding("GB2312")))
                {
                    sw.WriteLine(mData.First().GetHeader());
                    for (int i=0;i<mData.Count();i++)
                    {
                        sw.WriteLine(mData[i].ToString());
                    }
                    sw.Flush();
                    sw.Close();
                }
            }
        }
        void LoadData()
        {
            mData.Clear();
            try
            {
                using (StreamReader sr = new StreamReader(data_path, Encoding.GetEncoding("GB2312")))
                {
                    //第1行是标题
                    string header = sr.ReadLine();

                    while (!sr.EndOfStream)
                    {
                        string s = sr.ReadLine();
                        FlyData_FeedbackHeat f = new FlyData_FeedbackHeat();
                        if (!f.TryParse(header, s))
                        {
                            break;//异常失败！！！
                        }
                        mData.RAdd(f);
                    }
                }
            }
            catch(Exception e)
            {

            }
            if (mData.Count() > 0)
            {
                LastBM = mData.GetLastNo();
                FirstBM = LastBM + 1 - mData.Count();
            }
            else
            {
                LastBM = -1;
                FirstBM = -1;
            }
        }
        #endregion


        /// <summary>
        /// 获取上一次没有交集的数据序号
        /// </summary>
        /// <param name="index">在列表中的待比较数据序号</param>
        /// <returns></returns>
        int GetJustBeforeIdx(FlyData_FeedbackHeat d_now, int index)
        {
            for (int i = 0; i <= index; i++)
            {
                int idx = index - i;
                FlyData_FeedbackHeat d = mData[idx];
                if (d.EndTime <= d_now.Time)
                    return idx;
            }
            return -1;
        }
        bool CanCompared(STABILITY stability)
        {
            switch (stability)
            {
                case STABILITY.ERROR_NO_ARRIVE:
                case STABILITY.ERROR_POSITION_NOTSURE:
                case STABILITY.ERROR_SIGMA_OVERSIZE:
                    return false;
                default:
                    return true;
                //case STABILITY.IDLE:
                //case STABILITY.ERROR_ROTATE_CHANGED:
                //case STABILITY.ERROR_THICK_CHANGED:
                //case STABILITY.ERROR_CORREL:
                //case STABILITY.OK_SIGMA_SMALL_ENOUGH:
                //case STABILITY.OK_CORREL:
                //case STABILITY.OK_HEAT_AND_THICK_CORREL:
                //    return true;

            }
        }

        
        /// <summary>
        /// 更新稳定状态， 一个就能判断的状态
        /// </summary>
        /// <param name="d"></param>
        void UpdateStable1(FlyData_FeedbackHeat d)
        {
            if (d.RotateCnt <= 0)//旋转次数太少，位置不能确定
            {
                d.Stability = STABILITY.ERROR_POSITION_NOTSURE;
                return;
            }


            {
                DateTime dt_takeeffect = d.HTime + Delay;//起效时间

                if (d.Time >= dt_takeeffect)//最早的时间都比起效时间晚，不用删除
                {

                }
                else
                {
                    DateTime dt = d.Time + TimeSpan.FromTicks((long)((d.EndTime - d.Time).Ticks * 0.3));
                    if (dt < dt_takeeffect)
                    {
                        //有30% 数据都是以前的，无效， 加热还没起效
                        d.Stability = STABILITY.ERROR_NO_ARRIVE;
                        return;
                    }
                }
            }

            int avg = Misc.MyMath.Avg(d.Thicks);
            CurrBreakUp = Common.MyMath.BreakUp(d.Thicks) * 100.0;
            int sigma = Misc.MyMath.Sigma(d.Thicks);
            double sigma2_percents = 100.0 * 2 * sigma / avg;
            Curr2Sigma = sigma2_percents;
            
            if (sigma2_percents >= ThresholdSigmaMax)
            {
                //一副数据，Sigma > 15% ： 不稳定，变化太大，超出控制范围 ， （当为自动时，停止所有加热）
                d.Stability = STABILITY.ERROR_SIGMA_OVERSIZE;
                return;
            }
        }

        /// <summary>
        /// 更新稳定状态,需要2幅数据才能比较的
        /// </summary>
        /// <param name="index">在列表的数据</param>
        void UpdateStable2(FlyData_FeedbackHeat d)
        {
            if (mData.Count() == 0)//没有以前的数据
                return;

            //找到之前没有交集的一幅数据, 并且它不是异常的
            int idx_last = mData.Count() - 1;
            FlyData_FeedbackHeat d_last;
            while (true)
            {
                idx_last = GetJustBeforeIdx(d, idx_last);
                if (idx_last < 0)//没有上一幅数据，暂时待定
                {
                    return;
                }
                d_last = mData[idx_last];
                if (CanCompared(d_last.Stability))
                {
                    break;
                }
                idx_last--;
                if (idx_last < 0)//没有上一幅数据，暂时待定
                    return;
            }

            if (Math.Abs((d_last.RotatePeriod - d.RotatePeriod).TotalSeconds / d.RotatePeriod.TotalSeconds) > 0.03)
            {
                //连续两幅图旋转时间变化 > 3%：不稳定，旋转速度波动大，测量不准确
                d.Stability = STABILITY.ERROR_ROTATE_CHANGED;
                return;
            }

            int avg = Misc.MyMath.Avg(d.Thicks);
            int avg_last = Misc.MyMath.Avg(d_last.Thicks);
            if (Math.Abs( ((double)(avg_last - avg)) / avg) > 0.05)
            {
                //厚度变化5%， 不稳定
                d.Stability = STABILITY.ERROR_THICK_CHANGED;
                return;
            }

            int[] thickpercents_diff, thickpercents_mid, heatpercents_diff, heatpercents_mid;

            GetPercentDatas(d, d_last,
                out thickpercents_diff, out thickpercents_mid,
                out heatpercents_diff, out heatpercents_mid);

            UpdateR(thickpercents_diff, thickpercents_mid, heatpercents_diff, heatpercents_mid);

            if (CurrR >= ThresholdR)
            {
                d.Stability = STABILITY.OK_HEAT_AND_THICK_CORREL;
                if (d.Heats.All((h) => { return h == 0; }))
                    d.Stability = STABILITY.OK_CORREL;
            }
        }

        void GetPercentDatas(FlyData_FeedbackHeat d, FlyData_FeedbackHeat d_last,
            out int[] thickpercents_diff,out int[] thickpercents_mid,
            out int[] heatpercents_diff,out int[] heatpercents_mid
            )
        {
            //厚度%偏差
            int[] thickpercents_now = Common.MyMath.GetPercent(d.Thicks);
            //当两幅图复位区号不一致时，移动以前的数据，使之一致
            int[] thickpercents_last = Common.MyMath.Move(Common.MyMath.GetPercent(d_last.Thicks), d.OrgBoltNo - d_last.OrgBoltNo);
            thickpercents_diff = Common.MyMath.GetDiff(thickpercents_now, thickpercents_last);
            thickpercents_mid = Common.MyMath.GetMid(thickpercents_now, thickpercents_last);

            //加热%偏差
            int[] heatpercents_now = Common.MyMath.OffsetAvgBe0(d.Heats);//平移到平均值为0
            heatpercents_now = Common.MyMath.ZoomIn(heatpercents_now, BoltCnt / ChannelCnt);//放大数量为分区量
            heatpercents_now = Common.MyMath.Filter(heatpercents_now, HeatEffectCurve.ToArray());//滤波变为加热对厚度的效果，还没 / Kp

            int[] heatpercents_last = Common.MyMath.OffsetAvgBe0(d_last.Heats);//平移到平均值为0
            heatpercents_last = Common.MyMath.ZoomIn(heatpercents_last, BoltCnt / ChannelCnt);//放大数量为分区量
            heatpercents_last = Common.MyMath.Filter(heatpercents_last, HeatEffectCurve.ToArray());//滤波变为加热对厚度的效果，还没 / Kp

            heatpercents_diff = Common.MyMath.GetDiff(heatpercents_last, heatpercents_now);//-加热增量, 它是反转的！！！！
            heatpercents_mid = Common.MyMath.GetMid(heatpercents_now, heatpercents_last);//加热均值
        }

        void UpdateR(
            int[] thickpercents_diff, int[] thickpercents_mid,
            int[] heatpercents_diff, int[] heatpercents_mid)
        {
            //降低要求
            thickpercents_diff = Common.MyMath.Filter(thickpercents_diff, 3);
            thickpercents_mid = Common.MyMath.Filter(thickpercents_mid, 3);
            heatpercents_diff = Common.MyMath.Filter(heatpercents_diff, 3);
            heatpercents_mid = Common.MyMath.Filter(heatpercents_mid, 3);

            double kp = (IsUsedLocalKp) ? LocalKp : Kp;
            if (kp < 1)
                kp = 1;

            //当加热全为0，使用StableRange0
            int stableRange = (heatpercents_diff.All((h) => h == 0)) ? StableRange0 : StableRange;
            if (stableRange < 1)
                stableRange = 1;

             
            for (int i = 0; i < BoltCnt; i++)
            {
                BoltHeatRecord record = new BoltHeatRecord()
                {
                    ThickDiff = thickpercents_diff[i],
                    ThickMid = thickpercents_mid[i],
                    HeatDiff = -heatpercents_diff[i],
                    HeatMid = heatpercents_mid[i]
                };
                mBoltData[i].ThickRange = StableRange0;
                mBoltData[i].HeatRange = 5;
                if ((Misc.MyBase.ISVALIDATA(thickpercents_diff[i])) &&
                    (Math.Abs(thickpercents_diff[i] + heatpercents_diff[i] / kp) <= stableRange))
                {
                    //稳定！！！！！
                    mBoltData[i].IsStable = true;
                    mBoltData[i].StableAdd(record);
                    
                }
                else
                {
                    mBoltData[i].IsStable = false;
                    mBoltData[i].UnstableAdd(record);
                }
            }

            CurrR = 1.0 * mBoltData.Count((_b) => { return _b.IsStable; }) / mBoltData.Count();


            var IsStables = from r in mBoltData select r.IsStable;
            BoltIsStable = IsStables.ToArray();

        }
        /// <summary>
        /// 执行自动对位
        /// </summary>
        /// <param name="d"></param>
        /// <returns>处理完</returns>
        void UpdateAutoONo(FlyData_FeedbackHeat d)
        {
           //d 这幅图，是刚加热生效的， 它必须是稳定的， 只有找到以前空加热的数据，对比就好了。


            if (mData.Count() == 0)//没有以前的数据
            {
                //异常
                AutoONoResult = EAutoONoResult.Err_Break;
                return;
            }


            //找到之前没有交集的一幅数据, 并且它不是异常的

            //找出空的那幅数据！！！！！
            int idx_last = mData.Count() - 1;
            FlyData_FeedbackHeat d_last;
            while (true)
            {
                idx_last = GetJustBeforeIdx(d, idx_last);
                if (idx_last < 0)//没有上一幅数据，暂时待定
                {
                    //异常
                    AutoONoResult = EAutoONoResult.Err_Break;
                    return;
                }
                d_last = mData[idx_last];
                if (CanCompared(d_last.Stability))
                {
                    break;
                }
                idx_last--;
                if (idx_last < 0)//没有上一幅数据，暂时待定
                {
                    //异常
                    AutoONoResult = EAutoONoResult.Err_Break;
                    return;
                }
            }

            if (Math.Abs((d_last.RotatePeriod - d.RotatePeriod).TotalSeconds / d.RotatePeriod.TotalSeconds) > 0.03)
            {
                //连续两幅图旋转时间变化 > 3%：不稳定，旋转速度波动大，测量不准确
                d.Stability = STABILITY.ERROR_ROTATE_CHANGED;
                //异常
                AutoONoResult = EAutoONoResult.Err_Break;
                return;
            }

            int avg = Misc.MyMath.Avg(d.Thicks);
            int avg_last = Misc.MyMath.Avg(d_last.Thicks);
            if (Math.Abs(((double)(avg_last - avg)) / avg) > 0.05)
            {
                //厚度变化5%， 不稳定
                d.Stability = STABILITY.ERROR_THICK_CHANGED;

                //异常
                AutoONoResult = EAutoONoResult.Err_Break;
                return;
            }



            int[] thickpercents_diff, thickpercents_mid, heatpercents_diff, heatpercents_mid;

            GetPercentDatas(d, d_last,
                out thickpercents_diff, out thickpercents_mid,
                out heatpercents_diff, out heatpercents_mid);

            //计算极差
            MaxMin = Common.MyMath.CalMaxMin(Common.MyMath.Filter(thickpercents_diff, 3));
            
            //计算平移
            int offset;
            double max_r;

            Common.MyMath.CalBestMove(heatpercents_diff, thickpercents_diff, 0.5, out offset, out max_r);
            MaxR = max_r;

            int orgboltno = d.OrgBoltNo + offset;
            if (orgboltno > BoltCnt)
                orgboltno -= BoltCnt;
            else if (orgboltno < 1)
                orgboltno += BoltCnt;

            BestOrgBoltNo = orgboltno;

            //计算Kp
            int[] thickpercents_diff_mov = Common.MyMath.Move(thickpercents_diff, offset);

            double b;
            double a;
            Misc.MyMath.Linest(heatpercents_diff, thickpercents_diff_mov, out a, out b);
            BestKp = a;

            if (MaxMin >= ThresholdMaxMin)
            {
                if (MaxR >= ThresholdR)
                {
                    //计算结果可靠性很高
                    AutoONoResult = EAutoONoResult.OK;
                }
                else
                {
                    AutoONoResult = EAutoONoResult.Err_MaxR;
                }
            }
            else
            {
                AutoONoResult = EAutoONoResult.Err_MaxMin;
            }

            if (AutoONoResult == EAutoONoResult.OK)
            {
                Kp = BestKp;

                if (offset != 0)
                {
                    d.Thicks = Common.MyMath.Move(d.Thicks, offset);
                    d.OrgBoltNo = BestOrgBoltNo;


                    thickpercents_diff = Common.MyMath.Move(thickpercents_diff, offset);
                    thickpercents_mid = Common.MyMath.Move(thickpercents_mid, offset);
                    ClearBoltHeat();
                }
            }

            UpdateR(thickpercents_diff, thickpercents_mid, heatpercents_diff, heatpercents_mid);

            if (CurrR >= ThresholdR)
            {
                d.Stability = STABILITY.OK_HEAT_AND_THICK_CORREL;
                if (d.Heats.All((h) => { return h == 0; }))
                    d.Stability = STABILITY.OK_CORREL;
            }
        }




        #region 列表
        /// <summary>
        /// 获取记录历史 返回类型为 FlyData_FeedbackHeat
        /// </summary>
        /// <param name="bookmark">记录点</param>
        /// <param name="AsyncDelegate"></param>
        /// <param name="AsyncState"></param>
        public void GetHeatsData(int bookmark, AsyncCBHandler AsyncDelegate, object AsyncState)
        {
            int idx = mData.No2Index(bookmark);
            if (idx < 0 || idx >= mData.Count())
            {
                //返回空数据
                AsyncDelegate(AsyncState, null);
            }
            else
            {
                AsyncDelegate(AsyncState, mData[idx]);
            }
        }

        #endregion

        /// <summary>
        /// 清空每个分区的加热记录
        /// </summary>
        public void ClearBoltHeat()
        {
            foreach (BoltHeat h in mBoltData)
            {
                h.StableList.Clear();
                h.UnstableList.Clear();
            }
        }

        /// <summary>
        /// 获取每个分区的加热历史 返回 FlyData_BoltHeatRecord
        /// </summary>
        /// <param name="no">分区号</param>
        /// <param name="AsyncDelegate"></param>
        /// <param name="AsyncState"></param>
        public void GetBoltHeatRecord(int no, AsyncCBHandler AsyncDelegate, object AsyncState)
        {
            if (no < 1 || no > mBoltData.Count())
            {
                AsyncDelegate(AsyncState, null);
            }
            else
            {
                FlyData_BoltHeatRecord f = new FlyData_BoltHeatRecord();
                f.StableList = mBoltData[no - 1].StableList.ToArray();
                f.UnstableList = mBoltData[no - 1].UnstableList.ToArray();
                AsyncDelegate(AsyncState, f);
            }
        }

        public void Apply()
        {
            Save();
        }
        bool Load()
        {
            return Misc.SaveToXmlHepler.Load("heatbuf.xml", this);
        }
        void Save()
        {
            Misc.SaveToXmlHepler.Save("heatbuf.xml", this);
        }

        #region INotifyPropertyChanged 成员

        public event PropertyChangedEventHandler PropertyChanged;
        protected void NotifyPropertyChanged(string propertyname)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyname));
            }
        }
        #endregion

        public string[] GetSavePropertyNames()
        {
            return new string[]{
                "HeatEffectCurve",
                "StableRange",
                "StableRange0",
                "ThresholdR",
                "ThresholdMaxMin",
                "ThresholdSigmaMax",
                "IsUsedLocalKp",
                "LocalKp"
            };
        }
    }

    /// <summary>
    /// 单个分区判断
    /// </summary>
    public class BoltHeat
    {
        /// <summary>
        /// 当前是否稳定
        /// </summary>
        public bool IsStable = false;
        /// <summary>
        /// 稳定列表
        /// </summary>
        public RList<BoltHeatRecord> StableList;
        /// <summary>
        /// 不稳定列表
        /// </summary>
        public RList<BoltHeatRecord> UnstableList;
        /// <summary>
        /// 厚度%相同的定义
        /// </summary>
        public int ThickRange=5;
        /// <summary>
        /// 加热%相同的定义
        /// </summary>
        public int HeatRange=5;

        public BoltHeat()
        {
            StableList = new RList<BoltHeatRecord>(60);
            UnstableList = new RList<BoltHeatRecord>(60);
            
        }
        public void StableAdd(BoltHeatRecord r)
        {
            var ss = from s in StableList
                     where
                     (Math.Abs(s.HeatDiff - r.HeatDiff) <= HeatRange) &&
                     (Math.Abs(s.HeatMid - r.HeatMid) <= HeatRange) &&
                     (Math.Abs(s.ThickDiff - r.ThickDiff) <= ThickRange) &&
                     (Math.Abs(s.ThickMid - r.ThickMid) <= ThickRange)
                     select s;
            if (ss.Count() > 0)
            {
                ss.First().Cnt++;
            }
            else
            {
                StableList.Add(r);
            }
        }
        public void UnstableAdd(BoltHeatRecord r)
        {
            var ss = from s in UnstableList
                     where
                     (Math.Abs(s.HeatDiff - r.HeatDiff) <= HeatRange) &&
                     (Math.Abs(s.HeatMid - r.HeatMid) <= HeatRange) &&
                     (Math.Abs(s.ThickDiff - r.ThickDiff) <= ThickRange) &&
                     (Math.Abs(s.ThickMid - r.ThickMid) <= ThickRange)
                     select s;
            if (ss.Count() > 0)
            {
                ss.First().Cnt++;
            }
            else
            {
                UnstableList.Add(r);
            }
        }
        /// <summary>
        /// 根据历史，判断最佳输出
        /// </summary>
        /// <param name="thickpercent">当前厚度%</param>
        /// <param name="heat">当前加热%</param>
        /// <param name="offset">准备要改变的加热量</param>
        /// <returns></returns>
        public int Suggest(int thickpercent, int heat, int offset)
        {
            
            if (offset == 0)//没有加热，直接返回
                return offset;
            if (StableList.Count() == 0 && UnstableList.Count() == 0)//没有历史，直接返回
                return offset;

            //从稳定的历史找相同的加热
            var lr_s = from r in StableList
                    where r.IsSameThick(thickpercent, ThickRange) &&
                    (Math.Abs(Math.Abs(offset) - Math.Abs(r.HeatDiff)) <= HeatRange)
                    select r;
            int cnt = lr_s.Sum((r) => { return r.Cnt; });
            if (cnt > 3)//数量要足够多，才可信
            {
                //看看以前这样加热 厚度变化了多少
                int thickdiff;
                if (offset > 0)
                {
                    thickdiff = (int)lr_s.Average((r) =>
                    {
                        if (r.HeatDiff > 0)
                            return r.ThickDiff;
                        else
                            return -r.ThickDiff;
                    });
                }
                else
                {
                    thickdiff = (int)lr_s.Average((r) =>
                    {
                        if (r.HeatDiff > 0)
                            return -r.ThickDiff;
                        else
                            return r.ThickDiff;
                    });
                }
                if (Math.Abs(thickdiff) <= ThickRange)
                {
                    //变化很小，不如别调
                    //TODO, 加热以前最小的加热量
                    //int min_heat = lr_s.Min((r) => { return Math.Min(Math.Abs(r.Heat0), Math.Abs(r.Heat1)); });
                    //offset = min_heat - heat;
                    //return offset;
                    return 0;
                }
            }
            else
            {
                //这样加热没有稳定的历史

                //从不稳定的历史找相同的加热
                var lr_u = from r in UnstableList
                           where r.IsSameThick(thickpercent, ThickRange) &&
                           (Math.Abs(Math.Abs(offset) - Math.Abs(r.HeatDiff)) <= HeatRange)
                           select r;
                cnt = lr_u.Sum((r) => { return r.Cnt; });
                if (cnt > 3)//数量要足够多，才可信
                {
                    //这样加热肯定不稳定,别调了
                    return 0;
                }
            }
            return offset;
        }

        

    }

}