ningshuxia
2025-04-16 ed113213fc94c3d9886ea08dfddd09d08d9ba7d5
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
namespace IStation.Test
{
 
    public class DynamicThresholdProcessorHelper
    {
 
        public static List<(int, double, double)> Filter(List<(int, double, double)> ptList)
        {
            var pressures = ptList.Select(p => p.Item3).ToList();
 
            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
 
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;
 
            return ptList.Where(p => p.Item3 >= lower && p.Item3 <= upper).ToList();
        }
 
       
 
 
        public static List<PointViewModel> Filter(List<PointViewModel> ptList)
        {
            var pressures = ptList.Select(p => p.Y).ToList();
 
            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
             
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;
 
            return ptList.Where(p => p.Y >= lower && p.Y <= upper).ToList();
        }
 
        public static List<PumpViewModel> Filter(List<PumpViewModel> ptList)
        {
            var pressures = ptList.Select(p => p.PressureDiff).ToList();
 
            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
 
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;
 
            return ptList.Where(p => p.PressureDiff >= lower && p.PressureDiff <= upper).ToList();
        }
 
        public static List<Model.StationSignalRecord> Filter(List<Model.StationSignalRecord> ptList)
        {
            var pressures = ptList.Select(p => p.TotalPressure).ToList();
 
            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
 
 
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;
 
            return ptList.Where(p => p.TotalPressure >= lower && p.TotalPressure <= upper).ToList();
        }
 
 
        public static List<Model.PumpSignalRecord> Filter(List<Model.PumpSignalRecord> ptList)
        {
            var pressures = ptList.Select(p => p.Head).ToList();
 
            // 计算统计量
            var (mean, stdDev) = CalculateStats(pressures);
            double skewness = CalculateSkewness(pressures);
            // 动态调整σ倍数
            double sigmaMultiplier = CalculateSigmaMultiplier(skewness);
            sigmaMultiplier = 3;//目前默认 标准差
 
 
            // 计算边界
            double lower = mean - sigmaMultiplier * stdDev;
            double upper = mean + sigmaMultiplier * stdDev;
 
            return ptList.Where(p => p.Head >= lower && p.Head <= upper).OrderBy(x => x.FlowRate).ToList();
        }
 
 
        // 核心统计计算
        public static (double mean, double stdDev) CalculateStats(List<double> values)
        {
            double mean = values.Average();
            double stdDev = Math.Sqrt(values.Sum(v => Math.Pow(v - mean, 2)) / (values.Count - 1));
            return (mean, stdDev);
        }
 
        // 偏度计算(Pearson's moment coefficient)
        public static double CalculateSkewness(List<double> values)
        {
            double mean = values.Average();
            double std = CalculateStats(values).stdDev;
            double sum = values.Sum(v => Math.Pow((v - mean) / std, 3));
            return (sum * values.Count) / ((values.Count - 1) * (values.Count - 2));
        }
 
        // 动态σ倍数计算规则
        private static double CalculateSigmaMultiplier(double skewness)
        {
 
            return skewness switch
            {
                > 1.0 => 2.0,    // 强正偏态
                > 0.5 => 2.5,
                > -0.5 => 3.0,   // 近似正态
                > -1.0 => 3.5,
                _ => 4.0    // 强负偏态
            };
        }
 
    }
 
 
 
}