JG_TpsLabStudio_LTS/tps/TpsLabStudio/models/PowerAndFreqStability.cs

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

namespace Tps_LQ_Transmitter.models
{
    class PowerAndFreqStability: BaseModel
    {
        double[,] WTempPowerVal;
        double[,] dBTempPowerVal;
        string serial = "****";

        public PowerAndFreqStability()
        {
            TemplateName = "功率及频率稳定度测试";
        }
        /// <summary>
        /// 功率及频率稳定度测试
        /// </summary>
        public override bool Run(TestNode parameters, List<TestNode> nodes)
        {
            double y_value, x_value, TestFreq;
            ShowMessage(MsgType.Info, string.Format("第{0}个频点功率及频率稳定度测试开始", parameters.PointIndex));

            Random random = new Random();

            //获取仪器
            var SA = this.tps.GetDevice("频谱仪");
          

            TransmitterSerialPort SerialClient = new TransmitterSerialPort();
            PowerAndFreqStabilityOutData Data = new PowerAndFreqStabilityOutData();
            DataType PowerPrint = new DataType();//功率(dBm)
            DataType FreqPrint = new DataType();//实测频率
            DataType FreqAccuracyPrint = new DataType();//频率稳定度
            DataType PowerSumPrint = new DataType();//两路功率总和(w)
            DataType PowerFlatnessPrint = new DataType();//两路功率不平度（dB）

            if (SA == null)
            {
                ShowMessage(MsgType.Error, string.Format("仪器不齐全，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
          //  y_value = double.Parse(SA.Query("读通道功率"));
            OpenExcel("功率及频率稳定度", out Spire.Xls.Workbook workbook, out Spire.Xls.Worksheet sheet);
            if (sheet == null)
            {
                ShowMessage(MsgType.Error, "找不到" + tps.TestProject + "模板.xlsx");
                return false;
            }


            ConfigParameter PowerPara = new ConfigParameter();
            //MatchComPara CfigComParas = new MatchComPara();
            //CfigComParas = LoadComWorkBook();

            //if (CfigComParas == null)
            //{
            //    return false;
            //}

            //byte FourthByte = 0x00;
            //string ComPort = CfigComParas.GetComPort("1");
            //byte ThridByte = Convert.ToByte(CfigComParas.GetThirdByte("1"), 16);
            PowerPara.StepFrequency = 0;
            
            PowerPara.OutLoss = parameters.Parameters.GetParameter<double>("输出损耗");
           // PowerPara.StartFrequency = parameters.Parameters.GetParameter<double>("起始频率");
           // PowerPara.StepFrequency = parameters.Parameters.GetParameter<double>("频率步进");
           // parameters.PointTotal = parameters.Parameters.GetParameter<int>("频点数量");
         //   PowerPara.StopFrequency = parameters.Parameters.GetParameter<double>("终止频率");
            PowerPara.SPAN = parameters.Parameters.GetParameter<string>("扫描带宽（SPAN）");
            PowerPara.CHSPAN = parameters.Parameters.GetParameter<string>("通道扫描带宽（SPAN）");
            PowerPara.ACHBand = parameters.Parameters.GetParameter<string>("通道带宽");
            PowerPara.REF = parameters.Parameters.GetParameter<string>("参考电平（REF）");
            PowerPara.RBW = parameters.Parameters.GetParameter<string>("分辨率带宽（RBW）");
            PowerPara.VBW = parameters.Parameters.GetParameter<string>("视频带宽（VBW）");
            //PowerPara.ControlDelay = parameters.Parameters.GetParameter<int>("控制延时");
            PowerPara.PowerLower = parameters.Parameters.GetParameter<double>("功率下限");
            PowerPara.PowerUpper = parameters.Parameters.GetParameter<double>("功率上限");
            PowerPara.FreqAccuracyUpper = parameters.Parameters.GetParameter<double>("频率稳定度上限");
            PowerPara.PowerSumLower = parameters.Parameters.GetParameter<double>("两路功率总和下限");
            PowerPara.PowerSumUpper = parameters.Parameters.GetParameter<double>("两路功率总和上限");
            PowerPara.PowerFlatnessUpper = parameters.Parameters.GetParameter<double>("功率不平度上限");
            if (  (PowerPara.SPAN == null) || (PowerPara.REF == null) || (PowerPara.RBW == null) || (PowerPara.VBW == null) || (PowerPara.PowerLower == 0)
                || (PowerPara.PowerUpper == 0) || (PowerPara.FreqAccuracyUpper == 0) || (PowerPara.PowerSumLower == 0) || (PowerPara.PowerSumUpper == 0) || (PowerPara.PowerFlatnessUpper == 0))
            {
                ShowMessage(MsgType.Error, string.Format("配置文件中频率参数为空，{0}/{1}无法运行", parameters.Channel, parameters.Name));
                return false;
            }
            //if (PowerPara.ControlDelay == 0)
            //{
            //    PowerPara.ControlDelay = 10;
            //}
            //SerialClient.SerialOpen(ComPort);
            if (true)//需具备仪器
            {
                SA.Write("仪器复位"); SA.Query("OPC");                           
                

            }
            //if ((parameters.PointTotal != 0) && (parameters.PointTotal != 1) && (PowerPara.StepFrequency == 0))
            //{
            //    PowerPara.StepFrequency = ((int)(((PowerPara.StopFrequency - PowerPara.StartFrequency) / (parameters.PointTotal - 1)) * 100)) / 100;
            //}
            //if (PowerPara.StepFrequency != 0)
            //{
            //    parameters.PointTotal = ((int)((PowerPara.StopFrequency - PowerPara.StartFrequency) / PowerPara.StepFrequency)) + 1;
            //}
            //parameters.PointTotal = CfigComParas.ComParameters.Count;
            double CenterFreq;
            Data.Power = new double[parameters.PointTotal];
            Data.Freq = new double[parameters.PointTotal];
            Data.FreqAccuracy = new double[parameters.PointTotal];
            if (tps.Serial != serial)
            {
                WTempPowerVal = new double[2, parameters.PointTotal] ;
                dBTempPowerVal = new double[2, parameters.PointTotal];
                serial = tps.Serial;
                for (int initVal1 = 0; initVal1 < 2; initVal1++)
                {
                    for (int initVal2 = 0; initVal2 < parameters.PointTotal; initVal2++)
                    {
                        WTempPowerVal[initVal1, initVal2] = -100;
                        dBTempPowerVal[initVal1, initVal2] = -100;
                    }
                }
            }
            
            //for (int parameters.PointIndex = 0; parameters.PointIndex < parameters.PointTotal; parameters.PointIndex++)
            {

                //string sa= CfigComParas.GetFourthByte((parameters.PointIndex + 1).ToString());
                //FourthByte = Convert.ToByte(CfigComParas.GetFourthByte((parameters.PointIndex + 1).ToString()), 16);
                //CenterFreq = double.Parse(CfigComParas.Getfreqpoint((parameters.PointIndex + 1).ToString()));
                //CenterFreq = PowerPara.StartFrequency + PowerPara.StepFrequency * FourthByte;
                
                if (true)//需具备仪器
                {
                    //控制
                    //SerialClient.DUT_Transmitter_Ctrol(ThridByte, FourthByte);
                    //Thread.Sleep(PowerPara.ControlDelay);//单位ms

                    SA.Write("设置频谱测试模式"); SA.Query("OPC");
                    
                    SA.Write("SPAN", PowerPara.SPAN); SA.Query("OPC");
                    SA.Write("RBW", PowerPara.RBW); SA.Query("OPC");
                    SA.Write("VBW", PowerPara.VBW); SA.Query("OPC");
                    SA.Write("REF", PowerPara.REF); SA.Query("OPC");
                    SA.Write("CENTER", parameters.CenterFreq.ToString()); SA.Query("OPC");
                    SA.Write("SingleOrCont", "1"); SA.Query("OPC");
                    Thread.Sleep(500);
                    SA.Write("MARK打开", "1"); SA.Query("OPC");
                    Thread.Sleep(500);
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                        SA.Write("打开MARK精度", "1"); SA.Query("OPC");
                        Thread.Sleep(200);
                    }
                    SA.Write("PEAK", "1"); SA.Query("OPC");
                    Thread.Sleep(500);
                    // SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                    //   SA.Write("单次扫描"); SA.Query("OPC");
                    //   Thread.Sleep(100);
                    // string i=SA.Query("读MARK高精度频率", "1");
                    string val = "";
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                        val = SA.Query("读MARK高精度频率", "1");
                    }
                    else
                    {
                        val = SA.Query("读MARK频率", "1");
                    }

                    TestFreq = double.Parse(val);
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                        SA.Write("MARK关闭", "1"); SA.Query("OPC");
                    }
                        


                    SA.Write("设置通道功率模式"); SA.Query("OPC");
                    SA.Write("SingleOrCont", "0"); SA.Query("OPC");
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                        
                        SA.Write("设置通道REF", PowerPara.REF); SA.Query("OPC");
                    }
                    else 
                    {
                        SA.Write("SPAN", PowerPara.CHSPAN); SA.Query("OPC");
                        SA.Write("REF", PowerPara.REF); SA.Query("OPC");

                    }

                    SA.Write("设置通道带宽", PowerPara.ACHBand); SA.Query("OPC"); ;//设置完设置通道带宽后，设置通道SPAN会变，所以通道SPAN放在通道带宽后
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                        SA.Write("设置通道SPAN", PowerPara.CHSPAN); SA.Query("OPC");
                    }
                    SA.Write("单次扫描"); SA.Query("OPC");
                    if (SA.Query("IDN").Contains("N9030"))
                    {
                       // PsaPeakValue_CHTracedata(SA, out y_value, out x_value, true);
                        y_value = double.Parse(SA.Query("读通道功率"));
                    }
                    else
                    {
                       // PsaPeakValue_Tracedata(SA, out y_value, out x_value, true);
                        y_value = double.Parse(SA.Query("读通道功率"));

                    }
                    

                    Data.Power[parameters.PointIndex] = y_value + PowerPara.OutLoss;//功率

                }

                //Data.Power[parameters.PointIndex] = random.Next(3000, 4000) / 100.0;//随机数
                PowerPrint.Test_name = parameters.Channel + "-功率测试(W)-" + parameters.CenterFreq.ToString() + "MHz";
                PowerPrint.Lower = PowerPara.PowerLower;
                PowerPrint.Upper = PowerPara.PowerUpper;
                PowerPrint.TestVal = Math.Round(Math.Pow(10, (Data.Power[parameters.PointIndex] / 10)) / 1000, 2);//功率W

                if ((PowerPrint.TestVal >= PowerPrint.Lower) && (PowerPrint.TestVal <= PowerPrint.Upper))
                {
                    PowerPrint.Result = "是";
                }
                else
                {
                    PowerPrint.Result = "否";
                }
                FreqPrint.Test_name = parameters.Channel + "-频率测试(MHz)-" + parameters.CenterFreq.ToString() + "MHz";
                FreqPrint.Lower =Math.Round(  parameters.CenterFreq - ((PowerPara.FreqAccuracyUpper * parameters.CenterFreq)),2);
                FreqPrint.Upper = Math.Round((PowerPara.FreqAccuracyUpper * parameters.CenterFreq) + parameters.CenterFreq, 2);
                FreqPrint.TestVal = Math.Round(TestFreq / 1000000, 3);//实测频率
                //FreqPrint.TestVal = random.Next(-600, 6000) / 100.0 + CenterFreq;//随机数
                if ((FreqPrint.TestVal >= FreqPrint.Lower) && (FreqPrint.TestVal <= FreqPrint.Upper))
                {
                    FreqPrint.Result = "是";
                }
                else
                {
                    FreqPrint.Result = "否";
                }

                FreqAccuracyPrint.Test_name = parameters.Channel + "-频率稳定度测试-" + parameters.CenterFreq.ToString() + "MHz";
                FreqAccuracyPrint.Upper = PowerPara.FreqAccuracyUpper;
                FreqAccuracyPrint.TestVal = Math.Round(Math.Abs(TestFreq - parameters.CenterFreq * 1000000) / (parameters.CenterFreq * 1000000), 6);//频率稳定度
                //FreqAccuracyPrint.TestVal = Math.Round(Math.Abs((random.Next(-600, 6000) / 100.0 + CenterFreq)*1000000 - CenterFreq * 1000000) / (CenterFreq * 1000000), 6);//随机数
                if (FreqAccuracyPrint.TestVal <= FreqAccuracyPrint.Upper)
                {
                    FreqAccuracyPrint.Result = "是";
                }
                else
                {
                    FreqAccuracyPrint.Result = "否";
                }
                tps.TestTableAddCell(tps.Serial,PowerPrint.Test_name,tps.SystemChofSerial, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);
                tps.TestTableAddCell(tps.Serial,FreqPrint.Test_name, tps.SystemChofSerial,FreqPrint.Lower.ToString(), FreqPrint.Upper.ToString(), FreqPrint.TestVal.ToString(), FreqPrint.Result);
                if (parameters.Channel == "通道1")
                {
                    
                    WriteExcelData(sheet, parameters.PointIndex, 1, PowerPrint.Test_name, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);
                    WriteExcelData(sheet, parameters.PointIndex, 3, FreqPrint.Test_name, FreqPrint.Lower.ToString(), FreqPrint.Upper.ToString(), FreqPrint.TestVal.ToString(), FreqPrint.Result);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 10, PowerPrint.Result, PowerPrint.TestVal);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 7, FreqPrint.Result, FreqPrint.TestVal);
                }
                else if (parameters.Channel == "通道2")
                {
                  
                    WriteExcelData(sheet, parameters.PointIndex, 2, PowerPrint.Test_name, PowerPrint.Lower.ToString(), PowerPrint.Upper.ToString(), PowerPrint.TestVal.ToString(), PowerPrint.Result);
                    WriteExcelData(sheet, parameters.PointIndex, 4, FreqPrint.Test_name, FreqPrint.Lower.ToString(), FreqPrint.Upper.ToString(), FreqPrint.TestVal.ToString(), FreqPrint.Result);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 11, PowerPrint.Result, PowerPrint.TestVal);
                    //tps.SetTestTableCellValue(parameters.PointIndex + 15, 7, FreqPrint.Result, FreqPrint.TestVal);
                }

                #region 功率不平度及两路功率总和计算
                if (parameters.Channel == "通道1")
                {
                    WTempPowerVal[0, parameters.PointIndex] = PowerPrint.TestVal;//W
                    dBTempPowerVal[0, parameters.PointIndex] = Data.Power[parameters.PointIndex];//dB
                }
                else
                {
                    WTempPowerVal[1, parameters.PointIndex] = PowerPrint.TestVal;//W
                    dBTempPowerVal[1, parameters.PointIndex] = Data.Power[parameters.PointIndex];//dB
                }

                if (WTempPowerVal[0, parameters.PointIndex] > -100 && WTempPowerVal[1, parameters.PointIndex] > -100)
                {
                    PowerSumPrint.Test_name =  "两路功率总和(W)-" + parameters.CenterFreq.ToString() + "MHz";
                    PowerSumPrint.Lower = PowerPara.PowerSumLower;
                    PowerSumPrint.Upper = PowerPara.PowerSumUpper;
                    PowerSumPrint.TestVal = Math.Round(WTempPowerVal[0, parameters.PointIndex] + WTempPowerVal[1, parameters.PointIndex],2);//W
                    if ((PowerSumPrint.TestVal >= PowerSumPrint.Lower) && (PowerSumPrint.TestVal <= PowerSumPrint.Upper))
                    {
                        PowerSumPrint.Result = "是";
                    }
                    else
                    {
                        PowerSumPrint.Result = "否";
                    }
                    PowerFlatnessPrint.Test_name =  "功率不平度(dB)-" + parameters.CenterFreq.ToString() + "MHz";
                    PowerFlatnessPrint.Upper = PowerPara.PowerFlatnessUpper;
                    PowerFlatnessPrint.TestVal = Math.Round(Math.Abs(dBTempPowerVal[0, parameters.PointIndex] - dBTempPowerVal[1, parameters.PointIndex]),2);//dB
                    if ((PowerFlatnessPrint.TestVal >= 0) && (PowerFlatnessPrint.TestVal <= PowerFlatnessPrint.Upper))
                    {
                        PowerFlatnessPrint.Result = "是";
                    }
                    else
                    {
                        PowerFlatnessPrint.Result = "否";
                    }
                   
                    tps.TestTableAddCell(tps.Serial,PowerSumPrint.Test_name,tps.SystemChofSerial, PowerSumPrint.Lower.ToString(), PowerSumPrint.Upper.ToString(), PowerSumPrint.TestVal.ToString(), PowerSumPrint.Result);
                    tps.TestTableAddCell(tps.Serial,PowerFlatnessPrint.Test_name,tps.SystemChofSerial, "0", PowerFlatnessPrint.Upper.ToString(), PowerFlatnessPrint.TestVal.ToString(), PowerFlatnessPrint.Result);
                   // WriteExcelData(sheet, parameters.PointIndex, 3, PowerSumPrint.Test_name, PowerSumPrint.Lower.ToString(), "/", PowerSumPrint.TestVal.ToString(), PowerSumPrint.Result);
                   // WriteExcelData(sheet, parameters.PointIndex, 4, PowerFlatnessPrint.Test_name, PowerFlatnessPrint.Lower.ToString(), "/", PowerFlatnessPrint.TestVal.ToString(), PowerFlatnessPrint.Result);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 12, PowerSumPrint.Result, PowerSumPrint.TestVal);
                    //tps.SetTestTableCellValue(parameters.PointIndex, 13, PowerFlatnessPrint.Result,PowerFlatnessPrint.TestVal);

                }
                #endregion
            }
            //SerialClient.DUT_Transmitter_Ctrol( 00, 00);//控制掉电
            //SerialClient.SerialClose();
            SaveExcel(workbook);
            ShowMessage(MsgType.Info, string.Format("第{0}个频点功率及频率稳定度测试结束", parameters.PointIndex));
            return true;
        }

        

        public void PsaPeakValue_CHTracedata(AppLibs.Devices.IVISA psa, out double Y_Maxvalue, out double X_Maxvalue, bool IsReturnX = false)
        {
            System.Threading.Thread.Sleep(20);
            X_Maxvalue = 0;
            Y_Maxvalue = 0;

            psa.Write("单次扫描");

            psa.Query("OPC");
            
            //string tracedata = psa.Query("读曲线");
            string tracedata = psa.Query("读通道曲线");
            string[] tracedatas = tracedata.Split(',');
            double[] tracedata_double = new double[tracedatas.Length-1];
            for (int i = 0; i < tracedatas.Length-1; i++)
            {
                tracedata_double[i] = double.Parse(tracedatas[i]);
            }
            Y_Maxvalue = tracedata_double.Max();
            if (IsReturnX)
            {
                int x = Array.IndexOf(tracedata_double, Y_Maxvalue);
                double startfreq = double.Parse(psa.Query("读起始频率"));
                double stopfreq = double.Parse(psa.Query("读截止频率"));
                double counts = double.Parse(psa.Query("测试点数读取"));
                X_Maxvalue = startfreq + (stopfreq - startfreq) * x / (counts - 2);
            }
            Y_Maxvalue = Math.Round(Y_Maxvalue, 3);
        }
        public void PsaPeakValue_Tracedata(AppLibs.Devices.IVISA psa, out double Y_Maxvalue, out double X_Maxvalue, bool IsReturnX = false)
        {
            System.Threading.Thread.Sleep(20);
            X_Maxvalue = 0;
            Y_Maxvalue = 0;

            psa.Write("单次扫描");

            psa.Query("OPC");

            string tracedata = psa.Query("读曲线");
           // string tracedata = psa.Query("读通道曲线");
            string[] tracedatas = tracedata.Split(',');
            double[] tracedata_double = new double[tracedatas.Length - 1];
            for (int i = 0; i < tracedatas.Length - 1; i++)
            {
                tracedata_double[i] = double.Parse(tracedatas[i]);
            }
            Y_Maxvalue = tracedata_double.Max();
            if (IsReturnX)
            {
                int x = Array.IndexOf(tracedata_double, Y_Maxvalue);
                double startfreq = double.Parse(psa.Query("读起始频率"));
                double stopfreq = double.Parse(psa.Query("读截止频率"));
                double counts = double.Parse(psa.Query("测试点数读取"));
                X_Maxvalue = startfreq + (stopfreq - startfreq) * x / (counts - 2);
            }
            Y_Maxvalue = Math.Round(Y_Maxvalue, 3);
        }
        public class ConfigParameter
        {
            /// <summary>
            /// 串口
            /// </summary>
            public string ComPort { set; get; }
            /// <summary>
            /// 输出损耗
            /// </summary>
            public double OutLoss { set; get; }
            /// <summary>
            /// 产品测试的起始频率
            /// </summary>
            public double StartFrequency { set; get; }
            /// <summary>
            /// 产品测试的频率步进
            /// </summary>
            public double StepFrequency { set; get; }
            /// <summary>
            /// 产品测试的频点数量
            /// </summary>
            public int FrequencyNumber { set; get; }
            /// <summary>
            /// 产品的工作频带上限(终止频率)
            /// 功能：用于判断从起始频率按一定的步进测试是否超出产品工作频段上限
            /// </summary>
            public double StopFrequency { set; get; }
            /// <summary>
            ///设置频谱仪的SPAN
            /// </summary>
            public string SPAN { set; get; }
            /// <summary>
            ///设置频谱仪的通道SPAN
            /// </summary>
            public string CHSPAN { set; get; }
            /// <summary>
            /// 通道带宽
            /// </summary>
            public string ACHBand { set; get; }
            /// <summary>
            /// 设置参考电平
            /// </summary>
            public string REF { set; get; }
            /// <summary>
            /// 设置RBW
            /// </summary>
            public string RBW { set; get; }
            /// <summary>
            /// 设置VBW
            /// </summary>
            public string VBW { set; get; }
            /// <summary>
            /// 控制延时
            /// </summary>
            public int ControlDelay { set; get; }
            /// <summary>
            /// 功率下限
            /// </summary>
            public double  PowerLower { set; get; }
            /// <summary>
            /// 功率上限
            /// </summary>
            public double PowerUpper { set; get; }
            /// <summary>
            /// 频率稳定度上限
            /// </summary>
            public double FreqAccuracyUpper { set; get; }
            /// <summary>
            /// 两路功率总和下限
            /// </summary>
            public double PowerSumLower { set; get; }
            /// <summary>
            /// 两路功率总和上限
            /// </summary>
            public double PowerSumUpper { set; get; }
            /// <summary>
            /// 功率不平度上限
            /// </summary>
            public double PowerFlatnessUpper { set; get; }

        }

        public class PowerAndFreqStabilityOutData
        {
            /// <summary>
            /// 输出功率(W)
            /// </summary>
            public double[] Power { set; get; }
           /// <summary>
           /// 频率稳定度
           /// </summary>
            public double[] FreqAccuracy { set; get; }
            /// <summary>
            /// 实测频点
            /// </summary>
            public double[] Freq { set; get; }
            /// <summary>
            /// 两路功率总和(W)
            /// </summary>
            public double[] PowerSum { set; get; }
            /// <summary>
            /// 两路功率不平度(dB)
            /// </summary>
            public double[] PowerFlatness { set; get; }

        }
        //public class DataType
        //{

        //    /// <summary>
        //    /// 测试名称
        //    /// </summary>
        //    public string Test_name { set; get; }
        //    /// <summary>
        //    /// 指标下限
        //    /// </summary>
        //    public double Lower { set; get; }
        //    /// <summary>
        //    /// 指标上限
        //    /// </summary>
        //    public double Upper { set; get; }
        //    /// <summary>
        //    /// 测试值
        //    /// </summary>
        //    public double TestVal { set; get; }
        //    /// <summary>
        //    /// 判断结果
        //    /// </summary>
        //    public bool Result { set; get; }


        //}
    }
}