package com.gyee.generation.service; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.gyee.common.contant.ContantXk; import com.gyee.common.model.PointData; import com.gyee.generation.init.CacheContext; import com.gyee.generation.model.auto.*; import com.gyee.generation.model.vo.CureFittingVo; import com.gyee.generation.model.vo.PointVo; import com.gyee.generation.model.vo.PointfVo; import com.gyee.generation.service.auto.*; import com.gyee.generation.util.DateUtils; import com.gyee.generation.util.StringUtils; import com.gyee.generation.util.realtimesource.IEdosUtil; import com.gyee.generation.util.realtimesource.math.LineUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Service; import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; @Service public class PowerCurveFittingByTimeService { private static final Logger logger = LoggerFactory.getLogger(PowerCurveFittingByTimeService.class); @Resource private IEdosUtil edosUtil; @Value("${curvefitting.dimension}") private Integer dimension; @Value("${curvefitting.scale}") private Double scale; @Value("${initialcode}") private String initialcode; public Map windturbineCapacity; @Resource private IProEconWtCurveFittingMonthService proEconWtCurveFittingMonthService; @Resource private IProEconWtCurveFittingYearService proEconWtCurveFittingYearService; @Resource private IProEconWtCurveFittingService proEconWtCurveFittingService; @Resource private IProEconCurveFittingMainService proEconCurveFittingMainService; @Resource private IProEconCurveFittingSubService proEconCurveFittingSubService; @Resource private IProEconCurveFittMonthMainService proEconCurveFittMonthMainService; @Resource private IProEconCurveFittMonthSubService proEconCurveFittMonthSubService; @Resource private IProEconWtPowerCurveFittingService proEconWtPowerCurveFittingService; @Resource private IProEconCurveFittYearSubService proEconCurveFittYearSubService; @Resource private IProEconCurveFittYearMainService proEconCurveFittYearMainService; public void cureFittingDay(Date recordDate) throws Exception { //日期变为昨天 Date end = DateUtils.addDays(DateUtils.truncate(recordDate), -1); Calendar c = Calendar.getInstance(); c.setTime(end); Date begin = DateUtils.addDays(end, -6); Map windMap = new HashMap<>(); //初始化风机装机容量 if (windturbineCapacity == null) { windturbineCapacity = new HashMap<>(); Map modelMap = CacheContext.modelMap; for (ProBasicEquipment windturbine : CacheContext.wtls) { if (modelMap.containsKey(windturbine.getModelId())) { windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction()); } } } for (ProBasicEquipment wt : CacheContext.wtls) { String windturbineId = wt.getId(); Map windturbinetestingpointnewMap = CacheContext.wtpAimap.get(wt.getId()); //设备有功功率 String pointIdGL = windturbinetestingpointnewMap.get(ContantXk.CJ_SSGL).getNemCode(); //设备明细状态 String pointIdZT = windturbinetestingpointnewMap.get(ContantXk.MXZT).getNemCode(); String pointIdFS; if (wt.getWindpowerstationId().contains("GDC")) { //测风塔70米风速 if (windturbinetestingpointnewMap.containsKey(ContantXk.FCCFTFS70)) { ProBasicEquipmentPoint point = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70); if (StringUtils.notEmp(point.getNemCode()) && !point.getNemCode().equals(initialcode)) { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70).getNemCode(); } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { //设备风速 pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } CureFittingVo item = new CureFittingVo(); item.setPointIdFS(pointIdFS); item.setPointIdZT(pointIdZT); item.setPointIdGL(pointIdGL); //获取标杆风机编号 if (CacheContext.wtstandardmap.containsKey(wt.getId())) { item.setStandardId(CacheContext.wtstandardmap.get(wt.getId())); } else { item.setStandardId(wt.getId()); } windMap.put(windturbineId, item); } for (String key : windMap.keySet()) { //初始化集合 windMap.get(key).setYsjglPoints(new ArrayList<>()); windMap.get(key).setYzyglPoints(new ArrayList<>()); windMap.get(key).setRsjglPoints(new ArrayList<>()); windMap.get(key).setRzyglPoints(new ArrayList<>()); windMap.get(key).setNsjglPoints(new ArrayList<>()); windMap.get(key).setNzyglPoints(new ArrayList<>()); if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) { logger.info(key); continue; } //拟合日功率曲线 curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), key); List vos = windMap.get(key).getRsjglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setRsjglPoints(vos); vos = windMap.get(key).getRzyglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setRzyglPoints(vos); } for (String key : windMap.keySet()) { Double modelpower = 1500.0; if (windturbineCapacity.containsKey(key)) { modelpower = windturbineCapacity.get(key); } //日的昨天 List dayLastMonthPoints = new ArrayList<>(); //日的去年同期 List dayLastYearPoints = new ArrayList<>(); //日标准功率 List dayStandardPoints = new ArrayList<>(); //保证功率 List bzglpowerPoints = new ArrayList<>(); if (CacheContext.wtstandardmap.containsKey(key)) { String standardId = CacheContext.wtstandardmap.get(key); if (StringUtils.notEmp(standardId)) { if (windMap.containsKey(key)) { dayStandardPoints = windMap.get(standardId).getRsjglPoints(); } } } //*********************************************日曲线偏差上个日和上一年记录**********************************************************/ Date d1 = DateUtils.addDays(recordDate, -1); Date d2 = DateUtils.addYears(recordDate, -1); List wcfls = proEconWtCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(d1) == 0).sorted(Comparator.comparing(ProEconWtCurveFitting::getSpeed)).collect(Collectors.toList()); dayBuildPoints(wcfls, dayLastMonthPoints); wcfls = proEconWtCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(d2) == 0).sorted(Comparator.comparing(ProEconWtCurveFitting::getSpeed)).collect(Collectors.toList()); //与轶总的原始代码对比不一致，临时修改测试 dayBuildPoints(wcfls, dayLastMonthPoints); //*********************************************日曲线偏差上个月和上一年记录**********************************************************/ if (CacheContext.wtmap.containsKey(key)) { String modelid = CacheContext.wtmap.get(key).getModelId(); if (StringUtils.notEmp(modelid)) { //获取模型功率曲线 if (CacheContext.theoreticalPowerMap.containsKey(modelid)) { for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) { PointVo point = new PointVo(); point.setX(speed); point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower()); bzglpowerPoints.add(point); } } } } //*********************************************当日曲线偏差记录**********************************************************/ Optional cfmdayo = proEconCurveFittingMainService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(recordDate) == 0).findFirst(); ProEconCurveFittingMain cfmday; if (cfmdayo.isPresent()) { cfmday = cfmdayo.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfmday.getId()); proEconCurveFittingMainService.remove(wrapper); } cfmday = new ProEconCurveFittingMain(); cfmday.setWindturbineId(key); cfmday.setRecordDate(DateUtils.truncate(recordDate)); //日---实际/最优 cfmday.setDeviationRate1(pcl(windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), modelpower)); //日---实际/保证 cfmday.setDeviationRate2(pcl(windMap.get(key).getRsjglPoints(), bzglpowerPoints, modelpower)); //日---最优/保证 cfmday.setDeviationRate3(pcl(windMap.get(key).getRzyglPoints(), bzglpowerPoints, modelpower)); //日---实际/上日实际 cfmday.setMonthDeviationRate(pcl(windMap.get(key).getRsjglPoints(), dayLastMonthPoints, modelpower)); //日---实际/同期实际 cfmday.setYearDeviationRate(pcl(windMap.get(key).getRsjglPoints(), dayLastYearPoints, modelpower)); //日---实际/标杆实际 cfmday.setStandardDeviationRate(pcl(windMap.get(key).getRsjglPoints(), dayStandardPoints, modelpower)); proEconCurveFittingMainService.save(cfmday); //*********************************************当日曲线偏差记录**********************************************************/ pLCBuild(key, recordDate, windMap, modelpower, 3, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 4, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 5, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 6, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 7, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 8, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 9, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 10, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 11, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 12, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); pLCBuild(key, recordDate, windMap, modelpower, 13, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints); insertPoints(recordDate, windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), key); logger.info(key); // // logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date())); } } public void cureFittingMonth(Date recordDate) throws Exception { //日期变为昨天 Date end = DateUtils.addDays(DateUtils.truncate(recordDate), -1); Calendar c = Calendar.getInstance(); c.setTime(recordDate); int day_year = c.get(Calendar.YEAR); int day_month = c.get(Calendar.MONTH) + 1; c.set(Calendar.DAY_OF_MONTH, 1); Date begin = c.getTime(); //上个月 c.setTime(DateUtils.addMonths(begin, -1)); int month_year = c.get(Calendar.YEAR); int month_month = c.get(Calendar.MONTH) + 1; //去年同期 c.setTime(DateUtils.addYears(begin, -1)); int year_year = c.get(Calendar.YEAR); int year_month = c.get(Calendar.MONTH) + 1; Map windMap = new HashMap<>(); if (windturbineCapacity == null) { windturbineCapacity = new HashMap<>(); Map modelMap = CacheContext.modelMap; for (ProBasicEquipment windturbine : CacheContext.wtls) { if (modelMap.containsKey(windturbine.getModelId())) { windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction()); } } } for (ProBasicEquipment wt : CacheContext.wtls) { String windturbineId = wt.getId(); Map windturbinetestingpointnewMap = CacheContext.wtpAimap.get(wt.getId()); //设备有功功率 String pointIdGL = windturbinetestingpointnewMap.get(ContantXk.CJ_SSGL).getNemCode(); //设备明细状态 String pointIdZT = windturbinetestingpointnewMap.get(ContantXk.MXZT).getNemCode(); String pointIdFS; if (wt.getWindpowerstationId().contains("GDC")) { //测风塔70米风速 if (windturbinetestingpointnewMap.containsKey(ContantXk.FCCFTFS70)) { ProBasicEquipmentPoint point = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70); if (StringUtils.notEmp(point.getNemCode()) && !point.getNemCode().equals(initialcode)) { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70).getNemCode(); } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { //设备风速 pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } CureFittingVo item = new CureFittingVo(); item.setPointIdFS(pointIdFS); item.setPointIdZT(pointIdZT); item.setPointIdGL(pointIdGL); //获取标杆风机编号 if (CacheContext.wtstandardmap.containsKey(wt.getId())) { item.setStandardId(CacheContext.wtstandardmap.get(wt.getId())); } else { item.setStandardId(wt.getId()); } windMap.put(windturbineId, item); } for (String key : windMap.keySet()) { //初始化集合 windMap.get(key).setYsjglPoints(new ArrayList<>()); windMap.get(key).setYzyglPoints(new ArrayList<>()); windMap.get(key).setRsjglPoints(new ArrayList<>()); windMap.get(key).setRzyglPoints(new ArrayList<>()); windMap.get(key).setNsjglPoints(new ArrayList<>()); windMap.get(key).setNzyglPoints(new ArrayList<>()); if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) { logger.info(key); continue; } //拟合月功率曲线 curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key); List vos = windMap.get(key).getYsjglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setYsjglPoints(vos); vos = windMap.get(key).getYzyglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setYzyglPoints(vos); } for (String key : windMap.keySet()) { Double modelpower = 1500.0; if (windturbineCapacity.containsKey(key)) { modelpower = windturbineCapacity.get(key); } //月的上月 List monthLastMonthPoints = new ArrayList<>(); //月的去年同期 List monthLastYearPoints = new ArrayList<>(); //月标准功率 List monthStandardPoints = new ArrayList<>(); //保证功率 List bzglpowerPoints = new ArrayList<>(); if (CacheContext.wtstandardmap.containsKey(key)) { String standardId = CacheContext.wtstandardmap.get(key); if (StringUtils.notEmp(standardId)) { if (windMap.containsKey(key)) { monthStandardPoints = windMap.get(standardId).getYsjglPoints(); } } } String stringyear = String.valueOf(day_year); String stringmonth = String.valueOf(day_month); String stringyear2 = String.valueOf(month_year); String stringmonth2 = String.valueOf(month_month); String stringyear3 = String.valueOf(year_year); String stringmonth3 = String.valueOf(year_month); //*********************************************月曲线偏差上个月和上一年记录**********************************************************/ List wcfmls = proEconWtCurveFittingMonthService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear2) && i.getMonth().equals(stringmonth2)).sorted(Comparator.comparing(ProEconWtCurveFittingMonth::getSpeed)).collect(Collectors.toList()); monthBuildPoints(wcfmls, monthLastMonthPoints); wcfmls = proEconWtCurveFittingMonthService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear3) && i.getMonth().equals(stringmonth3)).sorted(Comparator.comparing(ProEconWtCurveFittingMonth::getSpeed)).collect(Collectors.toList()); monthBuildPoints(wcfmls, monthLastYearPoints); //*********************************************月曲线偏差上个月和上一年记录**********************************************************/ if (CacheContext.wtmap.containsKey(key)) { String modelid = CacheContext.wtmap.get(key).getModelId(); if (StringUtils.notEmp(modelid)) { //获取模型功率曲线 if (CacheContext.theoreticalPowerMap.containsKey(modelid)) { for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) { PointVo point = new PointVo(); point.setX(speed); point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower()); bzglpowerPoints.add(point); } } } } //*********************************************年曲线偏差记录**********************************************************/ //*********************************************当月曲线偏差记录**********************************************************/ Optional cfmmontho = proEconCurveFittMonthMainService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear) && i.getMonth().equals(stringmonth)).findFirst(); ProEconCurveFittMonthMain cfmmonth; if (cfmmontho.isPresent()) { cfmmonth = cfmmontho.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfmmonth.getId()); proEconCurveFittMonthMainService.remove(wrapper); } cfmmonth = new ProEconCurveFittMonthMain(); cfmmonth.setWindturbineId(key); cfmmonth.setYear(String.valueOf(day_year)); cfmmonth.setMonth(String.valueOf(day_month)); //月---实际/最优 cfmmonth.setDeviationRate1(pcl(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), modelpower)); //月---实际/保证 cfmmonth.setDeviationRate2(pcl(windMap.get(key).getYsjglPoints(), bzglpowerPoints, modelpower)); //月---最优/保证 cfmmonth.setDeviationRate3(pcl(windMap.get(key).getYzyglPoints(), bzglpowerPoints, modelpower)); //月---实际/上月实际 cfmmonth.setMonthDeviationRate(pcl(windMap.get(key).getYsjglPoints(), monthLastMonthPoints, modelpower)); //月---实际/同期实际 cfmmonth.setYearDeviationRate(pcl(windMap.get(key).getYsjglPoints(), monthLastYearPoints, modelpower)); //月---实际/标杆实际 cfmmonth.setStandardDeviationRate(pcl(windMap.get(key).getYsjglPoints(), monthStandardPoints, modelpower)); proEconCurveFittMonthMainService.save(cfmmonth); //*********************************************当月曲线偏差记录**********************************************************/ pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 3, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 4, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 5, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 6, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 7, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 8, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 9, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 10, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 11, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 12, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 13, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints); insertPoints(stringyear, stringmonth, windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key); insertPoints2( windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key); logger.info(key); // // logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date())); } } public void cureFittingYear(Date recordDate) throws Exception { //日期变为昨天 Date end = DateUtils.addDays(DateUtils.truncate(recordDate), -1); Calendar c = Calendar.getInstance(); c.setTime(recordDate); int day_year = c.get(Calendar.YEAR); c.set(Calendar.DAY_OF_MONTH, 1); c.set(Calendar.MONTH, 0); Date begin = c.getTime(); //去年同期 c.setTime(DateUtils.addYears(begin, -1)); int year_year = c.get(Calendar.YEAR); Map windMap = new HashMap<>(); if (windturbineCapacity == null) { windturbineCapacity = new HashMap<>(); Map modelMap = CacheContext.modelMap; for (ProBasicEquipment windturbine : CacheContext.wtls) { if (modelMap.containsKey(windturbine.getModelId())) { windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction()); } } } for (ProBasicEquipment wt : CacheContext.wtls) { String windturbineId = wt.getId(); Map windturbinetestingpointnewMap = CacheContext.wtpAimap.get(wt.getId()); //设备有功功率 String pointIdGL = windturbinetestingpointnewMap.get(ContantXk.CJ_SSGL).getNemCode(); //设备明细状态 String pointIdZT = windturbinetestingpointnewMap.get(ContantXk.MXZT).getNemCode(); String pointIdFS; if (wt.getWindpowerstationId().contains("GDC")) { //测风塔70米风速 if (windturbinetestingpointnewMap.containsKey(ContantXk.FCCFTFS70)) { ProBasicEquipmentPoint point = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70); if (StringUtils.notEmp(point.getNemCode()) && !point.getNemCode().equals(initialcode)) { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70).getNemCode(); } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } } else { //设备风速 pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode(); } CureFittingVo item = new CureFittingVo(); item.setPointIdFS(pointIdFS); item.setPointIdZT(pointIdZT); item.setPointIdGL(pointIdGL); //获取标杆风机编号 if (CacheContext.wtstandardmap.containsKey(wt.getId())) { item.setStandardId(CacheContext.wtstandardmap.get(wt.getId())); } else { item.setStandardId(wt.getId()); } windMap.put(windturbineId, item); } for (String key : windMap.keySet()) { //初始化集合 windMap.get(key).setYsjglPoints(new ArrayList<>()); windMap.get(key).setYzyglPoints(new ArrayList<>()); windMap.get(key).setRsjglPoints(new ArrayList<>()); windMap.get(key).setRzyglPoints(new ArrayList<>()); windMap.get(key).setNsjglPoints(new ArrayList<>()); windMap.get(key).setNzyglPoints(new ArrayList<>()); if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) { logger.info(key); continue; } //拟合年功率曲线 curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key); List vos = windMap.get(key).getNsjglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setNsjglPoints(vos); vos = windMap.get(key).getNzyglPoints().stream().filter(it -> it.getX() >= 0 && it.getX() <= 25).sorted(Comparator.comparing(PointVo::getX)).collect(Collectors.toList()); windMap.get(key).setNzyglPoints(vos); } for (String key : windMap.keySet()) { Double modelpower = 1500.0; if (windturbineCapacity.containsKey(key)) { modelpower = windturbineCapacity.get(key); } //年的上月 List yearLastMonthPoints = new ArrayList<>(); //年的去年同期 List yearLastYearPoints; //年标准功率 List yearStandardPoints = new ArrayList<>(); //日的昨天 //保证功率 List bzglpowerPoints = new ArrayList<>(); if (CacheContext.wtstandardmap.containsKey(key)) { String standardId = CacheContext.wtstandardmap.get(key); if (StringUtils.notEmp(standardId)) { if (windMap.containsKey(key)) { yearStandardPoints = windMap.get(standardId).getNsjglPoints(); } } } String stringyear = String.valueOf(day_year); String stringyear3 = String.valueOf(year_year); // /*********************************************年曲线偏差上个月和上一年记录**********************************************************/ List wcfyls = proEconWtCurveFittingYearService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear3)).sorted(Comparator.comparing(ProEconWtCurveFittingYear::getSpeed)).collect(Collectors.toList()); //与轶总的原始代码对比不一致，新增代码修改测试 yearBuildPoints(wcfyls, yearLastMonthPoints); yearLastYearPoints = yearLastMonthPoints; //*********************************************年曲线偏差上个月和上一年记录**********************************************************/ if (CacheContext.wtmap.containsKey(key)) { String modelid = CacheContext.wtmap.get(key).getModelId(); if (StringUtils.notEmp(modelid)) { //获取模型功率曲线 if (CacheContext.theoreticalPowerMap.containsKey(modelid)) { for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) { PointVo point = new PointVo(); point.setX(speed); point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower()); bzglpowerPoints.add(point); } } } } //*********************************************年曲线偏差记录**********************************************************/ //*********************************************当年曲线偏差记录**********************************************************/ Optional cfmyearo = proEconCurveFittYearMainService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear)).findFirst(); ProEconCurveFittYearMain cfmyear; if (cfmyearo.isPresent()) { cfmyear = cfmyearo.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfmyear.getId()); proEconCurveFittMonthMainService.remove(wrapper); } cfmyear = new ProEconCurveFittYearMain(); cfmyear.setWindturbineId(key); cfmyear.setYear(String.valueOf(day_year)); //年---实际/最优 cfmyear.setDeviationRate1(pcl(windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), modelpower)); //年---实际/保证 cfmyear.setDeviationRate2(pcl(windMap.get(key).getNsjglPoints(), bzglpowerPoints, modelpower)); //年---最优/保证 cfmyear.setDeviationRate3(pcl(windMap.get(key).getNzyglPoints(), bzglpowerPoints, modelpower)); //年---实际/上月实际 cfmyear.setMonthDeviationRate(pcl(windMap.get(key).getNsjglPoints(), yearLastMonthPoints, modelpower)); //年---实际/同期实际 cfmyear.setYearDeviationRate(pcl(windMap.get(key).getNsjglPoints(), yearLastYearPoints, modelpower)); //年---实际/标杆实际 cfmyear.setStandardDeviationRate(pcl(windMap.get(key).getNsjglPoints(), yearStandardPoints, modelpower)); proEconCurveFittYearMainService.save(cfmyear); //*********************************************当年曲线偏差记录**********************************************************/ pLCBuild(key, stringyear, windMap, modelpower, 3, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 4, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 5, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 6, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 7, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 8, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 9, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 10, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 11, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 12, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, windMap, modelpower, 13, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); insertPoints(stringyear, windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key); logger.info(key); // // logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date())); } } public void pLCBuild(String key, Date current, Map windMap, Double modelpower, double speed, List bzglpowerPoints, List lastMonthPoints, List lastYearPoints, List lastStandardPoints ) { String speedStr = String.valueOf(speed); //*********************************************当日曲线偏差子表记录**********************************************************/ Optional cfmso = proEconCurveFittingSubService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(current) == 0 && i.getSpeed().equals(speedStr)).findFirst(); ProEconCurveFittingSub cfms; if (cfmso.isPresent()) { cfms = cfmso.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfms.getId()); proEconCurveFittingSubService.remove(wrapper); } cfms = new ProEconCurveFittingSub(); cfms.setWindturbineId(key); cfms.setSpeed(String.valueOf(speed)); cfms.setRecordDate(DateUtils.truncate(current)); cfms.setDeviationRate1(pcl2(windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), modelpower, speed)); //日---实际/保证 cfms.setDeviationRate2(pcl2(windMap.get(key).getRsjglPoints(), bzglpowerPoints, modelpower, speed)); //日---最优/保证 cfms.setDeviationRate3(pcl2(windMap.get(key).getRzyglPoints(), bzglpowerPoints, modelpower, speed)); //日---实际/上日实际 cfms.setMonthDeviationRate(pcl2(windMap.get(key).getRsjglPoints(), lastMonthPoints, modelpower, speed)); //日---实际/同期实际 cfms.setYearDeviationRate(pcl2(windMap.get(key).getRsjglPoints(), lastYearPoints, modelpower, speed)); //日---实际/标杆实际 cfms.setStandardDeviationRate(pcl2(windMap.get(key).getRsjglPoints(), lastStandardPoints, modelpower, speed)); proEconCurveFittingSubService.save(cfms); //*********************************************当日曲线偏差子表记录**********************************************************/ } public void pLCBuild(String key, String stringyear, String stringmonth, Map windMap, Double modelpower, double speed, List bzglpowerPoints, List lastMonthPoints, List lastYearPoints, List lastStandardPoints ) { String speedStr = String.valueOf(speed); //*********************************************当月曲线偏差子表记录**********************************************************/ Optional cfmsmontho = proEconCurveFittMonthSubService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear) && i.getMonth().equals(stringmonth) && i.getSpeed().equals(speedStr)).findFirst(); ProEconCurveFittMonthSub cfmsmonth; if (cfmsmontho.isPresent()) { cfmsmonth = cfmsmontho.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfmsmonth.getId()); proEconCurveFittMonthSubService.remove(wrapper); } cfmsmonth = new ProEconCurveFittMonthSub(); cfmsmonth.setWindturbineId(key); cfmsmonth.setYear(stringyear); cfmsmonth.setMonth(stringmonth); cfmsmonth.setSpeed(String.valueOf(speed)); //月---实际/最优 cfmsmonth.setDeviationRate1(pcl2(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), modelpower, speed)); //月---实际/保证 cfmsmonth.setDeviationRate2(pcl2(windMap.get(key).getYsjglPoints(), bzglpowerPoints, modelpower, speed)); //月---最优/保证 cfmsmonth.setDeviationRate3(pcl2(windMap.get(key).getYzyglPoints(), bzglpowerPoints, modelpower, speed)); //月---实际/上月实际 cfmsmonth.setMonthDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastMonthPoints, modelpower, speed)); //月---实际/同期实际 cfmsmonth.setYearDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastYearPoints, modelpower, speed)); //月---实际/标杆实际 cfmsmonth.setStandardDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastStandardPoints, modelpower, speed)); proEconCurveFittMonthSubService.save(cfmsmonth); //*********************************************当月曲线偏差子表记录**********************************************************/ } public void pLCBuild(String key, String stringyear, Map windMap, Double modelpower, double speed, List bzglpowerPoints, List lastMonthPoints, List lastYearPoints, List lastStandardPoints ) { String speedStr = String.valueOf(speed); //*********************************************当年曲线偏差子表记录**********************************************************/ Optional cfmsyearo = proEconCurveFittYearSubService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear) && i.getSpeed().equals(speedStr)).findFirst(); ProEconCurveFittYearSub cfmsyear; if (cfmsyearo.isPresent()) { cfmsyear = cfmsyearo.get(); QueryWrapper wrapper = new QueryWrapper<>(); wrapper.eq("id", cfmsyear.getId()); proEconCurveFittYearSubService.remove(wrapper); } cfmsyear = new ProEconCurveFittYearSub(); cfmsyear.setWindturbineId(key); cfmsyear.setYear(stringyear); cfmsyear.setSpeed(String.valueOf(speed)); proEconCurveFittYearSubService.save(cfmsyear); //年---实际/最优 cfmsyear.setDeviationRate1(pcl2(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), modelpower, speed)); //年---实际/保证 cfmsyear.setDeviationRate2(pcl2(windMap.get(key).getYsjglPoints(), bzglpowerPoints, modelpower, speed)); //年---最优/保证 cfmsyear.setDeviationRate3(pcl2(windMap.get(key).getYzyglPoints(), bzglpowerPoints, modelpower, speed)); //年---实际/上月实际 cfmsyear.setMonthDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastMonthPoints, modelpower, speed)); //年---实际/同期实际 cfmsyear.setYearDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastYearPoints, modelpower, speed)); //年---实际/标杆实际 cfmsyear.setStandardDeviationRate(pcl2(windMap.get(key).getYsjglPoints(), lastStandardPoints, modelpower, speed)); proEconCurveFittYearSubService.save(cfmsyear); //*********************************************当年曲线偏差子表记录**********************************************************/ } private void insertPoints(Date current, List sjglls, List zyglls, String windturbineId) { //*********************************************当日曲线偏差记录**********************************************************/ List wtcfidls = proEconWtCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(windturbineId) && i.getRecordDate().compareTo(current) == 0).map(ProEconWtCurveFitting::getId).collect(Collectors.toList()); for (int i = 0; i < wtcfidls.size(); i++) { proEconWtCurveFittingService.removeByIds(wtcfidls); } if (sjglls.size() == zyglls.size()) { for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFitting item = new ProEconWtCurveFitting(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; // item.SPEED = Double.Truncate(pointsF2[i].X); } else { // boolean l = String.valueOf(sjglls.get(i).getX()).contains("."); // if (l) { // continue; // } item.setSpeed(sjglls.get(i).getX()); } item.setActualPower(sjglls.get(i).getY()); item.setOptimalPower(zyglls.get(i).getY()); item.setRecordDate(DateUtils.truncate(current)); proEconWtCurveFittingService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size())); for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFitting item = new ProEconWtCurveFitting(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; //item.SPEED = Double.Truncate(pointsF2[i].X); } else { boolean l = String.valueOf(sjglls.get(i).getX()).contains("."); if (l) { continue; } item.setSpeed(sjglls.get(i).getX()); } int finalI = i; OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst(); if (op.isPresent()) { item.setOptimalPower(op.getAsDouble()); } else { item.setOptimalPower(0.0); } item.setActualPower(sjglls.get(i).getY()); item.setRecordDate(current); proEconWtCurveFittingService.save(item); } } //*********************************************当日曲线偏差记录**********************************************************/ } } private void insertPoints(String year, String month, List sjglls, List zyglls, String windturbineId) { //*********************************************当月曲线偏差记录**********************************************************/ List wtcfmmonthidls = proEconWtCurveFittingMonthService.list().stream().filter(i -> i.getWindturbineId().equals(windturbineId) && i.getYear().equals(year) && i.getMonth().equals(month)).map(ProEconWtCurveFittingMonth::getId).collect(Collectors.toList()); for (int i = 0; i < wtcfmmonthidls.size(); i++) { proEconWtCurveFittingMonthService.removeByIds(wtcfmmonthidls); } if (sjglls.size() == zyglls.size()) { for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFittingMonth item = new ProEconWtCurveFittingMonth(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; // item.SPEED = Double.Truncate(pointsF1[i].X); } else { item.setSpeed(sjglls.get(i).getX()); } item.setActualPower(sjglls.get(i).getY()); item.setOptimalPower(zyglls.get(i).getY()); item.setYear(String.valueOf(year)); item.setMonth(String.valueOf(month)); proEconWtCurveFittingMonthService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size())); for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFittingMonth item = new ProEconWtCurveFittingMonth(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; //item.SPEED = Double.Truncate(pointsF1[i].X); } else { item.setSpeed(sjglls.get(i).getX()); } item.setActualPower(sjglls.get(i).getY()); int finalI = i; OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst(); if (op.isPresent()) { item.setOptimalPower(op.getAsDouble()); } else { item.setOptimalPower(0.0); } item.setYear(String.valueOf(year)); item.setMonth(String.valueOf(month)); proEconWtCurveFittingMonthService.save(item); } } } //*********************************************当月曲线偏差记录**********************************************************/ } private void insertPoints(String year, List sjglls, List zyglls, String windturbineId) { //*********************************************当年曲线偏差记录**********************************************************/ List wtcfmyearidls = proEconWtCurveFittingYearService.list().stream().filter(i -> i.getWindturbineId().equals(windturbineId) && i.getYear().equals(year)).map(ProEconWtCurveFittingYear::getId).collect(Collectors.toList()); for (int i = 0; i < wtcfmyearidls.size(); i++) { proEconWtCurveFittingYearService.removeByIds(wtcfmyearidls); } if (sjglls.size() == zyglls.size()) { for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFittingYear item = new ProEconWtCurveFittingYear(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; // item.SPEED = Double.Truncate(pointsF1[i].X); } else { item.setSpeed(sjglls.get(i).getX()); } item.setActualPower(sjglls.get(i).getY()); item.setOptimalPower(zyglls.get(i).getY()); item.setYear(String.valueOf(year)); proEconWtCurveFittingYearService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size())); for (int i = 0; i < sjglls.size(); i++) { ProEconWtCurveFittingYear item = new ProEconWtCurveFittingYear(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; //item.SPEED = Double.Truncate(pointsF1[i].X); } else { item.setSpeed(sjglls.get(i).getX()); } item.setActualPower(sjglls.get(i).getY()); int finalI = i; OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst(); if (op.isPresent()) { item.setOptimalPower(op.getAsDouble()); } else { item.setOptimalPower(0.0); } item.setYear(String.valueOf(year)); proEconWtCurveFittingYearService.save(item); } } } //*********************************************当年曲线偏差记录**********************************************************/ } private void insertPoints2(List monthSjglls, List monthZyglls, String windturbineId) { List wtpcfidls = proEconWtPowerCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(windturbineId)).map(ProEconWtPowerCurveFitting::getId).collect(Collectors.toList()); for (int i = 0; i < wtpcfidls.size(); i++) { proEconWtPowerCurveFittingService.removeByIds(wtpcfidls); } if (monthSjglls.size() == monthZyglls.size()) { for (int i = 0; i < monthSjglls.size(); i++) { ProEconWtPowerCurveFitting item = new ProEconWtPowerCurveFitting(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; // item.SPEED = Double.Truncate(pointsF1[i].X); } else { boolean l = String.valueOf(monthSjglls.get(i).getX()).contains("."); if (l) { continue; } item.setSpeed(monthSjglls.get(i).getX()); } item.setActualPower(monthSjglls.get(i).getY()); item.setOptimalPower(monthZyglls.get(i).getY()); proEconWtPowerCurveFittingService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, monthSjglls.size(), monthZyglls.size())); for (int i = 0; i < monthSjglls.size(); i++) { ProEconWtPowerCurveFitting item = new ProEconWtPowerCurveFitting(); item.setWindturbineId(windturbineId); if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { continue; //item.SPEED = Double.Truncate(pointsF1[i].X); } else { boolean l = String.valueOf(monthSjglls.get(i).getX()).contains("."); if (l) { continue; } item.setSpeed(monthSjglls.get(i).getX()); } item.setActualPower(monthSjglls.get(i).getY()); int finalI = i; OptionalDouble op = monthZyglls.stream().filter(x -> Objects.equals(x.getX(), monthSjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst(); if (op.isPresent()) { item.setOptimalPower(op.getAsDouble()); } else { item.setOptimalPower(0.0); } proEconWtPowerCurveFittingService.save(item); } } } } private void yearBuildPoints(List data, List points) { if (data != null) { for (ProEconWtCurveFittingYear datum : data) { PointVo point = new PointVo(); point.setX(datum.getSpeed()); point.setY(datum.getActualPower()); points.add(point); } } } private void monthBuildPoints(List data, List points) { if (data != null) { for (ProEconWtCurveFittingMonth datum : data) { PointVo point = new PointVo(); point.setX(datum.getSpeed()); point.setY(datum.getActualPower()); points.add(point); } } } private void dayBuildPoints(List data, List points) { if (data != null) { for (ProEconWtCurveFitting datum : data) { PointVo point = new PointVo(); point.setX(datum.getSpeed()); point.setY(datum.getActualPower()); points.add(point); } } } //曲线偏差率 private double pcl(List points1, List points2, Double modelpower) { double result = -0; double pc = 0; if (points1 != null && points1.size() != 0 && points2 != null && points2.size() != 0) { double count = 0; double sum = 0; double max = modelpower; for (PointVo point : points1) { List item = points2.stream().filter(it -> Objects.equals(it.getX(), point.getX())).collect(Collectors.toList()); if (item.size() > 0) { sum += Math.pow((point.getY() - item.get(0).getY()), 2); count++; pc += point.getY() - item.get(0).getY(); } } sum = Math.sqrt(sum); count = Math.sqrt(count); max = max * count; if (max != 0) { result = sum / max * 100; } if (pc < 0) { result = 0 - result; } } return result; } //曲线偏差率2 private double pcl2(List points1, List points2, Double modelpower, double speed) { double minSpeed = speed; double maxSpeed = minSpeed + 1; double result = -0; double pc = 0; if (points1 != null && points1.size() != 0 && points2 != null && points2.size() != 0) { double count = 0; double sum = 0; double max = modelpower; for (PointVo point : points1) { List item = points2.stream().filter(it -> Objects.equals(it.getX(), point.getX())).collect(Collectors.toList()); if (item.size() > 0 && item.get(0).getX() >= minSpeed && item.get(0).getX() < maxSpeed) { sum += Math.pow((point.getY() - item.get(0).getY()), 2); count++; pc += point.getY() - item.get(0).getY(); } } sum = Math.sqrt(sum); count = Math.sqrt(count); max = max * count; if (max != 0) { result = sum / max * 100; } if (pc < 0) { result = 0 - result; } } return result; } //todo-sl 添加数据筛选 private boolean filterData(PointData gl, PointData fs, PointData zt, double maxvalue, String windturbineId) throws Exception { // if (StringUtils.notEmp(gl)) { // //判定功率是否超过最大值 // if (gl.getPointValueInDouble() > maxvalue) { // return false; // } // } // // if (StringUtils.notEmp(fs)) { // //判定功率是否超过最大值 // if (fs.getPointValueInDouble() > 25) { // return false; // } // } // // //判定状态不为运行的进行过滤 // if (zt.getPointValueInDouble() != 2) { // return false; // } // // // //设置时间为10分钟前，10钟前有停机事件数据进行过滤 // Calendar c = Calendar.getInstance(); // c.setTimeInMillis(zt.getPointTime()); // Date end = c.getTime(); // c.add(Calendar.MINUTE, -10); // Date bedin = c.getTime(); // List points = edosUtil.getHistoryDatasSnap(zt.getEdnaId(), bedin.getTime() / 1000, end.getTime() / 1000); // if (!points.isEmpty()) { // for (PointData p : points) { // if (p.getPointValueInDouble() == 4) { // // return false; // } // // } // // } // // //设置时间为10分钟后，运行后10分钟数据进行过滤 // c = Calendar.getInstance(); // c.setTimeInMillis(zt.getPointTime()); // bedin = c.getTime(); // c.add(Calendar.MINUTE, 10); // end = c.getTime(); // points = edosUtil.getHistoryDatasSnap(zt.getEdnaId(), bedin.getTime() / 1000, end.getTime() / 1000); // if (!points.isEmpty()) { // for (PointData p : points) { // if (p.getPointValueInDouble() != 2) { // return false; // // } // // } // // } // Map> wtpAimap = CacheContext.wtpAimap; // Map wtpointmap = wtpAimap.get(windturbineId); // //与保证功率进行对比，偏差大于25%的进行过滤 // List pointid = new ArrayList<>(); // // pointid.add(wtpointmap.get(ContantXk.BZGL).getNemCode()); // List value = edosUtil.getHistMatrix(pointid, gl.getPointTime() / 1000); // // // if (null != value && value.size() > 0) { // double bzgl = value.get(0).getPointValueInDouble(); // double sjgl = gl.getPointValueInDouble(); // // double temp = Math.abs(sjgl - bzgl); // if (temp > sjgl * 0.25) { // return false; // } // } // // //欠发状态大于2过滤掉 // pointid = new ArrayList<>(); // // pointid.add(wtpointmap.get(ContantXk.LSQFZT).getNemCode()); // value = edosUtil.getHistMatrix(pointid, gl.getPointTime() / 1000); // if (null != value && value.size() > 0) { // double qfzt = value.get(0).getPointValueInDouble(); // // return !(qfzt > 2); // } return true; } //功率曲线拟合 public void curveFittingBuilder(Date begin, Date end, int dimension, double scale, String pointIdGL, String pointIdFS, String pointIdZT, List sjglPoints, List zyglPoints, String windturbineId) throws Exception { double maxPower = windturbineCapacity.get(windturbineId) * 1.3; List sjglnhpoints = new ArrayList<>(); Map zyglnhpoints = new HashMap<>(); if (end.after(begin)) { if (StringUtils.notEmp(pointIdGL) && StringUtils.notEmp(pointIdFS)) { List glpointstemp = edosUtil.getHistoryDatasSnap(pointIdGL, begin.getTime() / 1000, end.getTime() / 1000); List fspointstemp = edosUtil.getHistoryDatasSnap(pointIdFS, begin.getTime() / 1000, end.getTime() / 1000); List ztpointstemp = edosUtil.getHistoryDatasSnap(pointIdZT, begin.getTime() / 1000, end.getTime() / 1000); List glpoints = new ArrayList<>(); List fspoints = new ArrayList<>(); List ztpoints = new ArrayList<>(); if (!glpointstemp.isEmpty() && !fspointstemp.isEmpty() && !ztpointstemp.isEmpty() && glpointstemp.size() == fspointstemp.size() && fspointstemp.size() == ztpointstemp.size()) { for (int i = 0; i < glpointstemp.size(); i++) { if (filterData(glpointstemp.get(i), fspointstemp.get(i), ztpointstemp.get(i), maxPower, windturbineId)) { glpoints.add(glpointstemp.get(i)); fspoints.add(fspointstemp.get(i)); ztpoints.add(ztpointstemp.get(i)); } } } if (glpoints.size() != fspoints.size() || glpoints.size() != ztpoints.size()) { for (int i = 0; i < fspoints.size(); i++) { double x = fspoints.get(i).getPointValueInDouble(); double y = -1; double z = -1; int finalI1 = i; List yArray = glpoints.stream().filter(it -> it.getPointTime().compareTo(fspoints.get(finalI1).getPointTime()) == 0).collect(Collectors.toList()); if (yArray.size() > 0) { y = yArray.get(0).getPointValueInDouble(); } int finalI = i; yArray = ztpoints.stream().filter(it -> it.getPointTime().compareTo(fspoints.get(finalI).getPointTime()) == 0).collect(Collectors.toList()); if (yArray.size() > 0) { z = yArray.get(0).getPointValueInDouble(); } Double x1 = StringUtils.round(x, 2); Double y1 = y; boolean b = true; if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { b = (x >= 0 && y > 0); } else { if (z == 2) { b = (x >= 0 && x <= 30 && y >= 0 && y <= maxPower); if (b) { if (x > 3 && y <= 0) { b = false; } if (x <= 3 && y > 0) { b = false; } } } else { b = false; } } } if (b) { sjglnhpoints.add(new PointfVo(x1, y1)); if (zyglnhpoints.containsKey(x1)) { if (zyglnhpoints.get(x1).getY() < y1) { zyglnhpoints.put(x1, new PointfVo(x1, y1)); } } else { zyglnhpoints.put(x1, new PointfVo(x1, y1)); } } } } else { for (int i = 0; i < fspoints.size(); i++) { double x = fspoints.get(i).getPointValueInDouble(); double y = glpoints.get(i).getPointValueInDouble(); double z = ztpoints.get(i).getPointValueInDouble(); Double x1 = StringUtils.round(x, 2); Double y1 = y; boolean b = true; if (CacheContext.wtmap.containsKey(windturbineId)) { ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId); if (wt.getWindpowerstationId().contains("GDC")) { b = (x >= 0 && y > 0); } else { if (z == 2) { b = (x >= 0 && x <= 30 && y >= 0 && y <= maxPower); if (b) { if (x > 3 && y <= 0) { b = false; } if (x <= 3 && y > 0) { b = false; } } } else { b = false; } } } if (b) { sjglnhpoints.add(new PointfVo(x1, y1)); if (zyglnhpoints.containsKey(x1)) { if (zyglnhpoints.get(x1).getY() < y1) { zyglnhpoints.put(x1, new PointfVo(x1, y1)); } } else { zyglnhpoints.put(x1, new PointfVo(x1, y1)); } } } } sjglnhpoints.add(new PointfVo(0.0, 0.0)); sjglnhpoints = sjglnhpoints.stream().filter(it -> it.getX() >= 3).sorted(Comparator.comparing(PointfVo::getX)).collect(Collectors.toList()); if (sjglnhpoints.stream().min(Comparator.comparing(PointfVo::getX)).isPresent()) { double Xmax = sjglnhpoints.stream().max(Comparator.comparing(PointfVo::getX)).get().getX(); double Ymax = sjglnhpoints.stream().max(Comparator.comparing(PointfVo::getX)).get().getY(); System.out.println(""); } List temp = LineUtil.buildLine(sjglnhpoints.stream().mapToDouble(PointfVo::getX).toArray(), sjglnhpoints.stream().mapToDouble(PointfVo::getY).toArray(), sjglnhpoints.size(), dimension, scale); sjglPoints.addAll(temp); if (sjglPoints.size() != 0) { buildMyPoints(sjglPoints, scale); } if (!zyglnhpoints.containsKey(0.0)) zyglnhpoints.put(0.0, new PointfVo(0.0, 0.0)); List zygltemp = zyglnhpoints.values().stream().filter(it -> it.getX() >= 3).sorted(Comparator.comparing(PointfVo::getX)).collect(Collectors.toList()); if (zygltemp.size() != 0) { temp = LineUtil.buildLine(zygltemp.stream().mapToDouble(PointfVo::getX).toArray(), zygltemp.stream().mapToDouble(PointfVo::getY).toArray(), zygltemp.size(), dimension, scale); } zyglPoints.addAll(temp); if (zyglPoints.size() != 0) { buildMyPoints(zyglPoints, scale); } } } } private static void buildMyPoints(List sjglPoints, double scale) { int coefficient = 1; int dec = 0; int smax = 25; if (scale == 0.01) { coefficient = 100; dec = 2; } if (scale == 0.1) { coefficient = 10; dec = 1; } smax *= coefficient; double min = 0.0; double max = 0.0; double maxval = 0.0; if (sjglPoints.stream().min(Comparator.comparing(PointVo::getX)).isPresent()) { min = sjglPoints.stream().min(Comparator.comparing(PointVo::getX)).get().getX() * coefficient; } if (sjglPoints.stream().max(Comparator.comparing(PointVo::getX)).isPresent()) { max = sjglPoints.stream().max(Comparator.comparing(PointVo::getX)).get().getX() * coefficient; } if (sjglPoints.stream().max(Comparator.comparing(PointVo::getY)).isPresent()) { maxval = sjglPoints.stream().max(Comparator.comparing(PointVo::getY)).get().getY(); } for (double i = 0; i < min; i += 1) { PointVo point = new PointVo(); point.setX(StringUtils.round(i / coefficient, dec)); point.setY(0.0); sjglPoints.add(point); } for (double i = smax; i > max; i -= 1) { PointVo point = new PointVo(); point.setX(StringUtils.round(i / coefficient, dec)); point.setY(maxval); sjglPoints.add(point); } } }