CalFilmLen360.cs

using FLY.Thick.Blowing;
using FLY.Thick.Blowing.IService;
using Misc;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

namespace FLY.Thick.Blowing360.UI
{
    public class CalFilmLen360 : INotifyPropertyChanged
    {

        #region 状态
        /// <summary>
        /// 信息
        /// </summary>
        public string Msg { get; protected set; }

        /// <summary>
        /// 下载中
        /// </summary>
        public bool IsDownloading { get; protected set; }

        /// <summary>
        /// 数据准备好了
        /// </summary>
        public bool IsDataReady { get; protected set; }

        /// <summary>
        /// 计算中
        /// </summary>
        public bool IsCaling { get; protected set; }

        /// <summary>
        /// 有足够的数据，可以下载
        /// </summary>
        public bool IsCanDownload { get; protected set; }

        /// <summary>
        /// 当前数据总分钟数 min
        /// </summary>
        public int DataMaxMinute { get; protected set; }
        /// <summary>
        /// 必须获取的最少数据量 min
        /// </summary>
        public int DataMinMinute { get; protected set; }

        /// <summary>
        /// 最佳获取数据量 min
        /// </summary>
        public int DataBestMinute { get; protected set; }
        #endregion

        #region 参数

        public bool IsRPosMode { get; protected set; }
        /// <summary>
        /// 第1牵引速度
        /// </summary>
        public double Velocity1 { get; protected set; }

        /// <summary>
        /// 速度滤波 单位s
        /// </summary>
        public int VelocityFilter { get; protected set; } = 1;

        /// <summary>
        /// 膜距离
        /// </summary>
        public double FilmLength { get; protected set; }
        #endregion

        IBlowingFixService mCurrBlowing;
        IBlowingDetectService mCurrRDetect;
        BlowingDetect360Core mRDetectCore;

        List<ThkCell> mThkList = new List<ThkCell>();
        List<LimitCell> mLimitList = new List<LimitCell>();
        List<RollCell> mRollList = new List<RollCell>();
        List<RPosData> mRPosList = new List<RPosData>();

        #region 画图
        public List<TimeValue> LimitValues { get; } = new List<TimeValue>();

        public List<TimeValue> VelocityValues { get; } = new List<TimeValue>();

        public List<TimeValue> ThicknessValues { get; } = new List<TimeValue>();

        public List<TimeValue> AngleValues { get; } = new List<TimeValue>();

        public class Frame
        {
            /// <summary>
            /// 厚度
            /// </summary>
            public double[] Thicks;
            /// <summary>
            /// 旋转方向
            /// </summary>
            public Misc.DIRECTION Direction;
            /// <summary>
            /// 旋转次数
            /// </summary>
            public int RotationCnt;
            /// <summary>
            /// 与上一幅图的相关性
            /// </summary>
            public double R;
            /// <summary>
            /// 大于30%数据 非 NaN
            /// </summary>
            public bool IsVaild;
        }
        [PropertyChanged.DoNotCheckEquality]
        public List<Frame> Frames { get; set; } = new List<Frame>();
        #endregion

        int NBolts;
        int OrgBoltNo;

        DateTime dataBegin;
        /// <summary>
        /// 最小旋转次数
        /// </summary>
        const int minRotationCnt = 2;
        public CalFilmLen360()
        {
            mRDetectCore = new BlowingDetect360Core();
        }

        public void Init(IBlowingFixService mRenZiJiaFix, IBlowingDetectService mRDetect)
        {
            this.mCurrBlowing = mRenZiJiaFix;
            this.mCurrRDetect = mRDetect;

            this.FilmLength = mRDetect.FilmLength;

            Misc.BindingOperations.SetBinding(mCurrRDetect, nameof(IBlowingDetectService.BufTotalTime), () =>
            {
                DataMaxMinute = (int)(mCurrRDetect.BufTotalTime.TotalMinutes);
            });

            Misc.BindingOperations.SetBinding(mCurrRDetect, nameof(IBlowingDetectService.RotationCnt), () =>
            {
                if (mRDetect.RotationCnt < minRotationCnt)
                {
                    IsCanDownload = false;
                }
                else
                {
                    IsCanDownload = true;
                }
            });

            Misc.BindingOperations.SetBinding(mCurrRDetect, nameof(IBlowingDetectService.RenZiJiaPeriod), () =>
            {
                DataMinMinute = (int)(mRDetect.RenZiJiaPeriod.TotalMinutes * (minRotationCnt - 1));
                DataBestMinute = (int)Math.Round((mRDetect.RenZiJiaPeriod.TotalMinutes * 3));
            });



        }

        ActionQueue actionQueue = new ActionQueue();

        public bool DownloadData()
        {
            //应该在界面 检测错误原因
            if (IsDownloading)
                return false;

            if (IsCaling)
                return false;

            dataBegin = DateTime.Now - mCurrRDetect.BufTotalTime;
            IsDownloading = true;
            IsDataReady = false;

            //按步骤下载数据
            actionQueue.Clear();

            actionQueue.Add(DownloadData_limit);
            actionQueue.Add(DownloadData_roll);
            actionQueue.Add(DownloadData_ad);

            if (mCurrRDetect.IsRPosMode)
                actionQueue.Add(DownloadData_rPos);

            actionQueue.Add(DownloadData_OK);

            actionQueue.Start();
            return true;
        }

        public class ActionQueue
        {
            List<Action> actions = new List<Action>();
            public void Add(Action action)
            {
                actions.Add(action);
            }
            public bool Start()
            {
                return Next();
            }
            public bool Next()
            {
                if (actions.Count() > 0)
                {
                    var action = actions.First();
                    actions.RemoveAt(0);
                    action.Invoke();
                    return true;
                }
                return false;
            }

            public bool IsEmpty()
            {
                if (actions.Count() == 0)
                    return true;
                else
                    return false;
            }

            public void Clear()
            {
                actions.Clear();
            }
        }

        void DownloadData_limit()
        {
            DateTime dateTime = dataBegin;
            if (mLimitList.Count() > 0)
            {
                dateTime = mLimitList.Last().dt_begin;
                if (dateTime < dataBegin)
                {
                    //数据太久，先删除，再下载
                    mLimitList.Clear();
                    dateTime = dataBegin;
                }
            }
            Msg = $"下载 转向信号数据 ({dateTime} - Now]....";

            mCurrRDetect.GetLimitList(dateTime,
                (object asyncContext, object retData) => {
                    var p = retData as GetLimitListReponse;
                    if (p.datas != null && p.datas.Count() > 0)//有数据
                        mLimitList.AddRange(p.datas);

                    //下一步
                    actionQueue.Next();
                }, null);
        }
        void DownloadData_roll()
        {
            DateTime dateTime = dataBegin;
            if (mRollList.Count() > 0)
            {
                dateTime = mRollList.Last().Time;
                if (dateTime < dataBegin)
                {
                    //数据太久，先删除，再下载
                    mRollList.Clear();
                    dateTime = dataBegin;
                }
            }
            Msg = $"下载 辊信号数据 [{dateTime} - Now]....";

            mCurrRDetect.GetRollList(dateTime,
                (object asyncContext, object retData) => {
                    var p = retData as GetRollListReponse;
                    if (p.datas != null && p.datas.Count() > 0)
                        mRollList.AddRange(p.datas);

                    //下一步
                    actionQueue.Next();
                }, null);
        }

        void DownloadData_rPos()
        {
            DateTime dateTime = dataBegin;
            if (mRPosList.Count() > 0)
            {
                dateTime = mRPosList.Last().Time;
                if (dateTime < dataBegin)
                {
                    //数据太久，先删除，再下载
                    mRPosList.Clear();
                    dateTime = dataBegin;
                }
            }

            Msg = $"下载 旋转脉冲数据 [{dateTime} - Now]....";


            mCurrRDetect.GetRPosList(dateTime,
                (object asyncContext, object retData) => {
                    var p = retData as GetRPosListReponse;
                    if (p.datas != null && p.datas.Count() > 0)
                        mRPosList.AddRange(p.datas);

                    actionQueue.Next();
                }, null);
        }
        void DownloadData_ad()
        {
            DateTime dateTime = dataBegin;
            if (mThkList.Count() > 0)
            {
                dateTime = mThkList.Last().Time;
                if (dateTime < dataBegin)
                {
                    //数据太久，先删除，再下载
                    mThkList.Clear();
                    dateTime = dataBegin;
                }
            }

            Msg = $"下载 厚度数据 [{dateTime} - Now]....";
            mCurrBlowing.GetADList(dateTime,
                (object asyncContext, object retData) => {
                    var p = retData as GetADListReponse;
                    if (p.datas != null && p.datas.Count() > 0)
                    {
                        mThkList.AddRange(
                            p.datas.Select(
                                a => new ThkCell()
                                {
                                    Thk = a.thk,
                                    Time = a.dt
                                }
                            ));
                    }

                    actionQueue.Next();
                }, null);
        }

        void DownloadData_OK()
        {
            NBolts = mCurrBlowing.NBolts;
            OrgBoltNo = mCurrBlowing.OrgBoltNo;
            if (OrgBoltNo < 1)
                OrgBoltNo = 1;

            //把下载的数据，都放入 旋转模拟器
            mRDetectCore.Init(
                mCurrRDetect.RollPerimeter,
                mCurrRDetect.RenZiJiaPeriod,
                mCurrRDetect.FilmLength,
                mRollList,
                mLimitList,
                mCurrRDetect.DefaultTime,
                mCurrRDetect.IsRPosMode,
                mCurrRDetect.OrgRPos,
                mCurrRDetect.RPosOfR,
                mRPosList,
                mCurrRDetect.Direction);

            UpdateLimitValues();
            UpdateThicknessValues();
            UpdateVelocityValues(VelocityFilter);
            if (mCurrRDetect.IsRPosMode)
            {
                UpdateAngleValues();
            }

            UpdateThkList();
            UpdateFrames();

            Msg = "数据下载完成";
            IsDownloading = false;
            IsDataReady = true;
        }

        public void UpdateVelocityValues(int velocity_filter)
        {
            VelocityFilter = velocity_filter;
            var filter_half = TimeSpan.FromSeconds(VelocityFilter / 2.0);

            VelocityValues.Clear();

            for (int i = 0; i < mRollList.Count(); i++)
            {

                var sysTime_min = mRollList[i].SysTime - filter_half;
                var sysTime_max = mRollList[i].SysTime + filter_half;

                int i_begin = 0;
                int i_end = mRollList.Count() - 1;

                for (int j = i; j >= 0; j--)
                {
                    if (mRollList[j].SysTime <= sysTime_min)
                    {
                        //找到了 
                        i_begin = j;
                        break;
                    }
                }

                for (int j = i; j < mRollList.Count(); j++)
                {
                    if (mRollList[j].SysTime >= sysTime_max)
                    {
                        //找到了 
                        i_end = j;
                        break;
                    }
                }

                if (i_begin == i_end)
                {
                    i_begin = i;
                    i_end = i + 1;
                    if (i_end >= mRollList.Count())
                    {
                        i_begin = i - 1;
                        i_end = i;
                    }
                }

                TimeSpan ts = mRollList[i_end].SysTime - mRollList[i_begin].SysTime;
                double minute = 1.0 * ts.Ticks / TimeSpan.TicksPerMinute;
                double v = (i_end - i_begin) * mCurrRDetect.RollPerimeter / 1000 / minute;
                VelocityValues.Add(
                    new TimeValue()
                    {
                        Time = mRollList[i].Time,
                        Value = v
                    });
            }
            OnPropertyChanged(nameof(VelocityValues));

            Velocity1 = VelocityValues.Average(tv => tv.Value);


        }

        void UpdateThicknessValues()
        {
            ThicknessValues.Clear();
            foreach (var thkcell in mThkList)
            {
                ThicknessValues.Add(
                    new TimeValue()
                    {
                        Time = thkcell.Time,
                        Value = thkcell.Thk
                    });
            }
            OnPropertyChanged(nameof(ThicknessValues));
        }
        void UpdateLimitValues()
        {
            LimitValues.Clear();
            foreach (var limit in mLimitList)
            {
                DateTime dt = limit.dt_begin;
                if (dt == DateTime.MinValue)
                    dt = limit.dt_end;

                LimitValues.Add(new TimeValue() { Time = dt, Value = limit.no });
            }
            OnPropertyChanged(nameof(LimitValues));
        }

        /// <summary>
        /// 通过旋转脉冲算出旋转角度曲线
        /// </summary>
        void UpdateAngleValues()
        {
            AngleValues.Clear();
            if (mRPosList != null)
            {
                foreach (var rPosData in mRPosList)
                {
                    var angle = mRDetectCore.GetAngleByGlobalRPos(rPosData.GlobalRPos);
                    AngleValues.Add(new TimeValue() { Time = rPosData.Time, Value = angle });
                }
            }
            OnPropertyChanged(nameof(AngleValues));
        }

        void UpdateThkList()
        {
            for (int i = 0; i < mThkList.Count(); i++)
            {
                ThkCell c = mThkList[i];

                int ret = mRDetectCore.GetFilmInfo(
                    out FilmInfo filminfo,
                    mThkList[i].Time);
                if (ret > 0)//发生在辊信号的未来，把数据删除！！！！
                {
                    //异常
                    mThkList.RemoveRange(i, mThkList.Count() - i);
                    return;
                }
                if (filminfo.rotationCnt == 1)
                {

                }
                else if (filminfo.rotationCnt != 1)
                {

                }

                //计算相关性，只使用 膜边=0mm 模式
                c.Direction = filminfo.direction;
                c.Angles.Clear();
                c.Angles.Add(filminfo.angle1);
                c.RotationCnt = filminfo.rotationCnt;
                c.Velocity = filminfo.filmVelocity;
                c.InCV = filminfo.inCV;

            }
        }

        public void SetFilmLength(double filmLength)
        {
            FilmLength = filmLength;
            mRDetectCore.FilmLength = filmLength;
            UpdateThkList();
            UpdateFrames();
        }
        void UpdateFrames()
        {
            Frames = GetFrames();
        }
        List<Frame> GetFrames()
        {
            List<Frame> frames = new List<Frame>();
            int boltIndex = -1;
            List<double> datas = new List<double>();

            int roationCnt = -1;
            Frame frame = null;

            foreach (ThkCell c in mThkList)
            {
                int bi = (int)(NBolts * c.Angles[0] / 360);
                if (bi < 0) bi = 0;
                else if (bi >= NBolts) bi = NBolts - 1;


                int boltno = bi + OrgBoltNo;
                if (boltno > NBolts)
                    boltno -= NBolts;

                //添加到
                if ((roationCnt == -1) || (roationCnt != c.RotationCnt)
                    )
                {
                    roationCnt = c.RotationCnt;

                    frame = new Frame();
                    frame.RotationCnt = roationCnt;
                    frame.Direction = c.Direction;
                    frame.Thicks = new double[NBolts];
                    for (int j = 0; j < frame.Thicks.Count(); j++)
                        frame.Thicks[j] = double.NaN;

                    frames.Add(frame);
                    boltIndex = -1;
                }

                if ((boltIndex == -1) || (boltIndex != boltno - 1))
                {
                    datas.Clear();
                }

                datas.Add(c.Thk);
                boltIndex = boltno - 1;
                double avg = datas.AverageNoNull();

                if (!double.IsNaN(avg))
                    frame.Thicks[boltIndex] = avg;


            }

            //计算整体相关性，TODO
            //for (int i = 1; i < frames.Count; i++)
            //{
            //    frames[i].IsVaild = 1.0 * frames[i].Thicks.Count(t => !double.IsNaN(t)) / frames[i].Thicks.Count() > 0.3;
            //    if (frames[i].IsVaild)
            //    {
            //        //计算相关性
            //        frames[i].R = Misc.MyMath.Correl(frames[i].Thicks, frames[i - 1].Thicks);
            //    }

            //}
            return frames;
        }


        bool TestFilmLength(double filmlength, ref double max_r, ref double best_filmlength, out double r)
        {
            bool ret = false;
            mRDetectCore.FilmLength = filmlength;
            UpdateThkList();
            var frames = GetFrames();
            r = frames.Max(f => f.R);
            if (r > max_r)
            {
                max_r = r;
                best_filmlength = mRDetectCore.FilmLength;
                ret = true;
            }


            return ret;
        }

        public async void Cal(double begin_filmlength, double end_filmlength)
        {
            if (mRDetectCore.RotationCnt < 3)
            {
                Msg = "---警告--- 没法自动计算，旋转次数少于3次";
                return;
            }
            if (begin_filmlength < 3)
                begin_filmlength = 3;

            if (end_filmlength > 50)
                end_filmlength = 50;

            IsCaling = true;

            double max_r = 0;
            double best_filmlength = FilmLength;

            await Task.Factory.StartNew(() =>
            {
                for (double i = begin_filmlength; i < end_filmlength; i += 0.1)
                {
                    TestFilmLength(i, ref max_r, ref best_filmlength, out double r);
                    int progress = (int)((i - begin_filmlength) / (end_filmlength - begin_filmlength) * 100);
                    Msg = $"{progress:000}/100 {i:F1}m R={r:F3}  最合理[{best_filmlength:F1}m MaxR={max_r:F3}]";
                }
            });

            SetFilmLength(best_filmlength);
            Msg = $"最合理[{best_filmlength:F1}m MaxR={max_r:F3}]";
            IsCaling = false;
        }



        public event PropertyChangedEventHandler PropertyChanged;


        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        //string file_path = "bulkdb.json";
        public void Save(string file_path)
        {
            try
            {
                CalFilmLen360JsonDb param = new CalFilmLen360JsonDb()
                {
                    RollPerimeter = mRDetectCore.RollPerimeter,
                    RenZiJiaPeriod = mRDetectCore.RenZiJiaPeriod,
                    FilmLength = mRDetectCore.FilmLength,
                    mRollList = mRDetectCore.mRollList.Select(r => new RollCell() { Time = r.Time, SysTime = r.SysTime }).ToList(),
                    mLimitList = mRDetectCore.mLimitList,
                    DefaultTime = mRDetectCore.DefaultTime,
                    IsRPosMode = mRDetectCore.IsRPosMode,
                    mRPosList = mRDetectCore.mRPosList,
                    RPosOfR = mRDetectCore.RPosOfR,
                    OrgRPos = mRDetectCore.OrgRPos,

                    NBolts = NBolts,
                    OrgBoltNo = OrgBoltNo,
                    mADList = mThkList.Select(a => new ADSingle() { dt = a.Time, thk = a.Thk }).ToList()
                };

                File.WriteAllText(file_path, JsonConvert.SerializeObject(param, Formatting.Indented));
            }
            catch
            {
                //异常，没有json 编码失败

            }
        }
        public void Load(string file_path)
        {
            try
            {
                if (File.Exists(file_path))
                {
                    string json = File.ReadAllText(file_path);

                    var param = JsonConvert.DeserializeObject<CalFilmLen360JsonDb>(json);
                    Load(param);
                }
            }
            catch
            {
                //异常，没有json 解码失败

            }
        }

        void Load(CalFilmLen360JsonDb param)
        {
            mLimitList.Clear();
            mRPosList.Clear();
            mRollList.Clear();

            mLimitList.AddRange(param.mLimitList);
            mRPosList.AddRange(param.mRPosList);
            mRollList.AddRange(param.mRollList);

            IsRPosMode = param.IsRPosMode;

            mRDetectCore.Init(
                param.RollPerimeter,
                param.RenZiJiaPeriod,
                param.FilmLength,
                param.mRollList,
                param.mLimitList,
                param.DefaultTime,
                param.IsRPosMode,
                param.OrgRPos,
                param.RPosOfR,
                param.mRPosList,
                param.Direction);

            NBolts = param.NBolts;
            OrgBoltNo = param.OrgBoltNo;
            if (OrgBoltNo < 1)
                OrgBoltNo = 1;
            FilmLength = param.FilmLength;

            mLimitList = param.mLimitList;
            mRollList = param.mRollList;

            mThkList = param.mADList.Select(
                a => new ThkCell()
                {
                    Thk = a.thk,//TODO 以后把 mADList 变成 mThkList
                    Time = a.dt
                }
                ).ToList();

            UpdateLimitValues();
            UpdateThicknessValues();
            UpdateVelocityValues(VelocityFilter);
            UpdateAngleValues();

            UpdateThkList();
            UpdateFrames();

            IsDataReady = true;
        }

        public void Test()
        {
            CalFilmLen360JsonDb param = new CalFilmLen360JsonDb()
            {
                NBolts = 96,
                RollPerimeter = 314,
                FilmLength = 24,
                RenZiJiaPeriod = TimeSpan.FromMinutes(6.1),
                mADList = new List<ADSingle>(),
                mLimitList = new List<LimitCell>(),
                mRollList = new List<RollCell>()
            };

            #region 虚拟数据
            int[] thicks = new int[]{
                3518    ,
                3484    ,
                3634    ,
                3620    ,
                3579    ,
                3625    ,
                3635    ,
                3638    ,
                3635    ,
                3606    ,
                3611    ,
                3603    ,
                3590    ,
                3631    ,
                3646    ,
                3647    ,
                3710    ,
                3705    ,
                3607    ,
                3720    ,
                3680    ,
                3637    ,
                3659    ,
                3703    ,
                3860    ,
                3720    ,
                3615    ,
                3810    ,
                3772    ,
                3666    ,
                3614    ,
                3627    ,
                3618    ,
                3502    ,
                3575    ,
                3583    ,
                3615    ,
                3680    ,
                3730    ,
                3840    ,
                3927    ,
                3946    ,
                3923    ,
                3841    ,
                3797    ,
                3865    ,
                3810    ,
                3711    ,
                3754    ,
                3705    ,
                3723    ,
                3699    ,
                3723    ,
                3801    ,
                3786    ,
                3798    ,
                3907    ,
                3945    ,
                3828    ,
                3860    ,
                3846    ,
                3903    ,
                3871    ,
                3844    ,
                3759    ,
                3816    ,
                3886    ,
                3815    ,
                3789    ,
                3876    ,
                3942    ,
                3854    ,
                3842    ,
                3921    ,
                3846    ,
                3835    ,
                3886    ,
                3881    ,
                3820    ,
                3787    ,
                3730    ,
                3617    ,
                3650    ,
                3610    ,
                3536    ,
                3545    ,
                3564    ,
                3584    ,
                3580    ,
                3572    ,
                3571    ,
                3579    ,
                3620    ,
                3634    ,
                3484    ,
                3518    ,
                };

            //线速度 m/min
            double FilmVelocity = 20;
            TimeSpan Cool = TimeSpan.FromSeconds(2.3);
            //速度震荡周期 m
            double FV_Range = 2;
            TimeSpan DataLen = TimeSpan.FromMinutes(30);

            DateTime dt_begin = DateTime.Now;
            DateTime dt_end = dt_begin + DataLen;



            for (TimeSpan ts = TimeSpan.Zero; ts < DataLen; ts += TimeSpan.FromSeconds(1))
            {
                DateTime dt = dt_begin + ts;
                double min = ts.TotalMinutes;

                //速度以1/2旋转周期变化
                double v = FilmVelocity + Math.Sin(Math.PI * 2 * min / (param.RenZiJiaPeriod.TotalMinutes / 2)) * FV_Range;

                if (param.mRollList.Count() == 0)
                {
                    param.mRollList.Add(new RollCell() { Time = dt });
                }
                else
                {
                    while ((dt - param.mRollList.Last().Time).TotalMinutes * v > (param.RollPerimeter / 1000))
                    {
                        param.mRollList.Add(new RollCell()
                        {
                            Time = param.mRollList.Last().Time + TimeSpan.FromMinutes((param.RollPerimeter / 1000) / v)
                        });
                    }
                }

                //int n = ((int)(min / param.RenZiJiaPeriod.TotalMinutes)) % 2;

                double min2 = min - param.FilmLength / v + param.RenZiJiaPeriod.TotalMinutes * 2;

                //int n2 = ((int)(min2 / param.RenZiJiaPeriod.TotalMinutes)) % 2;
                double m = min2 % param.RenZiJiaPeriod.TotalMinutes;
                int idx = (int)(thicks.Count() * m / param.RenZiJiaPeriod.TotalMinutes);
                if (idx < 0) idx = 0;
                else if (idx > thicks.Count()) idx = thicks.Count() - 1;

                int thick;

                //if (n2 == 0)
                thick = thicks[idx];
                //else
                //    thick = thicks[thicks.Count() - 1 - idx];


                param.mADList.Add(new ADSingle
                {
                    dt = dt,
                    thk = thick
                });

                if (param.mLimitList.Count() == 0)
                {
                    if (dt >= dt_begin + param.RenZiJiaPeriod)
                    {
                        param.mLimitList.Add(new LimitCell()
                        {
                            dt_begin = dt_begin + param.RenZiJiaPeriod,
                            dt_end = dt_begin + param.RenZiJiaPeriod + Cool,
                            no = 0
                        });
                    }
                }
                else if (dt >= param.mLimitList.Last().dt_end + param.RenZiJiaPeriod)
                {
                    param.mLimitList.Add(new LimitCell()
                    {
                        dt_begin = param.mLimitList.Last().dt_end + param.RenZiJiaPeriod,
                        dt_end = param.mLimitList.Last().dt_end + param.RenZiJiaPeriod + Cool,
                        no = 0
                    });
                }
            }





            #endregion

            Load(param);
        }
    }

    public class CalFilmLen360JsonDb
    {
        /// <summary>
        /// 辊周长，单位mm
        /// </summary>
        public double RollPerimeter;
        /// <summary>
        /// 离开限位 到 撞下一个限位  的 旋转架转动时间， 需要初始值，以后测量出来的
        /// </summary>
        public TimeSpan RenZiJiaPeriod;
        /// <summary>
        /// 人字架到测厚仪膜长 单位m
        /// </summary>
        public double FilmLength;

        /// <summary>
        /// 辊信号列表
        /// </summary>
        public List<RollCell> mRollList;

        /// <summary>
        /// 转向信号列表
        /// </summary>
        public List<LimitCell> mLimitList;

        public List<ADSingle> mADList;

        public DateTime DefaultTime;
        public bool IsRPosMode;
        public int OrgRPos;
        public int RPosOfR;
        public List<RPosData> mRPosList;

        public int NBolts;
        public int OrgBoltNo = 1;

        public Misc.DIRECTION Direction;

    }
}