diff --git a/pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/constant/Param.java b/pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/constant/Param.java index e1911f662..c98708bcc 100644 --- a/pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/constant/Param.java +++ b/pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/constant/Param.java @@ -1,9 +1,6 @@ package com.njcn.device.pq.constant; - -import java.util.Arrays; import java.util.HashMap; -import java.util.List; import java.util.Map; /** @@ -41,24 +38,19 @@ public interface Param { * put(name:表ele_epd_pqd中的名称,value:页面展示的指标名称) */ Map DATABSEMAP = new HashMap(){{ - put("频率偏差","频率偏差"); put("线电压偏差","电压偏差"); + put("电压负序不平衡度","三相电压不平衡度"); + put("相电压电压变动幅度","电压波动"); put("相电压长时闪变","长时闪变"); - //put("线电压总有效值","谐波电压"); - //put("电流总有效值","谐波电流"); - //put("相电压总有效值","间谐波电压"); - put("电压负序不平衡度","负序电压不平衡度"); - put("电流负序不平衡度","负序电流"); - put("总稳态指标","三相总有功功率"); - put("相电压谐波总畸变率","电压总谐波畸变率"); + put("电流负序不平衡度","电流不平衡度"); }}; Map UHARMMAP = new HashMap(){{ - put("相电压谐波含有率序列","电压"); + put("相电压谐波含有率序列","谐波电压"); }}; Map IHARMMAP = new HashMap(){{ - put("谐波电流有效值","电流"); + put("谐波电流有效值","谐波电流"); }}; Map INTERHARMONICMAP = new HashMap(){{ diff --git a/pqs-event/event-api/src/main/java/com/njcn/event/pojo/constant/Param.java b/pqs-event/event-api/src/main/java/com/njcn/event/pojo/constant/Param.java index de4958d52..501acc089 100644 --- a/pqs-event/event-api/src/main/java/com/njcn/event/pojo/constant/Param.java +++ b/pqs-event/event-api/src/main/java/com/njcn/event/pojo/constant/Param.java @@ -28,4 +28,21 @@ public interface Param { String END =" 23:59:59"; String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"; + + String voltageOffset = "电压偏差"; + + String vTimes = "谐波电压"; + + String iTimes = "谐波电流"; + + String ubalance = "三相电压不平衡度"; + + String voltageFluctuation = "电压波动"; + + String flicker = "闪变"; + + String interHarmonic = "间谐波电压含有率"; + + String sequenceCurrentUnbalance = "电流不平衡度"; + } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/constant/Param.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/constant/Param.java index cf0cee4ef..f976cab0d 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/constant/Param.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/constant/Param.java @@ -71,19 +71,4 @@ public interface Param { String DECIMAL_FORMATTWOSTR = "#.##"; - String voltageOffset = "电压偏差"; - - String vTimes = "谐波电压"; - - String iTimes = "谐波电流"; - - String ubalance = "三相电压不平衡度"; - - String voltageFluctuation = "电压波动"; - - String flicker = "闪变"; - - String interHarmonic = "间谐波电压含有率"; - - String sequenceCurrentUnbalance = "电流不平衡度"; } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java index 428378f17..89ab6a610 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java @@ -1,7 +1,5 @@ package com.njcn.harmonic.pojo.vo; -import com.alibaba.excel.annotation.ExcelProperty; -import com.fasterxml.jackson.annotation.JsonFormat; import io.swagger.annotations.ApiModelProperty; import lombok.Data; import java.util.ArrayList; @@ -16,19 +14,15 @@ import java.util.List; public class PowerStatisticsTargetVO { @ApiModelProperty("时间") - @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") private String time; @ApiModelProperty("电压偏差") - @ExcelProperty(index =2,value = {"电压","B"}) private Integer voltageOffset = 0; @ApiModelProperty("谐波电压") - @ExcelProperty(index =3,value = {"电压","C"}) private Integer vTimes = 0; @ApiModelProperty("谐波电流") - @ExcelProperty(index =4,value = {"电流","A"}) private Integer iTimes = 0; @ApiModelProperty("三相电压不平衡度") @@ -46,9 +40,6 @@ public class PowerStatisticsTargetVO { @ApiModelProperty("电流不平衡度") private Integer sequenceCurrentUnbalance = 0; - @ApiModelProperty("区间字段(标识是哪个区间:10%~20%、20%~30%....)用于后端辅助计算") - private String field; - @ApiModelProperty("电压偏差详情") private List voltageOffsetList = new ArrayList<>(); @@ -73,58 +64,4 @@ public class PowerStatisticsTargetVO { @ApiModelProperty("电流不平衡度详情") private List sequenceCurrentUnbalanceList = new ArrayList<>(); - @ApiModelProperty("相别(用于后端辅助计算)") - private String phasicType; - - @ApiModelProperty("统计方式(用于后端辅助计算)") - private String valueType;; - - @ApiModelProperty("电压偏差国标限值(用于后端辅助计算)") - private Float voltageOffsetLimit; - - @ApiModelProperty("谐波电压国标限值(用于后端辅助计算)") - private List vTimesLimit = new ArrayList<>();; - - @ApiModelProperty("谐波电流国标限值(用于后端辅助计算)") - private List iTimesLimit = new ArrayList<>();; - - @ApiModelProperty("三相电压不平衡度国标限值(用于后端辅助计算)") - private Float ubalanceLimit; - - @ApiModelProperty("电压波动国标限值(用于后端辅助计算)") - private Float voltageFluctuationLimit; - - @ApiModelProperty("闪变国标限值(用于后端辅助计算)") - private Float flickerLimit; - - @ApiModelProperty("间谐波电压含有率国标限值(用于后端辅助计算)") - private List interHarmonicLimit = new ArrayList<>();; - - @ApiModelProperty("电流不平衡度国标限值(用于后端辅助计算)") - private Float sequenceCurrentUnbalanceLimit; - - @ApiModelProperty("电压偏差具体值(用于后端辅助计算)") - private Double voltageOffsetData; - - @ApiModelProperty("谐波电压具体值(用于后端辅助计算)") - private List vTimesData = new ArrayList<>();; - - @ApiModelProperty("谐波电流具体值(用于后端辅助计算)") - private List iTimesData = new ArrayList<>();; - - @ApiModelProperty("三相电压不平衡度具体值(用于后端辅助计算)") - private Double ubalanceData; - - @ApiModelProperty("电压波动具体值(用于后端辅助计算)") - private Double voltageFluctuationData; - - @ApiModelProperty("闪变具体值(用于后端辅助计算)") - private Double flickerData; - - @ApiModelProperty("间谐波电压含有率具体值(用于后端辅助计算)") - private List interHarmonicData = new ArrayList<>(); - - @ApiModelProperty("电流不平衡度具体值(用于后端辅助计算)") - private Double sequenceCurrentUnbalanceData; - } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVO.java index fe23a00dd..c6ea738ba 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVO.java @@ -1,5 +1,6 @@ package com.njcn.harmonic.pojo.vo; +import com.alibaba.excel.annotation.ExcelProperty; import io.swagger.annotations.ApiModelProperty; import lombok.Data; @@ -56,6 +57,9 @@ public class ThdDataVO { @ApiModelProperty("国标限值") private Float limit; + @ApiModelProperty("谐波次数") + private Integer frequency; + @ApiModelProperty("时间") private String time; diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java index 7e61b4851..2bb0eb8a0 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java @@ -29,6 +29,7 @@ import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import javax.servlet.http.HttpServletResponse; import java.io.IOException; +import java.lang.reflect.Field; import java.text.DecimalFormat; import java.util.*; import java.util.stream.Collectors; @@ -71,6 +72,7 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { //执行完就可以获取到区间数据了 RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeFeignClient.getDataByLineId(powerStatisticsParam.getLineId(), powerStatisticsParam.getSearchBeginTime(),powerStatisticsParam.getSearchEndTime()).getData(); + //如果的确没有统计到数据则默认 if(rActivePowerRangePO == null){ rActivePowerRangePO = new RActivePowerRangePO(); } @@ -98,253 +100,40 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { @Override public List getTargetLimitById(PowerStatisticsParam powerStatisticsParam) { - List data = new ArrayList<>(); + List record = new ArrayList<>(); RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam(); BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam); rActivePowerRangeParam.setSearch(true); - //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:每条数据当前时间中八个指标是否越限及他们的相别和统计方式是什么 - //基于record结构需要做维度的转换 - List record = rActivePowerRangeFeignClient.record(rActivePowerRangeParam).getData(); - //根据时间分组: - Map> map = record.stream().collect(Collectors.groupingBy(PowerStatisticsTargetVO::getTime)); - map.forEach((key, value) ->{ - PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO(); - powerStatisticsTargetVO.setTime(key); - powerStatisticsTargetVO.setField(powerStatisticsParam.getField()); - //各指标越限的相别及统计方式集合 - List> pvs = new ArrayList<>(); - //遍历当前时间下的区间指标(注意:可能多组只是说统计方式和相别不同) - for(PowerStatisticsTargetVO vo : value){ - //以下这些判断只要有一个指标越限了(不管是什么统计方式和相别)直接标识该指标越限(这些字段用于前端展示) - if(vo.getVoltageOffset().intValue() == 1) powerStatisticsTargetVO.setVoltageOffset(1); - if(vo.getVTimes().intValue() == 1) powerStatisticsTargetVO.setVTimes(1); - if(vo.getITimes().intValue() == 1) powerStatisticsTargetVO.setITimes(1); - if(vo.getUbalance().intValue() == 1) powerStatisticsTargetVO.setUbalance(1); - if(vo.getVoltageFluctuation().intValue() == 1) powerStatisticsTargetVO.setVoltageFluctuation(1); - if(vo.getFlicker().intValue() == 1) powerStatisticsTargetVO.setFlicker(1); - if(vo.getInterHarmonic().intValue() == 1) powerStatisticsTargetVO.setInterHarmonic(1); - if(vo.getSequenceCurrentUnbalance().intValue() == 1) powerStatisticsTargetVO.setSequenceCurrentUnbalance(1); - //以下逻辑用于前端点击指标时能看到指标具体的越限情况(比方说A相AVG越限了) - Map pv = new HashMap<>(); - pv.put(vo.getPhasicType(),vo.getValueType()); - //除了带有谐波次数的指标需要特殊处理其他正常添加到pvs中 - if(vo.getVoltageOffsetData()!=null) pv.put(Param.voltageOffset,df.format(vo.getVoltageOffsetData())); - if(vo.getUbalanceData()!=null) pv.put(Param.ubalance,df.format(vo.getUbalanceData())); - if(vo.getVoltageFluctuationData()!=null) pv.put(Param.voltageFluctuation,df.format(vo.getVoltageFluctuationData())); - if(vo.getFlickerData()!=null) pv.put(Param.flicker,df.format(vo.getFlickerData())); - if(vo.getSequenceCurrentUnbalanceData()!=null) pv.put(Param.sequenceCurrentUnbalance,df.format(vo.getSequenceCurrentUnbalanceData())); - pvs.add(pv); - } - powerStatisticsTargetVO.setVoltageOffsetList(initPV(pvs,Param.voltageOffset,value.get(0).getVoltageOffsetLimit())); - //谐波电压带有谐波次数需要特殊处理 - powerStatisticsTargetVO.setVTimesList(initFrequencyPV(value,Param.vTimes,value.get(0).getVTimesLimit())); - //谐波电流带有谐波次数需要特殊处理 - powerStatisticsTargetVO.setITimestList(initFrequencyPV(value,Param.iTimes,value.get(0).getITimesLimit())); - powerStatisticsTargetVO.setUbalanceList(initPV(pvs,Param.ubalance,value.get(0).getUbalanceLimit())); - powerStatisticsTargetVO.setVoltageFluctuationList(initPV(pvs,Param.voltageFluctuation,value.get(0).getVoltageFluctuationLimit())); - powerStatisticsTargetVO.setFlickerList(initPV(pvs,Param.flicker,value.get(0).getFlickerLimit())); - //间谐波电压含有率带有谐波次数需要特殊处理 - powerStatisticsTargetVO.setInterHarmonicList(initFrequencyPV(value,Param.interHarmonic,value.get(0).getInterHarmonicLimit())); - powerStatisticsTargetVO.setSequenceCurrentUnbalanceList(initPV(pvs,Param.sequenceCurrentUnbalance,value.get(0).getSequenceCurrentUnbalanceLimit())); - powerStatisticsTargetVO.setVTimesList(formatFrequency(powerStatisticsTargetVO.getVTimesList())); - powerStatisticsTargetVO.setITimestList(formatFrequency(powerStatisticsTargetVO.getITimestList())); - powerStatisticsTargetVO.setInterHarmonicList(formatFrequency(powerStatisticsTargetVO.getInterHarmonicList())); - data.add(powerStatisticsTargetVO); - }); - - return data.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList()); - } - - private List formatFrequency(List thdDataVOS){ - List data = new ArrayList<>(); - for(ThdDataVO thdDataVO : thdDataVOS){ - boolean isOk = false; - if(thdDataVO.getMINPhaseA()!= null && Float.parseFloat(thdDataVO.getMINPhaseA())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getMINPhaseB()!= null && Float.parseFloat(thdDataVO.getMINPhaseB())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getMINPhaseC()!= null && Float.parseFloat(thdDataVO.getMINPhaseC())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getMAXPhaseA()!= null && Float.parseFloat(thdDataVO.getMAXPhaseA())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getMAXPhaseB()!= null && Float.parseFloat(thdDataVO.getMAXPhaseB())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getMAXPhaseC()!= null && Float.parseFloat(thdDataVO.getMAXPhaseC())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getAVGPhaseA()!= null && Float.parseFloat(thdDataVO.getAVGPhaseA())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getAVGPhaseB()!= null && Float.parseFloat(thdDataVO.getAVGPhaseB())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getAVGPhaseC()!= null && Float.parseFloat(thdDataVO.getAVGPhaseC())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getCP95PhaseA()!= null && Float.parseFloat(thdDataVO.getCP95PhaseA())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getCP95PhaseB()!= null && Float.parseFloat(thdDataVO.getCP95PhaseB())>thdDataVO.getLimit()) isOk = true; - if(thdDataVO.getCP95PhaseC()!= null && Float.parseFloat(thdDataVO.getCP95PhaseC())>thdDataVO.getLimit()) isOk = true; - if(isOk){ - data.add(thdDataVO); + RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeFeignClient.getDataByLineId(powerStatisticsParam.getLineId(), + powerStatisticsParam.getSearchBeginTime(),powerStatisticsParam.getSearchEndTime()).getData(); + if(rActivePowerRangePO != null){ + String times = reflexObjValue(rActivePowerRangePO,"minsTime"+powerStatisticsParam.getField()).toString().replace("null",""); + rActivePowerRangeParam.setSearchTimeFort(false); + for(String se : times.split("&")){ + String startTime = se.split(",")[0]; + String endTime = se.split(",")[1]; + rActivePowerRangeParam.setSearchBeginTime(startTime); + rActivePowerRangeParam.setSearchEndTime(endTime); + record.addAll(rActivePowerRangeFeignClient.record(rActivePowerRangeParam).getData()); } } - return data; + return record.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList()); + } - private List initPV(List> pv, String name, Float limit){ - List thdDataVOS = new ArrayList<>(); - ThdDataVO tdv = new ThdDataVO(); - tdv.setAnotherName(name); - tdv.setLimit(limit); - //便利统计方式和相别集合渲染对应字段 - for(Map arr :pv){ - arr.forEach((phasicType, valueType) ->{ - switch (valueType){ - case InfluxDBTableConstant.AVG: - switch (phasicType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setAVGPhaseA(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setAVGPhaseB(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setAVGPhaseC(arr.get(name)); - break; - } - break; - case InfluxDBTableConstant.CP95: - switch (phasicType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setCP95PhaseA(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setCP95PhaseB(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setCP95PhaseC(arr.get(name)); - break; - } - break; - case InfluxDBTableConstant.MIN: - switch (phasicType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setMINPhaseA(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setMINPhaseB(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setMINPhaseC(arr.get(name)); - break; - } - break; - case InfluxDBTableConstant.MAX: - switch (phasicType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setMAXPhaseA(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setMAXPhaseB(arr.get(name)); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setMAXPhaseC(arr.get(name)); - break; - } - break; - } - }); - } - //如果所有的相别和统计方式都没有值则可直接忽略该条数据 - if(tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null - || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null - || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null - || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null - || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null - || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null){ - thdDataVOS.add(tdv); - } - return thdDataVOS; - } - - private List getFrequencyData(List pv,String valueType,String phasicType,String name){ - //根据不同的相别及统计方式分别获取该时间组下区间指标集合的具体值 - List data = pv.stream().filter(param->phasicType.equals(param.getPhasicType()) && valueType.equals(param.getValueType())).collect(Collectors.toList()); - if(!data.isEmpty()){ - switch (name){ - case Param.vTimes: - return data.get(0).getVTimesData(); - case Param.iTimes: - return data.get(0).getITimesData(); - case Param.interHarmonic: - return data.get(0).getInterHarmonicData(); - } + //反射获取值 + private Object reflexObjValue(Object obj, String fieldName) { + try { + Class clazz = obj.getClass(); + Field field = clazz.getDeclaredField(fieldName); + field.setAccessible(true); + return field.get(obj); + } catch (Exception e) { + e.printStackTrace(); } return null; } - private String frequencyPVList(List data,int index){ - try { - return df.format(data.get(index)); - } catch (Exception e) { - return null; - } - } - - private List initFrequencyPV(List pv, String name, List limit){ - List thdDataVOS = new ArrayList<>(); - if(!limit.isEmpty()){ - //根据不同的相别及统计方式分别获取该时间组下区间指标集合的具体值 - List avgA = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_A,name); - List avgB = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_B,name); - List avgC = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_C,name); - List cp94A = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_A,name); - List cp94B = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_B,name); - List cp94C = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_C,name); - List minA = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_A,name); - List minB = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_B,name); - List minC = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_C,name); - List maxA = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_A,name); - List maxB = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_B,name); - List maxC = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_C,name); - int k = 0,j = 0; - double c = 0; - switch (name){ - //谐波电压和电流默认谐波次数2-25 - case Param.vTimes: - case Param.iTimes: - k = 2; - j = 25; - break; - //间谐波电压含有率默认谐波次数1-16 - case Param.interHarmonic: - k = 1; - j = 16; - c = 0.5; - break; - } - for (int i = k; i <= j; i++) { - ThdDataVO tdv = new ThdDataVO(); - tdv.setAnotherName(name +(((i-c)+"").replace(".0",""))+"次"); - try { - tdv.setLimit(limit.get(i-k)); - //frequencyPVList次方法提提高容灾,如果真的出现数组越界只有一种情况:有些有功功率查不到对应的某些指标数据 - tdv.setAVGPhaseA(frequencyPVList(avgA,i-k)); - tdv.setAVGPhaseB(frequencyPVList(avgB,i-k)); - tdv.setAVGPhaseC(frequencyPVList(avgC,i-k)); - tdv.setCP95PhaseA(frequencyPVList(cp94A,i-k)); - tdv.setCP95PhaseB(frequencyPVList(cp94B,i-k)); - tdv.setCP95PhaseC(frequencyPVList(cp94C,i-k)); - tdv.setMINPhaseA(frequencyPVList(minA,i-k)); - tdv.setMINPhaseB(frequencyPVList(minB,i-k)); - tdv.setMINPhaseC(frequencyPVList(minC,i-k)); - tdv.setMAXPhaseA(frequencyPVList(maxA,i-k)); - tdv.setMAXPhaseB(frequencyPVList(maxB,i-k)); - tdv.setMAXPhaseC(frequencyPVList(maxC,i-k)); - } catch (Exception e) { - e.printStackTrace(); - } - //如果所有的相别和统计方式都没有值则可直接忽略该条数据 - if(tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null - || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null - || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null - || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null - || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null - || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null){ - thdDataVOS.add(tdv); - } - } - } - return thdDataVOS; - } - @Override public List getTargetByTime(PowerStatisticsParam powerStatisticsParam) { List result = new ArrayList(); diff --git a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/RActivePowerRangeParam.java b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/RActivePowerRangeParam.java index 1f8bf81df..83c56ea7d 100644 --- a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/RActivePowerRangeParam.java +++ b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/RActivePowerRangeParam.java @@ -53,4 +53,11 @@ public class RActivePowerRangeParam extends BaseParam { @ApiModelProperty("查询时是否统计数据(默认不统计)") private boolean searchForAdd = false; + /** + * search = true 该参数才有效 + * 查询时是否格式化时间 + */ + @ApiModelProperty("查询时是否格式化时间(默认需要格式化)") + private boolean searchTimeFort = true; + } diff --git a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/po/RActivePowerRangePO.java b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/po/RActivePowerRangePO.java index ef1b65e20..48ccd6ced 100644 --- a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/po/RActivePowerRangePO.java +++ b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/po/RActivePowerRangePO.java @@ -34,7 +34,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 0%~10%区间时间Json */ - private String minsTime0 = "{}"; + private String minsTime0; /** * 0%~10%区间个数 @@ -49,7 +49,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 10%~20%区间时间Json */ - private String minsTime1 = "{}";; + private String minsTime1; /** * 10%~20%区间个数 @@ -64,7 +64,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 20%~30%区间时间Json */ - private String minsTime2 = "{}";; + private String minsTime2; /** * 20%~30%区间个数 @@ -79,7 +79,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 30%~40%区间时间Json */ - private String minsTime3 = "{}";; + private String minsTime3; /** * 30%~40%区间个数 @@ -94,7 +94,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 40%~50%区间时间Json */ - private String minsTime4 = "{}";; + private String minsTime4; /** * 40%~50%区间个数 @@ -109,7 +109,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 50%~60%区间时间Json */ - private String minsTime5 = "{}";; + private String minsTime5; /** * 50%~60%区间个数 @@ -124,7 +124,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 60%~70%区间时间Json */ - private String minsTime6 = "{}";; + private String minsTime6; /** * 60%~70%区间个数 @@ -139,7 +139,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 70%~80%区间时间Json */ - private String minsTime7 = "{}";; + private String minsTime7; /** * 70%~80%区间个数 @@ -154,7 +154,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 80%~90%区间时间Json */ - private String minsTime8 = "{}";; + private String minsTime8; /** * 80%~90%区间个数 @@ -169,7 +169,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 90%~100%区间时间Json */ - private String minsTime9 = "{}";; + private String minsTime9; /** * 90%~100%区间个数 diff --git a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java index efe9d5da0..b21c3c2ce 100644 --- a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java +++ b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java @@ -12,6 +12,7 @@ import com.njcn.device.pq.api.OverLimitClient; import com.njcn.device.pq.pojo.po.NewStation; import com.njcn.event.pojo.constant.Param; import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO; +import com.njcn.harmonic.pojo.vo.ThdDataVO; import com.njcn.influx.pojo.bo.CommonQueryParam; import com.njcn.influx.pojo.constant.InfluxDBTableConstant; import com.njcn.influx.pojo.dto.StatisticalDataDTO; @@ -25,15 +26,19 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.lang.reflect.Field; +import java.text.DecimalFormat; import java.text.SimpleDateFormat; +import java.time.Instant; import java.time.LocalDate; import java.time.ZoneId; import java.time.format.DateTimeFormatter; import java.util.*; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Collectors; /** * 有功功率趋势 服务实现类 + * * @author guofeihu * @since 2024-08-22 */ @@ -44,6 +49,18 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A,InfluxDBTableConstant.PHASE_TYPE_B,InfluxDBTableConstant.PHASE_TYPE_C); + private List PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A, InfluxDBTableConstant.PHASE_TYPE_B, InfluxDBTableConstant.PHASE_TYPE_C); /** * 整个算法的业务逻辑: @@ -64,398 +83,560 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比 * 谐波电压 data_v v_thd 电压总谐波总谐波畸变率 有一个指标超标，则谐波电压超标 - * data_harmrate_v v2-v25 2-25次谐波电压含有率 + * data_harmrate_v v2-v25 2-25次谐波电压含有率 * 谐波电流 data_i i2-i25 2-25次谐波电流幅值 有一个指标超标，则谐波电压超标 * 三相电压不平衡度 data_v v_unbalance * 电压波动 data_fluc fluc * 长时闪变 data_plt plt * 间谐波电压含有率 data_inharm_v v1-v16 0.5-15.5次间谐波电压含有率 有一个指标超标，则谐波电压超标 * 电流不平衡度 data_i i_unbalance 这个不确定，找宝哥确认下 + * * @param rActivePowerRangeParam * @return */ @Override @Transactional(rollbackFor = Exception.class) public List record(RActivePowerRangeParam rActivePowerRangeParam) { - if(rActivePowerRangeParam == null){ + if (rActivePowerRangeParam == null) { rActivePowerRangeParam = new RActivePowerRangeParam(); } //返回的最终结果 List powerStatisticsTargetVOS = new ArrayList<>(); //默认初始化开始和结束时间 - String startTime = getTime(rActivePowerRangeParam.getInterval(),0); - String endTime = getTime(rActivePowerRangeParam.getInterval(),1); + String startTime = getTime(rActivePowerRangeParam.getInterval(), 0); + String endTime = getTime(rActivePowerRangeParam.getInterval(), 1); //获取时间段内的有功功率集合 List commonQueryParams = new ArrayList<>(); CommonQueryParam commonQueryParam = new CommonQueryParam(); //控制参数中如果search为true,则获取有功功率集合的时间段内为BaseParam中的searchBeginTime和searchEndTime(用于前端有功功率查询页面相关接口) - if(rActivePowerRangeParam.isSearch()){ - startTime = rActivePowerRangeParam.getSearchBeginTime()+Param.BEGIN; - endTime = rActivePowerRangeParam.getSearchEndTime()+Param.END; + if (rActivePowerRangeParam.isSearch()) { + if(rActivePowerRangeParam.isSearchTimeFort()){ + startTime = rActivePowerRangeParam.getSearchBeginTime() + Param.BEGIN; + endTime = rActivePowerRangeParam.getSearchEndTime() + Param.END; + }else{ + startTime = rActivePowerRangeParam.getSearchBeginTime(); + endTime = rActivePowerRangeParam.getSearchEndTime(); + } commonQueryParam.setLineId(rActivePowerRangeParam.getLineId()); } //时间段 commonQueryParam.setStartTime(startTime); commonQueryParam.setEndTime(endTime); - //临时模拟增加的条件(用于调试主要是数据量太大非常消耗时间) 2024-09-01 00:00:00 -// commonQueryParam.setDataType("AVG"); -// commonQueryParam.setPhasic("A"); - commonQueryParam.setStartTime("2024-08-10 00:00:00"); - commonQueryParam.setEndTime("2024-08-10 00:00:00"); - //模拟增加的条件结束 //功率表data_harmpower_p及字段p commonQueryParam.setTableName(InfluxDBTableConstant.DATA_HARM_POWER_P); commonQueryParam.setColumnName("p"); commonQueryParams.add(commonQueryParam); - //这边没有设置他的统计方式和相别是因为根据有功功率查询各个指标的时候要把所有的指标和统计方式都查出来一一比较 + //查询功率表(多个统计方式及相别) List dataHarmPowerPS = commonService.getNewDeviceRtDataByTime(commonQueryParams); //由于前端写死了各个指标的相别(只有A、B、C所以这边直接限制死了) - dataHarmPowerPS = dataHarmPowerPS.stream().filter(param->PHASE.contains(param.getPhaseType())).collect(Collectors.toList()); + dataHarmPowerPS = dataHarmPowerPS.stream().filter(param -> PHASE.contains(param.getPhaseType())).collect(Collectors.toList()); //有功功率趋势表是按照监测点来划分的 所以这边需要根据监测点来分组 - Map> map = dataHarmPowerPS.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getLineId)); + Map> lineMap = dataHarmPowerPS.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getLineId)); RActivePowerRangeParam finalRActivePowerRangeParam = rActivePowerRangeParam; //以下这段逻辑较耗时(主要是for循环),主要是要遍历所有的有功功率,在根据有功功率查询各个指标进行比较(最耗时的是有功功率查询各个指标,所以一但有功功率很多则遍历较慢) - log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},现在开始遍历,{}",map.size(),dataHarmPowerPS.size(),sdf.format(new Date())); - map.forEach((key, value) ->{ + log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},现在开始遍历,{}", lineMap.size(), dataHarmPowerPS.size(), sdf.format(new Date())); + lineMap.forEach((lineId, lineGroupList) -> { + log.info("当前遍历的监测点ID为:{},监测点集合长为:{},现在开始遍历,{}", lineId, lineGroupList.size(), sdf.format(new Date())); //获取监测点的国标限值 - List overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(key)).getData(); + List overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(lineId)).getData(); //该监测点必须要有国标限值 - if(overlimits != null && !overlimits.isEmpty()){ + if (overlimits != null && !overlimits.isEmpty()) { Overlimit overlimit = overlimits.get(0); //获取监测点 - LineDTO lineDTO = commLineClient.getLineDetail(key).getData(); + LineDTO lineDTO = commLineClient.getLineDetail(lineId).getData(); //监测点必须绑定新能源站 - if(lineDTO != null && lineDTO.getNewStationId() != null){ + if (lineDTO != null && lineDTO.getNewStationId() != null) { //获取监测点的新能源站 NewStation newStation = newStationClient.selectById(lineDTO.getNewStationId()).getData(); //新能源站有些切必须是风电场 - if(newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())){ + if (newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())) { RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO(); - rActivePowerRangePO.setLineId(key); + rActivePowerRangePO.setLineId(lineId); rActivePowerRangePO.setTimeId(LocalDate.now()); rActivePowerRangePO.setId(IdUtil.simpleUUID()); LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>(); - lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,key).eq(RActivePowerRangePO::getTimeId,LocalDate.now()); + lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId).eq(RActivePowerRangePO::getTimeId, LocalDate.now()); //控制参数-强制刷新 - if(finalRActivePowerRangeParam.isRefresh()){ + if (finalRActivePowerRangeParam.isRefresh()) { this.baseMapper.delete(lambdaQueryWrapper); } - //控制参数-是否查询及查询新增(主要用于harmonic-boot-getDataByLineId方法,避免每次执行都会执行for循环,也即当日执行完一次即可) - if(!this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd())){ + //控制参数-是否查询及查询新增(主要用于harmonic-boot-getDataByLineId方法,避免每次执行都会执行循环,也即当日执行完一次即可) + if (!this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd())) { return; } - int index = 1; - //耗时开始-计算各个区间个数及是否越限 - for(StatisticalDataDTO statisticalDataDTO : value){ - log.info("前监测点为:{},遍历第{}条...,现在开始遍历,{}",key,index,sdf.format(new Date())); + //当前监测点的功率数据在根据时间分组然后取出一个时间分组内最大的值 + Map> timeMap = lineGroupList.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getTime)); + timeMap.forEach((time, timeGroupList) -> { + //取出当前时间分组内最大的一个值来判断是否越界 + Optional optional = timeGroupList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)); + StatisticalDataDTO statisticalDataDTO = optional.get(); PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO(); //设置时间为当前功率的时间 powerStatisticsTargetVO.setTime(statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter)); - powerStatisticsTargetVO.setTime("2024-08-10 00:00:00"); //当前功率的p字段 / 风电场额定功率 double temp = statisticalDataDTO.getValue() / Double.parseDouble(newStation.getRatedPower()); - //区间过滤下(用于前端查询) - if(finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.getField() != null){ - if(Double.parseDouble(finalRActivePowerRangeParam.getField()) < temp * 10 && temp * 10 <= Double.parseDouble(finalRActivePowerRangeParam.getField())+1){ - //指标越限列表区间区分字段(用于前端查询) - powerStatisticsTargetVO.setField(finalRActivePowerRangeParam.getField()); - //判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段) - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,Integer.parseInt(finalRActivePowerRangeParam.getField()),powerStatisticsTargetVO); + //区间过滤下(如果进去此判断 那么只能是查询某个区间下的指标越限列表) + if (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.getField() != null) { + if (Double.parseDouble(finalRActivePowerRangeParam.getField()) < temp * 10 && temp * 10 <= Double.parseDouble(finalRActivePowerRangeParam.getField()) + 1) { + //判断当前区间每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段) + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, Integer.parseInt(finalRActivePowerRangeParam.getField()), powerStatisticsTargetVO); powerStatisticsTargetVOS.add(powerStatisticsTargetVO); } - continue; + } else { + //否则是正常的定时任务插入,或者前端搜索插入 + //设置每个区间的统计时间 + rActivePowerRangePO.setMinsTime0(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime1(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime2(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime3(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime4(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime5(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime6(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime7(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime8(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + rActivePowerRangePO.setMinsTime9(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime()); + if (temp <= 0.1) { + //占有率区间个数+1 + rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1); + //判断当前区间每个指标是否越限 + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 0, powerStatisticsTargetVO); + } else if (0.1 < temp && temp <= 0.2) { + rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 1, powerStatisticsTargetVO); + } else if (0.2 < temp && temp <= 0.3) { + rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 2, powerStatisticsTargetVO); + } else if (0.3 < temp && temp <= 0.4) { + rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 3, powerStatisticsTargetVO); + } else if (0.4 < temp && temp <= 0.5) { + rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 4, powerStatisticsTargetVO); + } else if (0.5 < temp && temp <= 0.6) { + rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 5, powerStatisticsTargetVO); + } else if (0.6 < temp && temp <= 0.7) { + rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 6, powerStatisticsTargetVO); + } else if (0.7 < temp && temp <= 0.8) { + rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 7, powerStatisticsTargetVO); + } else if (0.8 < temp && temp <= 0.9) { + rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 8, powerStatisticsTargetVO); + } else if (temp > 0.9) { + rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1); + installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 9, powerStatisticsTargetVO); + } + powerStatisticsTargetVOS.add(powerStatisticsTargetVO); } - if(temp <= 0.1){ - //占有率区间个数+1 - rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1); - //指标越限列表区间区分字段(用于前端查询) - powerStatisticsTargetVO.setField("0"); - //判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段) - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,0,powerStatisticsTargetVO); - }else if(0.1 < temp && temp <= 0.2){ - rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1); - powerStatisticsTargetVO.setField("1"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,1,powerStatisticsTargetVO); - }else if(0.2 < temp && temp <= 0.3){ - rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1); - powerStatisticsTargetVO.setField("2"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,2,powerStatisticsTargetVO); - }else if(0.3 < temp && temp <= 0.4){ - rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1); - powerStatisticsTargetVO.setField("3"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,3,powerStatisticsTargetVO); - }else if(0.4 < temp && temp <= 0.5){ - rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1); - powerStatisticsTargetVO.setField("4"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,4,powerStatisticsTargetVO); - }else if(0.5 < temp && temp <= 0.6){ - rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1); - powerStatisticsTargetVO.setField("5"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,5,powerStatisticsTargetVO); - }else if(0.6 < temp && temp <= 0.7){ - rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1); - powerStatisticsTargetVO.setField("6"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,6,powerStatisticsTargetVO); - }else if(0.7 < temp && temp <= 0.8){ - rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1); - powerStatisticsTargetVO.setField("7"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,7,powerStatisticsTargetVO); - }else if(0.8 < temp && temp <= 0.9){ - rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1); - powerStatisticsTargetVO.setField("8"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,8,powerStatisticsTargetVO); - }else if(temp > 0.9){ - rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1); - powerStatisticsTargetVO.setField("9"); - installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,9,powerStatisticsTargetVO); - } - powerStatisticsTargetVOS.add(powerStatisticsTargetVO); - log.info("前监测点为:{},遍历第{}条...,遍历结束,{}",key,index,sdf.format(new Date())); - index++; - } + }); //根据日期及lineId当天不能重复执行 - if(this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd() || !finalRActivePowerRangeParam.isSearch())){ + if (this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd() || !finalRActivePowerRangeParam.isSearch())) { this.baseMapper.insert(rActivePowerRangePO); } } } } }); - log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},遍历结束,{}",map.size(),dataHarmPowerPS.size(),sdf.format(new Date())); - if(rActivePowerRangeParam.isSearch()){ - //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:每条数据当前时间中八个指标是否越限及他们的相别和统计方式是什么 + log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},遍历结束,{}", lineMap.size(), dataHarmPowerPS.size(), sdf.format(new Date())); + if (rActivePowerRangeParam.isSearch()) { return powerStatisticsTargetVOS; } return null; } - private void installLimit(RActivePowerRangePO rActivePowerRangePO,StatisticalDataDTO statisticalDataDTO,Overlimit overlimit,int type,PowerStatisticsTargetVO powerStatisticsTargetVO){ - //记录统计方式 - powerStatisticsTargetVO.setValueType(statisticalDataDTO.getValueType()); - //记录相别 - powerStatisticsTargetVO.setPhasicType(statisticalDataDTO.getPhaseType()); - //以下的结果集按道理最多只有一条(因为确定的相别统计方式及开始和结束时间都一致,除了有谐波次数的指标) + private void installLimit(RActivePowerRangePO rActivePowerRangePO, StatisticalDataDTO statisticalDataDTO, Overlimit overlimit, int type, PowerStatisticsTargetVO powerStatisticsTargetVO) { + //根据当前最大值的功率查询各个指标信息 //电压偏差 - List vu_dev = commonQuery(InfluxDBTableConstant.DATA_V,"vu_dev",statisticalDataDTO,null,null); + List vu_dev = commonQuery(InfluxDBTableConstant.DATA_V, "vuDev", statisticalDataDTO, null, null); //谐波电压 - List v_thd = commonQuery(InfluxDBTableConstant.DATA_V,"v_thd",statisticalDataDTO,null,null); - List v = commonQuery(InfluxDBTableConstant.DATA_HARM_RATE_V,"v",statisticalDataDTO,2,25); + List v_thd = commonQuery(InfluxDBTableConstant.DATA_V, "vThd", statisticalDataDTO, null, null); + List v = commonQuery(InfluxDBTableConstant.DATA_HARM_RATE_V, "v", statisticalDataDTO, 2, 25); //谐波电流 - List i = commonQuery(InfluxDBTableConstant.DATA_I,"i",statisticalDataDTO,2,25); + List i = commonQuery(InfluxDBTableConstant.DATA_I, "i", statisticalDataDTO, 2, 25); //三相电压不平衡度 - List v_unbalance = commonQuery(InfluxDBTableConstant.DATA_V,"v_unbalance",statisticalDataDTO,null,null); + List v_unbalance = commonQuery(InfluxDBTableConstant.DATA_V, "vUnbalance", statisticalDataDTO, null, null); //电压波动 - List fluc = commonQuery(InfluxDBTableConstant.DATA_FLUC,"fluc",statisticalDataDTO,null,null); + List fluc = commonQuery(InfluxDBTableConstant.DATA_FLUC, "fluc", statisticalDataDTO, null, null); //长时闪变 - List plt = commonQuery(InfluxDBTableConstant.DATA_PLT,"plt",statisticalDataDTO,null,null); + List plt = commonQuery(InfluxDBTableConstant.DATA_PLT, "plt", statisticalDataDTO, null, null); //间谐波电压含有率 - List v1 = commonQuery(InfluxDBTableConstant.DATA_IN_HARM_V,"v",statisticalDataDTO,1,16); + List v1 = commonQuery(InfluxDBTableConstant.DATA_IN_HARM_V, "v", statisticalDataDTO, 1, 16); //电流不平衡度 - List i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I,"i_unbalance",statisticalDataDTO,null,null); - //此标识用来记录当前区间下指标是否越限(0%~10%是否越限,10%~20%是否越限.....) + List i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I, "iUnbalance", statisticalDataDTO, null, null); + //此标识用来记录当前区间下指标是否越限 boolean isLimit = false; - //电压偏差国标限值 - powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev()); - //电压偏差是否越限比较 - for(StatisticalDataDTO dto : vu_dev){ - //电压偏差具体值 - powerStatisticsTargetVO.setVoltageOffsetData(dto.getValue()); - //电压偏差国标限值有额外的判断 - if(dto.getValue()>0){ - powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev()); - }else{ - powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getUvoltageDev()); - } - //如果vu_dev>0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比 - if((dto.getValue()>0 && Double.compare(dto.getValue(),overlimit.getVoltageDev())>0) - || (dto.getValue()<0 && Double.compare(dto.getValue(),overlimit.getUvoltageDev())>0)){ - isLimit = true; - //标志电压偏差越限 - powerStatisticsTargetVO.setVoltageOffset(1); - } + + //电压偏差是否越限比较(此指标比较较为特殊所以单独一个重载的判断方法) + Float isVoltageOffsetLimit = isLimit(vu_dev, overlimit); + //电压偏差指标详细数据 + powerStatisticsTargetVO.setVoltageOffsetList(toThdDataVO(vu_dev, Param.voltageOffset, null, isVoltageOffsetLimit)); + if (isVoltageOffsetLimit != null) { + isLimit = true; + //电压偏差越限 + powerStatisticsTargetVO.setVoltageOffset(1); } - //谐波电压比较较为特殊需要比较两个点(以v为主) - //谐波电压是否越限比较 - for(StatisticalDataDTO dto : v_thd){ - if(Double.compare(dto.getValue(),overlimit.getUaberrance())>0){ - isLimit = true; - powerStatisticsTargetVO.setVTimes(1); - } + + //谐波电压比较较为特殊需要比较两个点 + //谐波电压指标详细数据 + powerStatisticsTargetVO.setVTimesList(toThdDataVO(v, Param.vTimes, overlimit, null)); + //谐波电压是否越限比较(不过指标详细数据还是取data_harmrate_v表里的数据) + if (isLimit(v, Param.vTimes, InfluxDBTableConstant.CP95, overlimit, null)) { + isLimit = true; + //谐波电流越限 + powerStatisticsTargetVO.setVTimes(1); } - int num = 2; - for(StatisticalDataDTO dto : v){ - Float value = frequencyValue(overlimit,num,"uharm"); - if(value != null){ - //记录谐波电压2到25次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询2-25次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走) - powerStatisticsTargetVO.getVTimesLimit().add(value); - //谐波电压具体值 - powerStatisticsTargetVO.getVTimesData().add(dto.getValue()); - if(Double.compare(dto.getValue(),value)>0){ - isLimit = true; - //标志谐波电压越限 - powerStatisticsTargetVO.setVTimes(1); - } - } - num++; + if (isLimit(v_thd, Param.vTimes, InfluxDBTableConstant.CP95, null, overlimit.getUaberrance())) { + isLimit = true; + //谐波电流越限 + powerStatisticsTargetVO.setVTimes(1); } - num = 2; + + //谐波电流指标详细数据 + powerStatisticsTargetVO.setITimestList(toThdDataVO(i, Param.iTimes, overlimit, null)); //谐波电流是否越限比较 - for(StatisticalDataDTO dto : i){ - Float value = frequencyValue(overlimit,num,"iharm"); - if(value != null){ - //记录谐波电流2到25次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询2-25次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走) - powerStatisticsTargetVO.getITimesLimit().add(value); - //谐波电流具体值 - powerStatisticsTargetVO.getITimesData().add(dto.getValue()); - if(Double.compare(dto.getValue(),value)>0){ - isLimit = true; - //标志谐波电流越限 - powerStatisticsTargetVO.setITimes(1); - } - } - num++; + if (isLimit(i, Param.vTimes, InfluxDBTableConstant.CP95, overlimit, null)) { + isLimit = true; + //谐波电流越限 + powerStatisticsTargetVO.setITimes(1); } - //三相电压不平衡度国标限值 - powerStatisticsTargetVO.setUbalanceLimit(overlimit.getUbalance()); + + //三相电压不平衡度指标详细数据 + powerStatisticsTargetVO.setUbalanceList(toThdDataVO(v_unbalance, Param.ubalance, null, overlimit.getUbalance())); //三相电压不平衡度是否越限比较 - for(StatisticalDataDTO dto : v_unbalance){ - //三相电压不平衡度具体值 - powerStatisticsTargetVO.setUbalanceData(dto.getValue()); - if(Double.compare(dto.getValue(),overlimit.getUbalance())>0){ - isLimit = true; - //标志三相电压不平衡度越限 - powerStatisticsTargetVO.setUbalance(1); - } + if (isLimit(v_unbalance, Param.ubalance, InfluxDBTableConstant.CP95, null, overlimit.getUbalance())) { + isLimit = true; + //三相电压不平衡度越限 + powerStatisticsTargetVO.setUbalance(1); } - //电压波动国标限值 - powerStatisticsTargetVO.setVoltageFluctuationLimit(overlimit.getVoltageFluctuation()); + + //电压波动指标详细数据 + powerStatisticsTargetVO.setVoltageFluctuationList(toThdDataVO(fluc, Param.voltageFluctuation, null, overlimit.getVoltageFluctuation())); //电压波动是否越限比较 - for(StatisticalDataDTO dto : fluc){ - //电压波动具体值 - powerStatisticsTargetVO.setVoltageFluctuationData(dto.getValue()); - if(Double.compare(dto.getValue(),overlimit.getVoltageFluctuation())>0){ - isLimit = true; - //标志电压波动越限 - powerStatisticsTargetVO.setVoltageFluctuation(1); - } + if (isLimit(fluc, Param.voltageFluctuation, InfluxDBTableConstant.MAX, null, overlimit.getVoltageFluctuation())) { + isLimit = true; + //电压波动变越限 + powerStatisticsTargetVO.setVoltageFluctuation(1); } - //长时闪变国标限值 - powerStatisticsTargetVO.setFlickerLimit(overlimit.getFlicker()); + + //长时闪变指标详细数据 + powerStatisticsTargetVO.setFlickerList(toThdDataVO(plt, Param.flicker, null, overlimit.getFlicker())); //长时闪变是否越限比较 - for(StatisticalDataDTO dto : plt){ - //长时闪变具体值 - powerStatisticsTargetVO.setFlickerData(dto.getValue()); - if(Double.compare(dto.getValue(),overlimit.getFlicker())>0){ - isLimit = true; - //标志长时闪变越限 - powerStatisticsTargetVO.setFlicker(1); - } + if (isLimit(plt, Param.flicker, InfluxDBTableConstant.MAX, null, overlimit.getFlicker())) { + isLimit = true; + //长时闪变越限 + powerStatisticsTargetVO.setFlicker(1); } - num = 1; + + //间谐波电压含有率指标详细数据 + powerStatisticsTargetVO.setInterHarmonicList(toThdDataVO(v1, Param.interHarmonic, overlimit, null)); //间谐波电压含有率是否越限比较 - for(StatisticalDataDTO dto : v1){ - Float value = frequencyValue(overlimit,num,"inuharm"); - if(value != null){ - //记录间谐波电压含有率1到16次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询1-16次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走) - powerStatisticsTargetVO.getInterHarmonicLimit().add(value); - //间谐波电压含有率具体值 - powerStatisticsTargetVO.getInterHarmonicData().add(dto.getValue()); - if(Double.compare(dto.getValue(),value)>0){ - isLimit = true; - //标志间谐波电压含有率越限 - powerStatisticsTargetVO.setInterHarmonic(1); - } - } - num++; + if (isLimit(v1, Param.interHarmonic, InfluxDBTableConstant.CP95, overlimit, null)) { + isLimit = true; + //间谐波电压含有率越限 + powerStatisticsTargetVO.setInterHarmonic(1); } - //电流不平衡度国标限值 - powerStatisticsTargetVO.setSequenceCurrentUnbalanceLimit(overlimit.getINeg()); + + //电流不平衡度指标详细数据 + powerStatisticsTargetVO.setSequenceCurrentUnbalanceList(toThdDataVO(i_unbalance, Param.sequenceCurrentUnbalance, null, overlimit.getINeg())); //电流不平衡度是否越限比较 - for(StatisticalDataDTO dto : i_unbalance){ - //电流不平衡度具体值 - powerStatisticsTargetVO.setSequenceCurrentUnbalanceData(dto.getValue()); - if(Double.compare(dto.getValue(),overlimit.getINeg())>0){ - isLimit = true; - //标志电流不平衡度越限 - powerStatisticsTargetVO.setSequenceCurrentUnbalance(1); - } + if (isLimit(i_unbalance, Param.sequenceCurrentUnbalance, null, null, overlimit.getINeg())) { + isLimit = true; + //电流不平衡度越限 + powerStatisticsTargetVO.setSequenceCurrentUnbalance(1); } + //区间是否越限标识 - switch (type){ + switch (type) { case 0: - if(isLimit) rActivePowerRangePO.setIsOrNot0(1); + if (isLimit) rActivePowerRangePO.setIsOrNot0(1); break; case 1: - if(isLimit) rActivePowerRangePO.setIsOrNot1(1); + if (isLimit) rActivePowerRangePO.setIsOrNot1(1); break; case 2: - if(isLimit) rActivePowerRangePO.setIsOrNot2(1); + if (isLimit) rActivePowerRangePO.setIsOrNot2(1); break; case 3: - if(isLimit) rActivePowerRangePO.setIsOrNot3(1); + if (isLimit) rActivePowerRangePO.setIsOrNot3(1); break; case 4: - if(isLimit) rActivePowerRangePO.setIsOrNot4(1); + if (isLimit) rActivePowerRangePO.setIsOrNot4(1); break; case 5: - if(isLimit) rActivePowerRangePO.setIsOrNot5(1); + if (isLimit) rActivePowerRangePO.setIsOrNot5(1); break; case 6: - if(isLimit) rActivePowerRangePO.setIsOrNot6(1); + if (isLimit) rActivePowerRangePO.setIsOrNot6(1); break; case 7: - if(isLimit) rActivePowerRangePO.setIsOrNot7(1); + if (isLimit) rActivePowerRangePO.setIsOrNot7(1); break; case 8: - if(isLimit) rActivePowerRangePO.setIsOrNot8(1); + if (isLimit) rActivePowerRangePO.setIsOrNot8(1); break; case 9: - if(isLimit) rActivePowerRangePO.setIsOrNot9(1); + if (isLimit) rActivePowerRangePO.setIsOrNot9(1); break; } } + private Float isLimit(List list, Overlimit overlimit) { + List maxList = list.stream().filter(dto -> dto.equals(InfluxDBTableConstant.MAX)).collect(Collectors.toList()); + List minList = list.stream().filter(dto -> dto.equals(InfluxDBTableConstant.MIN)).collect(Collectors.toList()); + StatisticalDataDTO maxDto = maxList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null); + StatisticalDataDTO minDto = minList.stream().min(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null); + if (!maxList.isEmpty()) { + if (Double.compare(maxDto.getValue(), 0) > 0 && Double.compare(maxDto.getValue(), overlimit.getVoltageDev()) > 0) { + return overlimit.getVoltageDev(); + } + } + if (!minList.isEmpty()) { + if (Double.compare(minDto.getValue(), 0) < 0 && Double.compare(maxDto.getValue(), overlimit.getUvoltageDev()) > 0) { + return overlimit.getUvoltageDev(); + } + } + return null; + } + + private boolean isLimit(List list, String name, String valueType, Overlimit overlimit, Float limit) { + AtomicBoolean ist = new AtomicBoolean(false); + if (valueType != null) { + list = list.stream().filter(dto -> dto.getValueType().equals(valueType)).collect(Collectors.toList()); + } + if (overlimit != null) { + String field = ""; + switch (name) { + case Param.vTimes: + field = "uharm"; + break; + case Param.iTimes: + field = "iharm"; + break; + case Param.interHarmonic: + field = "inuharm"; + break; + } + Map> frequencyMap = list.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getFrequency)); + String finalField = field; + frequencyMap.forEach((frequency, frequencyGroupList) -> { + StatisticalDataDTO statisticalDataDTO = frequencyGroupList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null); + Float value = (Float) reflexObjValue(overlimit, finalField + Integer.parseInt(frequency)); + if (value != null) { + if (statisticalDataDTO.getValue() != null && Double.compare(statisticalDataDTO.getValue(), value) > 0) { + ist.set(true); + return; + } + } + }); + } else { + StatisticalDataDTO statisticalDataDTO = list.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null); + if (statisticalDataDTO != null && statisticalDataDTO.getValue() != null && Double.compare(statisticalDataDTO.getValue(), limit) > 0) { + return true; + } + } + return ist.get(); + } + + //根据各个指标数组信息组装成前端需要的格式 + private List toThdDataVO(List list, String name, Overlimit overlimit, Float limit) { + List thdDataVOS = new ArrayList<>(); + //带有谐波次数的指标 + if (overlimit != null) { + String field = ""; + double c = 0; + switch (name) { + //谐波电压和电流默认谐波次数2-25 + case Param.vTimes: + field = "uharm"; + break; + case Param.iTimes: + field = "iharm"; + break; + //间谐波电压含有率默认谐波次数1-16 + case Param.interHarmonic: + field = "inuharm"; + c = 0.5; + break; + } + //根据谐波次数分组,分组完则frequencyMap数据维度:当前谐波次数下的各个统计方式和相别他们的值是多少 + Map> frequencyMap = list.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getFrequency)); + double finalC = c; + String finalField = field; + frequencyMap.forEach((frequency, frequencyGroupList) -> { + Integer frequencyNum = Integer.parseInt(frequency); + //反射获取当前谐波次数对应的国标限值 + Float frequencyLimit = (Float) reflexObjValue(overlimit, finalField + frequencyNum); + //相别和统计方式的值和ThdDataVO字段相对于 + ThdDataVO tdv = initThdDataVO(frequencyGroupList,frequencyLimit); + if (tdv != null) { + tdv.setAnotherName(name + (((frequencyNum - finalC) + "").replace(".0", "")) + "次"); + tdv.setLimit((Float) reflexObjValue(overlimit, finalField + frequencyNum)); + tdv.setFrequency(frequencyNum); + thdDataVOS.add(tdv); + } + }); + } else { + //无谐波次数 + ThdDataVO tdv = initThdDataVO(list,limit); + if (tdv != null) { + tdv.setAnotherName(name); + tdv.setLimit(limit); + thdDataVOS.add(tdv); + } + } + return thdDataVOS.stream().sorted(Comparator.comparing(ThdDataVO::getFrequency)).collect(Collectors.toList()); + } + + private ThdDataVO initThdDataVO(List list,Float limit) { + ThdDataVO tdv = new ThdDataVO(); + boolean isF = false; + //list包含了一组不同相别不同统计方式的数据(最多12条,因为统计方式和相别自由组合最多12条) + for (StatisticalDataDTO statisticalDataDTO : list) { + String valueType = statisticalDataDTO.getValueType(); + String phasicType = statisticalDataDTO.getPhaseType(); + String value = null; + if (statisticalDataDTO.getValue() != null) { + value = df.format(statisticalDataDTO.getValue()); + //判断是否有指标越界(不管哪一个相别及统计方式的指标,) + if(Double.compare(statisticalDataDTO.getValue(), limit) > 0){ + isF = true; + } + } + //统计方式和相别渲染ThdDataVO + switch (valueType) { + case InfluxDBTableConstant.AVG: + switch (phasicType) { + case InfluxDBTableConstant.PHASE_TYPE_A: + tdv.setAVGPhaseA(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_B: + tdv.setAVGPhaseB(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_C: + tdv.setAVGPhaseC(value); + break; + } + break; + case InfluxDBTableConstant.CP95: + switch (phasicType) { + case InfluxDBTableConstant.PHASE_TYPE_A: + tdv.setCP95PhaseA(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_B: + tdv.setCP95PhaseB(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_C: + tdv.setCP95PhaseC(value); + break; + } + break; + case InfluxDBTableConstant.MIN: + switch (phasicType) { + case InfluxDBTableConstant.PHASE_TYPE_A: + tdv.setMINPhaseA(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_B: + tdv.setMINPhaseB(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_C: + tdv.setMINPhaseC(value); + break; + } + break; + case InfluxDBTableConstant.MAX: + switch (phasicType) { + case InfluxDBTableConstant.PHASE_TYPE_A: + tdv.setMAXPhaseA(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_B: + tdv.setMAXPhaseB(value); + break; + case InfluxDBTableConstant.PHASE_TYPE_C: + tdv.setMAXPhaseC(value); + break; + } + break; + } + } + //如果所有的相别和统计方式都没有值则可直接忽略该条数据或者没有一个相别及统计方式的指标越界也可以忽略 + if (tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null + || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null + || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null + || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null + || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null + || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null) { + if(isF){ + return tdv; + } + } + return null; + } + //组装公共查询(有谐波次数指标查询和没有谐波次数指标查询) - private List commonQuery(String tableName,String columnName,StatisticalDataDTO statisticalDataDTO,Integer start,Integer end){ - List commonQueryParams = new ArrayList<>(); - //不管哪种时间是固定的 + private List commonQuery(String tableName, String columnName, StatisticalDataDTO statisticalDataDTO, Integer start, Integer end) { String time = statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter); - time = "2024-08-10 00:00:00"; - CommonQueryParam commonQueryParam = new CommonQueryParam(); - //无谐波次数指标查询 - if(start == null){ - commonQueryParam.setStartTime(time); - commonQueryParam.setEndTime(time); - commonQueryParam.setLineId(statisticalDataDTO.getLineId()); - commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType()); - commonQueryParam.setDataType(statisticalDataDTO.getValueType()); - commonQueryParam.setTableName(tableName); - commonQueryParam.setColumnName(columnName); - commonQueryParams.add(commonQueryParam); - }else{ - //有谐波次数指标查询 - for (int i = start; i <= end; i++) { - commonQueryParam = new CommonQueryParam(); - commonQueryParam.setStartTime(time); - commonQueryParam.setEndTime(time); - commonQueryParam.setLineId(statisticalDataDTO.getLineId()); - commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType()); - commonQueryParam.setDataType(statisticalDataDTO.getValueType()); - commonQueryParam.setTableName(tableName); - commonQueryParam.setColumnName(columnName+"_"+i); - commonQueryParams.add(commonQueryParam); + List data = null; + switch (tableName) { + case InfluxDBTableConstant.DATA_V: + data = Collections.singletonList(iDataVService.getNewDataV(statisticalDataDTO.getLineId(), time, time)); + break; + case InfluxDBTableConstant.DATA_HARM_RATE_V: + data = Collections.singletonList(dataHarmRateVService.getNewDataHarmRateV(statisticalDataDTO.getLineId(), time, time)); + break; + case InfluxDBTableConstant.DATA_I: + data = Collections.singletonList(iDataIService.getNewDataI(statisticalDataDTO.getLineId(), time, time)); + break; + case InfluxDBTableConstant.DATA_FLUC: + data = Collections.singletonList(dataFlucService.getNewDataFluc(statisticalDataDTO.getLineId(), time, time)); + break; + case InfluxDBTableConstant.DATA_PLT: + data = Collections.singletonList(dataPltService.getNewDataPlt(statisticalDataDTO.getLineId(), time, time)); + break; + case InfluxDBTableConstant.DATA_IN_HARM_V: + data = Collections.singletonList(dataInHarmVService.getNewDataInHarmV(statisticalDataDTO.getLineId(), time, time)); + break; + } + List list = new ArrayList<>(); + if (!data.isEmpty()) { + data = (List) data.get(0); + for (Object item : data) { + String phaseType = (reflexObjValue(item, "phaseType").toString()); + if (PHASE.contains(phaseType)) { + if (start != null) { + for (int i = start; i <= end; i++) { + StatisticalDataDTO dto = new StatisticalDataDTO(); + dto.setPhaseType(phaseType); + dto.setValueType((reflexObjValue(item, "valueType").toString())); + dto.setTime((Instant) reflexObjValue(item, "time")); + dto.setLineId(reflexObjValue(item, "lineId").toString()); + dto.setValue((Double) reflexObjValue(item, columnName + i)); + dto.setFrequency(i + ""); + list.add(dto); + } + } else { + StatisticalDataDTO dto = new StatisticalDataDTO(); + dto.setPhaseType(phaseType); + dto.setValueType((reflexObjValue(item, "valueType").toString())); + dto.setTime((Instant) reflexObjValue(item, "time")); + dto.setLineId(reflexObjValue(item, "lineId").toString()); + dto.setValue((Double) reflexObjValue(item, columnName)); + list.add(dto); + } + } } } - return commonService.getNewDeviceRtDataByTime(commonQueryParams); + return list; } - //反射获取国标限值对应的字段值 - private Float frequencyValue(Overlimit overlimit,int num,String flag){ + //反射获取值 + private Object reflexObjValue(Object obj, String fieldName) { try { - Class clazz = overlimit.getClass(); - Field field = clazz.getDeclaredField(flag+num); + Class clazz = obj.getClass(); + Field field = clazz.getDeclaredField(fieldName); field.setAccessible(true); - return Float.parseFloat(field.get(overlimit).toString()); + return field.get(obj); } catch (Exception e) { e.printStackTrace(); } @@ -463,49 +644,59 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl lambdaQueryWrapper = new LambdaQueryWrapper(); - lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,lineId).eq(RActivePowerRangePO::getState,"1") - .between(RActivePowerRangePO::getTimeId,startTime,endTime); + lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId).eq(RActivePowerRangePO::getState, "1") + .between(RActivePowerRangePO::getTimeId, startTime, endTime); List rActivePowerRangePOS = this.baseMapper.selectList(lambdaQueryWrapper); - if(!rActivePowerRangePOS.isEmpty()){ + if (!rActivePowerRangePOS.isEmpty()) { RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO(); rActivePowerRangePO.setLineId(lineId); //多条记录则次数累加,是否越限只要有一个区间越限则统一视为该区间越限 - for(RActivePowerRangePO rangePO : rActivePowerRangePOS){ - rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0()+rActivePowerRangePO.getMinsNum0()); - rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1()+rActivePowerRangePO.getMinsNum1()); - rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2()+rActivePowerRangePO.getMinsNum2()); - rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3()+rActivePowerRangePO.getMinsNum3()); - rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4()+rActivePowerRangePO.getMinsNum4()); - rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5()+rActivePowerRangePO.getMinsNum5()); - rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6()+rActivePowerRangePO.getMinsNum6()); - rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7()+rActivePowerRangePO.getMinsNum7()); - rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8()+rActivePowerRangePO.getMinsNum8()); - rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9()+rActivePowerRangePO.getMinsNum9()); - rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0()+rActivePowerRangePO.getIsOrNot0()); - rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1()+rActivePowerRangePO.getIsOrNot1()); - rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2()+rActivePowerRangePO.getIsOrNot2()); - rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3()+rActivePowerRangePO.getIsOrNot3()); - rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4()+rActivePowerRangePO.getIsOrNot4()); - rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5()+rActivePowerRangePO.getIsOrNot5()); - rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6()+rActivePowerRangePO.getIsOrNot6()); - rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7()+rActivePowerRangePO.getIsOrNot7()); - rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8()+rActivePowerRangePO.getIsOrNot8()); - rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9()+rActivePowerRangePO.getIsOrNot9()); + for (RActivePowerRangePO rangePO : rActivePowerRangePOS) { + rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0() + rActivePowerRangePO.getMinsNum0()); + rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1() + rActivePowerRangePO.getMinsNum1()); + rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2() + rActivePowerRangePO.getMinsNum2()); + rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3() + rActivePowerRangePO.getMinsNum3()); + rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4() + rActivePowerRangePO.getMinsNum4()); + rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5() + rActivePowerRangePO.getMinsNum5()); + rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6() + rActivePowerRangePO.getMinsNum6()); + rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7() + rActivePowerRangePO.getMinsNum7()); + rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8() + rActivePowerRangePO.getMinsNum8()); + rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9() + rActivePowerRangePO.getMinsNum9()); + rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0() + rActivePowerRangePO.getIsOrNot0()); + rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1() + rActivePowerRangePO.getIsOrNot1()); + rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2() + rActivePowerRangePO.getIsOrNot2()); + rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3() + rActivePowerRangePO.getIsOrNot3()); + rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4() + rActivePowerRangePO.getIsOrNot4()); + rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5() + rActivePowerRangePO.getIsOrNot5()); + rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6() + rActivePowerRangePO.getIsOrNot6()); + rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7() + rActivePowerRangePO.getIsOrNot7()); + rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8() + rActivePowerRangePO.getIsOrNot8()); + rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9() + rActivePowerRangePO.getIsOrNot9()); + rActivePowerRangePO.setMinsTime0(rangePO.getMinsTime0() + "&" + rActivePowerRangePO.getMinsTime0()); + rActivePowerRangePO.setMinsTime1(rangePO.getMinsTime1() + "&" + rActivePowerRangePO.getMinsTime1()); + rActivePowerRangePO.setMinsTime2(rangePO.getMinsTime2() + "&" + rActivePowerRangePO.getMinsTime2()); + rActivePowerRangePO.setMinsTime3(rangePO.getMinsTime3() + "&" + rActivePowerRangePO.getMinsTime3()); + rActivePowerRangePO.setMinsTime4(rangePO.getMinsTime4() + "&" + rActivePowerRangePO.getMinsTime4()); + rActivePowerRangePO.setMinsTime5(rangePO.getMinsTime5() + "&" + rActivePowerRangePO.getMinsTime5()); + rActivePowerRangePO.setMinsTime6(rangePO.getMinsTime6() + "&" + rActivePowerRangePO.getMinsTime6()); + rActivePowerRangePO.setMinsTime7(rangePO.getMinsTime7() + "&" + rActivePowerRangePO.getMinsTime7()); + rActivePowerRangePO.setMinsTime8(rangePO.getMinsTime8() + "&" + rActivePowerRangePO.getMinsTime8()); + rActivePowerRangePO.setMinsTime9(rangePO.getMinsTime9() + "&" + rActivePowerRangePO.getMinsTime9()); } return rActivePowerRangePO; }