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 36fdb99f1..e1911f662 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 @@ -38,16 +38,15 @@ public interface Param { /** * 以下的四个Map为有功功率页面查看指标详情的四个指标分组下的具体指标(指标对应的可能不对 到时候直接改map里的key即可) - * 页面展示的指标名称 对应 的表ele_epd_pqd中的名称 - * map的key为的表ele_epd_pqd中的名称value为页面上展示的名称 + * put(name:表ele_epd_pqd中的名称,value:页面展示的指标名称) */ Map DATABSEMAP = new HashMap(){{ put("频率偏差","频率偏差"); put("线电压偏差","电压偏差"); put("相电压长时闪变","长时闪变"); - put("线电压总有效值","谐波电压"); - put("电流总有效值","谐波电流"); - put("相电压总有效值","间谐波电压"); + //put("线电压总有效值","谐波电压"); + //put("电流总有效值","谐波电流"); + //put("相电压总有效值","间谐波电压"); put("电压负序不平衡度","负序电压不平衡度"); put("电流负序不平衡度","负序电流"); put("总稳态指标","三相总有功功率"); 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 eac1409c1..cf0cee4ef 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 @@ -1,6 +1,5 @@ package com.njcn.harmonic.constant; - /** * @author 徐扬 */ @@ -71,4 +70,20 @@ public interface Param { String DECIMAL_FORMATSTR = "#0.0000"; 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/param/PowerStatisticsParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java index dee6a13b6..e1c02d254 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java @@ -5,6 +5,7 @@ import io.swagger.annotations.ApiModelProperty; import lombok.Data; import lombok.EqualsAndHashCode; import javax.validation.constraints.NotBlank; +import java.util.ArrayList; import java.util.List; /** @@ -27,33 +28,33 @@ public class PowerStatisticsParam extends BaseParam { private String field; @ApiModelProperty("区间1时间集合") - private List time0; + private List time0 = new ArrayList<>(); @ApiModelProperty("区间2时间集合") - private List time1; + private List time1 = new ArrayList<>(); @ApiModelProperty("区间3时间集合") - private List time2; + private List time2 = new ArrayList<>(); @ApiModelProperty("区间4时间集合") - private List time3; + private List time3 = new ArrayList<>(); @ApiModelProperty("区间5时间集合") - private List time4; + private List time4 = new ArrayList<>(); @ApiModelProperty("区间6时间集合") - private List time5; + private List time5 = new ArrayList<>(); @ApiModelProperty("区间7时间集合") - private List time6; + private List time6 = new ArrayList<>(); @ApiModelProperty("区间8时间集合") - private List time7; + private List time7 = new ArrayList<>(); @ApiModelProperty("区间9时间集合") - private List time8; + private List time8 = new ArrayList<>(); @ApiModelProperty("区间10时间集合") - private List time9; + private List time9 = new ArrayList<>(); } 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 b2570d610..428378f17 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,5 +1,6 @@ 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; @@ -19,12 +20,15 @@ public class PowerStatisticsTargetVO { 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("三相电压不平衡度") @@ -69,34 +73,58 @@ public class PowerStatisticsTargetVO { @ApiModelProperty("电流不平衡度详情") private List sequenceCurrentUnbalanceList = new ArrayList<>(); - @ApiModelProperty("越限相别(用于后端辅助计算)") + @ApiModelProperty("相别(用于后端辅助计算)") private String phasicType; - @ApiModelProperty("越限统计方式(用于后端辅助计算)") + @ApiModelProperty("统计方式(用于后端辅助计算)") private String valueType;; - @ApiModelProperty("电压偏差国标限制(用于后端辅助计算)") + @ApiModelProperty("电压偏差国标限值(用于后端辅助计算)") private Float voltageOffsetLimit; - @ApiModelProperty("谐波电压国标限制(用于后端辅助计算)") - private Float vTimesLimit; + @ApiModelProperty("谐波电压国标限值(用于后端辅助计算)") + private List vTimesLimit = new ArrayList<>();; - @ApiModelProperty("谐波电流国标限制(用于后端辅助计算)") - private Float iTimesLimit; + @ApiModelProperty("谐波电流国标限值(用于后端辅助计算)") + private List iTimesLimit = new ArrayList<>();; - @ApiModelProperty("三相电压不平衡度国标限制(用于后端辅助计算)") + @ApiModelProperty("三相电压不平衡度国标限值(用于后端辅助计算)") private Float ubalanceLimit; - @ApiModelProperty("电压波动国标限制(用于后端辅助计算)") + @ApiModelProperty("电压波动国标限值(用于后端辅助计算)") private Float voltageFluctuationLimit; - @ApiModelProperty("闪变国标限制(用于后端辅助计算)") + @ApiModelProperty("闪变国标限值(用于后端辅助计算)") private Float flickerLimit; - @ApiModelProperty("间谐波电压含有率国标限制(用于后端辅助计算)") - private Float interHarmonicLimit; + @ApiModelProperty("间谐波电压含有率国标限值(用于后端辅助计算)") + private List interHarmonicLimit = new ArrayList<>();; - @ApiModelProperty("电流不平衡度国标限制(用于后端辅助计算)") + @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 e57b96c88..fe23a00dd 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 @@ -17,24 +17,6 @@ public class ThdDataVO { @ApiModelProperty("单位") private String unit; - @ApiModelProperty("平均值A相") - private String AVGPhaseA; - - @ApiModelProperty("平均值B相") - private String AVGPhaseB; - - @ApiModelProperty("平均值C相") - private String AVGPhaseC; - - @ApiModelProperty("CP95A相") - private String CP95PhaseA; - - @ApiModelProperty("CP95B相") - private String CP95PhaseB; - - @ApiModelProperty("CP95C相") - private String CP95PhaseC; - @ApiModelProperty("最小值A相") private String MINPhaseA; @@ -53,22 +35,28 @@ public class ThdDataVO { @ApiModelProperty("最大值C相") private String MAXPhaseC; + @ApiModelProperty("平均值A相") + private String AVGPhaseA; + + @ApiModelProperty("平均值B相") + private String AVGPhaseB; + + @ApiModelProperty("平均值C相") + private String AVGPhaseC; + + @ApiModelProperty("CP95A相") + private String CP95PhaseA; + + @ApiModelProperty("CP95B相") + private String CP95PhaseB; + + @ApiModelProperty("CP95C相") + private String CP95PhaseC; + @ApiModelProperty("国标限值") private Float limit; - public void init(){ - this.AVGPhaseA = "0"; - this.AVGPhaseB = "0"; - this.AVGPhaseC = "0"; - this.CP95PhaseA = "0"; - this.CP95PhaseB = "0"; - this.CP95PhaseC = "0"; - this.MINPhaseA = "0"; - this.MINPhaseB = "0"; - this.MINPhaseC = "0"; - this.MAXPhaseA = "0"; - this.MAXPhaseB = "0"; - this.MAXPhaseC = "0"; - } + @ApiModelProperty("时间") + private String time; } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVOExcel.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVOExcel.java new file mode 100644 index 000000000..dcf783bb5 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVOExcel.java @@ -0,0 +1,75 @@ +package com.njcn.harmonic.pojo.vo; + +import com.alibaba.excel.annotation.ExcelProperty; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * 指标详情数据Excel实体类 + * @author guofeihu + * @since 2024-08-20 + */ +@Data +public class ThdDataVOExcel { + + @ApiModelProperty("时间") + @ExcelProperty(index =0,value = "时间") + private String time; + + @ApiModelProperty("名称") + @ExcelProperty(index =1,value = "指标") + private String anotherName; + + @ApiModelProperty("单位") + @ExcelProperty(index =2,value = "单位") + private String unit; + + @ApiModelProperty("最小值A相") + @ExcelProperty(index =3,value = {"最小值","A"}) + private String MINPhaseA; + + @ApiModelProperty("最小值B相") + @ExcelProperty(index =4,value = {"最小值","B"}) + private String MINPhaseB; + + @ApiModelProperty("最小值C相") + @ExcelProperty(index =5,value = {"最小值","C"}) + private String MINPhaseC; + + @ApiModelProperty("最大值A相") + @ExcelProperty(index =6,value = {"最大值","A"}) + private String MAXPhaseA; + + @ApiModelProperty("最大值B相") + @ExcelProperty(index =7,value = {"最大值","B"}) + private String MAXPhaseB; + + @ApiModelProperty("最大值C相") + @ExcelProperty(index =8,value = {"最大值","C"}) + private String MAXPhaseC; + + @ApiModelProperty("平均值A相") + @ExcelProperty(index =9,value = {"平均值","A"}) + private String AVGPhaseA; + + @ApiModelProperty("平均值B相") + @ExcelProperty(index =10,value = {"平均值","B"}) + private String AVGPhaseB; + + @ApiModelProperty("平均值C相") + @ExcelProperty(index =11,value = {"平均值","C"}) + private String AVGPhaseC; + + @ApiModelProperty("CP95A相") + @ExcelProperty(index =12,value = {"cp95","A"}) + private String CP95PhaseA; + + @ApiModelProperty("CP95B相") + @ExcelProperty(index =13,value = {"cp95","B"}) + private String CP95PhaseB; + + @ApiModelProperty("CP95C相") + @ExcelProperty(index =14,value = {"cp95","C"}) + private String CP95PhaseC; + +} diff --git a/pqs-harmonic/harmonic-boot/pom.xml b/pqs-harmonic/harmonic-boot/pom.xml index 339cd0d40..6ba5b8d00 100644 --- a/pqs-harmonic/harmonic-boot/pom.xml +++ b/pqs-harmonic/harmonic-boot/pom.xml @@ -100,6 +100,12 @@ 1.0.0 compile + + com.njcn + advance-api + 1.0.0 + compile + 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 8b0b542b9..c86b02dd5 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 @@ -3,12 +3,12 @@ package com.njcn.harmonic.service.activepowerrange.impl; import cn.afterturn.easypoi.excel.ExcelExportUtil; import cn.afterturn.easypoi.excel.entity.ExportParams; import cn.hutool.core.bean.BeanUtil; +import com.alibaba.excel.EasyExcel; +import com.alibaba.excel.ExcelWriter; +import com.alibaba.excel.write.metadata.WriteSheet; import com.njcn.harmonic.constant.Param; import com.njcn.harmonic.pojo.param.PowerStatisticsParam; -import com.njcn.harmonic.pojo.vo.PowerStatisticsExcelRangVO; -import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO; -import com.njcn.harmonic.pojo.vo.PowerStatisticsVO; -import com.njcn.harmonic.pojo.vo.ThdDataVO; +import com.njcn.harmonic.pojo.vo.*; import com.njcn.harmonic.service.activepowerrange.PowerStatisticsService; import com.njcn.influx.pojo.bo.CommonQueryParam; import com.njcn.influx.pojo.constant.InfluxDBTableConstant; @@ -28,6 +28,7 @@ import org.apache.poi.xssf.usermodel.XSSFSimpleShape; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import javax.servlet.http.HttpServletResponse; +import java.io.IOException; import java.text.DecimalFormat; import java.util.*; import java.util.stream.Collectors; @@ -51,12 +52,23 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { private final EpdFeignClient epdFeignClient; - private List METHODS = Arrays.asList("AVG","CP95","MIN","MAX"); + private List METHODS = Arrays.asList(InfluxDBTableConstant.AVG,InfluxDBTableConstant.CP95,InfluxDBTableConstant.MIN,InfluxDBTableConstant.MAX); - private List PHASE = Arrays.asList("A","B","C"); + private List PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A,InfluxDBTableConstant.PHASE_TYPE_B,InfluxDBTableConstant.PHASE_TYPE_C); + + private List times = Arrays.asList("0~10%","10~20%","20~30%","30~40%","40~50%","50~60%","60~70%","70~80%","80~90%","90~100%"); @Override public PowerStatisticsVO getDataByLineId(PowerStatisticsParam powerStatisticsParam) { + //每次执行区间查询前都走一遍定时任务算法(防止当天没有区间相关数据) + RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam(); + BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam); + //设置查询 + rActivePowerRangeParam.setSearch(true); + rActivePowerRangeParam.setSearchForAdd(true); + //执行定时任务根据前端点击的时间范围及监测点 + rActivePowerRangeFeignClient.record(rActivePowerRangeParam); + //执行完就可以获取到区间数据了 RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeFeignClient.getDataByLineId(powerStatisticsParam.getLineId(), powerStatisticsParam.getSearchBeginTime(),powerStatisticsParam.getSearchEndTime()).getData(); if(rActivePowerRangePO == null){ @@ -87,11 +99,10 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { @Override public List getTargetLimitById(PowerStatisticsParam powerStatisticsParam) { List data = new ArrayList<>(); - RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam(); BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam); rActivePowerRangeParam.setSearch(true); - //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:当前时间中八个指标是否越限及他们的相别和统计方式是什么 + //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:每条数据当前时间中八个指标是否越限及他们的相别和统计方式是什么 //基于record结构需要做维度的转换 List record = rActivePowerRangeFeignClient.record(rActivePowerRangeParam).getData(); //根据时间分组: @@ -99,126 +110,211 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { map.forEach((key, value) ->{ PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO(); powerStatisticsTargetVO.setTime(key); - ThdDataVO thdDataVO = new ThdDataVO(); - thdDataVO.init(); - Map voltageOffsetPV = new HashMap<>(); - Map vTimesPV = new HashMap<>(); - Map iTimesPV = new HashMap<>(); - Map ubalancePV = new HashMap<>(); - Map voltageFluctuationPV = new HashMap<>(); - Map flickerPV = new HashMap<>(); - Map interHarmonicPV = new HashMap<>(); - Map sequenceCurrentUnbalancePV = new HashMap<>(); + powerStatisticsTargetVO.setField(powerStatisticsParam.getField()); + //各指标越限的相别及统计方式集合 + List> pvs = new ArrayList<>(); + //遍历当前时间下的区间指标(注意:可能多组只是说统计方式和相别不同) for(PowerStatisticsTargetVO vo : value){ - if(vo.getVoltageOffset() == 1){ - powerStatisticsTargetVO.setVoltageOffset(1); - voltageOffsetPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getVTimes() == 1){ - powerStatisticsTargetVO.setVTimes(1); - vTimesPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getITimes() == 1){ - powerStatisticsTargetVO.setITimes(1); - iTimesPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getUbalance() == 1){ - powerStatisticsTargetVO.setUbalance(1); - ubalancePV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getVoltageFluctuation() == 1){ - powerStatisticsTargetVO.setVoltageFluctuation(1); - voltageFluctuationPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getFlicker() == 1){ - powerStatisticsTargetVO.setFlicker(1); - flickerPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getInterHarmonic() == 1){ - powerStatisticsTargetVO.setInterHarmonic(1); - interHarmonicPV.put(vo.getPhasicType(),vo.getValueType()); - } - if(vo.getSequenceCurrentUnbalance() == 1){ - powerStatisticsTargetVO.setSequenceCurrentUnbalance(1); - sequenceCurrentUnbalancePV.put(vo.getPhasicType(),vo.getValueType()); - } + //以下这些判断只要有一个指标越限了(不管是什么统计方式和相别)直接标识该指标越限(这些字段用于前端展示) + 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(voltageOffsetPV,"电压偏差",value.get(0).getVoltageOffsetLimit())); - powerStatisticsTargetVO.setVTimesList(initPV(vTimesPV,"谐波电压",value.get(0).getVTimesLimit())); - powerStatisticsTargetVO.setITimestList(initPV(iTimesPV,"谐波电流",value.get(0).getITimesLimit())); - powerStatisticsTargetVO.setUbalanceList(initPV(ubalancePV,"三相电压不平衡度",value.get(0).getUbalanceLimit())); - powerStatisticsTargetVO.setVoltageFluctuationList(initPV(voltageFluctuationPV,"电压波动",value.get(0).getVoltageFluctuationLimit())); - powerStatisticsTargetVO.setFlickerList(initPV(flickerPV,"闪变",value.get(0).getFlickerLimit())); - powerStatisticsTargetVO.setInterHarmonicList(initPV(interHarmonicPV,"间谐波电压含有率",value.get(0).getInterHarmonicLimit())); - powerStatisticsTargetVO.setSequenceCurrentUnbalanceList(initPV(sequenceCurrentUnbalancePV,"电流不平衡度",value.get(0).getSequenceCurrentUnbalanceLimit())); + 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())); data.add(powerStatisticsTargetVO); }); - return data; + return data.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList()); } - private List initPV(Map pv,String name,Float limit){ + private List initPV(List> pv, String name, Float limit){ List thdDataVOS = new ArrayList<>(); ThdDataVO tdv = new ThdDataVO(); tdv.setAnotherName(name); tdv.setLimit(limit); - tdv.init(); - pv.forEach((phasicType, valueType) ->{ - switch (valueType){ - case InfluxDBTableConstant.AVG: - switch (valueType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setAVGPhaseA("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setAVGPhaseB("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setAVGPhaseC("1"); - break; - } + //便利统计方式和相别集合渲染对应字段 + 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(); + } + } + 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; - case InfluxDBTableConstant.CP95: - switch (valueType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setCP95PhaseA("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setCP95PhaseB("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setCP95PhaseC("1"); - break; - } - break; - case InfluxDBTableConstant.MIN: - switch (valueType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setMINPhaseA("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setMINPhaseB("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setMINPhaseC("1"); - break; - } - break; - case InfluxDBTableConstant.MAX: - switch (valueType){ - case InfluxDBTableConstant.PHASE_TYPE_A: - tdv.setMAXPhaseA("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_B: - tdv.setMAXPhaseB("1"); - break; - case InfluxDBTableConstant.PHASE_TYPE_C: - tdv.setMAXPhaseC("1"); - break; - } + //间谐波电压含有率默认谐波次数1-16 + case Param.interHarmonic: + k = 1; + j = 16; + c = 0.5; break; } - }); - thdDataVOS.add(tdv); + 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.setMINPhaseA(frequencyPVList(minB,i-k)); + tdv.setMINPhaseA(frequencyPVList(minC,i-k)); + tdv.setMAXPhaseA(frequencyPVList(maxA,i-k)); + tdv.setMAXPhaseA(frequencyPVList(maxB,i-k)); + tdv.setMAXPhaseA(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; } @@ -226,6 +322,7 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { public List getTargetByTime(PowerStatisticsParam powerStatisticsParam) { List result = new ArrayList(); List eleEpdPqds = new ArrayList<>(); + //获取固定指标具体请看Param.DATABSEMAP if("1".equals(powerStatisticsParam.getStatisticalId())){ com.njcn.device.pq.constant.Param.DATABSEMAP.forEach((key,value) ->{ List epdPqds = epdFeignClient.findListByShowName(key).getData(); @@ -277,10 +374,12 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { eleEpdPqds.forEach(epdPqd->{ List commonQueryParams = new ArrayList<>(); commonQueryParams.clear(); + //带有谐波次数的指标 if(epdPqd.getHarmEnd()!=null && epdPqd.getHarmStart()!=null){ for (int i = epdPqd.getHarmStart().intValue(); i <= epdPqd.getHarmEnd().intValue(); i++) { ThdDataVO thdDataVO = new ThdDataVO(); thdDataVO.setUnit(epdPqd.getUnit()); + thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime()); String index = i+""; if(epdPqd.getShowName().equals("间谐波电压含有率")){ thdDataVO.setAnotherName(Integer.parseInt(index) - 0.5 + "次"); @@ -291,9 +390,11 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { result.add(thdDataVO); } }else{ + //无谐波次数的指标 ThdDataVO thdDataVO = new ThdDataVO(); thdDataVO.setAnotherName(epdPqd.getShowName()); thdDataVO.setUnit(epdPqd.getUnit()); + thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime()); getThdDataVO(null,thdDataVO,epdPqd,powerStatisticsParam); result.add(thdDataVO); } @@ -302,14 +403,15 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { } //将各个指标的所有的相别统计方式以表格的维度进行组装数据 - private ThdDataVO getThdDataVO(String columnName,ThdDataVO thdDataVO,EleEpdPqd epdPqd,PowerStatisticsParam powerStatisticsParam){ + private ThdDataVO getThdDataVO(String columnName, ThdDataVO thdDataVO, EleEpdPqd epdPqd, PowerStatisticsParam powerStatisticsParam){ List commonQueryParams = new ArrayList<>(); CommonQueryParam commonQueryParam = new CommonQueryParam(); commonQueryParam.setLineId(powerStatisticsParam.getLineId()); commonQueryParam.setTableName(epdPqd.getClassId()); commonQueryParam.setColumnName(columnName == null ? epdPqd.getOtherName():columnName); - commonQueryParam.setStartTime(powerStatisticsParam.getSearchBeginTime()+Param.START_TIME); - commonQueryParam.setEndTime(powerStatisticsParam.getSearchEndTime()+ Param.END_TIME); + commonQueryParam.setStartTime(powerStatisticsParam.getSearchBeginTime()); + commonQueryParam.setEndTime(powerStatisticsParam.getSearchEndTime()); + //唯一不同的条件时统计方式和相别,所以这边直接把所有的情况都考虑进去 commonQueryParam.setDataType(METHODS.get(0)); commonQueryParam.setPhasic(PHASE.get(0)); commonQueryParams.add(commonQueryParam); @@ -499,10 +601,80 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { @Override public void exportExcelListTemplate(PowerStatisticsParam powerStatisticsParam, HttpServletResponse response) { - ExportParams exportParams = new ExportParams(powerStatisticsParam.getSearchValue(), "指标越限列表数据"); - List powerStatisticsTargetVOS = getTargetLimitById(powerStatisticsParam); - Workbook workbook = ExcelExportUtil.exportExcel(exportParams, PowerStatisticsTargetVO.class, powerStatisticsTargetVOS); - PoiUtil.exportFileByWorkbook(workbook, powerStatisticsParam.getSearchValue()+".xlsx", response); + //获取各个区间的详细数据(就是调用getTargetByTime方法在进行某些指标的名称的处理) + List time0 = getExcelListRecord(powerStatisticsParam.getTime0(),powerStatisticsParam.getLineId()); + List time1 = getExcelListRecord(powerStatisticsParam.getTime1(),powerStatisticsParam.getLineId()); + List time2 = getExcelListRecord(powerStatisticsParam.getTime2(),powerStatisticsParam.getLineId()); + List time3 = getExcelListRecord(powerStatisticsParam.getTime3(),powerStatisticsParam.getLineId()); + List time4 = getExcelListRecord(powerStatisticsParam.getTime4(),powerStatisticsParam.getLineId()); + List time5 = getExcelListRecord(powerStatisticsParam.getTime5(),powerStatisticsParam.getLineId()); + List time6 = getExcelListRecord(powerStatisticsParam.getTime6(),powerStatisticsParam.getLineId()); + List time7 = getExcelListRecord(powerStatisticsParam.getTime7(),powerStatisticsParam.getLineId()); + List time8 = getExcelListRecord(powerStatisticsParam.getTime8(),powerStatisticsParam.getLineId()); + List time9 = getExcelListRecord(powerStatisticsParam.getTime9(),powerStatisticsParam.getLineId()); + try { + //10个区间10个sheet10组数据 + ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), ThdDataVOExcel.class).build(); + WriteSheet sheet0 = EasyExcel.writerSheet(0, times.get(0) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time0, sheet0); + WriteSheet sheet1 = EasyExcel.writerSheet(1, times.get(1) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time1, sheet1); + WriteSheet sheet2 = EasyExcel.writerSheet(2, times.get(2) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time2, sheet2); + WriteSheet sheet3 = EasyExcel.writerSheet(3, times.get(3) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time3, sheet3); + WriteSheet sheet4 = EasyExcel.writerSheet(4, times.get(4) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time4, sheet4); + WriteSheet sheet5 = EasyExcel.writerSheet(5, times.get(5) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time5, sheet5); + WriteSheet sheet6 = EasyExcel.writerSheet(6, times.get(6) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time6, sheet6); + WriteSheet sheet7 = EasyExcel.writerSheet(7, times.get(7) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time7, sheet7); + WriteSheet sheet8 = EasyExcel.writerSheet(8, times.get(8) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time8, sheet8); + WriteSheet sheet9 = EasyExcel.writerSheet(9, times.get(9) ).head(ThdDataVOExcel.class).build(); + excelWriter.write(time9, sheet9); + excelWriter.finish(); + } catch (IOException e) { + e.printStackTrace(); + } } + private List getExcelListRecord(List times, String lineId){ + List thdDataVOS = new ArrayList<>(); + List thdDataVOExcels = new ArrayList<>(); + PowerStatisticsParam powerStatisticsParam = new PowerStatisticsParam(); + powerStatisticsParam.setLineId(lineId); + for(String time : times){ + powerStatisticsParam.setSearchBeginTime(time); + powerStatisticsParam.setSearchEndTime(time); + for (int i = 1; i <= 4; i++) { + powerStatisticsParam.setStatisticalId(i+""); + List thdDataVOList = getTargetByTime(powerStatisticsParam); + if(i != 1){ + for(ThdDataVO thdDataVO : thdDataVOList){ + switch (i){ + case 2: + thdDataVO.setAnotherName("谐波电压"+thdDataVO.getAnotherName()); + break; + case 3: + thdDataVO.setAnotherName("谐波电流"+thdDataVO.getAnotherName()); + break; + case 4: + thdDataVO.setAnotherName("间谐波电压"+thdDataVO.getAnotherName()); + break; + } + } + } + thdDataVOS.addAll(thdDataVOList); + } + } + for(ThdDataVO thdDataVO : thdDataVOS){ + ThdDataVOExcel thdDataVOExcel = new ThdDataVOExcel(); + BeanUtils.copyProperties(thdDataVO, thdDataVOExcel); + thdDataVOExcels.add(thdDataVOExcel); + } + return thdDataVOExcels; + } } 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 c301ad23d..bb965441b 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 @@ -21,8 +21,10 @@ import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam; import com.njcn.prepare.harmonic.pojo.po.RActivePowerRangePO; import com.njcn.prepare.harmonic.service.mysql.event.RActivePowerRangeService; import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import java.lang.reflect.Field; +import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.ZoneId; import java.time.format.DateTimeFormatter; @@ -34,6 +36,7 @@ import java.util.stream.Collectors; * @author guofeihu * @since 2024-08-22 */ +@Slf4j @Service @RequiredArgsConstructor public class RActivePowerRangeServiceImpl extends MppServiceImpl implements RActivePowerRangeService { @@ -48,20 +51,42 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A,InfluxDBTableConstant.PHASE_TYPE_B,InfluxDBTableConstant.PHASE_TYPE_C); + + /** + * 整个算法的业务逻辑: + * 1:查询InfluxDb的功率表:data_harmpower_p + * 2:遍历功率集合将功率(p字段) / line_id监测点绑定的新能源场站中的风电场的额定功率,看落在哪个区间内 + * 3:遍历功率集合将每条功率对应的各个指标(指标的所有相别和统计方式都要一一比较)与国标限值比较看看是否越限(功率对应的各个指标详情请见下方) + * --------------------------------指标--------------------------------- + * 电压偏差 data_v vu_dev 电压偏差 如果vu_dev>0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比 + * 谐波电压 data_v v_thd 电压总谐波总谐波畸变率 有一个指标超标，则谐波电压超标 + * 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 public List record(RActivePowerRangeParam rActivePowerRangeParam) { if(rActivePowerRangeParam == null){ rActivePowerRangeParam = new RActivePowerRangeParam(); } - //根据事件间隔查询 SELECT * FROM "data_harmpower_p" limit 1 得到P - // 便利 用p / 风电场额定有功功率 * 100% 看落在那个占比 + //返回的最终结果 List powerStatisticsTargetVOS = new ArrayList<>(); - //定义开始和结束时间 + //默认初始化开始和结束时间 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; @@ -70,25 +95,37 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl dataHarmPowerPS = commonService.getNewDeviceRtDataByTime(commonQueryParams); + //由于前端写死了各个指标的相别(只有A、B、C所以这边直接限制死了) + dataHarmPowerPS = dataHarmPowerPS.stream().filter(param->PHASE.contains(param.getPhaseType())).collect(Collectors.toList()); //有功功率趋势表是按照监测点来划分的 所以这边需要根据监测点来分组 Map> map = 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) ->{ //获取监测点的国标限值 List overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(key)).getData(); + //该监测点必须要有国标限值 if(overlimits != null && !overlimits.isEmpty()){ Overlimit overlimit = overlimits.get(0); //获取监测点 LineDTO lineDTO = commLineClient.getLineDetail(key).getData(); + //监测点必须绑定新能源站 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())){ RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO(); rActivePowerRangePO.setLineId(key); @@ -96,19 +133,27 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl lambdaQueryWrapper = new LambdaQueryWrapper<>(); lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,key).eq(RActivePowerRangePO::getTimeId,LocalDate.now()); - //强制刷新 + //控制参数-强制刷新 if(finalRActivePowerRangeParam.isRefresh()){ this.baseMapper.delete(lambdaQueryWrapper); } - //计算各个区间个数 + //控制参数-是否查询及查询新增(主要用于harmonic-boot-getDataByLineId方法,避免每次执行都会执行for循环,也即当日执行完一次即可) + 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())); PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO(); + //设置时间为当前功率的时间 powerStatisticsTargetVO.setTime(statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter)); + //当前功率的p字段 / 风电场额定功率 double temp = statisticalDataDTO.getValue() / Double.parseDouble(newStation.getRatedPower()); if(temp <= 0.1){ //占有率区间个数+1 rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1); - //指标越限列表区间区分字段 + //指标越限列表区间区分字段(用于前端查询) powerStatisticsTargetVO.setField("0"); //判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段) installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,0,powerStatisticsTargetVO); @@ -149,8 +194,10 @@ public class RActivePowerRangeServiceImpl extends MppServiceImplparam.getField().equals(finalRActivePowerRangeParam.getField())).collect(Collectors.toList()); + if(finalRActivePowerRangeParam.getField() != null){ + return powerStatisticsTargetVOS.stream().filter(param->param.getField().equals(finalRActivePowerRangeParam.getField())).collect(Collectors.toList()); + } + 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()); + //以下的结果集按道理最多只有一条(因为确定的相别统计方式及开始和结束时间都一致,除了有谐波次数的指标) //电压偏差 List vu_dev = commonQuery(InfluxDBTableConstant.DATA_V,"vu_dev",statisticalDataDTO,null,null); //谐波电压 @@ -188,113 +243,133 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I,"i_unbalance",statisticalDataDTO,null,null); //此标识用来记录当前区间下指标是否越限(0%~10%是否越限,10%~20%是否越限.....) 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); - //记录电压偏差越限的相别 - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - //记录电压偏差越限的统计方式 - powerStatisticsTargetVO.setValueType(dto.getValueType()); - } - //电压偏差国标限制有判断 - if(dto.getValue()>0){ - powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev()); - }else{ - powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getUvoltageDev()); } } + //谐波电压比较较为特殊需要比较两个点(以v为主) //谐波电压是否越限比较 - //谐波电压国标限制 - powerStatisticsTargetVO.setVTimesLimit(overlimit.getUaberrance()); for(StatisticalDataDTO dto : v_thd){ if(Double.compare(dto.getValue(),overlimit.getUaberrance())>0){ isLimit = true; powerStatisticsTargetVO.setVTimes(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); } } + int num = 2; for(StatisticalDataDTO dto : v){ - if(frequencyCompare(overlimit,2,50,dto.getValue(),"uharm")){ - isLimit = true; - powerStatisticsTargetVO.setVTimes(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); + 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++; } + num = 2; //谐波电流是否越限比较 - //谐波电流国标限制(由于有谐波次数所以这边直接默认取第一个) - powerStatisticsTargetVO.setVTimesLimit(overlimit.getIharm2()); for(StatisticalDataDTO dto : i){ - if(frequencyCompare(overlimit,2,25,dto.getValue(),"iharm")){ - isLimit = true; - powerStatisticsTargetVO.setITimes(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); + 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++; } - //三相电压不平衡度是否越限比较 - //三相电压不平衡度国标限制 + //三相电压不平衡度国标限值 powerStatisticsTargetVO.setUbalanceLimit(overlimit.getUbalance()); + //三相电压不平衡度是否越限比较 for(StatisticalDataDTO dto : v_unbalance){ + //三相电压不平衡度具体值 + powerStatisticsTargetVO.setUbalanceData(dto.getValue()); if(Double.compare(dto.getValue(),overlimit.getUbalance())>0){ isLimit = true; + //标志三相电压不平衡度越限 powerStatisticsTargetVO.setUbalance(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); } } - //电压波动是否越限比较 - //电压波动国标限制 + //电压波动国标限值 powerStatisticsTargetVO.setVoltageFluctuationLimit(overlimit.getVoltageFluctuation()); + //电压波动是否越限比较 for(StatisticalDataDTO dto : fluc){ + //电压波动具体值 + powerStatisticsTargetVO.setVoltageFluctuationData(dto.getValue()); if(Double.compare(dto.getValue(),overlimit.getVoltageFluctuation())>0){ isLimit = true; + //标志电压波动越限 powerStatisticsTargetVO.setVoltageFluctuation(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); } } - //长时闪变是否越限比较 - //长时闪变国标限制 + //长时闪变国标限值 powerStatisticsTargetVO.setFlickerLimit(overlimit.getFlicker()); + //长时闪变是否越限比较 for(StatisticalDataDTO dto : plt){ + //长时闪变具体值 + powerStatisticsTargetVO.setFlickerData(dto.getValue()); if(Double.compare(dto.getValue(),overlimit.getFlicker())>0){ isLimit = true; + //标志长时闪变越限 powerStatisticsTargetVO.setFlicker(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); } } + num = 1; //间谐波电压含有率是否越限比较 - //间谐波电压含有率国标限制(由于有谐波次数所以这边直接默认取第一个) - powerStatisticsTargetVO.setInterHarmonicLimit(overlimit.getInuharm1()); for(StatisticalDataDTO dto : v1){ - if(frequencyCompare(overlimit,1,16,dto.getValue(),"inuharm")){ - isLimit = true; - powerStatisticsTargetVO.setInterHarmonic(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); + 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++; } - //电流不平衡度是否越限比较 - //间谐波电压含有率国标限制 + //电流不平衡度国标限值 powerStatisticsTargetVO.setSequenceCurrentUnbalanceLimit(overlimit.getINeg()); + //电流不平衡度是否越限比较 for(StatisticalDataDTO dto : i_unbalance){ + //电流不平衡度具体值 + powerStatisticsTargetVO.setSequenceCurrentUnbalanceData(dto.getValue()); if(Double.compare(dto.getValue(),overlimit.getINeg())>0){ isLimit = true; + //标志电流不平衡度越限 powerStatisticsTargetVO.setSequenceCurrentUnbalance(1); - powerStatisticsTargetVO.setPhasicType(dto.getPhaseType()); - powerStatisticsTargetVO.setValueType(dto.getValueType()); } } + //区间是否越限标识 switch (type){ case 0: if(isLimit) rActivePowerRangePO.setIsOrNot0(1); @@ -329,11 +404,13 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl commonQuery(String tableName,String columnName,StatisticalDataDTO statisticalDataDTO,Integer start,Integer end){ List commonQueryParams = new ArrayList<>(); + //不管哪种时间是固定的 String time = statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter); CommonQueryParam commonQueryParam = new CommonQueryParam(); + //无谐波次数查询 if(start == null){ commonQueryParam.setStartTime(time); commonQueryParam.setEndTime(time); @@ -344,6 +421,7 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl0){ - return true; - } - } + Class clazz = overlimit.getClass(); + Field field = clazz.getDeclaredField(flag+num); + field.setAccessible(true); + return Float.parseFloat(field.get(overlimit).toString()); } catch (Exception e) { e.printStackTrace(); } - return false; + return null; } + //根据时间间隔获取间隔前时间或获取昨晚最晚时间 private String getTime(long interval,int type){ DateTimeFormatter sdf = DateTimeFormatter.ofPattern(DateUtils.DATE_FORMAT_10); LocalDate yesterday; @@ -396,6 +472,7 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl