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.realtimesource.math.LineUtil; import com.gyee.generation.util.StringUtils; import com.gyee.generation.util.realtimesource.IEdosUtil; 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 PowerCurveFittingService { private static final Logger logger = LoggerFactory.getLogger(PowerCurveFittingService.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; //inserttype 0表示正常拟合工作，1表示存值到windturbinePowerCurveFitting表 public void cureFitting(Date nowDate, Date begion, int insertType, List wtls) throws Exception { //日期变为昨天 Date current = DateUtils.addDays(DateUtils.truncDay(nowDate), -1); Calendar c = Calendar.getInstance(); c.setTime(current); int year = c.get(Calendar.YEAR); int month = c.get(Calendar.MONTH) + 1; c.set(Calendar.DAY_OF_MONTH, 1); Date begin1 = c.getTime(); c.set(Calendar.MONTH, 0); Date begin3 = c.getTime(); Date begin2 = DateUtils.addDays(current, -6); Date end = DateUtils.truncDay(nowDate); if (begion.getTime() != new Date(0).getTime() && begion.getTime() != new Date(Long.MAX_VALUE).getTime()) { begin1 = begion; } int dimension = this.dimension; double scale = this.scale; //上个月 c.setTime(DateUtils.addMonths(begin1, -1)); int year2 = c.get(Calendar.YEAR); int month2 = c.get(Calendar.MONTH) + 1; //去年同期 c.setTime(DateUtils.addYears(begin1, -1)); int year3 = c.get(Calendar.YEAR); int month3 = c.get(Calendar.MONTH) + 1; Map windMap = new HashMap<>(); //初始化风机装机容量 if (windturbineCapacity == null) { windturbineCapacity = new HashMap<>(); Map modelMap = CacheContext.modelMap; for (ProBasicEquipment windturbine : wtls) { if (modelMap.containsKey(windturbine.getModelId())) { windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction()); } } } for (ProBasicEquipment wt : 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(begin1, 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); //拟合日功率曲线 curveFittingBuilder(begin2, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), key); 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); //拟合年功率曲线 curveFittingBuilder(begin3, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key); 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 monthLastMonthPoints = new ArrayList<>(); //月的去年同期 List monthLastYearPoints = new ArrayList<>(); //月标准功率 List monthStandardPoints = new ArrayList<>(); //日的昨天 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)) { yearStandardPoints = windMap.get(standardId).getNsjglPoints(); monthStandardPoints = windMap.get(standardId).getYsjglPoints(); dayStandardPoints = windMap.get(standardId).getRsjglPoints(); } } } String stringyear = String.valueOf(year); String stringmonth = String.valueOf(month); String stringyear2 = String.valueOf(year2); String stringmonth2 = String.valueOf(month2); String stringyear3 = String.valueOf(year3); String stringmonth3 = String.valueOf(month3); // /*********************************************年曲线偏差上个月和上一年记录**********************************************************/ List wcfyls = proEconWtCurveFittingYearService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getYear().equals(stringyear3)).collect(Collectors.toList()); //与轶总的原始代码对比不一致，新增代码修改测试 yearBuildPoints(wcfyls, yearLastMonthPoints); yearLastYearPoints = yearLastMonthPoints; //*********************************************年曲线偏差上个月和上一年记录**********************************************************/ //*********************************************月曲线偏差上个月和上一年记录**********************************************************/ 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)).collect(Collectors.toList()); wcfmls.sort(Comparator.comparing(ProEconWtCurveFittingMonth::getSpeed)); monthBuildPoints(wcfmls, monthLastYearPoints); //*********************************************月曲线偏差上个月和上一年记录**********************************************************/ //*********************************************日曲线偏差上个月和上一年记录**********************************************************/ Date d1 = DateUtils.addDays(current, -1); Date d2 = DateUtils.addYears(current, -1); List wcfls = proEconWtCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(d1) == 0).collect(Collectors.toList()); dayBuildPoints(wcfls, dayLastMonthPoints); wcfls = proEconWtCurveFittingService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(d2) == 0).collect(Collectors.toList()); //与轶总的原始代码对比不一致，临时修改测试 dayBuildPoints(wcfls, dayLastMonthPoints); //*********************************************日曲线偏差上个月和上一年记录**********************************************************/ if (CacheContext.wtmap.containsKey(key)) { String modelid = CacheContext.wtmap.get(key).getModelId(); if (StringUtils.notEmp(modelid)) { //获取模型功率曲线 if (CacheContext.modelpowermap.containsKey(modelid)) { for (Double speed : CacheContext.modelpowermap.get(modelid).keySet()) { PointVo point = new PointVo(); point.setX(speed); point.setY(CacheContext.modelpowermap.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(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); //*********************************************当年曲线偏差记录**********************************************************/ //*********************************************当月曲线偏差记录**********************************************************/ 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(year)); cfmmonth.setMonth(String.valueOf(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); //*********************************************当月曲线偏差记录**********************************************************/ //*********************************************当日曲线偏差记录**********************************************************/ Optional cfmdayo = proEconCurveFittingMainService.list().stream().filter(i -> i.getWindturbineId().equals(key) && i.getRecordDate().compareTo(current) == 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(current); //日---实际/最优 cfmday.setDeviationRate1( pcl(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), 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, stringyear, stringmonth, current, windMap, modelpower, 3, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 4, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 5, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 6, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 7, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 8, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 9, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 10, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 11, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 12, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); pLCBuild(key, stringyear, stringmonth, current, windMap, modelpower, 13, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints); if (insertType == 0) { insertPoints(current, stringyear, stringmonth, windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key); } else { insertPoints2(current, stringyear, stringmonth, windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), 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, String stringyear, String stringmonth, Date current, Map windMap, Double modelpower, double speed, List bzglpowerPoints, List monthLastMonthPoints, List monthLastYearPoints, List monthStandardPoints, List dayLastMonthPoints, List dayLastYearPoints, List dayStandardPoints, List yearLastMonthPoints, List yearLastYearPoints, List yearStandardPoints) { 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(), yearLastMonthPoints, modelpower, speed)); //年---实际/同期实际 cfmsyear.setYearDeviationRate( pcl2(windMap.get(key).getYsjglPoints(), yearLastYearPoints, modelpower, speed)); //年---实际/标杆实际 cfmsyear.setStandardDeviationRate( pcl2(windMap.get(key).getYsjglPoints(), yearStandardPoints, modelpower, speed)); proEconCurveFittYearSubService.save(cfmsyear); //*********************************************当年曲线偏差子表记录**********************************************************/ //*********************************************当月曲线偏差子表记录**********************************************************/ 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)); proEconCurveFittMonthSubService.save(cfmsmonth); //月---实际/最优 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(), monthLastMonthPoints, modelpower, speed)); //月---实际/同期实际 cfmsmonth.setYearDeviationRate( pcl2(windMap.get(key).getYsjglPoints(), monthLastYearPoints, modelpower, speed)); //月---实际/标杆实际 cfmsmonth.setStandardDeviationRate( pcl2(windMap.get(key).getYsjglPoints(), monthStandardPoints, modelpower, speed)); proEconCurveFittMonthSubService.save(cfmsmonth); //*********************************************当月曲线偏差子表记录**********************************************************/ //*********************************************当日曲线偏差子表记录**********************************************************/ 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(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(), dayLastMonthPoints, modelpower, speed)); //日---实际/同期实际 cfms.setYearDeviationRate( pcl2(windMap.get(key).getRsjglPoints(), dayLastYearPoints, modelpower, speed)); //日---实际/标杆实际 cfms.setStandardDeviationRate( pcl2(windMap.get(key).getRsjglPoints(), dayStandardPoints, modelpower, speed)); proEconCurveFittingSubService.save(cfms); //*********************************************当日曲线偏差子表记录**********************************************************/ } private void insertPoints(Date current, String year, String month, List monthSjglls, List monthZyglls, List daySjglls, List dayZyglls, List yearSjglls, List yearZyglls, 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 (yearSjglls.size() == yearZyglls.size()) { for (int i = 0; i < yearSjglls.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(yearSjglls.get(i).getX()); } item.setActualPower(yearSjglls.get(i).getY()); item.setOptimalPower(yearZyglls.get(i).getY()); item.setYear(String.valueOf(year)); proEconWtCurveFittingYearService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, yearSjglls.size(), yearZyglls.size())); for (int i = 0; i < yearSjglls.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(yearSjglls.get(i).getX()); } item.setActualPower(yearSjglls.get(i).getY()); int finalI = i; OptionalDouble op = yearZyglls.stream().filter(x -> Objects.equals(x.getX(), yearSjglls.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); } } } //*********************************************当年曲线偏差记录**********************************************************/ //*********************************************当月曲线偏差记录**********************************************************/ 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 (monthSjglls.size() == monthZyglls.size()) { for (int i = 0; i < monthSjglls.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(monthSjglls.get(i).getX()); } item.setActualPower(monthSjglls.get(i).getY()); item.setOptimalPower(monthZyglls.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, monthSjglls.size(), monthZyglls.size())); for (int i = 0; i < monthSjglls.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(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); } item.setYear(String.valueOf(year)); item.setMonth(String.valueOf(month)); proEconWtCurveFittingMonthService.save(item); } } } //*********************************************当月曲线偏差记录**********************************************************/ //*********************************************当日曲线偏差记录**********************************************************/ 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 (daySjglls.size() == dayZyglls.size()) { for (int i = 0; i < daySjglls.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(daySjglls.get(i).getX()).contains("."); if (l) { continue; } item.setSpeed(daySjglls.get(i).getX()); } item.setActualPower(daySjglls.get(i).getY()); item.setOptimalPower(dayZyglls.get(i).getY()); item.setRecordDate(current); proEconWtCurveFittingService.save(item); } } } else { logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, daySjglls.size(), dayZyglls.size())); for (int i = 0; i < daySjglls.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(daySjglls.get(i).getX()).contains("."); if (l) { continue; } item.setSpeed(daySjglls.get(i).getX()); } int finalI = i; OptionalDouble op = dayZyglls.stream().filter(x -> Objects.equals(x.getX(), daySjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst(); if (op.isPresent()) { item.setOptimalPower(op.getAsDouble()); } else { item.setOptimalPower(0.0); } item.setActualPower(daySjglls.get(i).getY()); item.setRecordDate(current); proEconWtCurveFittingService.save(item); } } //*********************************************当日曲线偏差记录**********************************************************/ } } private void insertPoints2(Date current, String year, String month, List monthSjglls, List monthZyglls, List daySjglls, List dayZyglls, List yearSjglls, List yearZyglls, 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 (gl.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(i).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(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)); } } } } 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()); 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); } } }