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

package com.gyee.generation.service;

import com.alibaba.fastjson.JSONObject;
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.*;
import com.gyee.generation.service.auto.*;
import com.gyee.generation.util.DateUtils;
import com.gyee.generation.util.DeviationRateUtil;
import com.gyee.generation.util.StringUtils;
import com.gyee.generation.util.realtimesource.IEdosUtil;
import com.gyee.generation.util.realtimesource.math.LineUtil;
import com.gyee.generation.util.redis.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class PowerCurveFittingByTimeService {

    private static final Logger logger = LoggerFactory.getLogger(PowerCurveFittingByTimeService.class);
    @Resource
    private IEdosUtil edosUtil;

    @Value("${curvefitting.dimension}")
    private Integer dimension;
    @Value("${curvefitting.scale}")
    private Double scale;
    @Value("${initialcode}")
    private String initialcode;
    public Map<String, Double> windturbineCapacity;


    @Resource
    private RedisService redisService;
    @Resource
    private IProEconWtCurveFittingMonthService proEconWtCurveFittingMonthService;

    @Resource
    private IProEconWtCurveFittingYearService proEconWtCurveFittingYearService;
    @Resource
    private IProEconWtCurveFittingService proEconWtCurveFittingService;

    @Resource
    private IProEconCurveFittingMainService proEconCurveFittingMainService;
    @Resource
    private IProEconCurveFittingSubService proEconCurveFittingSubService;
    @Resource
    private IProEconCurveFittMonthMainService proEconCurveFittMonthMainService;
    @Resource
    private IProEconCurveFittMonthSubService proEconCurveFittMonthSubService;
    @Resource
    private IProEconWtPowerCurveFittingService proEconWtPowerCurveFittingService;

    @Resource
    private IProEconCurveFittYearSubService proEconCurveFittYearSubService;
    @Resource
    private IProEconCurveFittYearMainService proEconCurveFittYearMainService;


    public void cureFittingDay(Date recordDate,String wpId) throws Exception {
        //日期变为昨天
        Date end = DateUtils.addDays(DateUtils.truncate(recordDate), -1);

        Calendar c = Calendar.getInstance();
        c.setTime(end);

        Date begin = DateUtils.addDays(end, -6);

        List<ProBasicEquipment> wtls=new ArrayList<>();
        if(StringUtils.notEmp(wpId) && CacheContext.wpwtmap.containsKey(wpId))
        {
            wtls=CacheContext.wpwtmap.get(wpId);
        }else
        {
            wtls=CacheContext.wtls;
        }

        StringBuilder sb=new StringBuilder();
        for(ProBasicEquipment wt:wtls)
        {
            sb.append("'").append(wt.getId()).append("',");
        }
        String wtIds=sb.substring(0,sb.length()-1);
        proEconWtCurveFittingService.deleteProEconWtCurveFittingFByDay(DateUtils.truncate(recordDate),wtIds);
        proEconCurveFittingMainService.deleteProEconCurveFittingMainFByDay(DateUtils.truncate(recordDate),wtIds);
        proEconCurveFittingSubService.deleteProEconCurveFittingSubFByDay(DateUtils.truncate(recordDate),wtIds);
        Map<String, CureFittingVo> windMap = new HashMap<>();

        //初始化风机装机容量

        if (windturbineCapacity == null) {
            windturbineCapacity = new HashMap<>();
            Map<String, ProEconEquipmentmodel> modelMap = CacheContext.modelMap;
            for (ProBasicEquipment windturbine : CacheContext.wtls) {
                if (modelMap.containsKey(windturbine.getModelId())) {
                    windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction());
                }
            }
        }



        for (ProBasicEquipment wt : wtls) {
            String windturbineId = wt.getId();

            if(wt.getWindpowerstationId().contains(WpType.GDC.id))
            {
                continue;
            }


            Map<String, ProBasicEquipmentPoint> windturbinetestingpointnewMap = CacheContext.wtpAimap.get(wt.getId());
            //设备有功功率
            String pointIdGL = null;
            //设备明细状态
            String pointIdZT =  null;

            String pointIdFS = null;
            if (windturbinetestingpointnewMap.containsKey(ContantXk.CJ_SSFS)) {

                pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
            }
            if (windturbinetestingpointnewMap.containsKey(ContantXk.CJ_SSGL)) {

                pointIdGL = windturbinetestingpointnewMap.get(ContantXk.CJ_SSGL).getNemCode();
            }
            if (windturbinetestingpointnewMap.containsKey(ContantXk.MXZT)) {

                pointIdZT = windturbinetestingpointnewMap.get(ContantXk.MXZT).getNemCode();
            }

            CureFittingVo item = new CureFittingVo();

            item.setPointIdFS(pointIdFS);
            item.setPointIdZT(pointIdZT);
            item.setPointIdGL(pointIdGL);

            //获取标杆风机编号
            if (CacheContext.wtstandardmap.containsKey(wt.getId())) {
                item.setStandardId(CacheContext.wtstandardmap.get(wt.getId()));
            } else {
                item.setStandardId(wt.getId());
            }

            windMap.put(windturbineId, item);
        }


        for (String key : windMap.keySet()) {
            //初始化集合
            windMap.get(key).setYsjglPoints(new ArrayList<>());
            windMap.get(key).setYzyglPoints(new ArrayList<>());
            windMap.get(key).setRsjglPoints(new ArrayList<>());
            windMap.get(key).setRzyglPoints(new ArrayList<>());
            windMap.get(key).setNsjglPoints(new ArrayList<>());
            windMap.get(key).setNzyglPoints(new ArrayList<>());


            if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) {
                logger.info(key);
                continue;
            }


            //拟合日功率曲线
            curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), key);
            List<PointVo> 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);

        }


        List<ProEconCurveFittingMain> mainls=new ArrayList<>();
        for (String key : windMap.keySet()) {

            Double modelpower = 1500.0;
            if (windturbineCapacity.containsKey(key)) {
                modelpower = windturbineCapacity.get(key);
            }


            //日的昨天
            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)) {

                        dayStandardPoints = windMap.get(standardId).getRsjglPoints();
                    }
                }
            }


//*********************************************日曲线偏差上个日和上一年记录**********************************************************/
            Date d1 = DateUtils.addDays(recordDate, -1);
            Date d2 = DateUtils.addYears(recordDate, -1);
            QueryWrapper<ProEconWtCurveFitting> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("record_date",d1).eq("windturbine_id",key);
            List<ProEconWtCurveFitting> wcfls = proEconWtCurveFittingService.list(queryWrapper)
                    .stream()
//                    .filter(i -> i.getWindturbineId().equals(key) &&
//                    i.getRecordDate().compareTo(d1) == 0)
                    .sorted(Comparator.comparing(ProEconWtCurveFitting::getSpeed)).collect(Collectors.toList());


            dayBuildPoints(wcfls, dayLastMonthPoints);

            QueryWrapper<ProEconWtCurveFitting> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("record_date",d2).eq("windturbine_id",key);
            wcfls = proEconWtCurveFittingService.list(queryWrapper2).stream()
//                    .filter(i -> i.getWindturbineId().equals(key) &&
//                    i.getRecordDate().compareTo(d2) == 0)
                    .sorted(Comparator.comparing(ProEconWtCurveFitting::getSpeed)).collect(Collectors.toList());

            //与轶总的原始代码对比不一致，临时修改测试
            dayBuildPoints(wcfls, dayLastMonthPoints);
//*********************************************日曲线偏差上个月和上一年记录**********************************************************/
            if (CacheContext.wtmap.containsKey(key)) {
                String modelid = CacheContext.wtmap.get(key).getModelId();
                if (StringUtils.notEmp(modelid)) {
                    //获取模型功率曲线
                    if (CacheContext.theoreticalPowerMap.containsKey(modelid)) {
                        for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) {
                            PointVo point = new PointVo();
                            point.setX(speed);
                            point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower());

                            bzglpowerPoints.add(point);
                        }
                    }
                }
            }



            //*********************************************当日曲线偏差记录**********************************************************/
            QueryWrapper<ProEconCurveFittingMain> queryWrapper3 = new QueryWrapper<>();
            queryWrapper3.eq("record_date",recordDate).eq("windturbine_id",key);
            Optional<ProEconCurveFittingMain> cfmdayo = proEconCurveFittingMainService.list(queryWrapper3).stream()
//                    .filter(i -> i.getWindturbineId().equals(key)
//                    && i.getRecordDate().compareTo(recordDate) == 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(DateUtils.truncate(recordDate));


            //日---实际/最优
            cfmday.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), modelpower));
            //日---实际/保证
            cfmday.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), bzglpowerPoints, modelpower));
            //日---最优/保证
            cfmday.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRzyglPoints(), bzglpowerPoints, modelpower));
            //日---实际/上日实际
            cfmday.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), dayLastMonthPoints, modelpower));
            //日---实际/同期实际
            cfmday.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), dayLastYearPoints, modelpower));
            //日---实际/标杆实际
            cfmday.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), dayStandardPoints, modelpower));

            mainls.add(cfmday);
            //proEconCurveFittingMainService.save(cfmday);
            //*********************************************当日曲线偏差记录**********************************************************/
            List<ProEconCurveFittingSub> subls=new ArrayList<>();
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 3, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 4, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 5, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 6, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 7, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 8, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 9, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 10, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 11, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 12, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));
            subls.add(pLCBuild(key, recordDate, windMap, modelpower, 13, bzglpowerPoints, dayLastMonthPoints, dayLastYearPoints, dayStandardPoints));

            List<ProEconCurveFittingSub> templs=new ArrayList<>();
            for(ProEconCurveFittingSub vo:subls)
            {
                templs.add(vo);
                if(templs.size()==1000)
                {
                    proEconCurveFittingSubService.saveBatch(templs);
                    templs=new ArrayList<>();
                }
            }

            if(!templs.isEmpty())
            {
                proEconCurveFittingSubService.saveBatch(templs);
            }
//            proEconCurveFittingSubService.saveBatch(subls);

            insertPoints(recordDate,  windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), key);

            logger.info(key);
//
//            logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date()));


        }

        List<ProEconCurveFittingMain> templs=new ArrayList<>();
        for(ProEconCurveFittingMain vo:mainls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconCurveFittingMainService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconCurveFittingMainService.saveBatch(templs);
        }
//        proEconCurveFittingMainService.saveBatch(mainls);
    }

    public void cureFittingMonth(Date recordDate,String type,String wpId) throws Exception {
        //日期变为下一天
        Date end = DateUtils.addDays(DateUtils.truncate(recordDate), 1);

        Calendar c = Calendar.getInstance();
        c.setTime(recordDate);
        int day_year = c.get(Calendar.YEAR);
        int day_month = c.get(Calendar.MONTH) + 1;

        List<ProBasicEquipment> wtls=new ArrayList<>();
        if(StringUtils.notEmp(wpId) && CacheContext.wpwtmap.containsKey(wpId))
        {
            wtls=CacheContext.wpwtmap.get(wpId);
        }else
        {
            wtls=CacheContext.wtls;
        }
        StringBuilder sb=new StringBuilder();
        for(ProBasicEquipment wt:wtls)
        {
            sb.append("'").append(wt.getId()).append("',");
        }
        String wtIds=sb.substring(0,sb.length()-1);
        proEconWtCurveFittingMonthService.deleteProEconWtCurveFittingFByMonth(String.valueOf(day_year),String.valueOf(day_month),wtIds);
        proEconCurveFittMonthMainService.deleteProEconCurveFittMonthMainFByMonth(String.valueOf(day_year),String.valueOf(day_month), wtIds);
        proEconCurveFittMonthSubService.deleteProEconCurveFittMonthSubFByMonth(String.valueOf(day_year),String.valueOf(day_month),wtIds);
        c.set(Calendar.DAY_OF_MONTH, 1);
        Date begin = DateUtils.truncate(c.getTime());

        //上个月
        c.setTime(DateUtils.addMonths(begin, -1));
        int month_year = c.get(Calendar.YEAR);
        int month_month = c.get(Calendar.MONTH) + 1;

        //去年同期
        c.setTime(DateUtils.addYears(begin, -1));
        int year_year = c.get(Calendar.YEAR);
        int year_month = c.get(Calendar.MONTH) + 1;

        Map<String, CureFittingVo> windMap = new HashMap<>();

        if (windturbineCapacity == null) {
            windturbineCapacity = new HashMap<>();
            Map<String, ProEconEquipmentmodel> modelMap = CacheContext.modelMap;
            for (ProBasicEquipment windturbine : CacheContext.wtls) {
                if (modelMap.containsKey(windturbine.getModelId())) {
                    windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction());
                }
            }
        }



        for (ProBasicEquipment wt : wtls) {
            String windturbineId = wt.getId();

            if(wt.getWindpowerstationId().contains(WpType.GDC.id) )
            {
                continue;
            }
            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(WpType.GDC.id)) {   //测风塔70米风速

                if (windturbinetestingpointnewMap.containsKey(ContantXk.FCCFTFS70)) {
                    ProBasicEquipmentPoint point = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70);

                    if (StringUtils.notEmp(point.getNemCode()) && !point.getNemCode().equals(initialcode)) {
                        pointIdFS = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70).getNemCode();
                    } else {
                        pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
                    }
                } else {
                    pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
                }


            } else {   //设备风速
                pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
            }


            CureFittingVo item = new CureFittingVo();

            item.setPointIdFS(pointIdFS);
            item.setPointIdZT(pointIdZT);
            item.setPointIdGL(pointIdGL);

            //获取标杆风机编号
            if (CacheContext.wtstandardmap.containsKey(wt.getId())) {
                item.setStandardId(CacheContext.wtstandardmap.get(wt.getId()));
            } else {
                item.setStandardId(wt.getId());
            }

            windMap.put(windturbineId, item);
        }

        for (String key : windMap.keySet()) {
            //初始化集合
            windMap.get(key).setYsjglPoints(new ArrayList<>());
            windMap.get(key).setYzyglPoints(new ArrayList<>());
            windMap.get(key).setRsjglPoints(new ArrayList<>());
            windMap.get(key).setRzyglPoints(new ArrayList<>());
            windMap.get(key).setNsjglPoints(new ArrayList<>());
            windMap.get(key).setNzyglPoints(new ArrayList<>());

            if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) {
                logger.info(key);
                continue;
            }

            //拟合月功率曲线
            curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key);

            List<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);

            logger.info(key+"曲线拟合完成！");
        }
        logger.info("曲线拟合完成！");
        List<ProEconCurveFittMonthMain> mainls=new ArrayList<>();
        for (String key : windMap.keySet()) {

            Double modelpower = 1500.0;
            if (windturbineCapacity.containsKey(key)) {
                modelpower = windturbineCapacity.get(key);
            }


            //月的上月
            List<PointVo> monthLastMonthPoints = new ArrayList<>();
            //月的去年同期
            List<PointVo> monthLastYearPoints = new ArrayList<>();
            //月标准功率
            List<PointVo> monthStandardPoints = 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)) {

                        monthStandardPoints = windMap.get(standardId).getYsjglPoints();

                    }
                }
            }
            String stringyear = String.valueOf(day_year);
            String stringmonth = String.valueOf(day_month);

            String stringyear2 = String.valueOf(month_year);
            String stringmonth2 = String.valueOf(month_month);

            String stringyear3 = String.valueOf(year_year);
            String stringmonth3 = String.valueOf(year_month);


//*********************************************月曲线偏差上个月和上一年记录**********************************************************/
            QueryWrapper<ProEconWtCurveFittingMonth> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("year",stringyear2).eq("month",stringmonth2).eq("windturbine_id",key);
            List<ProEconWtCurveFittingMonth> wcfmls = proEconWtCurveFittingMonthService.list(queryWrapper).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);
            QueryWrapper<ProEconWtCurveFittingMonth> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("year",stringyear3).eq("month",stringmonth3).eq("windturbine_id",key);
            wcfmls = proEconWtCurveFittingMonthService.list(queryWrapper2).stream()
//                    .filter(i -> i.getWindturbineId().equals(key) &&
//                    i.getYear().equals(stringyear3) && i.getMonth().equals(stringmonth3))
                    .sorted(Comparator.comparing(ProEconWtCurveFittingMonth::getSpeed)).collect(Collectors.toList());

            monthBuildPoints(wcfmls, monthLastYearPoints);
//*********************************************月曲线偏差上个月和上一年记录**********************************************************/

            if (CacheContext.wtmap.containsKey(key)) {
                String modelid = CacheContext.wtmap.get(key).getModelId();
                if (StringUtils.notEmp(modelid)) {
                    //获取模型功率曲线
                    if (CacheContext.theoreticalPowerMap.containsKey(modelid)) {
                        for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) {
                            PointVo point = new PointVo();
                            point.setX(speed);
                            point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower());

                            bzglpowerPoints.add(point);
                        }
                    }
                }
            }

//*********************************************年曲线偏差记录**********************************************************/


//*********************************************当月曲线偏差记录**********************************************************/
            QueryWrapper<ProEconCurveFittMonthMain> queryWrapper3 = new QueryWrapper<>();
            queryWrapper3.eq("year",stringyear).eq("month",stringmonth).eq("windturbine_id",key);
            Optional<ProEconCurveFittMonthMain> cfmmontho = proEconCurveFittMonthMainService.list(queryWrapper3).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(day_year));
            cfmmonth.setMonth(String.valueOf(day_month));

            //月---实际/最优
            cfmmonth.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), modelpower));
            //月---实际/保证
            cfmmonth.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), bzglpowerPoints, modelpower));
            //月---最优/保证
            cfmmonth.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYzyglPoints(), bzglpowerPoints, modelpower));
            //月---实际/上月实际
            cfmmonth.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), monthLastMonthPoints, modelpower));
            //月---实际/同期实际
            cfmmonth.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), monthLastYearPoints, modelpower));
            //月---实际/标杆实际
            cfmmonth.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), monthStandardPoints, modelpower));

            mainls.add(cfmmonth);
            // proEconCurveFittMonthMainService.save(cfmmonth);

            //*********************************************当月曲线偏差记录**********************************************************/
            List<ProEconCurveFittMonthSub> subls=new ArrayList<>();
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 3, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 4, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 5, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 6, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 7, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 8, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 9, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 10, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 11, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 12, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));
            subls.add(pLCBuild(key, stringyear, stringmonth, windMap, modelpower, 13, bzglpowerPoints, monthLastMonthPoints, monthLastYearPoints, monthStandardPoints));


            List<ProEconCurveFittMonthSub> templs=new ArrayList<>();
            for(ProEconCurveFittMonthSub vo:subls)
            {
                templs.add(vo);
                if(templs.size()==1000)
                {
                    proEconCurveFittMonthSubService.saveBatch(templs);
                    templs=new ArrayList<>();
                }
            }

            if(!templs.isEmpty())
            {
                proEconCurveFittMonthSubService.saveBatch(templs);
            }
//            proEconCurveFittMonthSubService.saveBatch(subls);
            insertPoints(stringyear, stringmonth, windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key);

            if(type.equals("1"))
            {
                insertPoints2( windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), key);
            }

            logger.info(key+"月曲线偏差率完成！");
//            logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date()));


        }

        List<ProEconCurveFittMonthMain> templs=new ArrayList<>();
        for(ProEconCurveFittMonthMain vo:mainls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconCurveFittMonthMainService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconCurveFittMonthMainService.saveBatch(templs);
        }
//        proEconCurveFittMonthMainService.saveBatch(mainls);

        logger.info("曲线保存完成！");
    }


    public void cureFittingYear(Date recordDate,String wpId) throws Exception {
        //日期变为昨天
        Date end = DateUtils.addDays(DateUtils.truncate(recordDate), 1);

        Calendar c = Calendar.getInstance();

        c.setTime(recordDate);
        int day_year = c.get(Calendar.YEAR);
        List<ProBasicEquipment> wtls=new ArrayList<>();
        if(StringUtils.notEmp(wpId) && CacheContext.wpwtmap.containsKey(wpId))
        {
            wtls=CacheContext.wpwtmap.get(wpId);
        }else
        {
            wtls=CacheContext.wtls;
        }
        StringBuilder sb=new StringBuilder();
        for(ProBasicEquipment wt:wtls)
        {
            sb.append("'").append(wt.getId()).append("',");
        }
        String wtIds=sb.substring(0,sb.length()-1);

        proEconWtCurveFittingYearService.deleteProEconWtCurveFittingFByYear(String.valueOf(day_year), wtIds);
        proEconCurveFittYearMainService.deleteProEconCurveFittYearMainFByYear(String.valueOf(day_year), wtIds);
        proEconCurveFittYearSubService.deleteProEconCurveFittYearSubFByYear(String.valueOf(day_year), wtIds);
        c.set(Calendar.DAY_OF_MONTH, 1);
        c.set(Calendar.MONTH, 0);
        Date begin = c.getTime();


        //去年同期
        c.setTime(DateUtils.addYears(begin, -1));
        int year_year = c.get(Calendar.YEAR);


        Map<String, CureFittingVo> windMap = new HashMap<>();

        if (windturbineCapacity == null) {
            windturbineCapacity = new HashMap<>();
            Map<String, ProEconEquipmentmodel> modelMap = CacheContext.modelMap;
            for (ProBasicEquipment windturbine : CacheContext.wtls) {
                if (modelMap.containsKey(windturbine.getModelId())) {
                    windturbineCapacity.put(windturbine.getId(), modelMap.get(windturbine.getModelId()).getPowerProduction());
                }
            }
        }


        for (ProBasicEquipment wt : wtls) {
            String windturbineId = wt.getId();

            if(wt.getWindpowerstationId().contains(WpType.GDC.id))
            {
                continue;
            }
            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(WpType.GDC.id)) {   //测风塔70米风速

                if (windturbinetestingpointnewMap.containsKey(ContantXk.FCCFTFS70)) {
                    ProBasicEquipmentPoint point = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70);

                    if (StringUtils.notEmp(point.getNemCode()) && !point.getNemCode().equals(initialcode)) {
                        pointIdFS = windturbinetestingpointnewMap.get(ContantXk.FCCFTFS70).getNemCode();
                    } else {
                        pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
                    }
                } else {
                    pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
                }


            } else {   //设备风速
                pointIdFS = windturbinetestingpointnewMap.get(ContantXk.CJ_SSFS).getNemCode();
            }


            CureFittingVo item = new CureFittingVo();

            item.setPointIdFS(pointIdFS);
            item.setPointIdZT(pointIdZT);
            item.setPointIdGL(pointIdGL);

            //获取标杆风机编号
            if (CacheContext.wtstandardmap.containsKey(wt.getId())) {
                item.setStandardId(CacheContext.wtstandardmap.get(wt.getId()));
            } else {
                item.setStandardId(wt.getId());
            }

            windMap.put(windturbineId, item);
        }

        for (String key : windMap.keySet()) {
            //初始化集合
            windMap.get(key).setYsjglPoints(new ArrayList<>());
            windMap.get(key).setYzyglPoints(new ArrayList<>());
            windMap.get(key).setRsjglPoints(new ArrayList<>());
            windMap.get(key).setRzyglPoints(new ArrayList<>());
            windMap.get(key).setNsjglPoints(new ArrayList<>());
            windMap.get(key).setNzyglPoints(new ArrayList<>());

//            if (windMap.get(key).getPointIdGL() == null || windMap.get(key).getPointIdFS() == null || windMap.get(key).getPointIdZT() == null) {
//                logger.info(key);
//                continue;
//            }


            //拟合年功率曲线
            //  curveFittingBuilder(begin, end, dimension, scale, windMap.get(key).getPointIdGL(), windMap.get(key).getPointIdFS(), windMap.get(key).getPointIdZT(), windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key);
            QueryWrapper<ProEconWtPowerCurveFitting> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("windturbine_id",key);
            List<ProEconWtPowerCurveFitting> wtpowerls= proEconWtPowerCurveFittingService.list(queryWrapper)
                    .stream()
//                    .filter(i->i.getWindturbineId().equals(key))
                    .sorted(Comparator.comparing(ProEconWtPowerCurveFitting::getSpeed)).collect(Collectors.toList());

            List<PointVo> zyglls=new ArrayList<>();
            List<PointVo> sjglls=new ArrayList<>();
            if(!wtpowerls.isEmpty())
            {

                for(ProEconWtPowerCurveFitting wtp:wtpowerls)
                {
                    PointVo zyvo=new PointVo();
                    zyvo.setX(wtp.getSpeed());
                    zyvo.setY(wtp.getOptimalPower());
                    zyglls.add(zyvo);

                    PointVo sjvo=new PointVo();
                    sjvo.setX(wtp.getSpeed());
                    sjvo.setY(wtp.getActualPower());
                    sjglls.add(sjvo);
                }
            }
//            List<PointVo> 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);


            windMap.get(key).setNsjglPoints(sjglls);
            windMap.get(key).setNzyglPoints(zyglls);
        }

        List<ProEconCurveFittYearMain> mainls=new ArrayList<>();
        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> bzglpowerPoints = new ArrayList<>();


            if (CacheContext.wtstandardmap.containsKey(key)) {
                String standardId = CacheContext.wtstandardmap.get(key);
                if (StringUtils.notEmp(standardId)) {
                    if (windMap.containsKey(key)) {
                        yearStandardPoints = windMap.get(standardId).getNsjglPoints();

                    }
                }
            }

            String stringyear = String.valueOf(day_year);


            String stringyear3 = String.valueOf(year_year);


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

            QueryWrapper<ProEconWtCurveFittingYear> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("year",stringyear3).eq("windturbine_id",key);
            List<ProEconWtCurveFittingYear> wcfyls = proEconWtCurveFittingYearService.list(queryWrapper).stream()
//                    .filter(i -> i.getWindturbineId().equals(key) &&
//                    i.getYear().equals(stringyear3))
                    .sorted(Comparator.comparing(ProEconWtCurveFittingYear::getSpeed)).collect(Collectors.toList());

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

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

            if (CacheContext.wtmap.containsKey(key)) {
                String modelid = CacheContext.wtmap.get(key).getModelId();
                if (StringUtils.notEmp(modelid)) {
                    //获取模型功率曲线
                    if (CacheContext.theoreticalPowerMap.containsKey(modelid)) {
                        for (Double speed : CacheContext.theoreticalPowerMap.get(modelid).keySet()) {
                            PointVo point = new PointVo();
                            point.setX(speed);
                            point.setY(CacheContext.theoreticalPowerMap.get(modelid).get(speed).getEnsurePower());

                            bzglpowerPoints.add(point);
                        }
                    }
                }
            }
//*********************************************年曲线偏差记录**********************************************************/

//*********************************************当年曲线偏差记录**********************************************************/
            QueryWrapper<ProEconCurveFittYearMain> queryWrapper2 = new QueryWrapper<>();
            queryWrapper2.eq("year",stringyear).eq("windturbine_id",key);
            Optional<ProEconCurveFittYearMain> cfmyearo = proEconCurveFittYearMainService.list(queryWrapper2)
                    .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(day_year));


            //年---实际/最优
            cfmyear.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), modelpower));
            //年---实际/保证
            cfmyear.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), bzglpowerPoints, modelpower));
            //年---最优/保证
            cfmyear.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNzyglPoints(), bzglpowerPoints, modelpower));
            //年---实际/上月实际
            cfmyear.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), yearLastMonthPoints, modelpower));
            //年---实际/同期实际
            cfmyear.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), yearLastYearPoints, modelpower));
            //年---实际/标杆实际
            cfmyear.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), yearStandardPoints, modelpower));

            mainls.add(cfmyear);
            // proEconCurveFittYearMainService.save(cfmyear);

//*********************************************当年曲线偏差记录**********************************************************/
            List<ProEconCurveFittYearSub> subls=new ArrayList<>();
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 3, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 4, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 5, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 6, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 7, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 8, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 9, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 10, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 11, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 12, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));
            subls.add(pLCBuild(key, stringyear, windMap, modelpower, 13, bzglpowerPoints, yearLastMonthPoints, yearLastYearPoints, yearStandardPoints));


            List<ProEconCurveFittYearSub> templs=new ArrayList<>();
            for(ProEconCurveFittYearSub vo:subls)
            {
                templs.add(vo);
                if(templs.size()==1000)
                {
                    proEconCurveFittYearSubService.saveBatch(templs);
                    templs=new ArrayList<>();
                }
            }

            if(!templs.isEmpty())
            {
                proEconCurveFittYearSubService.saveBatch(templs);
            }
//            proEconCurveFittYearSubService.saveBatch(subls);
            insertPoints(stringyear, windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), key);

            logger.info(key);
//
//            logger.info(String.format("{1}:更新sqlserver数据库记录数：{0}", z, new Date()));


        }

        List<ProEconCurveFittYearMain> templs=new ArrayList<>();
        for(ProEconCurveFittYearMain vo:mainls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconCurveFittYearMainService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconCurveFittYearMainService.saveBatch(templs);
        }
//        proEconCurveFittYearMainService.saveBatch(mainls);
    }


    public ProEconCurveFittingSub pLCBuild(String key, Date current, Map<String, CureFittingVo> windMap, Double modelpower, double speed,
                                           List<PointVo> bzglpowerPoints, List<PointVo> lastMonthPoints, List<PointVo> lastYearPoints, List<PointVo> lastStandardPoints
    ) {

//        String speedStr = String.valueOf(speed);

//*********************************************当日曲线偏差子表记录**********************************************************/
        QueryWrapper<ProEconCurveFittingSub> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("record_date",current).eq("speed",speed).eq("windturbine_id",key);
        Optional<ProEconCurveFittingSub> cfmso = proEconCurveFittingSubService.list(queryWrapper2)
                .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(speed);
        cfms.setRecordDate(DateUtils.truncate(current));


        cfms.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), windMap.get(key).getRzyglPoints(), modelpower, speed));
        //日---实际/保证
        cfms.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), bzglpowerPoints, modelpower, speed));
        //日---最优/保证
        cfms.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRzyglPoints(), bzglpowerPoints, modelpower, speed));
        //日---实际/上日实际
        cfms.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), lastMonthPoints, modelpower, speed));
        //日---实际/同期实际
        cfms.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), lastYearPoints, modelpower, speed));
        //日---实际/标杆实际
        cfms.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getRsjglPoints(), lastStandardPoints, modelpower, speed));

        return cfms;

        //proEconCurveFittingSubService.save(cfms);
//*********************************************当日曲线偏差子表记录**********************************************************/
    }

    public ProEconCurveFittMonthSub pLCBuild(String key, String stringyear, String stringmonth, Map<String, CureFittingVo> windMap, Double modelpower, double speed,
                                             List<PointVo> bzglpowerPoints, List<PointVo> lastMonthPoints, List<PointVo> lastYearPoints, List<PointVo> lastStandardPoints
    ) {
//        String speedStr = String.valueOf(speed);

        //*********************************************当月曲线偏差子表记录**********************************************************/
        QueryWrapper<ProEconCurveFittMonthSub> queryWrapper2 = new QueryWrapper<>();
        queryWrapper2.eq("year",stringyear).eq("month",stringmonth).eq("speed",speed).eq("windturbine_id",key);
        Optional<ProEconCurveFittMonthSub> cfmsmontho = proEconCurveFittMonthSubService.list(queryWrapper2).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(speed);



        //月---实际/最优
        cfmsmonth.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), windMap.get(key).getYzyglPoints(), modelpower, speed));
        //月---实际/保证
        cfmsmonth.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), bzglpowerPoints, modelpower, speed));
        //月---最优/保证
        cfmsmonth.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYzyglPoints(), bzglpowerPoints, modelpower, speed));
        //月---实际/上月实际
        cfmsmonth.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), lastMonthPoints, modelpower, speed));
        //月---实际/同期实际
        cfmsmonth.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), lastYearPoints, modelpower, speed));
        //月---实际/标杆实际
        cfmsmonth.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getYsjglPoints(), lastStandardPoints, modelpower, speed));

//        proEconCurveFittMonthSubService.save(cfmsmonth);

        return cfmsmonth;
//*********************************************当月曲线偏差子表记录**********************************************************/
    }

    public ProEconCurveFittYearSub pLCBuild(String key, String stringyear, Map<String, CureFittingVo> windMap, Double modelpower, double speed,
                                            List<PointVo> bzglpowerPoints, List<PointVo> lastMonthPoints, List<PointVo> lastYearPoints, List<PointVo> lastStandardPoints
    ) {
//        String speedStr = String.valueOf(speed);

        //*********************************************当年曲线偏差子表记录**********************************************************/
        QueryWrapper<ProEconCurveFittYearSub> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("year",stringyear).eq("speed",speed).eq("windturbine_id",key);
        Optional<ProEconCurveFittYearSub> cfmsyearo = proEconCurveFittYearSubService.list(queryWrapper).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(speed);

        // proEconCurveFittYearSubService.save(cfmsyear);

        //年---实际/最优
        cfmsyear.setDeviationRate1(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), windMap.get(key).getNzyglPoints(), modelpower, speed));
        //年---实际/保证
        cfmsyear.setDeviationRate2(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), bzglpowerPoints, modelpower, speed));
        //年---最优/保证
        cfmsyear.setDeviationRate3(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNzyglPoints(), bzglpowerPoints, modelpower, speed));
        //年---实际/上月实际
        cfmsyear.setMonthDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), lastMonthPoints, modelpower, speed));
        //年---实际/同期实际
        cfmsyear.setYearDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), lastYearPoints, modelpower, speed));
        //年---实际/标杆实际
        cfmsyear.setStandardDeviationRate(DeviationRateUtil.calculateDeviationRate(windMap.get(key).getNsjglPoints(), lastStandardPoints, modelpower, speed));

//        proEconCurveFittYearSubService.save(cfmsyear);
        return cfmsyear;
//*********************************************当年曲线偏差子表记录**********************************************************/
    }


    private void insertPoints(Date current, List<PointVo> sjglls, List<PointVo> zyglls, String windturbineId) {

        //*********************************************当日曲线偏差记录**********************************************************/
//        List<Long> 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);
//        }

        List<ProEconWtCurveFitting> wtcfls=new ArrayList<>();
        if (sjglls.size() == zyglls.size()) {
            for (int i = 0; i < sjglls.size(); i++) {
                ProEconWtCurveFitting item = new ProEconWtCurveFitting();
                item.setWindturbineId(windturbineId);

                if (CacheContext.wtmap.containsKey(windturbineId)) {
                    ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                    if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                        continue;
                        // item.SPEED = Double.Truncate(pointsF2[i].X);
                    } else {
//                        boolean l = String.valueOf(sjglls.get(i).getX()).contains(".");
//                        if (l) {
//                            continue;
//                        }
//                        item.setSpeed(sjglls.get(i).getX());
                        item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                    }


//                    item.setActualPower(sjglls.get(i).getY());
//                    item.setOptimalPower(zyglls.get(i).getY());

                    item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                    item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                    item.setRecordDate(DateUtils.truncate(current));

                    wtcfls.add(item);
                    //proEconWtCurveFittingService.save(item);

                }

            }
        } else {
            logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size()));

            for (int i = 0; i < sjglls.size(); i++) {
                ProEconWtCurveFitting item = new ProEconWtCurveFitting();
                item.setWindturbineId(windturbineId);

                if (CacheContext.wtmap.containsKey(windturbineId)) {
                    ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                    if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                        continue;
                        //item.SPEED = Double.Truncate(pointsF2[i].X);
                    } else {
                        boolean l = String.valueOf(sjglls.get(i).getX()).contains(".");
                        if (l) {
                            continue;
                        }
//                        item.setSpeed(sjglls.get(i).getX());
                        item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                    }


                    int finalI = i;
                    OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst();

                    if (op.isPresent()) {
                        item.setOptimalPower(op.getAsDouble());
                    } else {
                        item.setOptimalPower(0.0);
                    }

//                    item.setActualPower(sjglls.get(i).getY());
                    item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                    item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                    item.setRecordDate(current);
                    wtcfls.add(item);
                    //proEconWtCurveFittingService.save(item);
                }

            }
            //*********************************************当日曲线偏差记录**********************************************************/
        }

        List<ProEconWtCurveFitting> templs=new ArrayList<>();
        for(ProEconWtCurveFitting vo:wtcfls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconWtCurveFittingService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconWtCurveFittingService.saveBatch(templs);
        }
//        proEconWtCurveFittingService.saveBatch(wtcfls);


        if(!wtcfls.isEmpty())
        {
            redisService.select(9);
            String s = JSONObject.toJSONString(wtcfls);
            redisService.set(CurveType.dayCurve.id+"_"+windturbineId, s);
        }

    }


    private void insertPoints(String year, String month, List<PointVo> sjglls, List<PointVo> zyglls, String windturbineId) {

        //*********************************************当月曲线偏差记录**********************************************************/
//        List<Long> 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);
//        }
        List<ProEconWtCurveFittingMonth> wtcfls=new ArrayList<>();
        if (sjglls.size() == zyglls.size()) {
            for (int i = 0; i < sjglls.size(); i++) {
                ProEconWtCurveFittingMonth item = new ProEconWtCurveFittingMonth();

                item.setWindturbineId(windturbineId);
                if (CacheContext.wtmap.containsKey(windturbineId)) {
                    ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                    if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                        continue;
                        // item.SPEED = Double.Truncate(pointsF1[i].X);
                    } else {
                        //item.setSpeed(sjglls.get(i).getX());
                        item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                    }
//                    item.setActualPower(sjglls.get(i).getY());
//                    item.setOptimalPower(zyglls.get(i).getY());
                    item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                    item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                    item.setYear(String.valueOf(year));
                    item.setMonth(String.valueOf(month));
                    wtcfls.add(item);
                    // proEconWtCurveFittingMonthService.save(item);
                }

            }
        } else {
            logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size()));


            if(!sjglls.isEmpty() && !zyglls.isEmpty()   && sjglls.size() == zyglls.size())
            {
                for (int i = 0; i < sjglls.size(); i++) {
                    ProEconWtCurveFittingMonth item = new ProEconWtCurveFittingMonth();
                    item.setWindturbineId(windturbineId);
                    if (CacheContext.wtmap.containsKey(windturbineId)) {

                        ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                        if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                            continue;
                            //item.SPEED = Double.Truncate(pointsF1[i].X);
                        } else {

//                        item.setSpeed(sjglls.get(i).getX());
                            item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                        }
//                    item.setActualPower(sjglls.get(i).getY());

                        int finalI = i;
                        OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst();

                        if (op.isPresent()) {
                            item.setOptimalPower(op.getAsDouble());
                        } else {
                            item.setOptimalPower(0.0);
                        }
                        item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                        item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                        item.setYear(String.valueOf(year));
                        item.setMonth(String.valueOf(month));
                        wtcfls.add(item);
                        //proEconWtCurveFittingMonthService.save(item);
                    }

                }
            }

        }
        //*********************************************当月曲线偏差记录**********************************************************/

        List<ProEconWtCurveFittingMonth> templs=new ArrayList<>();
        for(ProEconWtCurveFittingMonth vo:wtcfls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconWtCurveFittingMonthService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconWtCurveFittingMonthService.saveBatch(templs);
        }
//        proEconWtCurveFittingMonthService.saveBatch(wtcfls);

        if(!wtcfls.isEmpty())
        {
            redisService.select(9);
            String s = JSONObject.toJSONString(wtcfls);
            redisService.set(CurveType.monthCurve.id+"_"+windturbineId, s);
        }

    }

    private void insertPoints(String year,  List<PointVo> sjglls, List<PointVo> zyglls, String windturbineId) {
        //*********************************************当年曲线偏差记录**********************************************************/
//        List<Long> 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);
//        }
        List<ProEconWtCurveFittingYear> wtcfls=new ArrayList<>();
        if (sjglls.size() == zyglls.size()) {
            for (int i = 0; i < sjglls.size(); i++) {
                ProEconWtCurveFittingYear item = new ProEconWtCurveFittingYear();

                item.setWindturbineId(windturbineId);
                if (CacheContext.wtmap.containsKey(windturbineId)) {
                    ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                    if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                        continue;
                        // item.SPEED = Double.Truncate(pointsF1[i].X);
                    } else {
//                        item.setSpeed(sjglls.get(i).getX());
                        item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                    }
//                    item.setActualPower(sjglls.get(i).getY());
//                    item.setOptimalPower(zyglls.get(i).getY());
                    item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                    item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                    item.setYear(String.valueOf(year));
                    wtcfls.add(item);
                    // proEconWtCurveFittingYearService.save(item);
                }

            }
        } else {
            logger.warn(String.format("下标不一致的风机编号：{0}，实际功率：{1}，最有功率：{2}", windturbineId, sjglls.size(), zyglls.size()));


            for (int i = 0; i < sjglls.size(); i++) {
                ProEconWtCurveFittingYear item = new ProEconWtCurveFittingYear();
                item.setWindturbineId(windturbineId);
                if (CacheContext.wtmap.containsKey(windturbineId)) {

                    ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                    if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                        continue;
                        //item.SPEED = Double.Truncate(pointsF1[i].X);
                    } else {

//                        item.setSpeed(sjglls.get(i).getX());
                        item.setSpeed(StringUtils.round(sjglls.get(i).getX(),2));
                    }
//                    item.setActualPower(sjglls.get(i).getY());

                    int finalI = i;
                    OptionalDouble op = zyglls.stream().filter(x -> Objects.equals(x.getX(), sjglls.get(finalI).getX())).mapToDouble(PointVo::getY).findFirst();

                    if (op.isPresent()) {
                        item.setOptimalPower(op.getAsDouble());
                    } else {
                        item.setOptimalPower(0.0);
                    }
                    item.setActualPower(StringUtils.round(sjglls.get(i).getY(),2));
                    item.setOptimalPower(StringUtils.round(zyglls.get(i).getY(),2));
                    item.setYear(String.valueOf(year));
                    wtcfls.add(item);
                    //proEconWtCurveFittingYearService.save(item);
                }

            }
        }
        //*********************************************当年曲线偏差记录**********************************************************/


        List<ProEconWtCurveFittingYear> templs=new ArrayList<>();
        for(ProEconWtCurveFittingYear vo:wtcfls)
        {
            templs.add(vo);
            if(templs.size()==1000)
            {
                proEconWtCurveFittingYearService.saveBatch(templs);
                templs=new ArrayList<>();
            }
        }

        if(!templs.isEmpty())
        {
            proEconWtCurveFittingYearService.saveBatch(templs);
        }
//        proEconWtCurveFittingYearService.saveBatch(wtcfls);

        if(!wtcfls.isEmpty())
        {
            redisService.select(9);
            String s = JSONObject.toJSONString(wtcfls);
            redisService.set(CurveType.yearCurve.id+"_"+windturbineId, s);
        }
    }
    private void insertPoints2(List<PointVo> monthSjglls, List<PointVo> monthZyglls, String windturbineId) {



        if(!monthSjglls.isEmpty() && !monthZyglls.isEmpty())
        {
            QueryWrapper<ProEconWtPowerCurveFitting> queryWrapper = new QueryWrapper<>();
            if (com.gyee.common.model.StringUtils.isNotEmpty(windturbineId)){
                queryWrapper.eq("windturbine_id",windturbineId);
            }

            List<ProEconWtPowerCurveFitting> ls= proEconWtPowerCurveFittingService.list(queryWrapper);

            List<Long> wtpcfidls = ls.stream().map(ProEconWtPowerCurveFitting::getId).collect(Collectors.toList());

            for (int i = 0; i < wtpcfidls.size(); i++) {
                proEconWtPowerCurveFittingService.removeByIds(wtpcfidls);
            }


//        proEconWtPowerCurveFittingService.deleteProEconWtPowerCurveFitting();
            List<ProEconWtPowerCurveFitting> wtcfls=new ArrayList<>();
            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(WpType.GDC.id)) {
                            continue;
                            // item.SPEED = Double.Truncate(pointsF1[i].X);
                        } else {
                            //item.setSpeed(sjglls.get(i).getX());
                            item.setSpeed(StringUtils.round(monthSjglls.get(i).getX(),2));
                        }
//                    item.setActualPower(sjglls.get(i).getY());
//                    item.setOptimalPower(zyglls.get(i).getY());
                        item.setActualPower(StringUtils.round(monthSjglls.get(i).getY(),2));
                        item.setOptimalPower(StringUtils.round(monthSjglls.get(i).getY(),2));
                        wtcfls.add(item);
                        // proEconWtCurveFittingMonthService.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(WpType.GDC.id)) {
                            continue;
                            //item.SPEED = Double.Truncate(pointsF1[i].X);
                        } else {

//                        item.setSpeed(sjglls.get(i).getX());
                            item.setSpeed(StringUtils.round(monthSjglls.get(i).getX(),2));
                        }
//                    item.setActualPower(sjglls.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.setActualPower(StringUtils.round(monthSjglls.get(i).getY(),2));
                        item.setOptimalPower(StringUtils.round(monthSjglls.get(i).getY(),2));
                        wtcfls.add(item);
                        //proEconWtCurveFittingMonthService.save(item);
                    }

                }
            }
            //*********************************************当月曲线偏差记录**********************************************************/


            List<ProEconWtPowerCurveFitting> templs=new ArrayList<>();
            for(ProEconWtPowerCurveFitting vo:wtcfls)
            {
                templs.add(vo);
                if(templs.size()==1000)
                {
                    proEconWtPowerCurveFittingService.saveBatch(templs);
                    templs=new ArrayList<>();
                }
            }

            if(!templs.isEmpty())
            {
                proEconWtPowerCurveFittingService.saveBatch(templs);
            }
        }

//        proEconWtPowerCurveFittingService.saveBatch(wtcfls);
    }

    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 DeviationRateUtil.calculateDeviationRate(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 DeviationRateUtil.calculateDeviationRate(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, List<PointData> ztls,List<PointData> qfztls,int i, double maxPower,double maxSpeed, String windturbineId) throws Exception {
        if (StringUtils.notEmp(gl)) {
            //判定功率是否超过最大值
            if (gl.getPointValueInDouble() > maxPower || gl.getPointValueInDouble()<0) {
                return false;
            }
        }

        if (StringUtils.notEmp(fs)) {
            //判定功率是否超过最大值
            if (fs.getPointValueInDouble() > maxSpeed || fs.getPointValueInDouble()<0) {
                return false;
            }
        }

        //判定状态不为运行的进行过滤
        if (ztls.get(i).getPointValueInDouble() != 2) {
            return false;
        }

        if(i!=0)
        {

            if (ztls.get(i-1).getPointValueInDouble() != 2) {
                return false;
            }
        }

        //欠发
        if (fs.getPointValueInDouble() == 0 && fs.getPointValueInDouble() >= 6 && fs.getPointValueInDouble() < 12.5 && qfztls.get(i).getPointValueInDouble() > 2) {
            return false;
        }else if (fs.getPointValueInDouble() >= 12.5 && qfztls.get(i).getPointValueInDouble() < 1) {
            return false;
        }


        if (CacheContext.wtmap.containsKey(windturbineId)) {
            String modelid = CacheContext.wtmap.get(windturbineId).getModelId();
            if (StringUtils.notEmp(modelid)) {
                //获取保证功率曲线中的风速和功率
                if (CacheContext.theoreticalPowerMap.containsKey(modelid)) {
                    Map<Double,ProBasicModelPowerRd> theoreticalMap= CacheContext.theoreticalPowerMap.get(modelid);


                    double speed=StringUtils.round(fs.getPointValueInDouble(),2);

                    double power = theoreticalMap.get(speed).getEnsurePower();  //不同风速对应的保证功率
                    double k = gl.getPointValueInDouble() / power;  //保证功率/实际功率   k:偏差百分比
                    if (gl.getPointValueInDouble() > 0) {
                        if (k < 0.95 && maxPower <= power) {
                            return false;
                        }
                        if (k < 0.9 && maxPower > power) {
                            return false;
                        }
                        if (k < 0.85 && speed < 6 && speed > 4) {
                            return false;
                        }

                        if (k < 0.9 && speed <= 4 && speed > 3.5) {
                            return false;
                        }

                    }

                }
            }
        }
//
//        //欠发状态大于2过滤掉
//        if (qfztls.get(i).getPointValueInDouble() > 2) {
//
//            return false;
//        }

        return true;
    }

    //功率曲线拟合
    private 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) ;
        double maxSpeed = 25;
        List<PointfVo> sjglnhpoints = new ArrayList<>();
        Map<Double, PointfVo> zyglnhpoints = new HashMap<>();

        Map<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = CacheContext.wtpAimap;
        Map<String, ProBasicEquipmentPoint> wtpointmap = wtpAimap.get(windturbineId);
        String qfzt= wtpointmap.get(ContantXk.LSQFZT).getNemCode();

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


                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,qfzttemp,i, maxPower,maxSpeed, 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(0).getPointValueInDouble();
                        }

                        int finalI = i;
                        yArray = ztpoints.stream().filter(it -> it.getPointTime().compareTo(fspoints.get(finalI).getPointTime()) == 0).collect(Collectors.toList());
                        if (yArray.size() > 0) {

                            z = yArray.get(0).getPointValueInDouble();
                        }


                        Double x1 = StringUtils.round(x, 2);
                        Double y1 = y;


                        boolean b = true;

                        if (CacheContext.wtmap.containsKey(windturbineId)) {

                            ProBasicEquipment wt = CacheContext.wtmap.get(windturbineId);
                            if (wt.getWindpowerstationId().contains(WpType.GDC.id)) {
                                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(WpType.GDC.id)) {
                                b = (x >= 0 && y > 0);
                            } else {
                                if (z == 2) {

                                    b = (x >= 0 && x <= 30 && y >= 0 && y <= maxPower);

                                    if (b) {
                                        if (x > 3 && y <= 0) {
                                            b = false;
                                        }
                                        if (x <= 3 && y > 0) {
                                            b = false;
                                        }
                                    }

                                } else {
                                    b = false;
                                }
                            }
                        }

                        if (b) {
                            sjglnhpoints.add(new PointfVo(x1, y1));

                            if (zyglnhpoints.containsKey(x1)) {
                                if (zyglnhpoints.get(x1).getY() < y1) {
                                    zyglnhpoints.put(x1, new PointfVo(x1, y1));

                                }
                            } else {
                                zyglnhpoints.put(x1, new PointfVo(x1, y1));
                            }

                        }
                    }
                }
                sjglnhpoints.add(new PointfVo(0.0, 0.0));

                sjglnhpoints = sjglnhpoints.stream().filter(it -> it.getX() >= 3).sorted(Comparator.comparing(PointfVo::getX)).collect(Collectors.toList());
//                if (sjglnhpoints.stream().min(Comparator.comparing(PointfVo::getX)).isPresent()) {
//                    double  Xmax = sjglnhpoints.stream().max(Comparator.comparing(PointfVo::getX)).get().getX();
//                    double  Ymax = sjglnhpoints.stream().max(Comparator.comparing(PointfVo::getX)).get().getY();
//                    System.out.println("");
//                }

                List<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);
        }
    }

}