Microservice/pqs
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

异常数据功能代码优化

Browse Source
This commit is contained in:
雨木c
2023-08-23 16:01:50 +08:00
parent 39c910a33d
commit ef0ab5eac4
10 changed files with 268 additions and 667 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
pqs-advance/advance-boot/src/main/resources/qvvr_dll_cause.dll → pqs-advance/advance-boot/src/main/resources/qvvr_cause_dll.dll
View File

9
pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/api/OverLimitClient.java
View File

@@ -11,6 +11,7 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
import java.util.Map;
/**
* 监测点数据完整性
@@ -29,4 +30,12 @@ public interface OverLimitClient {
*/
@PostMapping("/getOverLimitByLineIds")
HttpResult<List<Overlimit>> getOverLimitByLineIds(@RequestBody List<String> lineIds);
/**
*
* @author cdf
* @date 2023/6/7
*/
@PostMapping("/getLimitMapsByLineIds")
HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(@RequestBody List<String> lineIds);
}

7
pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/api/fallback/OverLimitFallbackFactory.java
View File

@@ -13,6 +13,7 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* 告警管理熔断降级
@@ -38,6 +39,12 @@ public class OverLimitFallbackFactory implements FallbackFactory<OverLimitClient
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(List<String> lineIds) {
log.error("{}异常，降级处理，异常为：{}", "获取监测点限值map", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

14
pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/controller/OverLimitController.java
View File

@@ -23,7 +23,9 @@ import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
/**
* 监测点限值
@@ -52,4 +54,16 @@ public class OverLimitController extends BaseController {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getLimitMapsByLineIds")
@ApiOperation("监测点集合获取限值")
@ApiImplicitParam(name = "lineIds", value = "监测点ids", required = true)
@ApiIgnore
public HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(@RequestBody List<String> lineIds){
String methodDescribe = getMethodDescribe("getLimitMapsByLineIds");
List<Map<String, Object>> overLimitList= iOverLimitService.listMaps(new LambdaQueryWrapper<Overlimit>().in(Overlimit::getId,lineIds));
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe);
}
}

3
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/mysql/po/line/MpSurplusAbnormalD.java
View File

@@ -461,4 +461,7 @@ public class MpSurplusAbnormalD {
private Float inuharm16 = -3.14159f;
}

6
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/LineParam.java
View File

@@ -15,6 +15,9 @@ import java.util.List;
@Data
public class LineParam {
/**
* 监测点id,集合为空则默认全部监测点
*/
@ApiModelProperty(name = "lineIds",value = "监测点索引集合")
private List<String> lineIds;
@@ -28,13 +31,14 @@ public class LineParam {
@NotNull(message = "时间类型不可为空")
private Integer type;
@ApiModelProperty(name = "dataDate",value = "时间")
@ApiModelProperty(name = "dataDate",value = "时间日期")
@NotBlank(message = "时间不可为空")
private String dataDate;
/**
* 标识从那个库里查询数据
*/
@Deprecated
@ApiModelProperty(name = "dataSource",value = "数据源（0:oracle，1:influxdb 2:mysql）")
private Integer dataSource;

13
pqs-prepare/prepare-boot/pom.xml
View File

@@ -46,12 +46,7 @@
<version>${project.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.njcn</groupId>
<artifactId>process-api</artifactId>
<version>${project.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.njcn</groupId>
<artifactId>common-influxDB</artifactId>
@@ -154,11 +149,7 @@
<artifactId>orai18n</artifactId>
<version>21.1.0.0</version>
</dependency>
<dependency>
<groupId>com.njcn</groupId>
<artifactId>process-api</artifactId>
<version>1.0.0</version>
</dependency>
<!-- <dependency>-->
<!-- <groupId>com.njcn</groupId>-->
<!-- <artifactId>influxdb-springboot-starter</artifactId>-->

5
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/NormalLimitController.java
View File

@@ -18,6 +18,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 用于每天统计前一天异常监测点数据(需要在r_stat_limit_target_d数据后面执行)
* @author denghuajun
* @version 1.0.0
* @date 2022年10月17日 19:56
@@ -33,10 +34,10 @@ public class NormalLimitController extends BaseController {
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getNormLimitData")
@ApiOperation("告警数据预处理")
@ApiOperation("监测点告警数据预处理")
public HttpResult<String> getNormLimitData(@RequestBody LineParam lineParam) {
String methodDescribe = getMethodDescribe("getNormLimitData");
normLimitService.AbnormalLineData(lineParam);
normLimitService.abnormalLineData(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

862
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/NormalLimitServiceImpl.java
View File

@@ -1,16 +1,22 @@
package com.njcn.prepare.harmonic.service.mysql.Impl.line;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.TimeInterval;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.common.pojo.dto.SimpleDTO;
import com.njcn.common.pojo.enums.common.ServerEnum;
import com.njcn.device.pq.api.GeneralDeviceInfoClient;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.device.pq.api.OverLimitClient;
import com.njcn.device.pq.pojo.dto.GeneralDeviceDTO;
import com.njcn.device.pq.pojo.param.DeviceInfoParam;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.harmonic.pojo.po.RStatDataVD;
import com.njcn.harmonic.pojo.po.day.*;
import com.njcn.influxdb.param.InfluxDBPublicParam;
import com.njcn.influxdb.utils.InfluxDbUtils;
import com.njcn.prepare.harmonic.mapper.mysql.day.*;
import com.njcn.prepare.harmonic.mapper.mysql.line.AbnormalMapper;
import com.njcn.prepare.harmonic.pojo.mysql.po.line.MpSurplusAbnormalD;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
@@ -18,13 +24,18 @@ import com.njcn.prepare.harmonic.service.mysql.line.NormalLimitService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @author denghuajun
@@ -34,6 +45,7 @@ import java.util.*;
@Service
@AllArgsConstructor
@Slf4j
public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplusAbnormalD> implements NormalLimitService {
private final GeneralDeviceInfoClient generalDeviceInfoClient;
@@ -45,42 +57,82 @@ public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplu
private final DeptFeignClient deptFeignClient;
private final OverLimitClient overLimitClient;
private final RStatDataHarmRateVDMapper rStatDataHarmRateVDMapper;
private final RStatDataInHarmVDMapper rStatDataInHarmVDMapper;
private final RStatDataVDMapper rStatDataVDMapper;
private final RStatDataIDMapper rStatDataIDMapper;
private final RStatDataPltDMapper rStatDataPltDMapper;
@Override
@Async("asyncExecutor")
public Boolean AbnormalLineData(LineParam lineParam) {
//@Async("asyncExecutor")
public Boolean abnormalLineData(LineParam lineParam) {
TimeInterval timeInterval = new TimeInterval();
List<String> lineIds = new ArrayList<>();
List<MpSurplusAbnormalD> all = new ArrayList<>();
if (CollectionUtils.isEmpty(lineParam.getLineIds())) {
Dept dept = deptFeignClient.getRootDept().getData();
DeviceInfoParam deviceInfoParam = new DeviceInfoParam();
deviceInfoParam.setDeptIndex(dept.getId());
deviceInfoParam.setPowerFlag(2);
deviceInfoParam.setMonitorFlag(2);
deviceInfoParam.setServerName(ServerEnum.HARMONIC.getName());
SimpleDTO simpleDTO = new SimpleDTO();
simpleDTO.setName("电网拓扑");
simpleDTO.setSort(0);
simpleDTO.setCode("Power_Network");
deviceInfoParam.setStatisticalType(simpleDTO);
//处理监测点
List<GeneralDeviceDTO> deviceDataList = generalDeviceInfoClient.getPracticalAllDeviceInfo(deviceInfoParam).getData();
for (GeneralDeviceDTO generalDeviceDTO : deviceDataList) {
lineIds.addAll(generalDeviceDTO.getLineIndexes());
}
lineIds = generalDeviceInfoClient.deptGetRunLine(dept.getId()).getData();
} else {
//不为空则为补招
lineIds.addAll(lineParam.getLineIds());
lineIds = lineParam.getLineIds();
}
String lastSql = " and time>='" + lineParam.getDataDate() + InfluxDBPublicParam.START_TIME + "' and time <='" + lineParam.getDataDate() + InfluxDBPublicParam.END_TIME + "'";
if (!lineIds.isEmpty()) {
if (CollUtil.isNotEmpty(lineIds)) {
List<Map<String, Object>> overLimitMap = overLimitClient.getLimitMapsByLineIds(lineIds).getData();
Map<String, Map<String, Object>> ovMap = overLimitMap.stream().collect(Collectors.toMap(item -> item.get("id").toString(), Function.identity()));
for (String lineIndex : lineIds) {
Boolean flag = false;
//获取当前监测点的限值详情
Overlimit overlimit = lineFeignClient.getOverLimitData(lineIndex).getData();
if (!ovMap.containsKey(lineIndex)) {
log.error(LocalDateTime.now() + "--监测点<" + lineIndex + ">不存在限值！");
return false;
}
Map<String, Object> overLimit = ovMap.get(lineIndex);
//谐波电压
LambdaQueryWrapper<RStatDataHarmrateVDPO> lambdaQueryV = new LambdaQueryWrapper<>();
lambdaQueryV.eq(RStatDataHarmrateVDPO::getLineId, lineIndex).eq(RStatDataHarmrateVDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<Map<String, Object>> harmVMap = rStatDataHarmRateVDMapper.selectMaps(lambdaQueryV);
Map<String, List<Map<String, Object>>> tenMap = harmVMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString()));
//谐波电流幅值
LambdaQueryWrapper<RStatDataIDPO> lambdaQueryI = new LambdaQueryWrapper<>();
lambdaQueryI.eq(RStatDataIDPO::getLineId, lineIndex).eq(RStatDataIDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<Map<String, Object>> harmIMap = rStatDataIDMapper.selectMaps(lambdaQueryI);
Map<String, List<Map<String, Object>>> iMap = harmIMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString()));
//间谐波电压
LambdaQueryWrapper<RStatDataInharmVDPO> lambdaQueryInV = new LambdaQueryWrapper<>();
lambdaQueryInV.eq(RStatDataInharmVDPO::getLineId, lineIndex).eq(RStatDataInharmVDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<Map<String, Object>> harmInVMap = rStatDataInHarmVDMapper.selectMaps(lambdaQueryInV);
Map<String, List<Map<String, Object>>> inMap = harmInVMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString()));
//三相电压
LambdaQueryWrapper<RStatDataVDPO> lambdaQueryDataV = new LambdaQueryWrapper<>();
lambdaQueryDataV.eq(RStatDataVDPO::getLineId, lineIndex).eq(RStatDataVDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<RStatDataVDPO> rStatDataVDPOList = rStatDataVDMapper.selectList(lambdaQueryDataV);
Map<String, List<RStatDataVDPO>> dataVMap = rStatDataVDPOList.stream().collect(Collectors.groupingBy(RStatDataVDPO::getPhaseType));
//电流
LambdaQueryWrapper<RStatDataIDPO> lambdaQueryDataI = new LambdaQueryWrapper<>();
lambdaQueryDataI.eq(RStatDataIDPO::getLineId, lineIndex).eq(RStatDataIDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<RStatDataIDPO> rStatDataIDPOList = rStatDataIDMapper.selectList(lambdaQueryDataI);
Map<String, List<RStatDataIDPO>> dataIMap = rStatDataIDPOList.stream().collect(Collectors.groupingBy(RStatDataIDPO::getPhaseType));
//长时闪变
LambdaQueryWrapper<RStatDataPltDPO> lambdaQueryDataPlt = new LambdaQueryWrapper<>();
lambdaQueryDataPlt.eq(RStatDataPltDPO::getLineId, lineIndex).eq(RStatDataPltDPO::getTime, lineParam.getDataDate() + InfluxDBPublicParam.START_TIME);
List<RStatDataPltDPO> rStatDataPltDPOList = rStatDataPltDMapper.selectList(lambdaQueryDataPlt);
Map<String, List<RStatDataPltDPO>> dataPltMap = rStatDataPltDPOList.stream().collect(Collectors.groupingBy(RStatDataPltDPO::getPhaseType));
String phasic = "";
for (int phase = 1; phase < 5; phase++) {
@@ -99,629 +151,138 @@ public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplu
break;
}
MpSurplusAbnormalD mpSurplusAbnormalCp95 = new MpSurplusAbnormalD();
mpSurplusAbnormalCp95.setPhasicType(phasic);
mpSurplusAbnormalCp95.setValueType("CP95");
mpSurplusAbnormalCp95.setId(lineIndex);
mpSurplusAbnormalCp95.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalD = new MpSurplusAbnormalD();
mpSurplusAbnormalD.setPhasicType(phasic);
mpSurplusAbnormalD.setValueType("CP95");
mpSurplusAbnormalD.setId(lineIndex);
mpSurplusAbnormalD.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalAvg = new MpSurplusAbnormalD();
mpSurplusAbnormalAvg.setPhasicType(phasic);
mpSurplusAbnormalAvg.setValueType("AVG");
mpSurplusAbnormalAvg.setId(lineIndex);
mpSurplusAbnormalAvg.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalMax = new MpSurplusAbnormalD();
mpSurplusAbnormalMax.setPhasicType(phasic);
mpSurplusAbnormalMax.setValueType("MAX");
mpSurplusAbnormalMax.setId(lineIndex);
mpSurplusAbnormalMax.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalDMax = new MpSurplusAbnormalD();
mpSurplusAbnormalDMax.setPhasicType(phasic);
mpSurplusAbnormalDMax.setValueType("MAX");
mpSurplusAbnormalDMax.setId(lineIndex);
mpSurplusAbnormalDMax.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalMin = new MpSurplusAbnormalD();
mpSurplusAbnormalMin.setPhasicType(phasic);
mpSurplusAbnormalMin.setValueType("MIN");
mpSurplusAbnormalMin.setId(lineIndex);
mpSurplusAbnormalMin.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
if (dataVMap.containsKey(phasic)) {
List<RStatDataVDPO> mapList = dataVMap.get(phasic);
Map<String, RStatDataVDPO> vMap = mapList.stream().collect(Collectors.toMap(RStatDataVDPO::getValueType, Function.identity()));
MpSurplusAbnormalD mpSurplusAbnormalDMin = new MpSurplusAbnormalD();
mpSurplusAbnormalDMin.setPhasicType(phasic);
mpSurplusAbnormalDMin.setValueType("MIN");
mpSurplusAbnormalDMin.setId(lineIndex);
mpSurplusAbnormalDMin.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
MpSurplusAbnormalD mpSurplusAbnormalDAvg = new MpSurplusAbnormalD();
mpSurplusAbnormalDAvg.setPhasicType(phasic);
mpSurplusAbnormalDAvg.setValueType("AVG");
mpSurplusAbnormalDAvg.setId(lineIndex);
mpSurplusAbnormalDAvg.setTimeId(LocalDateTime.parse(lineParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
//判断标识 true:没有异常 false:存在异常
Boolean flag = true;
/*2-25次谐波电压含有率*/
String bang = " where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic+"' ";
StringBuilder tem = new StringBuilder();
for (int i = 2; i < 26; i++) {
if (i == 25) {
tem.append("MAX(v_").append(i).append(") as ").append("v_").append(i);
} else {
tem.append("MAX(v_").append(i).append(") as ").append("v_").append(i).append(",");
}
}
String sql = "select " + tem + " from data_harmrate_v "+ bang + " and value_type = 'CP95'"+InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapList = influxDbUtils.getMapResult(sql);
if (CollUtil.isNotEmpty(mapList)) {
List<String> useList = new ArrayList<>();
Float i2 = compareToOver(overlimit.getUharm2(), Float.parseFloat(mapList.get(0).get("v_2").toString()), flag);
if (Objects.nonNull(i2)) {
mpSurplusAbnormalD.setUharm2(i2);
useList.add("v_2");
}
Float i3 = compareToOver(overlimit.getUharm3(), Float.parseFloat(mapList.get(0).get("v_3").toString()), flag);
if (Objects.nonNull(i3)) {
mpSurplusAbnormalD.setUharm3(i3);
useList.add("v_3");
}
Float i4 = compareToOver(overlimit.getUharm4(), Float.parseFloat(mapList.get(0).get("v_4").toString()), flag);
if (Objects.nonNull(i4)) {
mpSurplusAbnormalD.setUharm4(i4);
}
Float i5 = compareToOver(overlimit.getUharm5(), Float.parseFloat(mapList.get(0).get("v_5").toString()), flag);
if (Objects.nonNull(i5)) {
mpSurplusAbnormalD.setUharm5(i5);
useList.add("v_5");
}
Float i6 = compareToOver(overlimit.getUharm6(), Float.parseFloat(mapList.get(0).get("v_6").toString()), flag);
if (Objects.nonNull(i6)) {
mpSurplusAbnormalD.setUharm6(i6);
useList.add("v_6");
}
Float i7 = compareToOver(overlimit.getUharm7(), Float.parseFloat(mapList.get(0).get("v_7").toString()), flag);
if (Objects.nonNull(i7)) {
mpSurplusAbnormalD.setUharm7(i7);
useList.add("v_7");
}
Float i8 = compareToOver(overlimit.getUharm8(), Float.parseFloat(mapList.get(0).get("v_8").toString()), flag);
if (Objects.nonNull(i8)) {
mpSurplusAbnormalD.setUharm8(i8);
useList.add("v_8");
}
Float i9 = compareToOver(overlimit.getUharm9(), Float.parseFloat(mapList.get(0).get("v_9").toString()), flag);
if (Objects.nonNull(i9)) {
mpSurplusAbnormalD.setUharm9(i9);
useList.add("v_9");
}
Float i10 = compareToOver(overlimit.getUharm10(), Float.parseFloat(mapList.get(0).get("v_10").toString()), flag);
if (Objects.nonNull(i10)) {
mpSurplusAbnormalD.setUharm10(i10);
useList.add("v_10");
}
Float i11 = compareToOver(overlimit.getUharm11(), Float.parseFloat(mapList.get(0).get("v_11").toString()), flag);
if (Objects.nonNull(i11)) {
mpSurplusAbnormalD.setUharm11(i11);
useList.add("v_11");
}
Float i12 = compareToOver(overlimit.getUharm12(), Float.parseFloat(mapList.get(0).get("v_12").toString()), flag);
if (Objects.nonNull(i12)) {
mpSurplusAbnormalD.setUharm12(i12);
useList.add("v_12");
}
Float i13 = compareToOver(overlimit.getUharm13(), Float.parseFloat(mapList.get(0).get("v_13").toString()), flag);
if (Objects.nonNull(i13)) {
mpSurplusAbnormalD.setUharm13(i13);
useList.add("v_13");
}
Float i14 = compareToOver(overlimit.getUharm14(), Float.parseFloat(mapList.get(0).get("v_14").toString()), flag);
if (Objects.nonNull(i14)) {
mpSurplusAbnormalD.setUharm14(i14);
useList.add("v_14");
}
Float i15 = compareToOver(overlimit.getUharm15(), Float.parseFloat(mapList.get(0).get("v_15").toString()), flag);
if (Objects.nonNull(i15)) {
mpSurplusAbnormalD.setUharm15(i15);
useList.add("v_15");
}
Float i16 = compareToOver(overlimit.getUharm16(), Float.parseFloat(mapList.get(0).get("v_16").toString()), flag);
if (Objects.nonNull(i16)) {
mpSurplusAbnormalD.setUharm16(i16);
useList.add("v_16");
}
Float i17 = compareToOver(overlimit.getUharm17(), Float.parseFloat(mapList.get(0).get("v_17").toString()), flag);
if (Objects.nonNull(i17)) {
mpSurplusAbnormalD.setUharm17(i17);
useList.add("v_17");
}
Float i18 = compareToOver(overlimit.getUharm18(), Float.parseFloat(mapList.get(0).get("v_18").toString()), flag);
if (Objects.nonNull(i18)) {
mpSurplusAbnormalD.setUharm18(i18);
useList.add("v_18");
}
Float i19 = compareToOver(overlimit.getUharm19(), Float.parseFloat(mapList.get(0).get("v_19").toString()), flag);
if (Objects.nonNull(i19)) {
mpSurplusAbnormalD.setUharm19(i19);
useList.add("v_19");
}
Float i20 = compareToOver(overlimit.getUharm20(), Float.parseFloat(mapList.get(0).get("v_20").toString()), flag);
if (Objects.nonNull(i20)) {
mpSurplusAbnormalD.setUharm20(i20);
useList.add("v_20");
}
Float i21 = compareToOver(overlimit.getUharm21(), Float.parseFloat(mapList.get(0).get("v_21").toString()), flag);
if (Objects.nonNull(i21)) {
mpSurplusAbnormalD.setUharm3(i21);
}
Float i22 = compareToOver(overlimit.getUharm22(), Float.parseFloat(mapList.get(0).get("v_22").toString()), flag);
if (Objects.nonNull(i22)) {
mpSurplusAbnormalD.setUharm22(i22);
useList.add("v_22");
}
Float i23 = compareToOver(overlimit.getUharm23(), Float.parseFloat(mapList.get(0).get("v_23").toString()), flag);
if (Objects.nonNull(i23)) {
mpSurplusAbnormalD.setUharm23(i23);
useList.add("v_23");
}
Float i24 = compareToOver(overlimit.getUharm24(), Float.parseFloat(mapList.get(0).get("v_24").toString()), flag);
if (Objects.nonNull(i24)) {
mpSurplusAbnormalD.setUharm2(i24);
useList.add("v_24");
}
Float i25 = compareToOver(overlimit.getUharm25(), Float.parseFloat(mapList.get(0).get("v_25").toString()), flag);
if (Objects.nonNull(i25)) {
mpSurplusAbnormalD.setUharm25(i25);
useList.add("v_25");
//三项电压不平衡度
if (vMap.get("CP95").getVUnbalance() > (Double) overLimit.get("ubalance")) {
mpSurplusAbnormalCp95.setUbalance(vMap.get("CP95").getVUnbalance().floatValue());
mpSurplusAbnormalAvg.setUbalance(vMap.get("AVG").getVUnbalance().floatValue());
mpSurplusAbnormalMin.setUbalance(vMap.get("MIN").getVUnbalance().floatValue());
mpSurplusAbnormalMax.setUbalance(vMap.get("MAX").getVUnbalance().floatValue());
flag = true;
}
if (CollUtil.isNotEmpty(useList)) {
assTest(useList,bang,"data_harmrate_v",1,mpSurplusAbnormalDMax,mpSurplusAbnormalDMin,mpSurplusAbnormalDAvg);
//电压畸变
if (vMap.get("CP95").getVThd() > (Double) overLimit.get("uaberrance")) {
mpSurplusAbnormalCp95.setUaberrance(vMap.get("CP95").getVThd().floatValue());
mpSurplusAbnormalAvg.setUaberrance(vMap.get("AVG").getVThd().floatValue());
mpSurplusAbnormalMin.setUaberrance(vMap.get("MIN").getVThd().floatValue());
mpSurplusAbnormalMax.setUaberrance(vMap.get("MAX").getVThd().floatValue());
flag = true;
}
//频率偏差
if (Math.abs(vMap.get("MAX").getFreqDev()) > (Double) overLimit.get("freq_dev") || Math.abs(vMap.get("MIN").getFreqDev()) > (Double) overLimit.get("freq_dev")) {
mpSurplusAbnormalCp95.setFreq(vMap.get("CP95").getFreqDev().floatValue());
mpSurplusAbnormalAvg.setFreq(vMap.get("AVG").getFreqDev().floatValue());
mpSurplusAbnormalMin.setFreq(vMap.get("MIN").getFreqDev().floatValue());
mpSurplusAbnormalMax.setFreq(vMap.get("MAX").getFreqDev().floatValue());
flag = true;
}
//电压上偏差
if (Math.abs(vMap.get("MAX").getVlDev()) > (Double) overLimit.get("voltage_dev")) {
mpSurplusAbnormalCp95.setVoltageDev(vMap.get("CP95").getVlDev().floatValue());
mpSurplusAbnormalAvg.setVoltageDev(vMap.get("AVG").getVlDev().floatValue());
mpSurplusAbnormalMin.setVoltageDev(vMap.get("MIN").getVlDev().floatValue());
mpSurplusAbnormalMax.setVoltageDev(vMap.get("MAX").getVlDev().floatValue());
flag = true;
}
}
/*2-25次谐波电流*/
StringBuilder tem1 = new StringBuilder();
for (int i = 2; i < 26; i++) {
if (i == 25) {
tem1.append("MAX(i_").append(i).append(") as ").append("i_").append(i);
} else {
tem1.append("MAX(i_").append(i).append(") as ").append("i_").append(i).append(",");
//负序电流
if (dataIMap.containsKey(phasic)) {
List<RStatDataIDPO> mapList = dataIMap.get(phasic);
Map<String, RStatDataIDPO> inegMap = mapList.stream().collect(Collectors.toMap(RStatDataIDPO::getValueType, Function.identity()));
if (inegMap.get("CP95").getINeg() > (Double) overLimit.get("i_neg")) {
mpSurplusAbnormalCp95.setINeg(inegMap.get("CP95").getINeg().floatValue());
mpSurplusAbnormalAvg.setINeg(inegMap.get("AVG").getINeg().floatValue());
mpSurplusAbnormalMin.setINeg(inegMap.get("MIN").getINeg().floatValue());
mpSurplusAbnormalMax.setINeg(inegMap.get("MAX").getINeg().floatValue());
flag = true;
}
}
String sqlData_I = "select " + tem1 + " from data_i "+bang+ " and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_I = influxDbUtils.getMapResult(sqlData_I);
if (CollUtil.isNotEmpty(mapData_I)) {
List<String> useList = new ArrayList<>();
Float i2 = compareToOver(overlimit.getIharm2(), Float.parseFloat(mapData_I.get(0).get("i_2").toString()), flag);
if (Objects.nonNull(i2)) {
mpSurplusAbnormalD.setIharm2(i2);
useList.add("i_2");
}
Float i3 = compareToOver(overlimit.getIharm3(), Float.parseFloat(mapData_I.get(0).get("i_3").toString()), flag);
if (Objects.nonNull(i3)) {
mpSurplusAbnormalD.setIharm3(i3);
useList.add("i_3");
}
Float i4 = compareToOver(overlimit.getIharm4(), Float.parseFloat(mapData_I.get(0).get("i_4").toString()), flag);
if (Objects.nonNull(i4)) {
mpSurplusAbnormalD.setIharm4(i4);
useList.add("i_4");
}
Float i5 = compareToOver(overlimit.getIharm5(), Float.parseFloat(mapData_I.get(0).get("i_5").toString()), flag);
if (Objects.nonNull(i5)) {
mpSurplusAbnormalD.setIharm5(i5);
useList.add("i_5");
}
Float i6 = compareToOver(overlimit.getIharm6(), Float.parseFloat(mapData_I.get(0).get("i_6").toString()), flag);
if (Objects.nonNull(i6)) {
mpSurplusAbnormalD.setIharm6(i6);
useList.add("i_6");
}
Float i7 = compareToOver(overlimit.getIharm7(), Float.parseFloat(mapData_I.get(0).get("i_7").toString()), flag);
if (Objects.nonNull(i7)) {
mpSurplusAbnormalD.setIharm7(i7);
useList.add("i_7");
}
Float i8 = compareToOver(overlimit.getIharm8(), Float.parseFloat(mapData_I.get(0).get("i_8").toString()), flag);
if (Objects.nonNull(i8)) {
mpSurplusAbnormalD.setIharm8(i8);
useList.add("i_8");
}
Float i9 = compareToOver(overlimit.getIharm9(), Float.parseFloat(mapData_I.get(0).get("i_9").toString()), flag);
if (Objects.nonNull(i9)) {
mpSurplusAbnormalD.setIharm9(i9);
useList.add("i_9");
}
Float i10 = compareToOver(overlimit.getIharm10(), Float.parseFloat(mapData_I.get(0).get("i_10").toString()), flag);
if (Objects.nonNull(i10)) {
mpSurplusAbnormalD.setIharm10(i10);
useList.add("i_10");
}
Float i11 = compareToOver(overlimit.getIharm11(), Float.parseFloat(mapData_I.get(0).get("i_11").toString()), flag);
if (Objects.nonNull(i11)) {
mpSurplusAbnormalD.setIharm11(i11);
useList.add("i_11");
}
Float i12 = compareToOver(overlimit.getIharm12(), Float.parseFloat(mapData_I.get(0).get("i_12").toString()), flag);
if (Objects.nonNull(i12)) {
mpSurplusAbnormalD.setIharm12(i12);
useList.add("i_12");
}
Float i13 = compareToOver(overlimit.getIharm13(), Float.parseFloat(mapData_I.get(0).get("i_13").toString()), flag);
if (Objects.nonNull(i13)) {
mpSurplusAbnormalD.setIharm13(i13);
useList.add("i_13");
}
Float i14 = compareToOver(overlimit.getIharm14(), Float.parseFloat(mapData_I.get(0).get("i_14").toString()), flag);
if (Objects.nonNull(i14)) {
mpSurplusAbnormalD.setIharm14(i14);
useList.add("i_14");
}
Float i15 = compareToOver(overlimit.getIharm15(), Float.parseFloat(mapData_I.get(0).get("i_15").toString()), flag);
if (Objects.nonNull(i15)) {
mpSurplusAbnormalD.setIharm15(i15);
useList.add("i_15");
}
Float i16 = compareToOver(overlimit.getIharm16(), Float.parseFloat(mapData_I.get(0).get("i_16").toString()), flag);
if (Objects.nonNull(i16)) {
mpSurplusAbnormalD.setIharm16(i16);
useList.add("i_16");
}
Float i17 = compareToOver(overlimit.getIharm17(), Float.parseFloat(mapData_I.get(0).get("i_17").toString()), flag);
if (Objects.nonNull(i17)) {
mpSurplusAbnormalD.setIharm17(i17);
useList.add("i_17");
}
Float i18 = compareToOver(overlimit.getIharm18(), Float.parseFloat(mapData_I.get(0).get("i_18").toString()), flag);
if (Objects.nonNull(i18)) {
mpSurplusAbnormalD.setIharm18(i18);
useList.add("i_18");
}
Float i19 = compareToOver(overlimit.getIharm19(), Float.parseFloat(mapData_I.get(0).get("i_19").toString()), flag);
if (Objects.nonNull(i19)) {
mpSurplusAbnormalD.setIharm19(i19);
useList.add("i_19");
}
Float i20 = compareToOver(overlimit.getIharm20(), Float.parseFloat(mapData_I.get(0).get("i_20").toString()), flag);
if (Objects.nonNull(i20)) {
mpSurplusAbnormalD.setIharm20(i20);
useList.add("i_20");
}
Float i21 = compareToOver(overlimit.getIharm21(), Float.parseFloat(mapData_I.get(0).get("i_21").toString()), flag);
if (Objects.nonNull(i21)) {
mpSurplusAbnormalD.setIharm3(i21);
useList.add("i_21");
}
Float i22 = compareToOver(overlimit.getIharm22(), Float.parseFloat(mapData_I.get(0).get("i_22").toString()), flag);
if (Objects.nonNull(i22)) {
mpSurplusAbnormalD.setIharm22(i22);
useList.add("i_22");
}
Float i23 = compareToOver(overlimit.getIharm23(), Float.parseFloat(mapData_I.get(0).get("i_23").toString()), flag);
if (Objects.nonNull(i23)) {
mpSurplusAbnormalD.setIharm23(i23);
useList.add("i_23");
}
Float i24 = compareToOver(overlimit.getIharm24(), Float.parseFloat(mapData_I.get(0).get("i_24").toString()), flag);
if (Objects.nonNull(i24)) {
mpSurplusAbnormalD.setIharm2(i24);
useList.add("i_24");
}
Float i25 = compareToOver(overlimit.getIharm25(), Float.parseFloat(mapData_I.get(0).get("i_25").toString()), flag);
if (Objects.nonNull(i25)) {
mpSurplusAbnormalD.setIharm25(i25);
useList.add("i_25");
}
if (CollUtil.isNotEmpty(useList)) {
assTest(useList,bang,"data_i",2,mpSurplusAbnormalDMax,mpSurplusAbnormalDMin,mpSurplusAbnormalDAvg);
//长时闪变
if (dataPltMap.containsKey(phasic)) {
List<RStatDataPltDPO> mapList = dataPltMap.get(phasic);
Map<String, RStatDataPltDPO> pltMap = mapList.stream().collect(Collectors.toMap(RStatDataPltDPO::getValueType, Function.identity()));
if (pltMap.get("MAX").getPlt() > (Double) overLimit.get("flicker")) {
mpSurplusAbnormalCp95.setFlicker(pltMap.get("CP95").getPlt().floatValue());
mpSurplusAbnormalAvg.setFlicker(pltMap.get("AVG").getPlt().floatValue());
mpSurplusAbnormalMin.setFlicker(pltMap.get("MIN").getPlt().floatValue());
mpSurplusAbnormalMax.setFlicker(pltMap.get("MAX").getPlt().floatValue());
flag = true;
}
}
/*0.5-15.5次间谐波电压含有率*/
StringBuilder tem2 = new StringBuilder();
for (int i = 1; i < 17; i++) {
if (i == 16) {
tem2.append("MAX(i_").append(i).append(") as ").append("i_").append(i);
} else {
tem2.append("MAX(i_").append(i).append(") as ").append("i_").append(i).append(",");
//谐波电压
dealData(tenMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,2,26,1,"uharm_","v_");
//谐波电流
dealData(iMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,2,26,2,"iharm_","i_");
//间谐波电压
dealData(inMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,1,17,3,"inuharm_","v_");
if(flag){
all.add(mpSurplusAbnormalCp95);
all.add(mpSurplusAbnormalAvg);
all.add(mpSurplusAbnormalMax);
all.add(mpSurplusAbnormalMin);
}
}
String sqlData_Ih = "select " + tem2 + " from data_inharm_v "+bang+ " and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_Ih = influxDbUtils.getMapResult(sqlData_Ih);
if (CollUtil.isNotEmpty(mapData_Ih)) {
List<String> useList = new ArrayList<>();
Float i1 = compareToOver(overlimit.getInuharm2(), Float.parseFloat(mapData_Ih.get(0).get("v_1").toString()), flag);
if (Objects.nonNull(i1)) {
mpSurplusAbnormalD.setInuharm1(i1);
useList.add("v_1");
}
Float i2 = compareToOver(overlimit.getInuharm2(), Float.parseFloat(mapData_Ih.get(0).get("v_2").toString()), flag);
if (Objects.nonNull(i2)) {
mpSurplusAbnormalD.setInuharm2(i2);
useList.add("v_2");
}
Float i3 = compareToOver(overlimit.getInuharm3(), Float.parseFloat(mapData_Ih.get(0).get("v_3").toString()), flag);
if (Objects.nonNull(i3)) {
mpSurplusAbnormalD.setInuharm3(i3);
useList.add("v_3");
}
Float i4 = compareToOver(overlimit.getInuharm4(), Float.parseFloat(mapData_Ih.get(0).get("v_4").toString()), flag);
if (Objects.nonNull(i4)) {
mpSurplusAbnormalD.setInuharm4(i4);
useList.add("v_4");
}
Float i5 = compareToOver(overlimit.getInuharm5(), Float.parseFloat(mapData_Ih.get(0).get("v_5").toString()), flag);
if (Objects.nonNull(i5)) {
mpSurplusAbnormalD.setInuharm5(i5);
useList.add("v_5");
}
Float i6 = compareToOver(overlimit.getInuharm6(), Float.parseFloat(mapData_Ih.get(0).get("v_6").toString()), flag);
if (Objects.nonNull(i6)) {
mpSurplusAbnormalD.setInuharm6(i6);
useList.add("v_6");
}
Float i7 = compareToOver(overlimit.getInuharm7(), Float.parseFloat(mapData_Ih.get(0).get("v_7").toString()), flag);
if (Objects.nonNull(i7)) {
mpSurplusAbnormalD.setInuharm7(i7);
useList.add("v_7");
}
Float i8 = compareToOver(overlimit.getInuharm8(), Float.parseFloat(mapData_Ih.get(0).get("v_8").toString()), flag);
if (Objects.nonNull(i8)) {
mpSurplusAbnormalD.setInuharm8(i8);
useList.add("v_8");
}
Float i9 = compareToOver(overlimit.getInuharm9(), Float.parseFloat(mapData_Ih.get(0).get("v_9").toString()), flag);
if (Objects.nonNull(i9)) {
mpSurplusAbnormalD.setInuharm9(i9);
useList.add("v_9");
}
Float i10 = compareToOver(overlimit.getInuharm10(), Float.parseFloat(mapData_Ih.get(0).get("v_10").toString()), flag);
if (Objects.nonNull(i10)) {
mpSurplusAbnormalD.setInuharm10(i10);
useList.add("v_10");
}
Float i11 = compareToOver(overlimit.getInuharm11(), Float.parseFloat(mapData_Ih.get(0).get("v_11").toString()), flag);
if (Objects.nonNull(i11)) {
mpSurplusAbnormalD.setInuharm11(i11);
useList.add("v_11");
}
Float i12 = compareToOver(overlimit.getInuharm12(), Float.parseFloat(mapData_Ih.get(0).get("v_12").toString()), flag);
if (Objects.nonNull(i12)) {
mpSurplusAbnormalD.setInuharm12(i12);
useList.add("v_12");
}
Float i13 = compareToOver(overlimit.getInuharm13(), Float.parseFloat(mapData_Ih.get(0).get("v_13").toString()), flag);
if (Objects.nonNull(i13)) {
mpSurplusAbnormalD.setInuharm13(i13);
useList.add("v_13");
}
Float i14 = compareToOver(overlimit.getInuharm14(), Float.parseFloat(mapData_Ih.get(0).get("v_14").toString()), flag);
if (Objects.nonNull(i14)) {
mpSurplusAbnormalD.setInuharm14(i14);
useList.add("v_14");
}
Float i15 = compareToOver(overlimit.getInuharm15(), Float.parseFloat(mapData_Ih.get(0).get("v_15").toString()), flag);
if (Objects.nonNull(i15)) {
mpSurplusAbnormalD.setInuharm15(i15);
useList.add("v_15");
}
Float i16 = compareToOver(overlimit.getInuharm16(), Float.parseFloat(mapData_Ih.get(0).get("v_16").toString()), flag);
if (Objects.nonNull(i16)) {
mpSurplusAbnormalD.setInuharm16(i16);
useList.add("v_16");
}
if (CollUtil.isNotEmpty(useList)) {
assTest(useList,bang,"data_inharm_v",3,mpSurplusAbnormalDMax,mpSurplusAbnormalDMin,mpSurplusAbnormalDAvg);
}
}
/*电压总谐波畸变率*/
String sqlData_Vthd = "select MAX(v_thd) as v_thd from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_Vthd = influxDbUtils.getMapResult(sqlData_Vthd);
if (CollUtil.isNotEmpty(mapData_Vthd)) {
float thd = Float.parseFloat(mapData_Vthd.get(0).get("v_thd").toString());
if (thd > overlimit.getUaberrance()) {
mpSurplusAbnormalD.setUaberrance(thd);
String vthMax = "select MAX(v_thd) as v_thd from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMax = influxDbUtils.getMapResult(vthMax);
mpSurplusAbnormalDMax.setUaberrance(Float.parseFloat(map_vthMax.get(0).get("v_thd").toString()));
String vthMin = "select MIN(v_thd) as v_thd from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMin.setUaberrance(Float.parseFloat(map_vthMin.get(0).get("v_thd").toString()));
String vthAvg = "select MEAN(v_thd) as v_thd from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setUaberrance(Float.parseFloat(map_vthAvg.get(0).get("v_thd").toString()));
flag = false;
}
}
/*负序电压不平衡度*/
String sqlData_Unbalance_Max = "select MAX(v_unbalance) as v_unbalance from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
String sqlData_Unbalance_CP95 = "select MAX(v_unbalance) as v_unbalance from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_Unbalance_Max = influxDbUtils.getMapResult(sqlData_Unbalance_Max);
List<Map<String, Object>> mapData_Unbalance_Cp95 = influxDbUtils.getMapResult(sqlData_Unbalance_CP95);
if (CollUtil.isNotEmpty(mapData_Unbalance_Max) && CollUtil.isNotEmpty(mapData_Unbalance_Cp95)) {
float ubMax = Float.parseFloat(mapData_Unbalance_Max.get(0).get("v_unbalance").toString());
float ubCp95 = Float.parseFloat(mapData_Unbalance_Cp95.get(0).get("v_unbalance").toString());
if (ubMax > overlimit.getUbalance() && ubCp95 > overlimit.getUbalance()) {
mpSurplusAbnormalD.setUbalance(ubCp95);
mpSurplusAbnormalDMax.setUbalance(ubMax);
String vthMin = "select MIN(v_unbalance) as v_unbalance from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMin.setUaberrance(Float.parseFloat(map_vthMin.get(0).get("v_unbalance").toString()));
String vthAvg = "select MEAN(v_unbalance) as v_unbalance from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setUaberrance(Float.parseFloat(map_vthAvg.get(0).get("v_unbalance").toString()));
flag = false;
}
}
/*负序电流*/
String sqlData_Neg_Max = "select MAX(i_neg) as i_neg from data_i where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
String sqlData_Neg_CP95 = "select MAX(i_neg) as i_neg from data_i where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_Neg_Max = influxDbUtils.getMapResult(sqlData_Neg_Max);
List<Map<String, Object>> mapData_Neg_Cp95 = influxDbUtils.getMapResult(sqlData_Neg_CP95);
if (CollUtil.isNotEmpty(mapData_Neg_Max) && CollUtil.isNotEmpty(mapData_Neg_Cp95)) {
float negMax = Float.parseFloat(mapData_Neg_Max.get(0).get("i_neg").toString());
float negCp95 = Float.parseFloat(mapData_Neg_Cp95.get(0).get("i_neg").toString());
if (negMax > overlimit.getINeg() && negCp95 > overlimit.getINeg()) {
mpSurplusAbnormalD.setINeg(negCp95);
mpSurplusAbnormalDMax.setINeg(negMax);
String vthMin = "select MIN(i_neg) as i_neg from data_i where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMin.setINeg(Float.parseFloat(map_vthMin.get(0).get("i_neg").toString()));
String vthAvg = "select MEAN(i_neg) as i_neg from data_i where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setINeg(Float.parseFloat(map_vthAvg.get(0).get("i_neg").toString()));
flag = false;
}
}
/*频率偏差、电压偏差*/
String sqlData_vu_Max = "select MAX(vu_dev) as vu_dev,MAX(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
String sqlData_vl_Min = "select MIN(vl_dev) as vl_dev,MIN(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_vu_Max = influxDbUtils.getMapResult(sqlData_vu_Max);
List<Map<String, Object>> mapData_vl_Min = influxDbUtils.getMapResult(sqlData_vl_Min);
if (CollUtil.isNotEmpty(mapData_vu_Max) && CollUtil.isNotEmpty(mapData_vl_Min)) {
float vuMax = Float.parseFloat(mapData_vu_Max.get(0).get("vu_dev").toString());
float freqMax = Float.parseFloat(mapData_vu_Max.get(0).get("freq_dev").toString());
if (vuMax > overlimit.getVoltageDev()) {
mpSurplusAbnormalDMax.setVoltageDev(vuMax);
String vthCp95 = "select MAX(vu_dev) as vu_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthCp95 = influxDbUtils.getMapResult(vthCp95);
mpSurplusAbnormalD.setVoltageDev(Float.parseFloat(map_vthCp95.get(0).get("vu_dev").toString()));
String vthMin = "select MIN(vu_dev) as vu_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMin.setVoltageDev(Float.parseFloat(map_vthMin.get(0).get("vu_dev").toString()));
String vthAvg = "select MEAN(vu_dev) as vu_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setVoltageDev(Float.parseFloat(map_vthAvg.get(0).get("vu_dev").toString()));
flag = false;
}
if (Math.abs(freqMax) > overlimit.getFreqDev()) {
mpSurplusAbnormalD.setFreq(freqMax);
String vthCp95 = "select MAX(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthCp95 = influxDbUtils.getMapResult(vthCp95);
mpSurplusAbnormalD.setFreq(Float.parseFloat(map_vthCp95.get(0).get("freq_dev").toString()));
String vthMin = "select MIN(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMin.setFreq(Float.parseFloat(map_vthMin.get(0).get("freq_dev").toString()));
String vthAvg = "select MEAN(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setFreq(Float.parseFloat(map_vthAvg.get(0).get("freq_dev").toString()));
flag = false;
}
float vlMin = Float.parseFloat(mapData_vl_Min.get(0).get("vl_dev").toString());
float freqMin = Float.parseFloat(mapData_vl_Min.get(0).get("freq_dev").toString());
if (vlMin < overlimit.getUvoltageDev()) {
mpSurplusAbnormalDMin.setUvoltageDev(vuMax);
String vthCp95 = "select MAX(vl_dev) as vl_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthCp95 = influxDbUtils.getMapResult(vthCp95);
mpSurplusAbnormalD.setUvoltageDev(Float.parseFloat(map_vthCp95.get(0).get("vl_dev").toString()));
String vthMin = "select MIN(vl_dev) as vl_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMax.setUvoltageDev(Float.parseFloat(map_vthMin.get(0).get("vl_dev").toString()));
String vthAvg = "select MEAN(vl_dev) as vl_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setUvoltageDev(Float.parseFloat(map_vthAvg.get(0).get("vl_dev").toString()));
flag = false;
}
if (Math.abs(freqMin) > overlimit.getFreqDev()) {
mpSurplusAbnormalD.setFreq(freqMin);
String vthCp95 = "select MAX(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthCp95 = influxDbUtils.getMapResult(vthCp95);
mpSurplusAbnormalD.setFreq(Float.parseFloat(map_vthCp95.get(0).get("freq_dev").toString()));
String vthMin = "select MIN(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMax.setFreq(Float.parseFloat(map_vthMin.get(0).get("freq_dev").toString()));
String vthAvg = "select MEAN(freq_dev) as freq_dev from data_v where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setFreq(Float.parseFloat(map_vthAvg.get(0).get("freq_dev").toString()));
flag = false;
}
}
/*长时闪变*/
String sqlData_plt_Max = "select MAX(plt) as plt from data_plt where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> mapData_plt = influxDbUtils.getMapResult(sqlData_plt_Max);
if (CollUtil.isNotEmpty(mapData_plt)) {
float thd = Float.parseFloat(mapData_plt.get(0).get("plt").toString());
if (thd > overlimit.getFlicker()) {
mpSurplusAbnormalD.setFlicker(thd);
String vthCp95 = "select MAX(plt) as plt from data_plt where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'CP95'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthCp95 = influxDbUtils.getMapResult(vthCp95);
mpSurplusAbnormalD.setFlicker(Float.parseFloat(map_vthCp95.get(0).get("plt").toString()));
String vthMin = "select MIN(plt) as plt from data_plt where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthMin = influxDbUtils.getMapResult(vthMin);
mpSurplusAbnormalDMax.setFlicker(Float.parseFloat(map_vthMin.get(0).get("plt").toString()));
String vthAvg = "select MEAN(plt) as plt from data_plt where line_id ='" + lineIndex + "' " + lastSql + " and phasic_type = '" + phasic + "' and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_vthAvg = influxDbUtils.getMapResult(vthAvg);
mpSurplusAbnormalDAvg.setFlicker(Float.parseFloat(map_vthAvg.get(0).get("plt").toString()));
flag = false;
}
}
if (!flag) {
all.add(mpSurplusAbnormalD);
all.add(mpSurplusAbnormalDMax);
all.add(mpSurplusAbnormalDMin);
all.add(mpSurplusAbnormalDAvg);
}
}
}
if (CollUtil.isNotEmpty(all)) {
//入库操作
this.saveBatch(all);
this.saveBatch(all,1000);
}
}
log.info("运行时长："+timeInterval.intervalSecond());
return true;
}
}
private Float compareToOver(Float overLimit, Float value, Boolean flag) {
if (value > overLimit) {
flag = false;
return value;
}
return null;
}
private void assPojoI(Map<String, Object> map, MpSurplusAbnormalD mpSurplusAbnormalD,Integer type){
if(type == 1){
/**
* type 1.谐波电压含有率 2.谐波电流幅值 其他.间谐波电流
*
* @author cdf
* @date 2023/8/22
*/
private void assPojo(Map<String, Object> map, MpSurplusAbnormalD mpSurplusAbnormalD, Integer type) {
if (type == 1) {
//谐波电压
map.forEach((key, val) -> {
switch (key) {
@@ -804,7 +365,7 @@ public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplu
}
});
}else if(type == 2){
} else if (type == 2) {
//谐波电流
map.forEach((key, val) -> {
switch (key) {
@@ -886,8 +447,8 @@ public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplu
throw new IllegalStateException("Unexpected value: " + key);
}
});
}else {
//间谐波电流
} else {
//间谐波电压
map.forEach((key, val) -> {
switch (key) {
case "v_1":
@@ -951,37 +512,48 @@ public class NormalLimitServiceImpl extends ServiceImpl<AbnormalMapper, MpSurplu
private void assTest(List<String> useList,String bang,String table,Integer type,MpSurplusAbnormalD mpSurplusAbnormalDMax,MpSurplusAbnormalD mpSurplusAbnormalDMin,MpSurplusAbnormalD mpSurplusAbnormalDAvg){
StringBuilder uMax = new StringBuilder();
StringBuilder uMin = new StringBuilder();
for (int i = 0; i < useList.size(); i++) {
if (i == useList.size() - 1) {
uMax.append("MAX(").append(useList.get(i)).append(") as ").append(useList.get(i));
uMin.append("MIN(").append(useList.get(i)).append(") as ").append(useList.get(i));
} else {
uMax.append("MAX(").append(useList.get(i)).append(") as ").append(useList.get(i)).append(",");
uMin.append("MIN(").append(useList.get(i)).append(") as ").append(useList.get(i)).append(",");
/**
*
* @author cdf
* @date 2023/8/23
*/
private void dealData(Map<String, List<Map<String, Object>>> inMap,
String phasic,Map<String, Object> overLimit,
Boolean flag,MpSurplusAbnormalD mpSurplusAbnormalCp95,MpSurplusAbnormalD mpSurplusAbnormalAvg,MpSurplusAbnormalD mpSurplusAbnormalMax,MpSurplusAbnormalD mpSurplusAbnormalMin
,int start,int count,int type,String overTag,String temTag){
if (inMap.containsKey(phasic)) {
List<Map<String, Object>> mapList = inMap.get(phasic);
Map<String, Map<String, Object>> harmMap = mapList.stream().collect(Collectors.toMap(item -> item.get("value_type").toString(), Function.identity()));
Map<String, Object> mCP95 = harmMap.get("CP95");
Map<String, Object> mAVG = harmMap.get("AVG");
Map<String, Object> mMAX = harmMap.get("MAX");
Map<String, Object> mMIN = harmMap.get("MIN");
Map<String, Object> moreValueCp95 = new HashMap<>();
Map<String, Object> moreValueAvg = new HashMap<>();
Map<String, Object> moreValueMax = new HashMap<>();
Map<String, Object> moreValueMin = new HashMap<>();
for (int i = start; i < count; i++) {
BigDecimal hv = (BigDecimal) mCP95.get(temTag + i);
String t = overTag + i;
BigDecimal over = BigDecimal.valueOf((Double) overLimit.get(t));
if (hv.compareTo(over) > 0) {
moreValueCp95.put(temTag + i, hv.floatValue());
moreValueAvg.put(temTag + i, mAVG.get(temTag + i));
moreValueMax.put(temTag + i, mMAX.get(temTag + i));
moreValueMin.put(temTag + i, mMIN.get(temTag + i));
}
}
String sqlMAX = "select " + uMax + " from "+table+bang +" and value_type = 'MAX'" + InfluxDBPublicParam.TIME_ZONE;
String sqlMIN = "select " + uMin + " from "+table+bang +" and value_type = 'MIN'" + InfluxDBPublicParam.TIME_ZONE;
String sqlAVG = "select " + uMax + " from "+table+bang +" and value_type = 'AVG'" + InfluxDBPublicParam.TIME_ZONE;
List<Map<String, Object>> map_MAX = influxDbUtils.getMapResult(sqlMAX);
if (CollUtil.isNotEmpty(map_MAX)) {
assPojoI(map_MAX.get(0),mpSurplusAbnormalDMax,type);
if (moreValueCp95.size() > 0) {
flag = true;
assPojo(moreValueCp95, mpSurplusAbnormalCp95, type);
assPojo(moreValueAvg, mpSurplusAbnormalAvg, type);
assPojo(moreValueMax, mpSurplusAbnormalMax, type);
assPojo(moreValueMin, mpSurplusAbnormalMin, type);
}
List<Map<String, Object>> map_MIN = influxDbUtils.getMapResult(sqlMIN);
if (CollUtil.isNotEmpty(map_MIN)) {
assPojoI(map_MIN.get(0),mpSurplusAbnormalDMin,type);
}
List<Map<String, Object>> map_AVG = influxDbUtils.getMapResult(sqlAVG);
if (CollUtil.isNotEmpty(map_AVG)) {
assPojoI(map_AVG.get(0),mpSurplusAbnormalDAvg,type);
}
}

2
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/line/NormalLimitService.java
View File

@@ -13,7 +13,7 @@ public interface NormalLimitService extends IService<MpSurplusAbnormalD> {
Boolean AbnormalLineData(LineParam lineParam);
Boolean abnormalLineData(LineParam lineParam);
}