using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Calculation
{
    /// <summary>
    /// 监测公式计算辅助类
    /// </summary>
    public class MonitorFormulaCalcuHelper 
    {
        #region 统计

        /// <summary>
        /// 统计
        /// </summary>
        public static double Statistical
            (
                string analyParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;
            double srcValue = 0;
            var analyModel = Model.Monitor.AnalyseParameters.ToModel(analyParas);
            if (analyModel == null)
            {
                Msg= "分析参数配置错误";
                return srcValue;
            }
            if (string.IsNullOrEmpty(analyModel.FormulaType))
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            switch (analyModel.FormulaType)
            {
                case Model.Monitor.FormulaType.Statistics_Max:
                    {
                        srcValue = StatisticalMaxValue(analyModel.FormulaParas,getMonitorPoint,getSignal,getRecordList,out Msg);
                    }
                    break;
                case Model.Monitor.FormulaType.Statistics_Min:
                    {
                        srcValue = StatisticalMinValue(analyModel.FormulaParas, getMonitorPoint, getSignal, getRecordList, out Msg);
                    }
                    break;
                case Model.Monitor.FormulaType.Statistics_Avg:
                    {
                        srcValue = StatisticalAvgValue(analyModel.FormulaParas, getMonitorPoint, getSignal, getRecordList, out Msg);
                    }
                    break;
                case Model.Monitor.FormulaType.Statistics_Diff:
                    {
                        srcValue = StatisticalDiffValue(analyModel.FormulaParas, getMonitorPoint, getSignal, getRecordList, out Msg);
                    }
                    break;
                case Model.Monitor.FormulaType.Statistics_Sum:
                    {
                        srcValue = StatisticalSumValue(analyModel.FormulaParas, getMonitorPoint, getSignal, getRecordList, out Msg);
                    }
                    break;
                default: 
                    {
                        Msg = "公式参数配置错误";
                    }
                    break;
            }
            return srcValue;
        }

        /// <summary>
        /// 统计最大值
        /// </summary>
        public static double StatisticalMaxValue
            (
                string formularParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long,Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;

            #region 数据验证

            var formulaModel = Model.Monitor.MaxValueStatisticsFormulaParas.ToModel(formularParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var relatedRecordList = getRecordList(relatedMonitor.ID, relatedSignal.ID,relatedMonitor.CronType);
            if (relatedRecordList == null || relatedRecordList.Count < 1)
            {
                Msg = "获取关联记录失败";
                return default;
            }

            var srcValueList = new List<double>();
            foreach (var relatedRecord in relatedRecordList)
            {
                if (double.TryParse(relatedRecord.DataValue, out double relatedDataValue))
                {
                    srcValueList.Add(relatedDataValue);
                }
            }
            if (srcValueList.Count < 1)
            {
                Msg = "获取有效关联记录为空";
                return default;
            }
            var srcValue = formulaModel.Statistic(srcValueList);

            #endregion

            return srcValue;

        }

        /// <summary>
        /// 统计最小值
        /// </summary>
        public static double StatisticalMinValue
            (
                string formularParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;

            #region 数据验证

            var formulaModel = Model.Monitor.MinValueStatisticsFormulaParas.ToModel(formularParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var relatedRecordList = getRecordList(relatedMonitor.ID, relatedSignal.ID,relatedMonitor.CronType);
            if (relatedRecordList == null || relatedRecordList.Count < 1)
            {
                Msg = "获取关联记录失败";
                return default;
            }

            var srcValueList = new List<double>();
            foreach (var relatedRecord in relatedRecordList)
            {
                if (double.TryParse(relatedRecord.DataValue, out double relatedDataValue))
                {
                    srcValueList.Add(relatedDataValue);
                }
            }
            if (srcValueList.Count < 1)
            {
                Msg = "获取有效关联记录为空";
                return default;
            }
            var srcValue = formulaModel.Statistic(srcValueList);

            #endregion

            return srcValue;

        }

        /// <summary>
        /// 统计平均值
        /// </summary>
        public static double StatisticalAvgValue
            (
                string formularParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;

            #region 数据验证

            var formulaModel = Model.Monitor.AvgValueStatisticsFormulaParas.ToModel(formularParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var relatedRecordList = getRecordList(relatedMonitor.ID, relatedSignal.ID,relatedMonitor.CronType);
            if (relatedRecordList == null || relatedRecordList.Count < 1)
            {
                Msg = "获取关联记录失败";
                return default;
            }

            var srcValueList = new List<double>();
            foreach (var relatedRecord in relatedRecordList)
            {
                if (double.TryParse(relatedRecord.DataValue, out double relatedDataValue))
                {
                    srcValueList.Add(relatedDataValue);
                }
            }
            if (srcValueList.Count < 1)
            {
                Msg = "获取有效关联记录为空";
                return default;
            }
            var srcValue = formulaModel.Statistic(srcValueList);

            #endregion

            return srcValue;

        }

        /// <summary>
        /// 统计差值
        /// </summary>
        public static double StatisticalDiffValue
            (
                string formularParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;

            #region 数据验证

            var formulaModel = Model.Monitor.DiffValueStatisticsFormulaParas.ToModel(formularParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var relatedRecordList = getRecordList(relatedMonitor.ID, relatedSignal.ID,relatedMonitor.CronType);
            if (relatedRecordList == null || relatedRecordList.Count < 1)
            {
                Msg = "获取关联记录失败";
                return default;
            }

            var srcValueList = new List<double>();
            foreach (var relatedRecord in relatedRecordList)
            {
                if (double.TryParse(relatedRecord.DataValue, out double relatedDataValue))
                {
                    srcValueList.Add(relatedDataValue);
                }
            }
            if (srcValueList.Count < 1)
            {
                Msg = "获取有效关联记录为空";
                return default;
            }
            var srcValue = formulaModel.Statistic(srcValueList);

            #endregion

            return srcValue;

        }

        /// <summary>
        /// 统计和值
        /// </summary>
        public static double StatisticalSumValue
            (
                string formularParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.Monitor.eCronType, List<Model.MonitorBasicRecordContent>> getRecordList,
                out string Msg
            )
        {
            Msg = string.Empty;

            #region 数据验证

            var formulaModel = Model.Monitor.SumValueStatisticsFormulaParas.ToModel(formularParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var relatedRecordList = getRecordList(relatedMonitor.ID, relatedSignal.ID,relatedMonitor.CronType);
            if (relatedRecordList == null || relatedRecordList.Count < 1)
            {
                Msg = "获取关联记录失败";
                return default;
            }

            var srcValueList = new List<double>();
            foreach (var relatedRecord in relatedRecordList)
            {
                if (double.TryParse(relatedRecord.DataValue, out double relatedDataValue))
                {
                    srcValueList.Add(relatedDataValue);
                }
            }
            if (srcValueList.Count < 1)
            {
                Msg = "获取有效关联记录为空";
                return default;
            }
            var srcValue = formulaModel.Statistic(srcValueList);

            #endregion

            return srcValue;

        }

        #endregion

        #region 映射

        /// <summary>
        /// 计算单一映射(实时)
        /// </summary>
        public static double CalcuSingleMapping
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long,long,Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            double srcValue = 0;

            #region 数据验证

            var formulaModel = Model.Monitor.SingleMappingCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID,relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return srcValue;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return srcValue;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return srcValue;
            }
            if (!formulaModel.Calculate(dataValue, out srcValue))
            {
                Msg = "计算原始值发生错误";
                return srcValue;
            }

            return srcValue;

            #endregion
        }

        /// <summary>
        /// 计算比较映射(实时)
        /// </summary>
        public static double CalcuCompareMapping 
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            double srcValue = 0;

            #region 数据验证

            var formulaModel = Model.Monitor.CompareMappingCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return srcValue;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return srcValue;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return srcValue;
            }
            if (!formulaModel.Calculate(dataValue, out srcValue))
            {
                Msg = "计算原始值发生错误";
                return srcValue;
            }

            return srcValue;

            #endregion
        }

        /// <summary>
        /// 计算区间映射(实时)
        /// </summary>
        public static double CalcuRangeMapping 
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            double srcValue = 0;

            #region 数据验证

            var formulaModel = Model.Monitor.RangeMappingCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return srcValue;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return srcValue;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return srcValue;
            }
            if (!formulaModel.Calculate(dataValue, out srcValue))
            {
                Msg = "计算原始值发生错误";
                return srcValue;
            }

            return srcValue;

            #endregion
        }

        #endregion

        #region 系数

        /// <summary>
        /// 计算一元系数(实时)
        /// </summary>
        public static double CalcuOnceRatio
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            double srcValue = 0;

            #region 数据验证

            var formulaModel = Model.Monitor.OnceRatioCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return srcValue;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return srcValue;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return srcValue;
            }
            if (!formulaModel.Calculate(dataValue, out srcValue))
            {
                Msg = "计算原始值发生错误";
                return srcValue;
            }

            return srcValue;

            #endregion

        }

        /// <summary>
        /// 计算二元系数(实时)
        /// </summary>
        public static double CalcuTwiceRatio
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            double srcValue = 0;

            #region 数据验证

            var formulaModel = Model.Monitor.TwiceRatioCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return srcValue;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            #endregion

            #region 计算原始值

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return srcValue;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return srcValue;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return srcValue;
            }
            if (!formulaModel.Calculate(dataValue, out srcValue))
            {
                Msg = "计算原始值发生错误";
                return srcValue;
            }

            return srcValue;

            #endregion
        }

        #endregion

        /// <summary>
        /// 计算运行状态
        /// </summary>
        public static double CalcuRunStatus
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.RunStatusCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            if (formulaModel.JudgeItems == null || formulaModel.JudgeItems.Count < 1)
            {
                Msg = "公式参数配置错误";
                return default;
            }

            int runStatus = RunStatus.UnKnown;
            //必须满足的列表
            var judgeAndItemList = formulaModel.JudgeItems.Where(x => x.OperateType == Model.Monitor.RunStatusCalculationFormulaParas.eOperateType.And).ToList();
            foreach (var judgeAndItem in judgeAndItemList)
            {
                switch (judgeAndItem.JudgeType)
                {
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.RS:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.RunStatusJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据运行状态项）";
                                break;
                            }
                            var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                            if (relatedMonitor == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                break;
                            }
                            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                break;
                            }
                            var relatedSignal = getSignal(relatedMonitor.ID);
                            if (relatedSignal == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联信号不存在";
                                break;
                            }
                            var startTime = DateTime.Now;
                            var relatedRecord = getLastRecord(relatedMonitor.ID,relatedSignal.ID);
                            var endTime = DateTime.Now;
                            var errorSecond = (endTime - startTime).TotalSeconds;
                            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                            if (realSolt == null)
                            {
                                realSolt = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            runStatus = dataValue > 0 ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.P:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据功率项）";
                                break;
                            }
                            var relatedMonitor = getMonitorPoint(judgeModel.ObjectID); 
                            if (relatedMonitor == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                break;
                            }
                            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                break;
                            }
                            var relatedSignal = getSignal(relatedMonitor.ID);
                            if (relatedSignal == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                break;
                            }
                            var startTime = DateTime.Now;
                            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                            var endTime = DateTime.Now;
                            var errorSecond = (endTime - startTime).TotalSeconds;
                            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                            if (realSolt == null)
                            {
                                realSolt = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            runStatus = dataValue >= judgeModel.ThresholdValue ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.Pr:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.PressureDiffThresholdJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据压差项）";
                                break;
                            }

                            #region 进口压力

                            var relatedMonitorPr1 = getMonitorPoint(judgeModel.Pr1);
                            if (relatedMonitorPr1 == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.Pr1},不存在";
                                break;
                            }
                            if (relatedMonitorPr1.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.Pr1},不可用";
                                break;
                            }
                            var relatedSignalPr1 = getSignal(relatedMonitorPr1.ID); 
                            if (relatedSignalPr1 == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{relatedMonitorPr1.ID},未检索到信号信息";
                                break;
                            }
                            var startTimePr1 = DateTime.Now;
                            var relatedRecordPr1 = getLastRecord(relatedMonitorPr1.ID, relatedSignalPr1.ID);
                            var endTimePr1 = DateTime.Now;
                            var errorSecondPr1 = (endTimePr1 - startTimePr1).TotalSeconds;
                            var realSoltPr1 = Model.Monitor.RealSlot.ToModel(relatedMonitorPr1.CronParas);
                            if (realSoltPr1 == null)
                            {
                                realSoltPr1 = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecordPr1.DataTime < realSoltPr1.GetStartTime(startTimePr1).AddSeconds(-errorSecondPr1))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecordPr1.DataValue, out double dataValuePr1))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            #endregion

                            #region 进口压力

                            var relatedMonitorPr2 = getMonitorPoint(judgeModel.Pr2);
                            if (relatedMonitorPr2 == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.Pr2},不存在";
                                break;
                            }
                            if (relatedMonitorPr2.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.Pr2},不可用";
                                break;
                            }
                            var relatedSignalPr2 = getSignal(relatedMonitorPr2.ID);
                            if (relatedSignalPr2 == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{relatedMonitorPr2.ID},未检索到信号信息";
                                break;
                            }
                            var startTimePr2 = DateTime.Now;
                            var relatedRecordPr2 = getLastRecord(relatedMonitorPr2.ID, relatedSignalPr2.ID);
                            var endTimePr2 = DateTime.Now;
                            var errorSecondPr2 = (endTimePr2 - startTimePr2).TotalSeconds;
                            var realSoltPr2 = Model.Monitor.RealSlot.ToModel(relatedMonitorPr2.CronParas);
                            if (realSoltPr2 == null)
                            {
                                realSoltPr2 = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecordPr2.DataTime < realSoltPr2.GetStartTime(startTimePr2).AddSeconds(-errorSecondPr2))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecordPr2.DataValue, out double dataValuePr2)) 
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }
                            #endregion

                            runStatus = dataValuePr2 - dataValuePr1 >= judgeModel.ThresholdValue ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.Q:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据流量项）";
                                break;
                            }
                            var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                            if (relatedMonitor == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                break;
                            }
                            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                break;
                            }
                            var relatedSignal = getSignal(relatedMonitor.ID);
                            if (relatedSignal == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                break;
                            }
                            var startTime = DateTime.Now;
                            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                            var endTime = DateTime.Now;
                            var errorSecond = (endTime - startTime).TotalSeconds;
                            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                            if (realSolt == null)
                            {
                                realSolt = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            runStatus = dataValue >= judgeModel.ThresholdValue ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.I:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据电流项）";
                                break;
                            }
                            var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                            if (relatedMonitor == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                break;
                            }
                            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                break;
                            }
                            var relatedSignal = getSignal(relatedMonitor.ID);
                            if (relatedSignal == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                break;
                            }
                            var startTime = DateTime.Now;
                            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                            var endTime = DateTime.Now;
                            var errorSecond = (endTime - startTime).TotalSeconds;
                            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                            if (realSolt == null)
                            {
                                realSolt = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            runStatus = dataValue >= judgeModel.ThresholdValue ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.HZ:
                        {
                            var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeAndItem.JudgeParas);
                            if (judgeModel == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "公式参数配置错误（根据频率项）";
                                break;
                            }
                            var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                            if (relatedMonitor == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                break;
                            }
                            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                break;
                            }
                            var relatedSignal = getSignal(relatedMonitor.ID);
                            if (relatedSignal == null)
                            {
                                runStatus = RunStatus.Shut;
                                Msg = $"关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                break;
                            }
                            var startTime = DateTime.Now;
                            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                            var endTime = DateTime.Now;
                            var errorSecond = (endTime - startTime).TotalSeconds;
                            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                            if (realSolt == null)
                            {
                                realSolt = new Model.Monitor.RealSlot();
                            }
                            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录已失效";
                                break;
                            }
                            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                            {
                                runStatus = RunStatus.Shut;
                                Msg = "关联记录数据格式错误";
                                break;
                            }

                            runStatus = dataValue >= judgeModel.ThresholdValue ? RunStatus.Run : RunStatus.Shut;
                        }
                        break;
                    default: break;
                }
                if (runStatus == RunStatus.Shut)
                {
                    break;
                }
            }

            //不需要满足的条件
            if (runStatus == RunStatus.UnKnown)
            {
                var judgeOrItemList = formulaModel.JudgeItems.Where(x => x.OperateType == Model.Monitor.RunStatusCalculationFormulaParas.eOperateType.Or).ToList();
                foreach (var judgeOrItem in judgeOrItemList)
                {
                    switch (judgeOrItem.JudgeType)
                    {
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.RS:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.RunStatusJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据运行状态项）";
                                    break;
                                }
                                var relatedMonitor = getMonitorPoint(judgeModel.ObjectID); 
                                if (relatedMonitor == null)
                                {
                                    Msg = $"关联测点：{judgeModel.ObjectID},不存在";
                                    break;
                                }
                                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = $"关联测点：{judgeModel.ObjectID},不可用";
                                    break;
                                }
                                var relatedSignal = getSignal(relatedMonitor.ID); 
                                if (relatedSignal == null)
                                {
                                    Msg = $"关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                    break;
                                }
                                var startTime = DateTime.Now;
                                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                                var endTime = DateTime.Now;
                                var errorSecond = (endTime - startTime).TotalSeconds;
                                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                                if (realSolt == null)
                                {
                                    realSolt = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }

                                if (dataValue > 0)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.P:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据功率项）";
                                    break;
                                }
                                var relatedMonitor = getMonitorPoint(judgeModel.ObjectID); 
                                if (relatedMonitor == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不存在";
                                    break;
                                }
                                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不可用";
                                    break;
                                }
                                var relatedSignal = getSignal(relatedMonitor.ID);
                                if (relatedSignal == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                    break;
                                }
                                var startTime = DateTime.Now;
                                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                                var endTime = DateTime.Now;
                                var errorSecond = (endTime - startTime).TotalSeconds;
                                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                                if (realSolt == null)
                                {
                                    realSolt = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }
                                if (dataValue >= judgeModel.ThresholdValue)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.Pr:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.PressureDiffThresholdJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据压差项）";
                                    break;
                                }

                                #region 进口压力

                                var relatedMonitorPr1 = getMonitorPoint(judgeModel.Pr1);
                                if (relatedMonitorPr1 == null)
                                {
                                    Msg = $"关联测点：{judgeModel.Pr1},不存在";
                                    break;
                                }
                                if (relatedMonitorPr1.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = $"关联测点：{judgeModel.Pr1},不可用";
                                    break;
                                }
                                var relatedSignalPr1 = getSignal(relatedMonitorPr1.ID);
                                if (relatedSignalPr1 == null)
                                {
                                    Msg = $"关联测点：{relatedMonitorPr1.ID},未检索到信号信息";
                                    break;
                                }
                                var startTimePr1 = DateTime.Now;
                                var relatedRecordPr1 = getLastRecord(relatedMonitorPr1.ID, relatedSignalPr1.ID);
                                var endTimePr1 = DateTime.Now;
                                var errorSecondPr1 = (endTimePr1 - startTimePr1).TotalSeconds;
                                var realSoltPr1 = Model.Monitor.RealSlot.ToModel(relatedMonitorPr1.CronParas);
                                if (realSoltPr1 == null)
                                {
                                    realSoltPr1 = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecordPr1.DataTime < realSoltPr1.GetStartTime(startTimePr1).AddSeconds(-errorSecondPr1))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecordPr1.DataValue, out double dataValuePr1))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }

                                #endregion

                                #region 进口压力

                                var relatedMonitorPr2 = getMonitorPoint(judgeModel.Pr2);
                                if (relatedMonitorPr2 == null)
                                {
                                    Msg = $"关联测点：{judgeModel.Pr2},不存在";
                                    break;
                                }
                                if (relatedMonitorPr2.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = $"关联测点：{judgeModel.Pr2},不可用";
                                    break;
                                }
                                var relatedSignalPr2 = getSignal(relatedMonitorPr2.ID);
                                if (relatedSignalPr2 == null)
                                {
                                    Msg = $"关联测点：{relatedMonitorPr2.ID},未检索到信号信息";
                                    break;
                                }
                                var startTimePr2 = DateTime.Now;
                                var relatedRecordPr2 = getLastRecord(relatedMonitorPr2.ID, relatedSignalPr2.ID);
                                var endTimePr2 = DateTime.Now;
                                var errorSecondPr2 = (endTimePr2 - startTimePr2).TotalSeconds;
                                var realSoltPr2 = Model.Monitor.RealSlot.ToModel(relatedMonitorPr2.CronParas);
                                if (realSoltPr2 == null)
                                {
                                    realSoltPr2 = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecordPr2.DataTime < realSoltPr2.GetStartTime(startTimePr2).AddSeconds(-errorSecondPr2))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecordPr2.DataValue, out double dataValuePr2))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }
                                #endregion
                                if (dataValuePr2 - dataValuePr1 >= judgeModel.ThresholdValue)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.Q:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据流量项）";
                                    break;
                                }
                                var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                                if (relatedMonitor == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不存在";
                                    break;
                                }
                                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不可用";
                                    break;
                                }
                                var relatedSignal = getSignal(relatedMonitor.ID);
                                if (relatedSignal == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                    break;
                                }
                                var startTime = DateTime.Now;
                                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                                var endTime = DateTime.Now;
                                var errorSecond = (endTime - startTime).TotalSeconds;
                                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                                if (realSolt == null)
                                {
                                    realSolt = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }
                                if (dataValue >= judgeModel.ThresholdValue)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.I:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据电流项）";
                                    break;
                                }
                                var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                                if (relatedMonitor == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不存在";
                                    break;
                                }
                                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不可用";
                                    break;
                                }
                                var relatedSignal = getSignal(relatedMonitor.ID);
                                if (relatedSignal == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                    break;
                                }
                                var startTime = DateTime.Now;
                                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                                var endTime = DateTime.Now;
                                var errorSecond = (endTime - startTime).TotalSeconds;
                                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                                if (realSolt == null)
                                {
                                    realSolt = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }
                                if (dataValue >= judgeModel.ThresholdValue)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        case Model.Monitor.RunStatusCalculationFormulaParas.eJudgeType.HZ:
                            {
                                var judgeModel = Model.Monitor.RunStatusCalculationFormulaParas.ThresholdJudgeParas.ToModel(judgeOrItem.JudgeParas);
                                if (judgeModel == null)
                                {
                                    Msg = "公式参数配置错误（根据频率项）";
                                    break;
                                }
                                var relatedMonitor = getMonitorPoint(judgeModel.ObjectID);
                                if (relatedMonitor == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不存在";
                                    break;
                                }
                                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},不可用";
                                    break;
                                }
                                var relatedSignal = getSignal(relatedMonitor.ID);
                                if (relatedSignal == null)
                                {
                                    Msg = "关联测点：{judgeModel.ObjectID},未检索到信号信息";
                                    break;
                                }
                                var startTime = DateTime.Now;
                                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                                var endTime = DateTime.Now;
                                var errorSecond = (endTime - startTime).TotalSeconds;
                                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                                if (realSolt == null)
                                {
                                    realSolt = new Model.Monitor.RealSlot();
                                }
                                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-errorSecond))
                                {
                                    Msg = "关联记录已失效";
                                    break;
                                }
                                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                                {
                                    Msg = "关联记录数据格式错误";
                                    break;
                                }
                                if (dataValue >= judgeModel.ThresholdValue)
                                {
                                    runStatus = RunStatus.Run;
                                }
                            }
                            break;
                        default: break;
                    }
                    if (runStatus == RunStatus.Run)
                    {
                        break;
                    }
                }
            }

            if (runStatus == RunStatus.UnKnown)
            {
                runStatus = RunStatus.Shut;
            }

            return runStatus;
        }


        /// <summary>
        /// 计算-和值
        /// </summary>
        public static double CalcuSum
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {

            Msg = string.Empty;
            var formulaModel = Model.Monitor.SumValueCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            if (formulaModel.ObjectIds == null || formulaModel.ObjectIds.Count < 1)
            {
                Msg = "公式参数配置错误";
                return default;
            }

            var relatedDataValueList = new List<double>();
            foreach (var objectId in formulaModel.ObjectIds)
            {
                var relatedMonitor = getMonitorPoint(objectId);
                if (relatedMonitor == null)
                {
                    Msg = "关联测点不存在";
                    break;
                }
                if (relatedMonitor.MonitorType != Model.eMonitorType.General)
                {
                    Msg = "关联测点不是常规测点";
                    break;
                }
                if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
                {
                    Msg = "关联测点不是实时测点";
                    break;
                }
                if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
                {
                    Msg = "关联测点不可用";
                    break;
                }
                var relatedSignal = getSignal(relatedMonitor.ID);
                if (relatedSignal == null)
                {
                    Msg = "关联信号不存在";
                    break;
                }

                var startTime = DateTime.Now;
                var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
                var endTime = DateTime.Now;
                var error_second = (endTime - startTime).TotalSeconds;
                if (relatedRecord == null)
                {
                    Msg = "未检索到记录信息";
                    break;
                }
                var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
                if (realSolt == null)
                {
                    realSolt = new Model.Monitor.RealSlot();
                }
                if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
                {
                    Msg = "关联记录已失效";
                    break;
                }
                if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
                {
                    Msg = "关联记录数据格式错误";
                    break;
                }
                relatedDataValueList.Add(dataValue);
            }
            if (relatedDataValueList.Count != formulaModel.ObjectIds.Count)
            {
                Msg = "关联数据记录异常";
                return default;
            }

            var srcValue = formulaModel.Calculate(relatedDataValueList);
            return srcValue;


        }

        /// <summary>
        /// 计算-差值
        /// </summary>
        public static double CalcuDiff
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.DiffValueCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }

            #region 第一个参数

            var relatedMonitor1 = getMonitorPoint(formulaModel.First);
            if (relatedMonitor1 == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor1.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor1.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor1.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal1 = getSignal(relatedMonitor1.ID);
            if (relatedSignal1 == null)
            {
                Msg = "关联信号不存在";
                return default;
            }
            var startTime1 = DateTime.Now;
            var relatedRecord1 = getLastRecord(relatedMonitor1.ID, relatedSignal1.ID);
            var endTime1 = DateTime.Now;
            var errorSecond1 = (endTime1 - startTime1).TotalSeconds;
            if (relatedRecord1 == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSolt1 = Model.Monitor.RealSlot.ToModel(relatedMonitor1.CronParas);
            if (realSolt1 == null)
            {
                realSolt1 = new Model.Monitor.RealSlot();
            }
            if (relatedRecord1.DataTime < realSolt1.GetStartTime(startTime1).AddSeconds(-errorSecond1))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecord1.DataValue, out double dataValue1))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 第二个参数

            var relatedMonitor2 = getMonitorPoint(formulaModel.Second);
            if (relatedMonitor2 == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor2.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor2.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor2.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal2 = getSignal(relatedMonitor2.ID);
            if (relatedSignal2 == null)
            {
                Msg = "关联信号不存在";
                return default;
            }
            var startTime2 = DateTime.Now;
            var relatedRecord2 = getLastRecord(relatedMonitor2.ID, relatedSignal2.ID);
            var endTime2 = DateTime.Now;
            var errorSecond2 = (endTime2 - startTime2).TotalSeconds;
            if (relatedRecord2 == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSolt2 = Model.Monitor.RealSlot.ToModel(relatedMonitor2.CronParas);
            if (realSolt2 == null)
            {
                realSolt2 = new Model.Monitor.RealSlot();
            }
            if (relatedRecord2.DataTime < realSolt2.GetStartTime(startTime2).AddSeconds(-errorSecond2))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecord2.DataValue, out double dataValue2))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion


            var srcValue =formulaModel.Calculate(dataValue2, dataValue1);
            return srcValue;
            

        }

        /// <summary>
        /// 计算数值累积
        /// </summary>
        public static double CalcuNumberAccumulate
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                int timeStep,
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                Func<Model.MonitorBasicRecord> getCurrentLastRecord,
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.NumberAccumulateCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            //原始值计算
            double second = timeStep;
            var record = getCurrentLastRecord();
            if (record != null)
            {
                second = (DateTime.Now - record.DataTime).TotalSeconds;
            }
            var srcValue = formulaModel.Calculate(dataValue, second);
            return srcValue;
        }

        /// <summary>
        /// 计算枚举累积
        /// </summary>
        public static double CalcuEnumAccumulate
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                int timeStep,
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                Func<Model.MonitorBasicRecord> getCurrentLastRecord,
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.EnumAccumulateCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }
            var relatedMonitor = getMonitorPoint(formulaModel.ObjectID);
            if (relatedMonitor == null)
            {
                Msg = "关联测点不存在";
                return default;
            }
            if (relatedMonitor.MonitorType != Model.eMonitorType.General)
            {
                Msg = "关联测点不是常规测点";
                return default;
            }
            if (relatedMonitor.CronType != Model.Monitor.eCronType.Real)
            {
                Msg = "关联测点不是实时测点";
                return default;
            }
            if (relatedMonitor.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点不可用";
                return default;
            }
            var relatedSignal = getSignal(relatedMonitor.ID);
            if (relatedSignal == null)
            {
                Msg = "关联信号不存在";
                return default;
            }

            var startTime = DateTime.Now;
            var relatedRecord = getLastRecord(relatedMonitor.ID, relatedSignal.ID);
            var endTime = DateTime.Now;
            var error_second = (endTime - startTime).TotalSeconds;
            if (relatedRecord == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSolt = Model.Monitor.RealSlot.ToModel(relatedMonitor.CronParas);
            if (realSolt == null)
            {
                realSolt = new Model.Monitor.RealSlot();
            }
            if (relatedRecord.DataTime < realSolt.GetStartTime(startTime).AddSeconds(-error_second))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecord.DataValue, out double dataValue))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            //原始值计算
            double second = timeStep;
            var record = getCurrentLastRecord();
            if (record != null)
            {
                second = (DateTime.Now - record.DataTime).TotalSeconds;
            }
            var srcValue = formulaModel.Calculate(dataValue, second);
            return srcValue;
        }

        /// <summary>
        /// 计算效率
        /// </summary>
        public static double CalcuE
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.ECalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }


            #region 流量参数

            var relatedMonitorQ = getMonitorPoint(formulaModel.Q);
            if (relatedMonitorQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},不存在";
                return default;
            }
            if (relatedMonitorQ.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.Q},不可用";
                return default;
            }
            var relatedSignalQ = getSignal(relatedMonitorQ.ID); 
            if (relatedSignalQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},未检索到信号信息";
                return default;
            }
            var startTimeQ = DateTime.Now;
            var relatedRecordQ = getLastRecord(relatedMonitorQ.ID, relatedSignalQ.ID);
            var endTimeQ = DateTime.Now;
            var errorSecondQ = (startTimeQ - endTimeQ).TotalSeconds;
            if (relatedRecordQ == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltQ = Model.Monitor.RealSlot.ToModel(relatedMonitorQ.CronParas);
            if (realSoltQ == null)
            {
                realSoltQ = new Model.Monitor.RealSlot();
            }
            if (relatedRecordQ.DataTime < realSoltQ.GetStartTime(startTimeQ).AddSeconds(-errorSecondQ))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordQ.DataValue, out double dataValueQ))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 扬程参数

            var relatedMonitorH = getMonitorPoint(formulaModel.H);
            if (relatedMonitorH == null)
            {
                Msg = "关联测点：{formulaModel.H},不存在";
                return default;
            }
            if (relatedMonitorH.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.H},不可用";
                return default;
            }
            var relatedSignalH = getSignal(relatedMonitorH.ID);
            if (relatedSignalH == null)
            {
                Msg = "关联测点：{formulaModel.H},未检索到信号信息";
                return default;
            }
            var startTimeH = DateTime.Now;
            var relatedRecordH = getLastRecord(relatedMonitorH.ID, relatedSignalH.ID);
            var endTimeH = DateTime.Now;
            var errorSecondH = (startTimeH - endTimeH).TotalSeconds;
            if (relatedRecordH == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltH = Model.Monitor.RealSlot.ToModel(relatedMonitorH.CronParas);
            if (realSoltH == null)
            {
                realSoltH = new Model.Monitor.RealSlot();
            }
            if (relatedRecordH.DataTime < realSoltH.GetStartTime(startTimeH).AddSeconds(-errorSecondH))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordH.DataValue, out double dataValueH)) 
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 功率参数

            var relatedMonitorP = getMonitorPoint(formulaModel.P);
            if (relatedMonitorP == null)
            {
                Msg = "关联测点：{formulaModel.P},不存在";
                return default;
            }
            if (relatedMonitorP.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.P},不可用";
                return default;
            }
            var relatedSignalP = getSignal(relatedMonitorP.ID);
            if (relatedSignalP == null)
            {
                Msg = "关联测点：{formulaModel.P},未检索到信号信息";
                return default;
            }
            var startTimeP = DateTime.Now;
            var relatedRecordP = getLastRecord(relatedMonitorP.ID, relatedSignalP.ID);
            var endTimeP = DateTime.Now;
            var errorSecondP = (startTimeP - endTimeP).TotalSeconds;
            if (relatedRecordP == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltP = Model.Monitor.RealSlot.ToModel(relatedMonitorP.CronParas);
            if (realSoltP == null)
            {
                realSoltP = new Model.Monitor.RealSlot();
            }
            if (relatedRecordP.DataTime < realSoltP.GetStartTime(startTimeP).AddSeconds(-errorSecondP))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordP.DataValue, out double dataValueP)) 
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            //原始值计算
            if (!formulaModel.Calculate(dataValueQ, dataValueH, dataValueP, out double dataValue))
            {
                Msg = "计算原始值错误";
                return default;
            }
            return dataValue;
        }

        /// <summary>
        /// 计算千吨能耗
        /// </summary>
        public static double CalcuWP
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.WPCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }


            #region 流量参数

            var relatedMonitorQ = getMonitorPoint(formulaModel.Q);
            if (relatedMonitorQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},不存在";
                return default;
            }
            if (relatedMonitorQ.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.Q},不可用";
                return default;
            }
            var relatedSignalQ = getSignal(relatedMonitorQ.ID);
            if (relatedSignalQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},未检索到信号信息";
                return default;
            }
            var startTimeQ = DateTime.Now;
            var relatedRecordQ = getLastRecord(relatedMonitorQ.ID, relatedSignalQ.ID);
            var endTimeQ = DateTime.Now;
            var errorSecondQ = (startTimeQ - endTimeQ).TotalSeconds;
            if (relatedRecordQ == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltQ = Model.Monitor.RealSlot.ToModel(relatedMonitorQ.CronParas);
            if (realSoltQ == null)
            {
                realSoltQ = new Model.Monitor.RealSlot();
            }
            if (relatedRecordQ.DataTime < realSoltQ.GetStartTime(startTimeQ).AddSeconds(-errorSecondQ))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordQ.DataValue, out double dataValueQ))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 功率参数

            var relatedMonitorP = getMonitorPoint(formulaModel.P);
            if (relatedMonitorP == null)
            {
                Msg = "关联测点：{formulaModel.P},不存在";
                return default;
            }
            if (relatedMonitorP.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.P},不可用";
                return default;
            }
            var relatedSignalP = getSignal(relatedMonitorP.ID);
            if (relatedSignalP == null)
            {
                Msg = "关联测点：{formulaModel.P},未检索到信号信息";
                return default;
            }
            var startTimeP = DateTime.Now;
            var relatedRecordP = getLastRecord(relatedMonitorP.ID, relatedSignalP.ID);
            var endTimeP = DateTime.Now;
            var errorSecondP = (startTimeP - endTimeP).TotalSeconds;
            if (relatedRecordP == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltP = Model.Monitor.RealSlot.ToModel(relatedMonitorP.CronParas);
            if (realSoltP == null)
            {
                realSoltP = new Model.Monitor.RealSlot();
            }
            if (relatedRecordP.DataTime < realSoltP.GetStartTime(startTimeP).AddSeconds(-errorSecondP))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordP.DataValue, out double dataValueP))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            //原始值计算
            if (!formulaModel.Calculate(dataValueP,dataValueQ, out double dataValue))
            {
                Msg = "计算原始值错误";
                return default;
            }
            return dataValue;
        }

        /// <summary>
        /// 计算效率
        /// </summary>
        public static double CalcuUWP
            (
                string formulaParas,//公式参数
                Func<long, Model.MonitorPoint> getMonitorPoint,//获取测点
                Func<long, Model.Signal_SignalType> getSignal,//获取信号
                Func<long, long, Model.MonitorBasicRecord> getLastRecord,//获取最后一条记录
                out string Msg//错误信息
            )
        {
            Msg = string.Empty;
            var formulaModel = Model.Monitor.UWPCalculationFormulaParas.ToModel(formulaParas);
            if (formulaModel == null)
            {
                Msg = "公式参数配置错误";
                return default;
            }


            #region 流量参数

            var relatedMonitorQ = getMonitorPoint(formulaModel.Q);
            if (relatedMonitorQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},不存在";
                return default;
            }
            if (relatedMonitorQ.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.Q},不可用";
                return default;
            }
            var relatedSignalQ = getSignal(relatedMonitorQ.ID);
            if (relatedSignalQ == null)
            {
                Msg = "关联测点：{formulaModel.Q},未检索到信号信息";
                return default;
            }
            var startTimeQ = DateTime.Now;
            var relatedRecordQ = getLastRecord(relatedMonitorQ.ID, relatedSignalQ.ID);
            var endTimeQ = DateTime.Now;
            var errorSecondQ = (startTimeQ - endTimeQ).TotalSeconds;
            if (relatedRecordQ == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltQ = Model.Monitor.RealSlot.ToModel(relatedMonitorQ.CronParas);
            if (realSoltQ == null)
            {
                realSoltQ = new Model.Monitor.RealSlot();
            }
            if (relatedRecordQ.DataTime < realSoltQ.GetStartTime(startTimeQ).AddSeconds(-errorSecondQ))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordQ.DataValue, out double dataValueQ))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 扬程参数

            var relatedMonitorH = getMonitorPoint(formulaModel.H);
            if (relatedMonitorH == null)
            {
                Msg = "关联测点：{formulaModel.H},不存在";
                return default;
            }
            if (relatedMonitorH.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.H},不可用";
                return default;
            }
            var relatedSignalH = getSignal(relatedMonitorH.ID);
            if (relatedSignalH == null)
            {
                Msg = "关联测点：{formulaModel.H},未检索到信号信息";
                return default;
            }
            var startTimeH = DateTime.Now;
            var relatedRecordH = getLastRecord(relatedMonitorH.ID, relatedSignalH.ID);
            var endTimeH = DateTime.Now;
            var errorSecondH = (startTimeH - endTimeH).TotalSeconds;
            if (relatedRecordH == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltH = Model.Monitor.RealSlot.ToModel(relatedMonitorH.CronParas);
            if (realSoltH == null)
            {
                realSoltH = new Model.Monitor.RealSlot();
            }
            if (relatedRecordH.DataTime < realSoltH.GetStartTime(startTimeH).AddSeconds(-errorSecondH))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordH.DataValue, out double dataValueH))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            #region 功率参数

            var relatedMonitorP = getMonitorPoint(formulaModel.P);
            if (relatedMonitorP == null)
            {
                Msg = "关联测点：{formulaModel.P},不存在";
                return default;
            }
            if (relatedMonitorP.UseStatus != Model.eUseStatus.Enable)
            {
                Msg = "关联测点：{formulaModel.P},不可用";
                return default;
            }
            var relatedSignalP = getSignal(relatedMonitorP.ID);
            if (relatedSignalP == null)
            {
                Msg = "关联测点：{formulaModel.P},未检索到信号信息";
                return default;
            }
            var startTimeP = DateTime.Now;
            var relatedRecordP = getLastRecord(relatedMonitorP.ID, relatedSignalP.ID);
            var endTimeP = DateTime.Now;
            var errorSecondP = (startTimeP - endTimeP).TotalSeconds;
            if (relatedRecordP == null)
            {
                Msg = "未检索到记录信息";
                return default;
            }
            var realSoltP = Model.Monitor.RealSlot.ToModel(relatedMonitorP.CronParas);
            if (realSoltP == null)
            {
                realSoltP = new Model.Monitor.RealSlot();
            }
            if (relatedRecordP.DataTime < realSoltP.GetStartTime(startTimeP).AddSeconds(-errorSecondP))
            {
                Msg = "关联记录已失效";
                return default;
            }
            if (!double.TryParse(relatedRecordP.DataValue, out double dataValueP))
            {
                Msg = "关联记录数据格式错误";
                return default;
            }

            #endregion

            //原始值计算
            if (!formulaModel.Calculate(dataValueP,dataValueQ, dataValueH, out double dataValue))
            {
                Msg = "计算原始值错误";
                return default;
            }
            return dataValue;
        }

    }
}