sis/realtime/generationXK-service/src/main/java/com/gyee/generation/service/PowerCurveFittingService.java

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<String, Double> 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<ProBasicEquipment> 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<String, CureFittingVo> windMap = new HashMap<>();


        //初始化风机装机容量

        if (windturbineCapacity == null) {
            windturbineCapacity = new HashMap<>();
            Map<String, ProEconEquipmentmodel> 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<String, ProBasicEquipmentPoint> 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<PointVo> 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<PointVo> yearLastMonthPoints = new ArrayList<>();
//            //年的去年同期
            List<PointVo> yearLastYearPoints;
//            //年标准功率
            List<PointVo> yearStandardPoints = new ArrayList<>();


            //月的上月
            List<PointVo> monthLastMonthPoints = new ArrayList<>();
            //月的去年同期
            List<PointVo> monthLastYearPoints = new ArrayList<>();
            //月标准功率
            List<PointVo> monthStandardPoints = new ArrayList<>();


            //日的昨天
            List<PointVo> dayLastMonthPoints = new ArrayList<>();
            //日的去年同期
            List<PointVo> dayLastYearPoints = new ArrayList<>();
            //日标准功率
            List<PointVo> dayStandardPoints = new ArrayList<>();

            //保证功率
            List<PointVo> 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<ProEconWtCurveFittingYear> wcfyls = proEconWtCurveFittingYearService.list().stream().filter(i -> i.getWindturbineId().equals(key) &&
                    i.getYear().equals(stringyear3)).collect(Collectors.toList());

            //与轶总的原始代码对比不一致，新增代码修改测试
            yearBuildPoints(wcfyls, yearLastMonthPoints);
            yearLastYearPoints = yearLastMonthPoints;

//*********************************************年曲线偏差上个月和上一年记录**********************************************************/
//*********************************************月曲线偏差上个月和上一年记录**********************************************************/

            List<ProEconWtCurveFittingMonth> 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<ProEconWtCurveFitting> 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<ProEconCurveFittYearMain> cfmyearo = proEconCurveFittYearMainService.list().stream().filter(i -> i.getWindturbineId().equals(key)
                    && i.getYear().equals(stringyear)).findFirst();
            ProEconCurveFittYearMain cfmyear;
            if (cfmyearo.isPresent()) {
                cfmyear = cfmyearo.get();

                QueryWrapper<ProEconCurveFittMonthMain> 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<ProEconCurveFittMonthMain> 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<ProEconCurveFittMonthMain> 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<ProEconCurveFittingMain> 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<ProEconCurveFittingMain> 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<String, CureFittingVo> windMap, Double modelpower, double speed,
                         List<PointVo> bzglpowerPoints, List<PointVo> monthLastMonthPoints, List<PointVo> monthLastYearPoints, List<PointVo> monthStandardPoints,
                         List<PointVo> dayLastMonthPoints, List<PointVo> dayLastYearPoints, List<PointVo> dayStandardPoints,
                         List<PointVo> yearLastMonthPoints, List<PointVo> yearLastYearPoints, List<PointVo> yearStandardPoints) {

        String speedStr = String.valueOf(speed);

        //*********************************************当年曲线偏差子表记录**********************************************************/

        Optional<ProEconCurveFittYearSub> 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<ProEconCurveFittYearSub> 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<ProEconCurveFittMonthSub> 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<ProEconCurveFittMonthSub> 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<ProEconCurveFittingSub> 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<ProEconCurveFittingSub> 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<PointVo> monthSjglls, List<PointVo> monthZyglls, List<PointVo> daySjglls, List<PointVo> dayZyglls, List<PointVo> yearSjglls, List<PointVo> yearZyglls, String windturbineId) {
        //*********************************************当年曲线偏差记录**********************************************************/
        List<Integer> 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<Integer> 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<Integer> 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<PointVo> monthSjglls, List<PointVo> monthZyglls, List<PointVo> daySjglls, List<PointVo> dayZyglls, List<PointVo> yearSjglls, List<PointVo> yearZyglls, String windturbineId) {


        List<Integer> 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<ProEconWtCurveFittingYear> data, List<PointVo> 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<ProEconWtCurveFittingMonth> data, List<PointVo> 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<ProEconWtCurveFitting> data, List<PointVo> 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<PointVo> points1, List<PointVo> 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<PointVo> 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<PointVo> points1, List<PointVo> 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<PointVo> 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<PointData> 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<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = CacheContext.wtpAimap;
        Map<String, ProBasicEquipmentPoint> wtpointmap = wtpAimap.get(windturbineId);
        //与保证功率进行对比，偏差大于25%的进行过滤
        List<String> pointid = new ArrayList<>();

        pointid.add(wtpointmap.get(ContantXk.BZGL).getNemCode());
        List<PointData> 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<PointVo> sjglPoints, List<PointVo> zyglPoints, String windturbineId) throws Exception {
        double maxPower = windturbineCapacity.get(windturbineId) * 1.3;
        List<PointfVo> sjglnhpoints = new ArrayList<>();
        Map<Double, PointfVo> zyglnhpoints = new HashMap<>();

        if (end.after(begin)) {
            if (StringUtils.notEmp(pointIdGL) && StringUtils.notEmp(pointIdFS)) {
                List<PointData> glpointstemp = edosUtil.getHistoryDatasSnap(pointIdGL, begin.getTime() / 1000, end.getTime() / 1000);
                List<PointData> fspointstemp = edosUtil.getHistoryDatasSnap(pointIdFS, begin.getTime() / 1000, end.getTime() / 1000);
                List<PointData> ztpointstemp = edosUtil.getHistoryDatasSnap(pointIdZT, begin.getTime() / 1000, end.getTime() / 1000);


                List<PointData> glpoints = new ArrayList<>();
                List<PointData> fspoints = new ArrayList<>();
                List<PointData> 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<PointData> 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<PointVo> 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<PointfVo> 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<PointVo> 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);
        }
    }

}