单点偏差率累加计算功能调整，超短期准确率改为：调和平均数准确率

cpp-admin/src/main/java/com/cpp/web/controller/tool/EnumSelectController.java

@@ -78,7 +78,7 @@ public class EnumSelectController {
 
 
     @GetMapping("/electricFieldTypeEnum")
-    public R getInverterStatusDataPage() {
+    public R electricFieldTypeEnum() {
 
         List<EnumSelect> list = new ArrayList<>();
         for (ElectricFieldTypeEnum value : ElectricFieldTypeEnum.values()) {

cpp-admin/src/main/java/com/cpp/web/service/accuracy/CalcAccuracy.java

@@ -37,7 +37,7 @@ public class CalcAccuracy {
         if (!electricFieldList.isEmpty()) {
             List<PowerStationStatusData> powerStationStatusDataList = powerStationStatusDataService.findByTimeBetween(startTime, endTime);
             if (!powerStationStatusDataList.isEmpty()) {
-                List<String> formulaTypes = Arrays.asList("DAY_SHORT_ACCURACY", "POINT_SHORT_ACCURACY", "DAY_ULTRA_SHORT_ACCURACY");
+                List<String> formulaTypes = Arrays.asList("DAY_SHORT_ACCURACY", "POINT_SHORT_ACCURACY", "POINT_ULTRA_SHORT_ACCURACY");
                 for (CalculateInterface calculateInterface : calculateInterfaces) {
                     if (listHasIntersection(calculateInterface.calculationTypes(), formulaTypes)) {
                         accuracyPassRateList.addAll(calculateInterface.calc(startTime, endTime, powerStationStatusDataList, electricFieldList, formulaTypes, province));

cpp-admin/src/main/java/com/cpp/web/service/accuracy/impl/CalculateForecastPowerShortTermCloudImpl.java

@@ -6,12 +6,12 @@ import com.cpp.web.domain.cloud.ForecastPowerShortTermCloud;
 import com.cpp.web.domain.enums.DataSourcesEnum;
 import com.cpp.web.domain.enums.ForecastTypeEnum;
 import com.cpp.web.domain.station.ElectricField;
+import com.cpp.web.domain.station.ForecastPowerShortTermStation;
 import com.cpp.web.domain.station.PowerStationStatusData;
 import com.cpp.web.service.accuracy.CalculateInterface;
 import com.cpp.web.service.cloud.ForecastPowerShortTermCloudService;
 import com.syjy.calculate.entity.CalculateRequest;
 import com.syjy.calculate.entity.CalculateResult;
-import com.syjy.calculate.entity.CalculationFormula;
 import com.syjy.calculate.entity.CalculationInfo;
 import com.syjy.calculate.service.AccuracyPassRateCalculateService;
 import lombok.RequiredArgsConstructor;
@@ -31,7 +31,7 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
 
 
     @Override
-    public List<AccuracyPassRate> calc(Date startTime,Date endTime,List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province){
+    public List<AccuracyPassRate> calc(Date startTime, Date endTime, List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province) {
 
         List<AccuracyPassRate> accuracyPassRates = new ArrayList<>();
 
@@ -59,7 +59,7 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
                         accuracyPassRate.setForecastModel(forecastModel);
                         accuracyPassRate.setForecastType(ForecastTypeEnum.dq);
                         accuracyPassRate.setForecastHowLongAgo(ago);
-                        List<CalculationInfo> calculationInfoList = new ArrayList<>();
+                        accuracyPassRate.setStationCode(electricField.getStationCode());
 
                         // 获取实际功率
                         Map<Date, List<ForecastPowerShortTermCloud>> dateForecastListMap = forecastPowerShortTermCloudList.stream().filter(p -> p.getStationCode().equals(stationCode)).collect(Collectors.groupingBy(ForecastPowerShortTermCloud::getTime, Collectors.toList()));
@@ -69,7 +69,7 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
                         BigDecimal cap = electricField.getCapacity();
 
                         if (formulaTypes.contains("DAY_SHORT_ACCURACY")) {//准确率计算
-
+                            List<CalculationInfo> calculationInfoList = new ArrayList<>();
                             // 从开始时间，每隔15分钟，一直循环到当前时间
                             for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                                 Date finalTime = new Date(stepTime);
@@ -77,21 +77,27 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
                                 CalculationInfo calculationInfo = new CalculationInfo();
                                 // 如果短期预测功率不为空且站场功率不为空
                                 if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                    ForecastPowerShortTermCloud forecastPowerShortTermCloud = dateForecastListMap.get(finalTime).get(0);
-                                    // 短期预测功率
-                                    calculationInfo.setTime(stepTime);
-                                    calculationInfo.setForecastAbleValue(forecastPowerShortTermCloud.getFpValue());
-                                    calculationInfo.setForecastTheoryValue(forecastPowerShortTermCloud.getFpValue());
-                                    calculationInfo.setForecastCapacity(cap);
-                                    calculationInfo.setForecastSuCapacity(cap);
 
                                     PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                    //实际
-                                    calculationInfo.setCapacity(cap);
-                                    calculationInfo.setOpenCapacity(cap);
-                                    calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                    calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                    calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                    //限电时不参与考核，抛去
+                                    if (!powerStationStatusData.getPowerRationing().equals(1)) {
+                                        ForecastPowerShortTermCloud forecastPowerShortTermCloud = dateForecastListMap.get(finalTime).get(0);
+                                        // 短期预测功率
+                                        calculationInfo.setTime(stepTime);
+                                        calculationInfo.setForecastAbleValue(forecastPowerShortTermCloud.getFpValue());
+                                        calculationInfo.setForecastTheoryValue(forecastPowerShortTermCloud.getFpValue());
+                                        calculationInfo.setForecastCapacity(cap);
+                                        calculationInfo.setForecastSuCapacity(cap);
+
+
+                                        //实际
+                                        calculationInfo.setCapacity(cap);
+                                        calculationInfo.setOpenCapacity(cap);
+                                        calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
+                                        calculationInfo.setRealValue(powerStationStatusData.getRealValue());
+                                        calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                    }
+
                                 }
 
                                 // 预测功率或实际功率为空的时候，不放入result中
@@ -103,7 +109,7 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
 
                             if (calculationInfoList == null || calculationInfoList.size() == 0) {
                                 accuracyPassRate.setAccuracy("无可用数据计算");
-                            }else {
+                            } else {
                                 // 获取计算基础数据
                                 CalculateRequest calculateRequest = new CalculateRequest();
                                 calculateRequest.setCalculationInfoList(calculationInfoList);
@@ -130,71 +136,33 @@ public class CalculateForecastPowerShortTermCloudImpl implements CalculateInterf
 
                         }
                         if (formulaTypes.contains("POINT_SHORT_ACCURACY")) {//单点偏差计算
-                            List<String> results = new ArrayList<>();
+
+                            BigDecimal sum = BigDecimal.ZERO;
+                            Boolean b = false;
 
                             for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                                 Date finalTime = new Date(stepTime);
-                                // 组装数据
-                                CalculationInfo calculationInfo = new CalculationInfo();
-                                // 如果短期预测功率不为空且站场功率不为空
+
                                 if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                    ForecastPowerShortTermCloud forecastPowerShortTermCloud = dateForecastListMap.get(finalTime).get(0);
-                                    // 短期预测功率
-                                    calculationInfo.setTime(stepTime);
-                                    calculationInfo.setForecastAbleValue(forecastPowerShortTermCloud.getFpValue());
-                                    calculationInfo.setForecastTheoryValue(forecastPowerShortTermCloud.getFpValue());
-                                    calculationInfo.setForecastCapacity(cap);
-                                    calculationInfo.setForecastSuCapacity(cap);
 
+                                    ForecastPowerShortTermCloud forecastPowerShortTermCloud = dateForecastListMap.get(finalTime).get(0);
                                     PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                    //实际
-                                    calculationInfo.setCapacity(cap);
-                                    calculationInfo.setOpenCapacity(cap);
-                                    calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                    calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                    calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
-                                }
 
-                                // 预测功率或实际功率为空的时候，不放入result中
-                                if (calculationInfo.getRealValue() != null && calculationInfo.getAbleValue() != null && calculationInfo.getForecastAbleValue() != null) {
-                                    // 获取计算基础数据
-                                    CalculateRequest calculateRequest = new CalculateRequest();
-                                    calculateRequest.setCalculationInfoList(calculationInfoList);
-                                    calculateRequest.setElectricCapacity(capacity);
-                                    calculateRequest.setProvince(province);
-                                    calculateRequest.setStationCode(stationCode);
-                                    calculateRequest.setFormulaType("POINT_SHORT_ACCURACY");
-                                    calculateRequest.setElectricType(electricType);
-                                    calculateRequest.setSign(electricField.getStationCode());
-                                    calculateRequest.setStationStatus("无");
-                                    calculateRequest.setStationCode(electricField.getStationCode());
-                                    CalculateResult resultMap = SpringUtils.getBean(AccuracyPassRateCalculateService.class).calculate(calculateRequest);
-                                    // 如果计算成功，从结果中获取value
-                                    if (String.valueOf(resultMap.get(CalculateResult.CODE_TAG)).
-                                            equals(CalculateResult.Type.SUCCESS.value())) {
-                                        results.add(String.valueOf(resultMap.get(CalculateResult.DATA_TAG)));
-                                    }
-                                    // 如果不成功，data不为空，则返回data中数据，否则返回msg
-                                    if (resultMap.get(CalculateResult.DATA_TAG) != null) {
-                                        results.add(String.valueOf(resultMap.get(CalculateResult.DATA_TAG)));
-                                    }
-                                    results.add(String.valueOf(resultMap.get(CalculateResult.MSG_TAG)));
+
+                                    BigDecimal subtractAbs = powerStationStatusData.getRealValue().subtract(forecastPowerShortTermCloud.getFpValue()).abs();
+                                    BigDecimal value = subtractAbs.divide(electricField.getCapacity(), 4, BigDecimal.ROUND_DOWN);
+                                    sum = sum.add(value);
+                                    b = true;
                                 }
+
                             }
 
-                            if (results.isEmpty()) {
-                                accuracyPassRate.setDeviationSum("无可用数据计算");
+                            if (b) {
+                                accuracyPassRate.setDeviationSum(sum.doubleValue()*100 + "%");
                             } else {
-                                double sum = 0d;
-                                for (String result : results) {
-                                    if (result.indexOf("%") > -1 && result.length() < 7) {
-                                        sum += Double.parseDouble(result.replace("%", ""));
-                                    }
-                                }
-                                if (accuracyPassRate.getDeviationSum() == null) {
-                                    accuracyPassRate.setDeviationSum(BigDecimal.valueOf(sum / 100).setScale(2, BigDecimal.ROUND_HALF_UP) + "");
-                                }
+                                accuracyPassRate.setDeviationSum("无可用数据计算");
                             }
+
                         }
                         accuracyPassRates.add(accuracyPassRate);
                     }

cpp-admin/src/main/java/com/cpp/web/service/accuracy/impl/CalculateForecastPowerShortTermRegulationImpl.java

@@ -9,7 +9,6 @@ import com.cpp.web.service.accuracy.CalculateInterface;
 import com.cpp.web.service.station.ForecastPowerShortTermRegulationService;
 import com.syjy.calculate.entity.CalculateRequest;
 import com.syjy.calculate.entity.CalculateResult;
-import com.syjy.calculate.entity.CalculationFormula;
 import com.syjy.calculate.entity.CalculationInfo;
 import com.syjy.calculate.service.AccuracyPassRateCalculateService;
 import lombok.RequiredArgsConstructor;
@@ -53,7 +52,7 @@ public class CalculateForecastPowerShortTermRegulationImpl implements CalculateI
                     accuracyPassRate.setForecastType(ForecastTypeEnum.dq);
                     accuracyPassRate.setStationCode(stationCode);
                     accuracyPassRate.setForecastHowLongAgo(ago);
-                    List<CalculationInfo> calculationInfoList = new ArrayList<>();
+
 
                     // 获取实际功率
                     Map<Date, List<ForecastPowerShortTermRegulation>> dateForecastListMap = agoListMap.get(ago).stream().filter(p -> p.getStationCode().equals(stationCode)).collect(Collectors.groupingBy(ForecastPowerShortTermRegulation::getTime, Collectors.toList()));
@@ -63,6 +62,7 @@ public class CalculateForecastPowerShortTermRegulationImpl implements CalculateI
                     BigDecimal cap = electricField.getCapacity();
 
                     if (formulaTypes.contains("DAY_SHORT_ACCURACY")) {//准确率计算
+                        List<CalculationInfo> calculationInfoList = new ArrayList<>();
                         // 从开始时间，每隔15分钟，一直循环到当前时间
                         for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                             Date finalTime = new Date(stepTime);
@@ -70,21 +70,27 @@ public class CalculateForecastPowerShortTermRegulationImpl implements CalculateI
                             CalculationInfo calculationInfo = new CalculationInfo();
                             // 如果短期预测功率不为空且站场功率不为空
                             if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                ForecastPowerShortTermRegulation forecastPowerShortTermRegulation = dateForecastListMap.get(finalTime).get(0);
-                                // 短期预测功率
-                                calculationInfo.setTime(stepTime);
-                                calculationInfo.setForecastAbleValue(forecastPowerShortTermRegulation.getFpValue());
-                                calculationInfo.setForecastTheoryValue(forecastPowerShortTermRegulation.getFpValue());
-                                calculationInfo.setForecastCapacity(cap);
-                                calculationInfo.setForecastSuCapacity(cap);
 
                                 PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                //实际
-                                calculationInfo.setCapacity(cap);
-                                calculationInfo.setOpenCapacity(cap);
-                                calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                //限电时不参与考核，抛去
+                                if (!powerStationStatusData.getPowerRationing().equals(1)){
+                                    ForecastPowerShortTermRegulation forecastPowerShortTermRegulation = dateForecastListMap.get(finalTime).get(0);
+                                    // 短期预测功率
+                                    calculationInfo.setTime(stepTime);
+                                    calculationInfo.setForecastAbleValue(forecastPowerShortTermRegulation.getFpValue());
+                                    calculationInfo.setForecastTheoryValue(forecastPowerShortTermRegulation.getFpValue());
+                                    calculationInfo.setForecastCapacity(cap);
+                                    calculationInfo.setForecastSuCapacity(cap);
+
+
+                                    //实际
+                                    calculationInfo.setCapacity(cap);
+                                    calculationInfo.setOpenCapacity(cap);
+                                    calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
+                                    calculationInfo.setRealValue(powerStationStatusData.getRealValue());
+                                    calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                }
+
                             }
 
                             // 预测功率或实际功率为空的时候，不放入result中
@@ -120,70 +126,33 @@ public class CalculateForecastPowerShortTermRegulationImpl implements CalculateI
                         }
                     }
                     if (formulaTypes.contains("POINT_SHORT_ACCURACY")) {//单点偏差计算
-                        List<String> results = new ArrayList<>();
+
+                        BigDecimal sum = BigDecimal.ZERO;
+                        Boolean b = false;
 
                         for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                             Date finalTime = new Date(stepTime);
-                            // 组装数据
-                            CalculationInfo calculationInfo = new CalculationInfo();
-                            // 如果短期预测功率不为空且站场功率不为空
+
                             if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                ForecastPowerShortTermRegulation forecastPowerShortTermRegulation = dateForecastListMap.get(finalTime).get(0);
-                                // 短期预测功率
-                                calculationInfo.setTime(stepTime);
-                                calculationInfo.setForecastAbleValue(forecastPowerShortTermRegulation.getFpValue());
-                                calculationInfo.setForecastTheoryValue(forecastPowerShortTermRegulation.getFpValue());
-                                calculationInfo.setForecastCapacity(cap);
-                                calculationInfo.setForecastSuCapacity(cap);
 
+                                ForecastPowerShortTermRegulation forecastPowerShortTermRegulation = dateForecastListMap.get(finalTime).get(0);
                                 PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                //实际
-                                calculationInfo.setCapacity(cap);
-                                calculationInfo.setOpenCapacity(cap);
-                                calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
-                            }
 
-                            // 预测功率或实际功率为空的时候，不放入result中
-                            if (calculationInfo.getRealValue() != null && calculationInfo.getAbleValue() != null && calculationInfo.getForecastAbleValue() != null) {
-                                // 获取计算基础数据
-                                CalculateRequest calculateRequest = new CalculateRequest();
-                                calculateRequest.setCalculationInfoList(Arrays.asList(calculationInfo));
-                                calculateRequest.setElectricCapacity(capacity);
-                                calculateRequest.setProvince(province);
-                                calculateRequest.setStationCode(stationCode);
-                                calculateRequest.setFormulaType("POINT_SHORT_ACCURACY");
-                                calculateRequest.setElectricType(electricType);
-                                calculateRequest.setSign(electricField.getStationCode());
-                                calculateRequest.setStationStatus("无");
-                                calculateRequest.setStationCode(electricField.getStationCode());
-                                CalculateResult resultMap = SpringUtils.getBean(AccuracyPassRateCalculateService.class).calculate(calculateRequest);
-                                // 如果计算成功，从结果中获取value
-                                if (String.valueOf(resultMap.get(CalculateResult.CODE_TAG)).
-                                        equals(CalculateResult.Type.SUCCESS.value())) {
-                                    results.add(String.valueOf(resultMap.get(CalculateResult.DATA_TAG)));
-                                } else {
-                                    results.add(String.valueOf(resultMap.get(CalculateResult.MSG_TAG)));
-                                }
 
+                                BigDecimal subtractAbs = powerStationStatusData.getRealValue().subtract(forecastPowerShortTermRegulation.getFpValue()).abs();
+                                BigDecimal value = subtractAbs.divide(electricField.getCapacity(), 4, BigDecimal.ROUND_DOWN);
+                                sum = sum.add(value);
+                                b = true;
                             }
+
                         }
-                        if (results.isEmpty()) {
-                            accuracyPassRate.setDeviationSum("无可用数据计算");
+
+                        if (b) {
+                            accuracyPassRate.setDeviationSum(sum.doubleValue()*100 + "%");
                         } else {
-                            double sum = 0d;
-                            for (String result : results) {
-                                if (result.indexOf("%") > -1 && result.length() < 7) {
-                                    sum += Double.parseDouble(result.replace("%", ""));
-                                }
-                            }
-                            if (accuracyPassRate.getDeviationSum() == null) {
-                                accuracyPassRate.setDeviationSum(BigDecimal.valueOf(sum / 100).setScale(2, BigDecimal.ROUND_HALF_UP) + "");
-                            }
+                            accuracyPassRate.setDeviationSum("无可用数据计算");
                         }
 
-
                     }
 
                     accuracyPassRates.add(accuracyPassRate);

cpp-admin/src/main/java/com/cpp/web/service/accuracy/impl/CalculateForecastPowerShortTermStationImpl.java

@@ -30,7 +30,7 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
     private final ForecastPowerShortTermStationService forecastPowerShortTermStationService;
 
     @Override
-    public List<AccuracyPassRate> calc(Date startTime,Date endTime,List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province){
+    public List<AccuracyPassRate> calc(Date startTime, Date endTime, List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province) {
 
         List<AccuracyPassRate> accuracyPassRates = new ArrayList<>();
 
@@ -56,7 +56,6 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
                     accuracyPassRate.setForecastType(ForecastTypeEnum.dq);
                     accuracyPassRate.setStationCode(stationCode);
                     accuracyPassRate.setForecastHowLongAgo(ago);
-                    List<CalculationInfo> calculationInfoList = new ArrayList<>();
 
                     // 短期预测功率
                     Map<Date, List<ForecastPowerShortTermStation>> dateForecastListMap = agoListMap.get(ago).stream().filter(p -> p.getStationCode().equals(stationCode)).collect(Collectors.groupingBy(ForecastPowerShortTermStation::getTime, Collectors.toList()));
@@ -66,6 +65,7 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
                     BigDecimal cap = electricField.getCapacity();
 
                     if (formulaTypes.contains("DAY_SHORT_ACCURACY")) {//准确率计算
+                        List<CalculationInfo> calculationInfoList = new ArrayList<>();
                         // 从开始时间，每隔15分钟，一直循环到当前时间
                         for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                             Date finalTime = new Date(stepTime);
@@ -73,21 +73,27 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
                             CalculationInfo calculationInfo = new CalculationInfo();
                             // 如果短期预测功率不为空且站场功率不为空
                             if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                ForecastPowerShortTermStation forecastPowerShortTermStation = dateForecastListMap.get(finalTime).get(0);
-                                // 短期预测功率
-                                calculationInfo.setTime(stepTime);
-                                calculationInfo.setForecastAbleValue(forecastPowerShortTermStation.getFpValue());
-                                calculationInfo.setForecastTheoryValue(forecastPowerShortTermStation.getFpValue());
-                                calculationInfo.setForecastCapacity(cap);
-                                calculationInfo.setForecastSuCapacity(cap);
 
                                 PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                //实际
-                                calculationInfo.setCapacity(cap);
-                                calculationInfo.setOpenCapacity(cap);
-                                calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                //限电时不参与考核，抛去
+                                if (!powerStationStatusData.getPowerRationing().equals(1)) {
+
+                                    ForecastPowerShortTermStation forecastPowerShortTermStation = dateForecastListMap.get(finalTime).get(0);
+                                    // 短期预测功率
+                                    calculationInfo.setTime(stepTime);
+                                    calculationInfo.setForecastAbleValue(forecastPowerShortTermStation.getFpValue());
+                                    calculationInfo.setForecastTheoryValue(forecastPowerShortTermStation.getFpValue());
+                                    calculationInfo.setForecastCapacity(cap);
+                                    calculationInfo.setForecastSuCapacity(cap);
+
+
+                                    //实际
+                                    calculationInfo.setCapacity(cap);
+                                    calculationInfo.setOpenCapacity(cap);
+                                    calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
+                                    calculationInfo.setRealValue(powerStationStatusData.getRealValue());
+                                    calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+                                }
                             }
 
                             // 预测功率或实际功率为空的时候，不放入result中
@@ -99,7 +105,7 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
 
                         if (calculationInfoList == null || calculationInfoList.size() == 0) {
                             accuracyPassRate.setAccuracy("无可用数据计算");
-                        }else {
+                        } else {
                             // 获取计算基础数据
                             CalculateRequest calculateRequest = new CalculateRequest();
                             calculateRequest.setCalculationInfoList(calculationInfoList);
@@ -123,69 +129,78 @@ public class CalculateForecastPowerShortTermStationImpl implements CalculateInte
                         }
                     }
                     if (formulaTypes.contains("POINT_SHORT_ACCURACY")) {//单点偏差计算
-                        List<String> results = new ArrayList<>();
+
+                        BigDecimal sum = BigDecimal.ZERO;
+                        Boolean b = false;
 
                         for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                             Date finalTime = new Date(stepTime);
-                            // 组装数据
-                            CalculationInfo calculationInfo = new CalculationInfo();
-                            // 如果短期预测功率不为空且站场功率不为空
+
                             if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                                ForecastPowerShortTermStation forecastPowerShortTermStation = dateForecastListMap.get(finalTime).get(0);
-                                // 短期预测功率
-                                calculationInfo.setTime(stepTime);
-                                calculationInfo.setForecastAbleValue(forecastPowerShortTermStation.getFpValue());
-                                calculationInfo.setForecastTheoryValue(forecastPowerShortTermStation.getFpValue());
-                                calculationInfo.setForecastCapacity(cap);
-                                calculationInfo.setForecastSuCapacity(cap);
 
+                                ForecastPowerShortTermStation forecastPowerShortTermStation = dateForecastListMap.get(finalTime).get(0);
                                 PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                                //实际
-                                calculationInfo.setCapacity(cap);
-                                calculationInfo.setOpenCapacity(cap);
-                                calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                                calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                                calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
-                            }
 
-                            // 预测功率或实际功率为空的时候，不放入result中
-                            if (calculationInfo.getRealValue() != null && calculationInfo.getAbleValue() != null && calculationInfo.getForecastAbleValue() != null) {
-                                // 获取计算基础数据
-                                CalculateRequest calculateRequest = new CalculateRequest();
-                                calculateRequest.setCalculationInfoList(Arrays.asList(calculationInfo));
-                                calculateRequest.setElectricCapacity(capacity);
-                                calculateRequest.setProvince(province);
-                                calculateRequest.setStationCode(stationCode);
-                                calculateRequest.setFormulaType("POINT_SHORT_ACCURACY");
-                                calculateRequest.setElectricType(electricType);
-                                calculateRequest.setSign(electricField.getStationCode());
-                                calculateRequest.setStationStatus("无");
-                                calculateRequest.setStationCode(electricField.getStationCode());
-                                CalculateResult resultMap = SpringUtils.getBean(AccuracyPassRateCalculateService.class).calculate(calculateRequest);
-                                // 如果计算成功，从结果中获取value
-                                if (String.valueOf(resultMap.get(CalculateResult.CODE_TAG)).
-                                        equals(CalculateResult.Type.SUCCESS.value())) {
-                                    results.add(String.valueOf(resultMap.get(CalculateResult.DATA_TAG)));
-                                } else {
-                                    results.add(String.valueOf(resultMap.get(CalculateResult.MSG_TAG)));
-                                }
 
+                                BigDecimal subtractAbs = powerStationStatusData.getRealValue().subtract(forecastPowerShortTermStation.getFpValue()).abs();
+                                BigDecimal value = subtractAbs.divide(electricField.getCapacity(), 4, BigDecimal.ROUND_DOWN);
+                                sum = sum.add(value);
+                                b = true;
                             }
+
                         }
-                        if (results.isEmpty()) {
-                            accuracyPassRate.setDeviationSum("无可用数据计算");
+
+                        if (b) {
+                            accuracyPassRate.setDeviationSum(sum.doubleValue()*100 + "%");
                         } else {
-                            double sum = 0d;
-                            for (String result : results) {
-                                if (result.indexOf("%") > -1 && result.length() < 7) {
-                                    sum += Double.parseDouble(result.replace("%", ""));
-                                }
-                            }
-                            if (accuracyPassRate.getDeviationSum() == null) {
-                                accuracyPassRate.setDeviationSum(BigDecimal.valueOf(sum / 100).setScale(2, BigDecimal.ROUND_HALF_UP) + "");
-                            }
+                            accuracyPassRate.setDeviationSum("无可用数据计算");
                         }
 
+//                        Boolean b = false;
+//                        BigDecimal yibai = BigDecimal.valueOf(100);
+//                        BigDecimal mkh = electricField.getCapacity().multiply(new BigDecimal(0.03));
+//                        for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
+//
+//                            Date finalTime = new Date(stepTime);
+//
+//                            if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
+//                                PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
+//
+//                                //限电时不参与考核，抛去
+//                                if (!powerStationStatusData.getPowerRationing().equals(1)) {
+//
+//                                    ForecastPowerShortTermStation forecastPowerShortTermStation = dateForecastListMap.get(finalTime).get(0);
+//
+//                                    BigDecimal pr = powerStationStatusData.getRealValue();
+//                                    BigDecimal pn = forecastPowerShortTermStation.getFpValue();
+//
+//                                    //预测功率0，实际功率<=容量的3% 不予考核 反之误差为100%
+//                                    if (pn.compareTo(BigDecimal.ZERO) == 0) {
+//                                        if (pr.compareTo(mkh) >= 0) {
+//                                            sum.add(yibai);
+//                                        }
+//                                        continue;
+//                                    }
+//
+//                                    //实际功率为0，预测功率<=容量的3% 不予考核 反之误差为100%
+//                                    if (pr.compareTo(BigDecimal.ZERO) == 0) {
+//                                        if (pn.compareTo(mkh) >= 0) {
+//                                            sum.add(yibai);
+//                                        }
+//                                        continue;
+//                                    }
+//
+//                                    BigDecimal subtract = pr.subtract(pn);
+//                                    sum = sum.add(subtract.divide(pn,2,BigDecimal.ROUND_DOWN));
+//
+//                                    b = true;
+//                                }
+//
+//                            }
+//                    }
+
+
+
                     }
                     accuracyPassRates.add(accuracyPassRate);
                 }

cpp-admin/src/main/java/com/cpp/web/service/accuracy/impl/CalculateForecastPowerUltraShortTermStationImpl.java

@@ -33,7 +33,7 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
     private final ISysConfigService sysConfigService;
 
     @Override
-    public List<AccuracyPassRate> calc(Date startTime,Date endTime,List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province){
+    public List<AccuracyPassRate> calc(Date startTime, Date endTime, List<PowerStationStatusData> powerStationStatusDataList, List<ElectricField> electricFieldList, List<String> formulaTypes, String province) {
 
         List<AccuracyPassRate> accuracyPassRates = new ArrayList<>();
         String cdq_ac_point = sysConfigService.selectConfigByKey("cdq_ac_point");
@@ -61,7 +61,7 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
             accuracyPassRate.setForecastType(ForecastTypeEnum.cdq);
             accuracyPassRate.setStationCode(stationCode);
             accuracyPassRate.setForecastHowLongAgo(ago);
-            List<CalculationInfo> calculationInfoList = new ArrayList<>();
+
 
             // 获取实际功率
             Map<Date, List<ForecastPowerUltraShortTermStation>> dateForecastListMap = forecastPowerShortTermStationList.stream().filter(p -> p.getStationCode().equals(stationCode)).collect(Collectors.groupingBy(ForecastPowerUltraShortTermStation::getTime, Collectors.toList()));
@@ -70,7 +70,8 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
             //解析中目前不带 开机和装机容量，无法计算准确率，先用场站容量代替
             BigDecimal cap = electricField.getCapacity();
 
-            if (formulaTypes.contains("DAY_ULTRA_SHORT_ACCURACY")) {
+            if (formulaTypes.contains("POINT_ULTRA_SHORT_ACCURACY")) {
+                List<CalculationInfo> calculationInfoList = new ArrayList<>();
                 // 从开始时间，每隔15分钟，一直循环到当前时间
                 for (long stepTime = startTime.getTime(); stepTime <= endTime.getTime(); stepTime += 900000L) {
                     Date finalTime = new Date(stepTime);
@@ -78,21 +79,27 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
                     CalculationInfo calculationInfo = new CalculationInfo();
                     // 如果短期预测功率不为空且站场功率不为空
                     if (dateForecastListMap.containsKey(finalTime) && datePowerListMap.containsKey(finalTime)) {
-                        ForecastPowerUltraShortTermStation forecastPowerUltraShortTermStation = dateForecastListMap.get(finalTime).get(0);
-                        // 短期预测功率
-                        calculationInfo.setTime(stepTime);
-                        calculationInfo.setForecastAbleValue(forecastPowerUltraShortTermStation.getFpValue());
-                        calculationInfo.setForecastTheoryValue(forecastPowerUltraShortTermStation.getFpValue());
-                        calculationInfo.setForecastCapacity(cap);
-                        calculationInfo.setForecastSuCapacity(cap);
 
                         PowerStationStatusData powerStationStatusData = datePowerListMap.get(finalTime).get(0);
-                        //实际
-                        calculationInfo.setCapacity(cap);
-                        calculationInfo.setOpenCapacity(cap);
-                        calculationInfo.setRealValue(powerStationStatusData.getRealValue());
-                        calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
-                        calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+
+                        //限电时不参与考核，抛去
+                        if (!powerStationStatusData.getPowerRationing().equals(1)) {
+                            //实际
+                            calculationInfo.setCapacity(cap);
+                            calculationInfo.setOpenCapacity(cap);
+                            calculationInfo.setRealValue(powerStationStatusData.getRealValue());
+                            calculationInfo.setAbleValue(powerStationStatusData.getAbleValue());
+                            calculationInfo.setTheoryValue(powerStationStatusData.getTheoryValue());
+
+
+                            ForecastPowerUltraShortTermStation forecastPowerUltraShortTermStation = dateForecastListMap.get(finalTime).get(0);
+                            // 短期预测功率
+                            calculationInfo.setTime(stepTime);
+                            calculationInfo.setForecastAbleValue(forecastPowerUltraShortTermStation.getFpValue());
+                            calculationInfo.setForecastTheoryValue(forecastPowerUltraShortTermStation.getFpValue());
+                            calculationInfo.setForecastCapacity(cap);
+                            calculationInfo.setForecastSuCapacity(cap);
+                        }
                     }
 
                     // 预测功率或实际功率为空的时候，不放入result中
@@ -113,7 +120,7 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
                 calculateRequest.setElectricCapacity(capacity);
                 calculateRequest.setProvince(province);
                 calculateRequest.setStationCode(stationCode);
-                calculateRequest.setFormulaType("DAY_ULTRA_SHORT_ACCURACY");
+                calculateRequest.setFormulaType("POINT_ULTRA_SHORT_ACCURACY");
                 calculateRequest.setElectricType(electricType);
                 calculateRequest.setSign(electricField.getStationCode());
                 calculateRequest.setStationStatus("无");
@@ -134,8 +141,8 @@ public class CalculateForecastPowerUltraShortTermStationImpl implements Calculat
         return accuracyPassRates;
     }
 
-    @Override
+//    @Override
     public List<String> calculationTypes() {
-        return Arrays.asList("DAY_ULTRA_SHORT_ACCURACY");
+        return Arrays.asList("POINT_ULTRA_SHORT_ACCURACY");
     }
 }

cpp-ui/src/views/statistics/stationAccuracy/index.vue

@@ -121,11 +121,11 @@ export default {
           field: "time"
         },
         {
-          label: "准确率",
+          label: "准确率(%)",
           field: "accuracy"
         },
         {
-          label: "单点偏差累加(cap*h)",
+          label: "单点偏差率累加(cap*%)",
           field: "deviationSum"
         },
         {
@@ -279,7 +279,7 @@ export default {
         backgroundColor: 'transparent',
         title: {
           top: 20,
-          text: '准确率',
+          text: '准确率(%)',
           textStyle: {
             fontWeight: 'normal',
             fontSize: 16,
@@ -302,7 +302,7 @@ export default {
           itemWidth: 14,
           itemHeight: 5,
           itemGap: 13,
-          data: ["准确率"],
+          data: ["准确率(%)"],
           right: '4%',
           textStyle: {
             fontSize: 12,
@@ -371,7 +371,7 @@ export default {
         }],
         series: [
           {
-            name: '准确率',
+            name: '准确率(%)',
             type: 'line',
             smooth: false,
             symbol: 'circle',
@@ -423,7 +423,7 @@ export default {
         backgroundColor: 'transparent',
         title: {
           top: 20,
-          text: '单点偏差累加',
+          text: '单点偏差率累加(cap*%)',
           textStyle: {
             fontWeight: 'normal',
             fontSize: 16,
@@ -446,7 +446,7 @@ export default {
           itemWidth: 14,
           itemHeight: 5,
           itemGap: 13,
-          data: ["单点偏差累加"],
+          data: ["单点偏差率累加(cap*%)"],
           right: '4%',
           textStyle: {
             fontSize: 12,
@@ -513,7 +513,7 @@ export default {
         }],
         series: [
           {
-            name: '单点偏差累加',
+            name: '单点偏差率累加(cap*%)',
             type: 'line',
             smooth: false,
             symbol: 'circle',