优化异常数据算法

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;

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()));
-                            dataPollutionD.setValue(PubUtils.doubleRound(2, calcVAllPollutionValue(dataVDtoList, dataHarmDtoList, overlimit) * line.getTimeInterval()));
+
-                        }else{
-                            dataPollutionD.setValue(0.0);
-                        }
                         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 = 0;
-        double thdPollutionValue = calcPollutionValue(overlimit.getUbalance(), thdValueList);
+        double harmRateVPollutionValue = 0;
-        //谐波值2~50次
+        if (CollUtil.isNotEmpty(dataVDtoList)) {
-        double harmRateVPollutionValue = calcHarmRateVPollutionValue(overlimit, dataHarmDtoList);
+            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;
     }
 

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;
 
 
     /**