修改录入方式

lixiaojun

2023-11-08 0363984a82f507db16460a1441bf856c40e13481

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
namespace Yw.Application
{
    /// <summary>
    /// CurveTool
    /// </summary>
    [Route("Curve/Tool")]
    [ApiDescriptionSettings("Curve", Name = "曲线工具", Order = 1000)]
    public partial class CurveTool_Controller : IDynamicApiController
    {
        /// <summary>
        /// 生成拟合点列表
        /// </summary>
        [Route("GeneralFitPointList@V1.0")]
        [HttpPost]
        public List<CurvePoint> GeneralFitPointList([Required] CurveExpressToolInput input)
        {
            var fitHelper = new FitHelper(input.DefinePoints, input.FitType);
            var pointNumber = ConfigHelper.PointNumber;
            if (input.PointNumber.HasValue)
            {
                pointNumber = input.PointNumber.Value;
            }
            var list = fitHelper.GetFitPoints(pointNumber);
            return list;
        }
 
        /// <summary>
        /// 生成泵拟合点列表
        /// </summary>
        [Route("GeneralPumpFitPointList@V1.0")]
        [HttpPost]
        public PumpCurveExpressToolOutput GeneralPumpFitPointList([Required] PumpCurveExpressToolInput input)
        {
            var vm = new PumpCurveExpressToolOutput();
 
            //扬程
            var pointNumberQH = ConfigHelper.PointNumber;
            if (input.PointNumberQH.HasValue)
            {
                pointNumberQH = input.PointNumberQH.Value;
            }
            var pointListQH = input.DefinePoints.Select(x => new CurvePoint(x.Q, x.H)).ToList();
            var fitHelperQH = new FitHelper(pointListQH, input.FitTypeQH);
            vm.PointListQH = fitHelperQH.GetFitPoints(pointNumberQH);
 
            //功率
            var hasQP = false;
            var pointNumberQP = ConfigHelper.PointNumber;
            if (input.PointNumberQP.HasValue)
            {
                pointNumberQP = input.PointNumberQP.Value;
            }
            var pointListQP = input.DefinePoints.Where(x => x.P.HasValue).Select(x => new CurvePoint(x.Q, x.P.Value)).ToList();
            if (pointListQP != null && pointListQP.Count > 3)
            {
                var fitPowQP = FitHelper.GetFitPow(input.FitTypeQP);
                if (pointListQP.Count > fitPowQP)
                {
                    var fitHelperQP = new FitHelper(pointListQP, input.FitTypeQP);
                    vm.PointListQP = fitHelperQP.GetFitPoints(pointNumberQP);
                    hasQP = true;
                }
            }
 
 
            //效率
            var hasQE = false;
            var pointNumberQE = ConfigHelper.PointNumber;
            if (input.PointNumberQE.HasValue)
            {
                pointNumberQE = input.PointNumberQE.Value;
            }
            var pointListQE = input.DefinePoints.Where(x => x.E.HasValue).Select(x => new CurvePoint(x.Q, x.E.Value)).ToList();
            if (pointListQE != null && pointListQE.Count > 3)
            {
                var fitPowQE = FitHelper.GetFitPow(input.FitTypeQE);
                if (pointListQE.Count > fitPowQE)
                {
                    var fitHelperQE = new FitHelper(pointListQE, input.FitTypeQE);
                    vm.PointListQE = fitHelperQE.GetFitPoints(pointNumberQE);
                    hasQE = true;
                }
            }
 
            if (!hasQP && hasQE)
            {
                pointListQP = new List<CurvePoint>();
                foreach (var item in pointListQE)
                {
                    var pointQH = pointListQH.Find(x => x.X == item.X);
                    var p = Yw.Calculation.PumpCalcuHelper.CalculateP(pointQH.X, pointQH.Y, item.Y);
                    pointListQP.Add(new CurvePoint(item.X, p));
                }
                var fitHelperQP = new FitHelper(pointListQP, input.FitTypeQE);
                vm.PointListQP = fitHelperQP.GetFitPoints(pointNumberQP);
            }
            else if (hasQP && !hasQE)
            {
                pointListQE = new List<CurvePoint>();
                foreach (var item in pointListQP)
                {
                    var pointQH = pointListQH.Find(x => x.X == item.X);
                    var e = Yw.Calculation.PumpCalcuHelper.CalculateE(pointQH.X, pointQH.Y, item.Y);
                    pointListQE.Add(new CurvePoint(item.X, e));
                }
                var fitHelperQE = new FitHelper(pointListQE, input.FitTypeQP);
                vm.PointListQE = fitHelperQE.GetFitPoints(pointNumberQE);
            }
 
            return vm;
 
        }
 
    }
}