优化异常数据算法

2026-01-04 14:50:51 +08:00
parent ab96d247fa
commit 4c239b1604
3 changed files with 257 additions and 49 deletions
--- a/algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/FlowAsyncServiceImpl.java
+++ b/algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/FlowAsyncServiceImpl.java
@@ -1087,198 +1087,267 @@ public class FlowAsyncServiceImpl implements FlowAsyncService {
    }

    public Map<String, Object> handleDataV(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(12);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //频率
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list1 = handleData(codeMap.get(DataCleanEnum.Freq.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list1)) {
-            bak.setFreq(1);
+            int errorCount = list1.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list1.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setFreq(errorCount);
+            bak.setFreqTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.Freq.getCode(), list1);
        }
        //频率偏差
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list2 = handleData(codeMap.get(DataCleanEnum.FreqDev.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list2)) {
-            bak.setFreqDev(1);
+            int errorCount = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setFreqDev(errorCount);
+            bak.setFreqDevTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.FreqDev.getCode(), list2);
        }
        //相电压有效值
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list3 = handleData(codeMap.get(DataCleanEnum.RmsV.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list3)) {
-            bak.setVRms(1);
+            int errorCount = list3.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list3.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVRms(errorCount);
+            bak.setVRmsTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.RmsV.getCode(), list3);
        }
        //正序电压
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list4 = handleData(codeMap.get(DataCleanEnum.VPos.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list4)) {
-            bak.setVPos(1);
+            int errorCount = list4.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list4.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVPos(errorCount);
+            bak.setVPosTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VPos.getCode(), list4);
        }
        //负序电压
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list5 = handleData(codeMap.get(DataCleanEnum.VNeg.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list5)) {
-            bak.setVNeg(1);
+            int errorCount = list5.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list5.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVNeg(errorCount);
+            bak.setVNegTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VNeg.getCode(), list5);
        }
        //零序电压
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list6 = handleData(codeMap.get(DataCleanEnum.VZero.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list6)) {
-            bak.setVZero(1);
+            int errorCount = list6.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list6.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVZero(errorCount);
+            bak.setVZeroTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VZero.getCode(), list6);
        }
        //电压不平衡度
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list7 = handleData(codeMap.get(DataCleanEnum.VUnbalance.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list7)) {
-            bak.setVUnbalance(1);
+            int errorCount = list7.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list7.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVUnbalance(errorCount);
+            bak.setVUnbalanceTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VUnbalance.getCode(), list7);
        }
        //线电压有效值
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list8 = handleData(codeMap.get(DataCleanEnum.RmsLvr.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list8)) {
-            bak.setRmsLvr(1);
+            int errorCount = list8.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list8.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setRmsLvr(errorCount);
+            bak.setRmsLvrTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.RmsLvr.getCode(), list8);
        }
        //电压正偏差
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list9 = handleData(codeMap.get(DataCleanEnum.VuDev.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list9)) {
-            bak.setVuDev(1);
+            int errorCount = list9.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list9.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVuDev(errorCount);
+            bak.setVuDevTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VuDev.getCode(), list9);
        }
        //电压负偏差
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list10 = handleData(codeMap.get(DataCleanEnum.VlDev.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list10)) {
-            bak.setVlDev(1);
+            int errorCount = list10.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list10.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVlDev(errorCount);
+            bak.setVlDevTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VlDev.getCode(), list10);
        }
        //电压总谐波畸变率
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list11 = handleData(codeMap.get(DataCleanEnum.VThd.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list11)) {
-            bak.setVThd(1);
+            int errorCount = list11.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list11.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVThd(errorCount);
+            bak.setVThdTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.VThd.getCode(), list11);
        }
        //相（线）电压基波有效值
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list12 = handleData(codeMap.get(DataCleanEnum.V_Data.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list12)) {
-            bak.setV(1);
+            int errorCount = list12.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list12.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setV(errorCount);
+            bak.setVTime(errorTime);
            map.put(DataCleanEnum.DataV.getCode() + "-" + DataCleanEnum.V_Data.getCode(), list12);
        }
        return map;
    }

    public Map<String, Object> handleDataI(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //电流有效值
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.RmsI.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setIRms(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setIRms(errorCount);
+            bak.setIRmsTime(errorTime);
            map.put(DataCleanEnum.DataI.getCode() + "-" + DataCleanEnum.RmsI.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleDataPlt(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //长时闪变
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.Plt.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setPlt(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setPlt(errorCount);
+            bak.setPltTime(errorTime);
            map.put(DataCleanEnum.DataPlt.getCode() + "-" + DataCleanEnum.Plt.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleInHarmV(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //间谐波电压含有率
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleHarmData(codeMap.get(DataCleanEnum.V_InHarm.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setVInharm(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVInharm(errorCount);
+            bak.setVInharmTime(errorTime);
            map.put(DataCleanEnum.DataInHarmV.getCode() + "-" + DataCleanEnum.V_InHarm.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleHarmRateV(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //谐波电压含有率
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleHarmData(codeMap.get(DataCleanEnum.V_Rate.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setVHarm(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVHarm(errorCount);
+            bak.setVHarmTime(errorTime);
            map.put(DataCleanEnum.DataHarmRateV.getCode() + "-" + DataCleanEnum.V_Rate.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleHarmPowerP(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //功率因素
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.Pf.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setPf(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setPf(errorCount);
+            bak.setPfTime(errorTime);
            map.put(DataCleanEnum.DataHarmPowerP.getCode() + "-" + DataCleanEnum.Pf.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleHarmPhasicV(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(2);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //谐波电压相角
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleHarmData(codeMap.get(DataCleanEnum.V.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setVPhasic(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setVPhasic(errorCount);
+            bak.setVPhasicTime(errorTime);
            map.put(DataCleanEnum.DataHarmPhasicV.getCode() + "-" + DataCleanEnum.V.getCode(), list);
        }
        //谐波电压基波相角
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list2 = handleData(codeMap.get(DataCleanEnum.V1.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list2)) {
-            bak.setV1Phasic(1);
+            int errorCount = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setV1Phasic(errorCount);
+            bak.setV1PhasicTime(errorTime);
            map.put(DataCleanEnum.DataHarmPhasicV.getCode() + "-" + DataCleanEnum.V1.getCode(), list2);
        }
        return map;
    }

    public Map<String, Object> handleDataFluc(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //电压波动
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.Fluc.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setFluc(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setFluc(errorCount);
+            bak.setFlucTime(errorTime);
            map.put(DataCleanEnum.DataFluc.getCode() + "-" + DataCleanEnum.Fluc.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleDataFlicker(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(1);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //短时闪变
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.Pst.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setPst(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setPst(errorCount);
+            bak.setPstTime(errorTime);
            map.put(DataCleanEnum.DataFlicker.getCode() + "-" + DataCleanEnum.Pst.getCode(), list);
        }
        return map;
    }

    public Map<String, Object> handleDataEvent(List<PqDataVerify> result, PqDataVerifyBak bak, Integer timeInterval) {
-        Map<String, Object> map = new HashMap<>();
+        Map<String, Object> map = new HashMap<>(2);
        Map<String, List<PqDataVerify>> codeMap = result.stream().collect(Collectors.groupingBy(PqDataVerify::getIndexCode));
        //暂降事件
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list = handleData(codeMap.get(DataCleanEnum.VoltageDip.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list)) {
-            bak.setDip(1);
+            int errorCount = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setDip(errorCount);
+            bak.setDipTime(errorTime);
            map.put(DataCleanEnum.RMpEventDetail.getCode() + "-" + DataCleanEnum.VoltageDip.getCode(), list);
        }
        //暂升事件
        List<DataCleanJsonDTO.DataHarmCleanJsonDTO> list2 = handleData(codeMap.get(DataCleanEnum.VoltageRise.getCode()), timeInterval);
        if (CollUtil.isNotEmpty(list2)) {
-            bak.setRise(1);
+            int errorCount = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorCounts).sum();
+            int errorTime = list2.stream().mapToInt(DataCleanJsonDTO.DataHarmCleanJsonDTO::getErrorTimes).sum();
+            bak.setRise(errorCount);
+            bak.setRiseTime(errorTime);
            map.put(DataCleanEnum.RMpEventDetail.getCode() + "-" + DataCleanEnum.VoltageRise.getCode(), list2);
        }
        return map;
--- a/algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/PollutionCalcImpl.java
+++ b/algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/PollutionCalcImpl.java
@@ -87,15 +87,11 @@ public class PollutionCalcImpl implements IPollutionCalc {
                        lineParam.setValueType(Arrays.asList(line.getTimeInterval() + ""));
                        lineParam.setLineId(Arrays.asList(id));

-
                        List<DataVDto> dataVDtoList = dataVFeignClient.getGroupByTimeDataV(lineParam).getData();
                        List<DataHarmDto> dataHarmDtoList = dataHarmRateVFeignClient.getGroupByTimeHarmRateV(lineParam).getData();
-                        if (CollUtil.isNotEmpty(dataVDtoList) && CollUtil.isNotEmpty(dataHarmDtoList)) {
-                            //计算谐波电压污染值
-                            dataPollutionD.setValue(PubUtils.doubleRound(2, calcVAllPollutionValue(dataVDtoList, dataHarmDtoList, overlimit) * line.getTimeInterval()));
-                        }else{
-                            dataPollutionD.setValue(0.0);
-                        }
+                        //计算谐波电压污染值
+                        dataPollutionD.setValue(PubUtils.doubleRound(2, calcVAllPollutionValue(dataVDtoList, dataHarmDtoList, overlimit) * line.getTimeInterval()));
+
                        list.add(dataPollutionD);
                        dataPollutionD = new DataPollutionD();
                        dataPollutionD.setLineId(id);
@@ -105,7 +101,7 @@ public class PollutionCalcImpl implements IPollutionCalc {
                        if (CollUtil.isNotEmpty(data)) {
                            //计算谐波电流污染值
                            dataPollutionD.setValue(PubUtils.doubleRound(2, calcIAllPollutionValue(data, overlimit) * line.getTimeInterval()));
-                        }else{
+                        } else {
                            dataPollutionD.setValue(0.0);
                        }
                        list.add(dataPollutionD);
@@ -129,10 +125,16 @@ public class PollutionCalcImpl implements IPollutionCalc {
    private double calcVAllPollutionValue(List<DataVDto> dataVDtoList, List<DataHarmDto> dataHarmDtoList, Overlimit overlimit) {
        // 计算时间范围内指标越限百分比
        // 总畸变率的限值
-        List<Double> thdValueList = dataVDtoList.stream().map(DataVDto::getVThd).collect(Collectors.toList());
-        double thdPollutionValue = calcPollutionValue(overlimit.getUbalance(), thdValueList);
-        //谐波值2~50次
-        double harmRateVPollutionValue = calcHarmRateVPollutionValue(overlimit, dataHarmDtoList);
+        double thdPollutionValue = 0;
+        double harmRateVPollutionValue = 0;
+        if (CollUtil.isNotEmpty(dataVDtoList)) {
+            List<Double> thdValueList = dataVDtoList.stream().map(DataVDto::getVThd).collect(Collectors.toList());
+            thdPollutionValue = calcPollutionValue(overlimit.getUbalance(), thdValueList);
+        }
+        if (CollUtil.isNotEmpty(dataVDtoList)) {
+            //谐波值2~50次
+            harmRateVPollutionValue = calcHarmRateVPollutionValue(overlimit, dataHarmDtoList);
+        }
        return thdPollutionValue + harmRateVPollutionValue;
    }

--- a/data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/PqDataVerifyBak.java
+++ b/data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/PqDataVerifyBak.java
@@ -12,7 +12,7 @@ import java.time.LocalDate;

 /**
 * <p>
- * 
+ *
 * </p>
 *
 * @author xy
@@ -37,7 +37,7 @@ public class PqDataVerifyBak implements Serializable {
     */
    @MppMultiId
    @TableField(value = "time_id")
-    @JsonFormat(pattern = "yyyy-MM-dd",timezone="GMT+8")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
    private LocalDate time;

    /**
@@ -53,138 +53,275 @@ public class PqDataVerifyBak implements Serializable {
    @TableField(value = "freq")
    private Integer freq = 0;

+    /**
+     * 频率异常时间
+     */
+    @TableField(value = "freq_time")
+    private Integer freqTime = 0;
+
    /**
     * 频率偏差指标
     */
    @TableField(value = "freq_dev")
    private Integer freqDev = 0;

+    /**
+     * 频率偏差异常时间
+     */
+    @TableField(value = "freq_dev_time")
+    private Integer freqDevTime = 0;
+
    /**
     * 相电压有效值
     */
    @TableField(value = "v_rms")
    private Integer vRms = 0;

+    /**
+     * 相电压有效值异常时间
+     */
+    @TableField(value = "v_rms_time")
+    private Integer vRmsTime = 0;
+
    /**
     * 正序电压
     */
    @TableField(value = "v_pos")
    private Integer vPos = 0;

+    /**
+     * 正序电压异常时间
+     */
+    @TableField(value = "v_pos_time")
+    private Integer vPosTime = 0;
+
    /**
     * 负序电压
     */
    @TableField(value = "v_neg")
    private Integer vNeg = 0;

+    /**
+     * 负序电压异常时间
+     */
+    @TableField(value = "v_neg_time")
+    private Integer vNegTime = 0;
+
    /**
     * 零序电压
     */
    @TableField(value = "v_zero")
    private Integer vZero = 0;

+    /**
+     * 零序电压异常时间
+     */
+    @TableField(value = "v_zero_time")
+    private Integer vZeroTime = 0;
+
    /**
     * 电压不平衡度
     */
    @TableField(value = "v_unbalance")
    private Integer vUnbalance = 0;

+    /**
+     * 电压不平衡度异常时间
+     */
+    @TableField(value = "v_unbalance_time")
+    private Integer vUnbalanceTime = 0;
+
    /**
     * 线电压有效值
     */
    @TableField(value = "rms_lvr")
    private Integer rmsLvr = 0;

+    /**
+     * 线电压有效值异常时间
+     */
+    @TableField(value = "rms_lvr_time")
+    private Integer rmsLvrTime = 0;
+
    /**
     * 电压正偏差
     */
    @TableField(value = "vu_dev")
    private Integer vuDev = 0;

+    /**
+     * 电压正偏差异常时间
+     */
+    @TableField(value = "vu_dev_time")
+    private Integer vuDevTime = 0;
+
    /**
     * 电压负偏差
     */
    @TableField(value = "vl_Dev")
    private Integer vlDev = 0;

+    /**
+     * 电压负偏差异常时间
+     */
+    @TableField(value = "vl_Dev_time")
+    private Integer vlDevTime = 0;
+
    /**
     * 电压总谐波畸变率
     */
    @TableField(value = "v_thd")
    private Integer vThd = 0;

+    /**
+     * 电压总谐波畸变率异常时间
+     */
+    @TableField(value = "v_thd_time")
+    private Integer vThdTime = 0;
+
    /**
     * 相电压基波有效值
     */
    @TableField(value = "v")
    private Integer v = 0;

+    /**
+     * 相电压基波有效值异常时间
+     */
+    @TableField(value = "v_time")
+    private Integer vTime = 0;
+
    /**
     * 电流有效值
     */
    @TableField(value = "i_rms")
    private Integer iRms = 0;

+    /**
+     * 电流有效值异常时间
+     */
+    @TableField(value = "i_rms_time")
+    private Integer iRmsTime = 0;
+
    /**
     * 长时闪变
     */
    @TableField(value = "plt")
    private Integer plt = 0;

+    /**
+     * 长时闪变异常时间
+     */
+    @TableField(value = "plt_time")
+    private Integer pltTime = 0;
+
    /**
     * 间谐波电压含有率
     */
    @TableField(value = "v_inharm")
    private Integer vInharm = 0;

+    /**
+     * 间谐波电压含有率异常时间
+     */
+    @TableField(value = "v_Inharm_time")
+    private Integer vInharmTime = 0;
+
    /**
     * 谐波电压含有率
     */
    @TableField(value = "v_harm")
    private Integer vHarm = 0;

+    /**
+     * 谐波电压含有率异常时间
+     */
+    @TableField(value = "v_harm_time")
+    private Integer vHarmTime = 0;
+
    /**
     * 功率因数
     */
    @TableField(value = "pf")
    private Integer pf = 0;

+    /**
+     * 功率因数异常时间
+     */
+    @TableField(value = "pf_time")
+    private Integer pfTime = 0;
+
    /**
     * 谐波电压相角
     */
    @TableField(value = "v_phasic")
    private Integer vPhasic = 0;

+    /**
+     * 谐波电压相角异常时间
+     */
+    @TableField(value = "v_phasic_time")
+    private Integer vPhasicTime = 0;
+
    /**
     * 谐波电压基波相角
     */
    @TableField(value = "v1_phasic")
    private Integer v1Phasic = 0;

+    /**
+     * 谐波电压基波相角异常时间
+     */
+    @TableField(value = "v1_phasic_time")
+    private Integer v1PhasicTime = 0;
+
    /**
     * 电压波动
     */
    @TableField(value = "fluc")
    private Integer fluc = 0;

+    /**
+     * 电压波动异常时间
+     */
+    @TableField(value = "fluc_time")
+    private Integer flucTime = 0;
+
    /**
     * 短时闪变
     */
    @TableField(value = "pst")
    private Integer pst = 0;

+    /**
+     * 短时闪变异常时间
+     */
+    @TableField(value = "pst_time")
+    private Integer pstTime = 0;

    /**
     * 电压暂降(0:正常 1:异常)
     */
    @TableField(value = "dip")
-    private Integer dip;
+    private Integer dip = 0;
+
+    /**
+     * 电压暂降异常时间
+     */
+    @TableField(value = "dip_time")
+    private Integer dipTime = 0;

    /**
     * 电压暂升(0:正常 1:异常)
     */
    @TableField(value = "rise")
-    private Integer rise;
+    private Integer rise = 0;
+
+    /**
+     * 电压暂升异常时间
+     */
+    @TableField(value = "rise_time")
+    private Integer riseTime = 0;


    /**