优化统计计算代码

yangys

2024-11-03 24c9043889aa9441be10e781bd6678758cb2f5d8

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
package com.qianwen.smartman.modules.mdc.utils;
 
import cn.hutool.core.util.NumberUtil;
import java.util.List;
import java.util.stream.Collectors;
import com.qianwen.smartman.common.constant.MdcConstant;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.mdc.entity.SuperAggregateState;
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
import com.qianwen.smartman.modules.mdc.enums.ProductivityTypeEnum;
import com.qianwen.smartman.modules.mdc.enums.RpsTypeEnum;
 
/**
 * 效率计算
 */
public class EifficiencyUtils {
    public static Double openShiftTypeCalculationResults(List<SuperAggregateState> superAggregateStates, ProductivityTypeEnum productivityType) {
        Double v;
        switch (productivityType) {
            case RUNNING:
                v = calculationRunning(FilterOffUtils.filterOffDay(superAggregateStates, OpenTypeEnums.RUNNING));
                break;
            case ALARM:
                v = calculationAlarm(FilterOffUtils.filterOffDay(superAggregateStates, OpenTypeEnums.ALARM));
                break;
            default:
                v = calculationOee(FilterOffUtils.filterOffDay(superAggregateStates, OpenTypeEnums.OEE));
                break;
        }
        return v;
    }
 
    public static Double calculationResults(List<SuperAggregateState> superAggregateStates, ProductivityTypeEnum productivityType) {
        Double v;
        switch (productivityType) {
            case RUNNING:
                v = calculationRunning(superAggregateStates);
                break;
            case ALARM:
                v = calculationAlarm(superAggregateStates);
                break;
            default:
                v = calculationOee(superAggregateStates);
                break;
        }
        return v;
    }
 
    /**
     * 计算运行率？
     * @param originalData
     * @return
     */
    public static Double calculationRunning(List<SuperAggregateState> originalData) {
        List<SuperAggregateState> originalData2 = FilterOffUtils.filterOffDay(originalData, OpenTypeEnums.RUNNING);
        double result = 0.0d;
        if (Func.isNotEmpty(originalData2)) {
            long sum = originalData2.stream().mapToLong((v0) -> {
                return v0.getDurationCollect();
            }).sum();
            double running = originalData2.stream().filter(e -> {
                return e.getRps().equals(Integer.valueOf(RpsTypeEnum.T1.getType()));
            }).mapToDouble((v0) -> {
                return v0.getDurationCollect();
            }).sum();
            result = !new Long("0").equals(Long.valueOf(sum)) ? Double.parseDouble(NumberUtil.decimalFormat(MdcConstant.RATE_FORMAT, running / sum)) : 0.0d;
        }
        return Double.valueOf(result);
    }
 
    /**
     * 计算报警率
     * @param originalData
     * @return
     */
    public static Double calculationAlarm(List<SuperAggregateState> originalData) {
        List<SuperAggregateState> originalData2 = FilterOffUtils.filterOffDay(originalData, OpenTypeEnums.ALARM);
        double result = 0.0d;
        if (Func.isNotEmpty(originalData2)) {
            //总时间
            double sum = originalData2.stream().mapToDouble((v0) -> {
                return v0.getDurationCollect();
            }).sum();
            double running = originalData2.stream().filter(e -> e.getRps().equals(RpsTypeEnum.T4.getType())).collect(Collectors.toList()).stream().mapToDouble(SuperAggregateState::getDurationCollect).sum();
            /*
            double running = ((List) originalData2.stream().filter(e -> {
                return e.getRps().equals(4);
            }).collect(Collectors.toList())).stream().mapToDouble((v0) -> {
                return v0.getDurationCollect();
            }).sum();*/
            result = sum != 0.0d ? Double.parseDouble(NumberUtil.decimalFormat(MdcConstant.RATE_FORMAT, running / sum)) : 0.0d;
        }
        return Double.valueOf(result);
    }
 
    /**
     * 计算OEE稼动率
     * @param originalData
     * @return
     */
    public static Double calculationOee(List<SuperAggregateState> originalData) {
        List<SuperAggregateState> originalData2 = FilterOffUtils.filterOffDay(originalData, OpenTypeEnums.OEE);
        double result = 0.0d;
        if (Func.isNotEmpty(originalData2)) {
            long sum = originalData2.stream().mapToLong((v0) -> {
                return v0.getDurationCollect();
            }).sum();
            double running = originalData2.stream().filter(e -> {
                return MdcConstant.IN_PLAN.equals(e.getIsPlan());
            }).mapToDouble((v0) -> {
                return v0.getDurationCollect();
            }).sum();
            result = !new Long("0").equals(Long.valueOf(sum)) ? Double.parseDouble(NumberUtil.decimalFormat(MdcConstant.RATE_FORMAT, running / sum)) : 0.0d;
        }
        return Double.valueOf(result);
    }
}