neim/neim-biz/src/main/java/com/jiayue/biz/service/impl/WindTowerCalculationDataServiceImpl.java

package com.jiayue.biz.service.impl;

import cn.hutool.core.convert.Convert;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jiayue.biz.conf.RequestDataHelper;
import com.jiayue.biz.domain.*;
import com.jiayue.biz.dto.SpeedAndDensityDto;
import com.jiayue.biz.mapper.WindTowerCalculationDataMapper;
import com.jiayue.biz.service.EquipmentAttributeService;
import com.jiayue.biz.service.WindTowerCalculationDataService;
import com.jiayue.biz.service.WindTowerInfoService;
import com.jiayue.biz.util.CalculationUtil;
import com.jiayue.biz.util.DateTimeUtil;
import com.jiayue.biz.util.SEDateUtil;
import com.jiayue.common.utils.DateUtil;
import flanagan.analysis.ProbabilityPlot;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 统计数据实现类
 *
 * @author zy
 * @date 2022-08-26
 */
@Slf4j
@Service
@AllArgsConstructor
public class WindTowerCalculationDataServiceImpl extends ServiceImpl<WindTowerCalculationDataMapper, WindTowerCalculationData> implements WindTowerCalculationDataService {

    //风功率密度和平均风速的统一标识
    private final String attributeFunction = "WindPowerDensity";
    private final String shearFunction = "shear";
    private final String turbulenceFunction = "turbulence";
    private final String wsFunction = "ws";
    private final String wsDayFunction = "wsDay";
    private final String wsMonthFunction = "wsMonth";
    private final String wpdFunction = "WindPowerDensity";
    private final String wsMaxMonthFunction = "maxWsMonth";
    private final String turbulenceDay = "turbulenceDay";
    private final String staDay = "staDay";

    private final String windShearFiledName = "windShear";
    private final String windShearDayFiledName = "windShearDay";

    //风切变计算指数
    private final BigDecimal lg30 = new BigDecimal("0.47712125471966244");//lg(30/10)
    private final BigDecimal lg50 = new BigDecimal("0.6989700043360189");//lg(50/10)
    private final BigDecimal lg60 = new BigDecimal("0.7781512503836436");//lg(60/10)
    private final BigDecimal lg70 = new BigDecimal("0.8450980400142568");//lg(70/10)
    private final BigDecimal lg80 = new BigDecimal("0.9030899869919435");//lg(80/10)
    private final BigDecimal lg90 = new BigDecimal("0.9542425094393249");//lg(90/10)
    private final BigDecimal lg100 = new BigDecimal("1.0");//lg(100/10)
    private final BigDecimal lg110 = new BigDecimal("1.0413926851582251");//lg(110/10)
    private final BigDecimal lg120 = new BigDecimal("1.0791812460476249");//lg(120/10)
    private final BigDecimal lg140 = new BigDecimal("1.146128035678238");//lg(140/10)
    private final BigDecimal lg150 = new BigDecimal("1.1760912590556813");//lg(150/10)


    private final WindTowerInfoService windTowerInfoService;

    private final EquipmentAttributeService equipmentAttributeService;


//    @Scheduled(cron = "0 0 2 1/1 * ? ")

    //    @Scheduled(cron = "0 0 2 1/1 * ? ")

    /**
     * 风功率密度和平均风速计算方法
     */
    public ArrayList<WindTowerCalculationData> calculateWindPowerDensity(Long startTime, Long endTime, String eqNo, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {
        //获取对应测风塔数据
        List<ProphaseAnemometryData> anemometryDataList = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime && p.getTs().getTime() <= endTime).collect(Collectors.toList());
        List<ProphaseWeatherData> weatherDataList = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startTime && p.getTs().getTime() <= endTime).collect(Collectors.toList());
        long hour = 3600000L;
        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqNo).list();
        String[] height = windTowerInfos.get(0).getHeights().split(",");
        //定义数据空集合用来装载 结果数据
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //遍历出过滤出的平均风速属性
            for (String h : height) {
                EquipmentAttribute equipmentAttributeAws = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(h + "aws")).collect(Collectors.toList()).get(0);
                EquipmentAttribute equipmentAttributeWpd = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(h + "wpd")).collect(Collectors.toList()).get(0);
                //删除时间段所有数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(new Date(startTime), new Date(endTime), eqNo, equipmentAttributeAws.getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(new Date(startTime), new Date(endTime), eqNo, equipmentAttributeWpd.getId());
                //遍历24小时，用来计算逐小时数据
                for (long time = startTime; time <= endTime; time += hour) {
                    //过滤出对应测风塔数据
                    long finalTime = time;
                    //风数据过滤
                    List<ProphaseAnemometryData> anemometryData = anemometryDataList.stream().filter(w -> w.getTs().getTime() >= finalTime && w.getTs().getTime() <= finalTime + hour - 1000 && w.getLayerHeight().equals(h)).collect(Collectors.toList());
                    //环境数据过滤
                    List<ProphaseWeatherData> weatherData = weatherDataList.stream().filter(w -> w.getTs().getTime() >= finalTime && w.getTs().getTime() <= finalTime + hour - 1000).collect(Collectors.toList());
                    //根据层高获取所有风速数据
                    List<BigDecimal> bigDecimals = anemometryData.stream().map((ProphaseAnemometryData p) -> {
                        if (p.getWsAve() != null) {
                            return BigDecimal.valueOf(p.getWsAve());
                        }
                        return BigDecimal.ZERO;
                    }).collect(Collectors.toList());

                    //风速数据时所有计算的根本，无数据不计算
                    if (!bigDecimals.isEmpty()) {
                        //计算平均风速和风功率密度到数据对象中
                        if (bigDecimals.get(0) == null) {
                            continue;
                        }
                        SpeedAndDensityDto speedAndDensityDto = getSpeedAndDensityDto(bigDecimals, anemometryData, weatherData);
                        //保存风速
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setTime(new Date(time));
                        windTowerCalculationData.setEbId(equipmentAttributeAws.getId());
                        windTowerCalculationData.setEquipmentId(eqNo);
                        windTowerCalculationData.setValue(speedAndDensityDto.getWindSpeed());
                        windTowerCalculationDataList.add(windTowerCalculationData);
                        list.add(windTowerCalculationData);
                        //保存风功率密度
                        WindTowerCalculationData windTowerCalculationDataWpd = new WindTowerCalculationData();
                        windTowerCalculationDataWpd.setTime(new Date(time));
                        windTowerCalculationDataWpd.setEbId(equipmentAttributeWpd.getId());
                        windTowerCalculationDataWpd.setEquipmentId(eqNo);
                        windTowerCalculationDataWpd.setValue(speedAndDensityDto.getWindPowerDensity());
                        windTowerCalculationDataList.add(windTowerCalculationDataWpd);
                        list.add(windTowerCalculationDataWpd);
                    }
                }

            }
        } catch (Exception e) {
            log.error("计算{}设备平均风速和风功率密度失败^ ^", eqNo);
            e.printStackTrace();
        }
        //保存
//        saveBatchByEquipmentId(list, eqNo);
        if (list.size() > 0) {
            log.info("平均风速和风功率密度成功^ ^");
        }
        return list;
    }


    /**
     * 获取风况数据（平均风速，风功率密度）
     *
     * @param bigDecimalList 风速数据
     * @return
     */
    public SpeedAndDensityDto getSpeedAndDensityDto(List<BigDecimal> bigDecimalList, List<ProphaseAnemometryData> anemometryData, List<ProphaseWeatherData> weatherData) {

        SpeedAndDensityDto speedAndDensityDto = new SpeedAndDensityDto();
        speedAndDensityDto.setWindSpeed(windSpeed(bigDecimalList));
        speedAndDensityDto.setWindPowerDensity(CalculationUtil.windEnergyDensity(anemometryData, weatherData));

        return speedAndDensityDto;
    }

    /**
     * 计算平均风速
     *
     * @param bigDecimalList 风速数据
     * @return
     */
    public BigDecimal windSpeed(List<BigDecimal> bigDecimalList) {
        return BigDecimal.valueOf(bigDecimalList.stream().collect(Collectors.averagingDouble(BigDecimal::doubleValue)));
    }


    /**
     * 空气密度曲线图
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备编号
     * @param uid         年月区分id
     * @return
     */
    public List<Object> getAirDensity(Long startTime, Long endTime, String equipmentId, String uid) {
        ArrayList<Object> onlyData = new ArrayList<>();
        ArrayList<Object> list = new ArrayList<>();
        SimpleDateFormat day = new SimpleDateFormat("dd");
        SimpleDateFormat dayForYear = new SimpleDateFormat("yyyy-MM");
        // 若当天时间为每个月一号， 结束时间为上个月得月末时间
        if (day.format(new Date()).equals("01") && dayForYear.format(new Date()).equals(dayForYear.format(new Date(endTime)))) {
            endTime = DateTimeUtil.getDayLastTime(DateTimeUtil.mouthLastDay(1).getTime()).getTime();
        } else {
            // 若当天时间不为每个月一号，结束时间为本月的当前时间-1（昨天）
//            long yesterday = new Date().getTime() - 1000 * 60 * 60 * 24;//昨天
            endTime = DateTimeUtil.endOfMonth(new Date(endTime)).getTime();
        }
        if (uid.equals("1")) {

            String airDensityFieldName = "airDensity";

            List<EquipmentAttribute> airDayFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, airDensityFieldName).list();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

            if (!airDayFieldNameList.isEmpty()) {
                String airDayEbId = airDayFieldNameList.get(0).getId();
                //开始时间
                Date startTimeOfCurrentMonth = SEDateUtil.getStartTimeOfCurrentDay(new Date(startTime));
                //结束时间
//                Date endTimeOfCurrentMonth = SEDateUtil.getEndTimeOfCurrentDay(new Date(endTime - 1));
                //获取所有空气密度数据
                List<WindTowerCalculationData> airDayList = getByStartTimeBetweenAndEquipmentIdAndEbId(startTimeOfCurrentMonth, new Date(endTime), equipmentId, airDayEbId);
                airDayList = airDayList.stream().sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
                //平均空气密度的总和
                BigDecimal airAveSum = BigDecimal.ZERO;
                for (WindTowerCalculationData w : airDayList) {
                    HashMap<Object, Object> airDayMap = new HashMap<>();
                    airAveSum = airAveSum.add(w.getValue());
                    String format = sdf.format(w.getTime());
                    airDayMap.put("time", format);
                    airDayMap.put("air", w.getValue());
                    list.add(airDayMap);
                }
                HashMap<Object, Object> aveAirMap = new HashMap<>();
                if (!airDayList.isEmpty()) {
                    aveAirMap.put("ave", airAveSum.divide(BigDecimal.valueOf(airDayList.size()), 2, RoundingMode.HALF_UP));
                }
                onlyData.add(list);
                onlyData.add(aveAirMap);
            }
        }
        if (uid.equals("2")) {

            //设置年份用的
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
            //给前端用的日期格式
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM");
            //获取查询的年份
            int toYear = Integer.parseInt(sdf.format(startTime));
            int toYear2 = Integer.parseInt(sdf.format(endTime));
            Calendar calendar = Calendar.getInstance();
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear);
            //当前年的开始时间
            long startHour = calendar.getTimeInMillis();
            //当前年的结束时间
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear2);
            calendar.roll(Calendar.DAY_OF_YEAR, -1);
            long endHour = calendar.getTimeInMillis() - 1l;
            String airDensityFieldName = "airDensityMonth";
            List<EquipmentAttribute> turDayFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, airDensityFieldName).list();
            if (!turDayFieldNameList.isEmpty()) {
                String airMonthEbId = turDayFieldNameList.get(0).getId();
                //开始时间
                Date startTimeOfCurrentMonth = SEDateUtil.getStartTimeOfCurrentDay(new Date(startHour));
                //结束时间
                Date endTimeOfCurrentMonth = SEDateUtil.getEndTimeOfCurrentDay(new Date(endHour));
                List<WindTowerCalculationData> airMonthList = getByStartTimeBetweenAndEquipmentIdAndEbId(startTimeOfCurrentMonth, endTimeOfCurrentMonth, equipmentId, airMonthEbId);
                airMonthList = airMonthList.stream().sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
                BigDecimal airAveSum = BigDecimal.ZERO;
                for (WindTowerCalculationData w : airMonthList) {
                    HashMap<Object, Object> airMonthMap = new HashMap<>();
                    airAveSum = airAveSum.add(w.getValue());
                    String format = sdf1.format(w.getTime());
                    airMonthMap.put("time", format);
                    airMonthMap.put("air", w.getValue());
                    list.add(airMonthMap);

                }
                HashMap<Object, Object> aveAirMap = new HashMap<>();
                if (!airMonthList.isEmpty()) {
                    aveAirMap.put("ave", airAveSum.divide(BigDecimal.valueOf(airMonthList.size()), 2, RoundingMode.HALF_UP));
                }
                onlyData.add(list);
                onlyData.add(aveAirMap);

            }

        }
        return onlyData;
    }

    /**
     * Gumbel分布概率
     *
     * @param startTime
     * @param endTime
     * @param eqId
     * @return
     */
    public List<Object> getGumbel(Long startTime, Long endTime, String eqId, String height) {
        //最终返回的集合
        ArrayList<Object> gumbelList = new ArrayList<>();
        //开始时间
        Date startTimeOfCurrentMonth = SEDateUtil.getStartTimeOfCurrentDay(new Date(startTime));
        //结束时间
        Date endTimeOfCurrentMonth = SEDateUtil.getEndTimeOfCurrentDay(new Date(endTime));
        //获取EquipmentAttribute表中的对应数据
        if (height == null || height.equals("")) {
            height = "80";
        }
        String[] heightAll = height.split(",");

        List<EquipmentAttribute> equipmentAttributeList1 = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getAttributeFunction, "maxWsMonth").list();

        List<WindTowerCalculationData> windTowerCalculationDataList1 = getByBetweenTimeAndEquipmentId(startTimeOfCurrentMonth, endTimeOfCurrentMonth, eqId);


        for (String h : heightAll) {
            //获取层高
            String heightGumbel = h + "maxwsMonth";
            List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeList1.stream().filter(w -> w.getFieldName().equals(heightGumbel)).collect(Collectors.toList());
            //获取对应的数据
            List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(equipmentAttributeList.get(0).getId()) && w.getEquipmentId().equals(eqId) &&
                    w.getTime().after(startTimeOfCurrentMonth) && w.getTime().before(endTimeOfCurrentMonth)).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());

            //准备放入Gumbel算法的集合
            ArrayList<Object> list = new ArrayList<>();
            for (WindTowerCalculationData windTowerCalculationData : windTowerCalculationDataList) {
                list.add(windTowerCalculationData.getValue().doubleValue());
            }
            if (list.size() > 5) {

                //把查询的最大风速集合放入公式
                ProbabilityPlot probabilityPlot = new ProbabilityPlot(list);
                probabilityPlot.suppressDisplay();
                //尺度参数 β
                double v = probabilityPlot.gumbelMaxSigma();
                //位置参数 α
                double u = probabilityPlot.gumbelMaxMu();

                TreeMap<BigDecimal, BigDecimal> gumbelMap = new TreeMap<>();
                BigDecimal wsMax = BigDecimal.ZERO;
                for (WindTowerCalculationData w : windTowerCalculationDataList) {
                    //最大风速值
                    BigDecimal wsValue = w.getValue();
                    //P(X)= exp {—exp[ -(X- α)/β]}  计算出在这个时间段的风速重现概率
                    wsMax = BigDecimal.valueOf(Math.exp(-(Math.exp(-(w.getValue().doubleValue() - u) / v)))).setScale(2, RoundingMode.HALF_UP);
                    //加入时间标识
                    gumbelMap.put(wsValue, wsMax);
                }
                ArrayList<Object> list1 = new ArrayList<>();

                for (Map.Entry<BigDecimal, BigDecimal> g : gumbelMap.entrySet()) {
                    HashMap<Object, Object> map = new HashMap<>();
                    //风速
                    map.put("wsMax", g.getKey());
                    //概率
                    map.put("gum", g.getValue());
                    list1.add(map);
                }

                HashMap<String, Object> heightGumbelMap = new HashMap<>();

                heightGumbelMap.put(h, list1);
                //加入层高标识
                for (Map.Entry<String, Object> h1 : heightGumbelMap.entrySet()) {
                    HashMap<Object, Object> map = new HashMap<>();
                    map.put("height", h1.getKey());
                    map.put("arr", h1.getValue());
                    gumbelList.add(map);
                }

            }

        }
        return gumbelList;
    }


    /**
     * 湍流统计曲线图
     *
     * @param height 层高
     * @param eqId   设备编号
     * @return List<Object>
     */
    public List<Object> getTurbulence(Long startTime, Long endTime, String height, String eqId) {
        //最后返回的
        ArrayList<Object> onlyData = new ArrayList<>();
        //装所有风速数据
        ArrayList<Object> arrList = new ArrayList<>();
        //装平均值
        ArrayList<Object> list1 = new ArrayList<>();
        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
        if (height == null || height.equals("")) {
            for (WindTowerInfo windTowerInfo : windTowerInfos) {
                height = windTowerInfo.getHeights();
            }

        }
        List<String> heightSort = new ArrayList<>();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        String[] heightAll = height.split(",");
        for (String s : heightAll) {
            heightSort.add(s);
        }

        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getAttributeFunction, "turbulenceMonth").list();
        // 根据开始时间、结束时间、设备id查询统计表
        List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);
        // 根据开始时间、结束时间分割的月份
        List<Long> timeList = DateTimeUtil.getIntervalTimeByMonth(new Date(startTime), new Date(endTime));
        for (String h : heightSort) {

            String turMonthFieldName = h + "turbulenceMonth";
            //存放数据
            // 获取EbId
            List<EquipmentAttribute> turDayFieldNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(turMonthFieldName)).collect(Collectors.toList());
            if (!turDayFieldNameList.isEmpty()) {
                String turDayEbId = turDayFieldNameList.get(0).getId();
                //平均风速集合
                List<WindTowerCalculationData> turDayList = new ArrayList<>();


                // 根据属性id过滤统计表
                List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(turDayEbId)).collect(Collectors.toList());
                ArrayList<Object> list = new ArrayList<>();
                BigDecimal turAve = BigDecimal.ZERO; // 平均湍流
                for (Long time : timeList) {
                    turDayList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(time)) == 0).collect(Collectors.toList());
                    BigDecimal value = BigDecimal.ZERO;
                    if (!turDayList.isEmpty()) {
                        value = turDayList.get(0).getValue();
                    }
                    HashMap<Object, Object> map = new HashMap<>();
                    String format = sdf.format(time);
                    map.put("tur", value.setScale(2, RoundingMode.HALF_UP));
                    map.put("time", format);
                    list.add(map);
                }
                // 曲线list
                Map<String, Object> finalMap = new HashMap<>();
                finalMap.put("height", h);
                finalMap.put("arr", list);
                arrList.add(finalMap);
                // 湍流数值集合
                List<BigDecimal> turList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
                if (!turList.isEmpty()) {
                    turAve = turList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(turList.size()), 2, RoundingMode.HALF_UP);
                }
            }
        }
        onlyData.add(arrList);
        onlyData.add(list1);

        return onlyData;
    }

    /**
     * 年资源统计（空气密度）
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param eqId      设备编号
     * @return List<Object>
     */
    public List<Object> getDensityYear(Long startTime, Long endTime, String eqId) {
        String fieldName = "airDensityMonth";
        List<EquipmentAttribute> densityTypeList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, fieldName).list();
        String densityId = densityTypeList.get(0).getId();
        //设置年份用的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        //获取查询的年份
        int toYearStart = Integer.parseInt(sdf.format(startTime));
        int toYearEnd = Integer.parseInt(sdf.format(endTime));
        ArrayList<Object> PDataList = new ArrayList<>();
        for (int i = toYearStart; i <= toYearEnd; i++) {
            Calendar calendar = Calendar.getInstance();
            calendar.clear();
            calendar.set(Calendar.YEAR, i);
            //当前年的开始时间
            long startHour = calendar.getTimeInMillis();
            calendar.clear();
            calendar.set(Calendar.YEAR, i);
            calendar.roll(Calendar.DAY_OF_YEAR, -1);
            //当前年的结束时间
            long endHour = calendar.getTimeInMillis() - 1l;
            //开始时间
            Date startTimeOfCurrentMonth = SEDateUtil.getStartTimeOfCurrentDay(new Date(startHour));
            //结束时间
            Date endTimeOfCurrentMonth = SEDateUtil.getEndTimeOfCurrentDay(new Date(endHour));
            List<WindTowerCalculationData> byBetweenTimeAndEquipmentId = getByBetweenTimeAndEquipmentId(startTimeOfCurrentMonth, endTimeOfCurrentMonth, eqId);
            List<WindTowerCalculationData> densityDataList = byBetweenTimeAndEquipmentId.stream().filter(w -> w.getEbId().equals(densityId)).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());

            BigDecimal pSum = BigDecimal.ZERO;

            for (WindTowerCalculationData w : densityDataList) {
                pSum = pSum.add(w.getValue());
            }
            HashMap<Object, Object> PTMap = new HashMap<>();
            if (!densityDataList.isEmpty()) {
                PTMap.put(i, pSum.divide(BigDecimal.valueOf(densityDataList.size()), 2, RoundingMode.HALF_UP));

            }
            for (Map.Entry<Object, Object> pt : PTMap.entrySet()) {
                HashMap<String, Object> map = new HashMap<>();
                map.put("time", pt.getKey());
                map.put("p", pt.getValue());
                PDataList.add(map);
            }


        }
        return PDataList;

    }


    /**
     * 年风资源统计(风速+风功率密度)
     *
     * @param startTime 开始年份
     * @param endTime   结束年份
     * @param height    层高
     * @param eqId      设备编号
     * @return List<Object>
     */
    public List<Object> getWindResources(Long startTime, Long endTime, String height, String eqId) {
        ArrayList<Object> DataList = new ArrayList<>();
        ArrayList<Object> DataOneList = new ArrayList<>();
        ArrayList<Object> DataTWOList = new ArrayList<>();

        Calendar calendar1 = Calendar.getInstance();
        calendar1.clear();
        calendar1.set(Calendar.YEAR, DateUtil.year(new Date(endTime)));
        calendar1.roll(Calendar.DAY_OF_YEAR, -1);
        //获取年份最后一天
        endTime = calendar1.getTime().getTime();
        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
        if (height == null || height.equals("")) {
            height = windTowerInfos.get(0).getHeights();
        }

        //设置年份用的
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        //获取查询的年份
        int toYearStart = Integer.parseInt(sdf.format(startTime));
        int toYearEnd = Integer.parseInt(sdf.format(endTime));

        List<String> heightSort = new ArrayList<>();

        String[] heightAll = height.split(",");

        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.list();
        List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);

        //遍历层高
        for (String h : heightAll) {
            //设置 层高+fieldName(数据库字段 50awsMonth)
            String fieldNameWs = h + "awsMonth";
            String fieldNameWpd = h + "wpdMonth";

            List<EquipmentAttribute> allWsFiledNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(fieldNameWs)).collect(Collectors.toList());
            List<EquipmentAttribute> allWpdFiledNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(fieldNameWpd)).collect(Collectors.toList());

            //存放最后数据的map 防止重复数据 new外面
            HashMap<Object, Object> map1 = new HashMap<>();

            HashMap<String, Object> HDMap = new HashMap<>();


            //年平均风速存放的list
            ArrayList<Object> list = new ArrayList<>();
            //年风功率密度存放的list
            ArrayList<Object> list1 = new ArrayList<>();
            for (int i = toYearStart; i <= toYearEnd; i++) {


                Calendar calendar = Calendar.getInstance();
                calendar.clear();
                calendar.set(Calendar.YEAR, i);
                //当前年的开始时间
                long startHour = calendar.getTimeInMillis();
                calendar.clear();
                calendar.set(Calendar.YEAR, i);
                calendar.roll(Calendar.DAY_OF_YEAR, -1);
                //当前年的结束时间
                long endHour = calendar.getTimeInMillis() - 1L;
                //开始时间
                Date startTimeOfCurrentMonth = SEDateUtil.getStartTimeOfCurrentDay(new Date(startHour));
                //结束时间
                Date endTimeOfCurrentMonth = SEDateUtil.getEndTimeOfCurrentDay(new Date(endHour));


                if (!allWsFiledNameList.isEmpty()) {
                    String awsMonthEqId = allWsFiledNameList.get(0).getId();


                    List<WindTowerCalculationData> allDataWsList = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(eqId) && w.getEbId().equals(awsMonthEqId) &&
                            w.getTime().after(startTimeOfCurrentMonth) && w.getTime().before(endTimeOfCurrentMonth)).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
                    BigDecimal wsYearData = BigDecimal.ZERO;
                    for (WindTowerCalculationData ws : allDataWsList) {
                        wsYearData = wsYearData.add(ws.getValue());
                    }
                    HashMap<Object, Object> wsMap = new HashMap<>();

                    if (!allDataWsList.isEmpty()) {
                        wsMap.put(i, wsYearData.divide(BigDecimal.valueOf(allDataWsList.size()), 2, RoundingMode.HALF_UP));
                    }

                    //给时间和年平均数值添加标识
                    for (Map.Entry<Object, Object> ws1 : wsMap.entrySet()) {
                        HashMap<Object, Object> map = new HashMap<>();
                        map.put("time", ws1.getKey());
                        map.put("ws", ws1.getValue());
                        list.add(map);
                    }
                    HashMap<String, Object> heightDataMap = new HashMap<>();
                    //放入层高
                    heightDataMap.put(h, list);
                    for (Map.Entry<String, Object> hd : heightDataMap.entrySet()) {
                        map1 = new HashMap<>();
                        map1.put("height", hd.getKey());
                        map1.put("arr", hd.getValue());

                    }


                }
                if (!allWpdFiledNameList.isEmpty()) {
                    String wpdMonthEqId = allWpdFiledNameList.get(0).getId();
                    List<WindTowerCalculationData> allDataWpdList = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(eqId) && w.getEbId().equals(wpdMonthEqId) &&
                            w.getTime().after(startTimeOfCurrentMonth) && w.getTime().before(endTimeOfCurrentMonth)).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
                    BigDecimal wpdYearData = BigDecimal.ZERO;
                    for (WindTowerCalculationData wpd : allDataWpdList) {
                        wpdYearData = wpdYearData.add(wpd.getValue());
                    }
                    HashMap<Object, Object> wpdMap = new HashMap<>();
                    //添加时间
                    if (!allDataWpdList.isEmpty()) {
                        wpdMap.put(i, wpdYearData.divide(BigDecimal.valueOf(allDataWpdList.size()), 2, RoundingMode.HALF_UP));
                    }

                    for (Map.Entry<Object, Object> wpd1 : wpdMap.entrySet()) {
                        HashMap<Object, Object> map = new HashMap<>();
                        map.put("time", wpd1.getKey());
                        map.put("wpd", wpd1.getValue());
                        list1.add(map);
                    }
                    HashMap<String, Object> heightDataMap = new HashMap<>();
                    heightDataMap.put(h, list1);


                    for (Map.Entry<String, Object> hd : heightDataMap.entrySet()) {
                        HDMap = new HashMap<>();
                        HDMap.put("height", hd.getKey());
                        HDMap.put("arr", hd.getValue());

                    }
                }
            }
            if (!map1.entrySet().isEmpty()) {
                DataOneList.add(map1);
            }
            if (!HDMap.entrySet().isEmpty()) {
                DataTWOList.add(HDMap);
            }


        }
        DataList.add(DataOneList);

        DataList.add(DataTWOList);


        return DataList;
    }

    /**
     * 时间段平均风速曲线图
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param height    测高
     * @param eqId      设备编号
     * @return List<Object>
     */
    public List<Object> getWindSpeed(Long startTime, Long endTime, String height, String eqId, String uid) {
        //最后返回的
        ArrayList<Object> onlyData = new ArrayList<>();
//        endTime = endTime - 1L;
//        SimpleDateFormat day = new SimpleDateFormat("dd");
//        SimpleDateFormat dayForYear = new SimpleDateFormat("yyyy-MM");
        // 若当天时间为每个月一号， 结束时间为上个月得月末时间
//        if (day.format(new Date()).equals("01") && dayForYear.format(new Date()).equals(dayForYear.format(new Date(endTime)))) {
//            endTime = DateTimeUtil.getDayLastTime(DateTimeUtil.mouthLastDay(1).getTime()).getTime();
//        } else {
//            // 若当天时间不为每个月一号，结束时间为本月的当前时间-1（昨天）
////            long yesterday = new Date().getTime() - 1000 * 60 * 60 * 24;//昨天
//            endTime = DateTimeUtil.endOfMonth(new Date(endTime)).getTime();
//        }
        //装所有风速数据
        ArrayList<Object> arrList = new ArrayList<>();
        BigDecimal minWs = BigDecimal.ZERO;
        BigDecimal maxWs = BigDecimal.ZERO;
        //装平均值
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<Object> list2 = new ArrayList<>();
        ArrayList<Object> list3 = new ArrayList<>();

        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.lambdaQuery().like(EquipmentAttribute::getAttributeFunction, "ws").list();

        String[] heights = null;
        if (height == null || height.equals("")) {
            List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
            heights = windTowerInfos.get(0).getHeights().split(",");
        } else {
            heights = height.split(",");
        }
        List<String> heightList = Arrays.asList(heights);
        if (uid.equals("1")) {//月逐日
            List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);
            // 根据时间升序
            windTowerCalculationDataList.sort(Comparator.comparing(WindTowerCalculationData::getTime));
            //遍历所有层高
            for (String h : heightList) {
                String awsDayFieldName = h + "awsDay";
                List<EquipmentAttribute> awsDayFieldNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(awsDayFieldName)).collect(Collectors.toList());
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                //存放数据

                if (!awsDayFieldNameList.isEmpty()) {
                    String awsDayEbId = awsDayFieldNameList.get(0).getId();
                    //平均风速集合
                    List<WindTowerCalculationData> awsDayList = new ArrayList<>();

                    List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(awsDayEbId)).collect(Collectors.toList());

                    BigDecimal awsAve = BigDecimal.ZERO;
                    ArrayList<Object> list = new ArrayList<>();
                    for (long i = startTime; i < endTime; i += 1000 * 60 * 60 * 24) {
                        long finalI = i;
                        awsDayList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(finalI)) == 0).collect(Collectors.toList());
                        HashMap<Object, Object> map = new HashMap<>();
                        String format = sdf.format(i);
                        BigDecimal value = BigDecimal.ZERO;
                        if (!awsDayList.isEmpty()) {
                            value = awsDayList.get(0).getValue();
                        }
                        map.put("ws", value);
                        map.put("time", format);
                        list.add(map);
                    }
                    // 曲线
                    HashMap<Object, Object> finalMap = new HashMap<>();
                    finalMap.put("height", h);
                    finalMap.put("arr", list);
                    arrList.add(finalMap);
                    //平均值
                    List<BigDecimal> aveWsList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
                    if (!aveWsList.isEmpty()) {
                        awsAve = aveWsList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(aveWsList.size()), 2, RoundingMode.HALF_UP);
                    }
                    HashMap<Object, Object> finalAveMap = new HashMap<>();
                    finalAveMap.put("height", h);
                    finalAveMap.put("aws", awsAve);
                    list1.add(finalAveMap);
                    //最小值 最大值
                    if (!filterList.isEmpty()) {
                        minWs = filterList.stream().min(Comparator.comparing(WindTowerCalculationData::getValue)).get().getValue();
                        maxWs = filterList.stream().max(Comparator.comparing(WindTowerCalculationData::getValue)).get().getValue();
                    }
                    HashMap<Object, Object> finalMinMap = new HashMap<>();
                    finalMinMap.put("height2", h);
                    finalMinMap.put("min", minWs);
                    list2.add(finalMinMap);
                    HashMap<Object, Object> finalMaxMap = new HashMap<>();
                    finalMaxMap.put("height3", h);
                    finalMaxMap.put("max", maxWs);
                    list3.add(finalMaxMap);
                }
            }
            onlyData.add(arrList);
            onlyData.add(list1);
            onlyData.add(list2);
            onlyData.add(list3);
        }
        if (uid.equals("2")) {
            //设置年份用的
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
            //给前端用的日期格式
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM");
            //获取查询的年份
            int toYear = Integer.parseInt(sdf.format(startTime));
            int toYear2 = Integer.parseInt(sdf.format(endTime));
            Calendar calendar = Calendar.getInstance();
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear);
            //当前年的开始时间
            long startHour = calendar.getTimeInMillis();
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear2);
            calendar.roll(Calendar.DAY_OF_YEAR, -1);
            //当前年的结束时间
            endTime = endTime + 100l;
            // 根据开始时间、结束时间分割的月份
            List<Long> timeList = DateTimeUtil.getIntervalTimeByMonth(new Date(startHour), new Date(endTime));
            // 开始年和结束年相同 getIntervalTimeByMonth 最后一个月会重复两次
            if (toYear == toYear2) {
                timeList.remove(timeList.size() - 1);
            }
            List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startHour), new Date(endTime), eqId);

            for (String h : heights) {

                String awsMonthFieldName = h + "awsMonth";
                //存放数据

                List<EquipmentAttribute> awsDayFieldNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(awsMonthFieldName)).collect(Collectors.toList());
                if (!awsDayFieldNameList.isEmpty()) {
                    String awsDayEbId = awsDayFieldNameList.get(0).getId();
                    //平均风速集合
                    List<WindTowerCalculationData> awsDayList = new ArrayList<>();

                    List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(awsDayEbId)).collect(Collectors.toList());
                    BigDecimal awsAve = BigDecimal.ZERO;
                    ArrayList<Object> list = new ArrayList<>();
                    for (long time : timeList) {
                        awsDayList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(time)) == 0).collect(Collectors.toList());
                        HashMap<Object, Object> map = new HashMap<>();
                        String format = sdf1.format(time);
                        BigDecimal value = BigDecimal.ZERO;
                        if (!awsDayList.isEmpty()) {
                            value = awsDayList.get(0).getValue();
                        }
                        map.put("ws", value);
                        map.put("time", format);
                        list.add(map);
                    }
                    // 曲线
                    HashMap<Object, Object> finalMap = new HashMap<>();
                    finalMap.put("height", h);
                    finalMap.put("arr", list);
                    arrList.add(finalMap);
                    //平均值
                    List<BigDecimal> aveWsList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
                    if (!aveWsList.isEmpty()) {
                        awsAve = aveWsList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(aveWsList.size()), 2, RoundingMode.HALF_UP);
                    }
                    HashMap<Object, Object> finalAveMap = new HashMap<>();
                    finalAveMap.put("height", h);
                    finalAveMap.put("aws", awsAve);
                    list1.add(finalAveMap);
                    //最小值 最大值
                    if (!filterList.isEmpty()) {
                        minWs = filterList.stream().min(Comparator.comparing(WindTowerCalculationData::getValue)).get().getValue();
                        maxWs = filterList.stream().max(Comparator.comparing(WindTowerCalculationData::getValue)).get().getValue();
                    }
                    HashMap<Object, Object> finalMinMap = new HashMap<>();
                    finalMinMap.put("height2", h);
                    finalMinMap.put("min", minWs);
                    list2.add(finalMinMap);
                    HashMap<Object, Object> finalMaxMap = new HashMap<>();
                    finalMaxMap.put("height3", h);
                    finalMaxMap.put("max", maxWs);
                    list3.add(finalMaxMap);
                }
            }
            onlyData.add(arrList);
            onlyData.add(list1);
            onlyData.add(list2);
            onlyData.add(list3);
        }
        return onlyData;

    }

    /**
     * 时间段风功率密度曲线图（统计查询）
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param height    测高
     * @param eqId      设备编号
     * @return List<Object>
     */
    public List<Object> getWpd(Long startTime, Long endTime, String height, String eqId, String uid) {
        //最后返回的
        ArrayList<Object> onlyData = new ArrayList<>();
//        endTime = endTime - 1L;
//        SimpleDateFormat day = new SimpleDateFormat("dd");
//        SimpleDateFormat dayForYear = new SimpleDateFormat("yyyy-MM");
//        // 若当天时间为每个月一号， 结束时间为上个月得月末时间
//        if (day.format(new Date()).equals("01") && dayForYear.format(new Date()).equals(dayForYear.format(new Date(endTime)))) {
//            endTime = DateTimeUtil.getDayLastTime(DateTimeUtil.mouthLastDay(1).getTime()).getTime();
//        } else {
//            // 若当天时间不为每个月一号，结束时间为本月的当前时间-1（昨天）
////            long yesterday = new Date().getTime() - 1000 * 60 * 60 * 24;//昨天
//            endTime = DateTimeUtil.endOfMonth(new Date(endTime)).getTime();
//        }
        //装所有风功率密度数据
        ArrayList<Object> arrList = new ArrayList<>();
        //装平均值
        ArrayList<Object> list1 = new ArrayList<>();
        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
        if (height == null || height.equals("")) {
            height = windTowerInfos.get(0).getHeights();
        }
//        List<String> heightSort = new ArrayList<>();

        String[] heightAll = height.split(",");
//        for (String s : heightAll) {
//            heightSort.add(s);
//        }
//        heightSort = heightSort.stream().sorted().collect(Collectors.toList());
        List<String> heightSort = Arrays.asList(heightAll);
        //查询统计属性表
        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getAttributeFunction, "WindPowerDensity").list();
        //查询统计数据表
        List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);


        if (uid.equals("1")) {
            //遍历所有层高
            for (String h : heightSort) {
                String wpdDayFieldName = h + "wpdDay";
                List<EquipmentAttribute> wpdDayFieldNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(wpdDayFieldName)).collect(Collectors.toList());
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                //存放数据

                if (!wpdDayFieldNameList.isEmpty()) {
                    String wpdDayEbId = wpdDayFieldNameList.get(0).getId();
                    //平均风速集合
                    List<WindTowerCalculationData> wpdDayList = new ArrayList<>();

                    List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(wpdDayEbId)).collect(Collectors.toList());

                    BigDecimal wpdAve = BigDecimal.ZERO;
                    ArrayList<Object> list = new ArrayList<>();
                    for (long i = startTime; i < endTime; i += 1000 * 60 * 60 * 24) {
                        long finalI = i;
                        wpdDayList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(finalI)) == 0).collect(Collectors.toList());
                        HashMap<Object, Object> map = new HashMap<>();
                        String format = sdf.format(i);
                        BigDecimal value = BigDecimal.ZERO;
                        if (!wpdDayList.isEmpty()) {
                            value = wpdDayList.get(0).getValue();
                        }
                        map.put("wpd", value);
                        map.put("time", format);
                        list.add(map);
                    }
                    // 曲线
                    HashMap<Object, Object> finalMap = new HashMap<>();
                    finalMap.put("height", h);
                    finalMap.put("arr", list);
                    arrList.add(finalMap);
                    //平均值
                    List<BigDecimal> aveWsList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
                    if (!aveWsList.isEmpty()) {
                        wpdAve = aveWsList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(aveWsList.size()), 2, RoundingMode.HALF_UP);
                    }
                    HashMap<Object, Object> finalAveMap = new HashMap<>();
                    finalAveMap.put("height", h);
                    finalAveMap.put("wpdAve", wpdAve);
                    list1.add(finalAveMap);

                }
            }
            onlyData.add(arrList);
            onlyData.add(list1);
        }
        if (uid.equals("2")) {

            //设置年份用的
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
            //给前端用的日期格式
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM");
            //获取查询的年份
            int toYear = Integer.parseInt(sdf.format(startTime));
            int toYear2 = Integer.parseInt(sdf.format(endTime));
            Calendar calendar = Calendar.getInstance();
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear);
            //当前年的开始时间
            long startHour = calendar.getTimeInMillis();
            calendar.clear();
            calendar.set(Calendar.YEAR, toYear2);
            calendar.roll(Calendar.DAY_OF_YEAR, -1);
            //当前年的结束时间
            endTime = endTime + 100L;
            // 根据开始时间、结束时间分割的月份
            List<Long> timeList = DateTimeUtil.getIntervalTimeByMonth(new Date(startHour), new Date(endTime));
            // 开始年和结束年相同 getIntervalTimeByMonth 最后一个月会重复两次
            if (toYear == toYear2) {
                timeList.remove(timeList.size() - 1);
            }
            windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startHour), new Date(endTime), eqId);

            for (String h : heightSort) {


                String wpdMonthFieldName = h + "wpdMonth";
                //存放数据

                List<EquipmentAttribute> wpdDayFieldNameList = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(wpdMonthFieldName)).collect(Collectors.toList());
                if (!wpdDayFieldNameList.isEmpty()) {
                    //获取对应的ebId
                    String wpdDayEbId = wpdDayFieldNameList.get(0).getId();
                    //平均风速集合
                    List<WindTowerCalculationData> wpdMonthList = new ArrayList<>();

                    List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(wpdDayEbId)).collect(Collectors.toList());
                    BigDecimal wpdAve = BigDecimal.ZERO;
                    ArrayList<Object> list = new ArrayList<>();
                    for (long time : timeList) {
                        wpdMonthList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(time)) == 0).collect(Collectors.toList());
                        HashMap<Object, Object> map = new HashMap<>();
                        String format = sdf1.format(time);
                        BigDecimal value = BigDecimal.ZERO;
                        if (!wpdMonthList.isEmpty()) {
                            value = wpdMonthList.get(0).getValue();
                        }
                        map.put("wpd", value);
                        map.put("time", format);
                        list.add(map);
                    }
                    // 曲线
                    HashMap<Object, Object> finalMap = new HashMap<>();
                    finalMap.put("height", h);
                    finalMap.put("arr", list);
                    arrList.add(finalMap);
                    //平均值
                    List<BigDecimal> aveWsList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
                    if (!aveWsList.isEmpty()) {
                        wpdAve = aveWsList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(aveWsList.size()), 2, RoundingMode.HALF_UP);
                    }
                    HashMap<Object, Object> finalAveMap = new HashMap<>();
                    finalAveMap.put("height", h);
                    finalAveMap.put("wpdAve", wpdAve);
                    list1.add(finalAveMap);
                }
            }
            onlyData.add(arrList);
            onlyData.add(list1);
        }
        return onlyData;

    }

    /**
     * 时间段(年逐月)风切变曲线图（统计查询）
     *
     * @param height 测高
     * @param eqId   设备编号
     * @return List<Object>
     */
    public List<Object> getShear(Long startTime, Long endTime, String height, String eqId) {
        //最后返回的
        ArrayList<Object> onlyData = new ArrayList<>();
        //装所有风功率密度数据
        ArrayList<Object> arrList = new ArrayList<>();
        //装平均值
        ArrayList<Object> list1 = new ArrayList<>();
        List<String> heightSort = new ArrayList<>();
        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
        //给前端用的日期格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM");

        //获取统计属性表
        List<EquipmentAttribute> shearDayFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, "windShearMonth").list();
        //获取统计数据表
        List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId).stream().sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());;
        // 根据开始时间、结束时间分割的月份
        List<Long> timeList = DateTimeUtil.getIntervalTimeByMonth(new Date(startTime), new Date(endTime));

        //存放数据
        if (!shearDayFieldNameList.isEmpty()) {
            String shearDayEbId = shearDayFieldNameList.get(0).getId();
            //风切变集合
            List<WindTowerCalculationData> shearMonthList = new ArrayList<>();

            List<WindTowerCalculationData> filterList = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(shearDayEbId)).collect(Collectors.toList());
            BigDecimal shearAve = BigDecimal.ZERO;
            ArrayList<Object> list = new ArrayList<>();
            for (long time : timeList) {
                shearMonthList = filterList.stream().filter(w -> w.getTime().compareTo(new Date(time)) == 0).collect(Collectors.toList());
                HashMap<Object, Object> map = new HashMap<>();
                String format = sdf1.format(time);
                BigDecimal value = BigDecimal.ZERO;
                if (!shearMonthList.isEmpty()) {
                    value = shearMonthList.get(0).getValue();
                }
                map.put("shear", value);
                map.put("time", format);
                list.add(map);
            }
            // 曲线
            HashMap<Object, Object> finalMap = new HashMap<>();
            finalMap.put("height", "综合风切变");
            finalMap.put("arr", list);
            arrList.add(finalMap);
            //平均值
            List<BigDecimal> aveWsList = filterList.stream().map(WindTowerCalculationData::getValue).collect(Collectors.toList());
            if (!aveWsList.isEmpty()) {
                shearAve = aveWsList.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(aveWsList.size()), 2, RoundingMode.HALF_UP);
            }
            HashMap<Object, Object> finalAveMap = new HashMap<>();
            finalAveMap.put("height", "综合风切变");
            finalAveMap.put("shearAve", shearAve);
            list1.add(finalAveMap);
        }

        onlyData.add(arrList);
        onlyData.add(list1);

        return onlyData;

    }


    /**
     * 计算日平均空气密度
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备ID
     * @return
     */
    public ArrayList<WindTowerCalculationData> airDensityDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerCalculationData> windTowerCalculationDataList) {

        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        Long dayTime = 86400000L;
        //空气密度属性
        EquipmentAttribute equipmentAttribute = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals("airDensity")).collect(Collectors.toList()).get(0);
        //删除时间段所有数据
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, equipmentAttribute.getId());
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {
                //每天的结束时间
                long start2 = start1 + dayTime - 1L;
                BigDecimal airDensityDay = new BigDecimal(0);
                long start = start1;
                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= start && p.getTs().getTime() <= start2).collect(Collectors.toList());
                for (ProphaseWeatherData map : collect) {
                    airDensityDay = airDensityDay.add(CalculationUtil.getBigDecimal(map.getAirDensity()));
                }
                //存平均值
                if (!collect.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(equipmentAttribute.getId());
                    windTowerCalculationData.setTime(new Date(start1));
                    windTowerCalculationData.setValue(airDensityDay.divide(new BigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationDataList.add(windTowerCalculationData);
                    list.add(windTowerCalculationData);
                }
            }
        } catch (Exception e) {
            log.error("计算日平均空气密度失败");
            e.printStackTrace();
        }

//        saveBatchByEquipmentId(list, equipmentId);
        log.info("计算日平均空气密度完成");
        return list;
    }


    /**
     * 计算月最大风速
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> wsMaxMonth(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {

        //获取时间段所有统计数据
//        List<Map<String, Object>> collects = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTime.getTime()
//                && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());

        List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());

        //获取所有层高
        String[] height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            for (String h : height) {
                //获取对应层高的字段
                String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "maxwsMonth")).collect(Collectors.toList()).get(0).getId();
                //删除时间段所有数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdMonth);
                if (!collect.isEmpty()) {
                    BigDecimal max = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getLayerHeight().equals(h)).mapToDouble(ProphaseAnemometryData::getWsMax).sum());
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebIdMonth);
                    windTowerCalculationData.setTime(startTime);
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(max.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
                    list.add(windTowerCalculationData);
                } else {
                    log.info("设备编号{}，{}月，{}米层高月最大风速计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1, h);
                }
            }
        } catch (Exception e) {
            log.error("设备编号{}月最大风速计算失败^ ^", equipmentId);
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}月最大风速计算成功^ ^", equipmentId);
        return list;
    }


    /**
     * 计算月平均空气密度
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备ID
     * @return
     */
    public ArrayList<WindTowerCalculationData> airDensityMonth(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList) {
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        //获取时间段所有统计数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startHour) && w.getTime().before(endTime)).collect(Collectors.toList());

        EquipmentAttribute equipmentAttribute = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals("airDensity")).collect(Collectors.toList()).get(0);
        EquipmentAttribute equipmentAttributeMonth = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals("airDensityMonth")).collect(Collectors.toList()).get(0);

        //删除
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startHour, endTime, equipmentId, equipmentAttributeMonth.getId());
        BigDecimal airDensityMonth = new BigDecimal(0);
        try {
            //找出空气密度和月空气密度属性

            //所有数据日空气密度
            List<WindTowerCalculationData> windCalDataList = windTowerCalculationDataList1.stream().filter(w -> w.getTime().after(startHour) &&
                    w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId) && w.getEbId().equals(equipmentAttribute.getId())).collect(Collectors.toList());
            for (WindTowerCalculationData w : windCalDataList) {
                airDensityMonth = airDensityMonth.add(w.getValue());
            }
            //平均值
            if (!windCalDataList.isEmpty()) {
                WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                windTowerCalculationData.setEbId(equipmentAttributeMonth.getId());
                windTowerCalculationData.setTime(startTime);
                windTowerCalculationData.setValue(airDensityMonth.divide(new BigDecimal(windCalDataList.size()), 2, RoundingMode.HALF_UP));
                windTowerCalculationData.setEquipmentId(equipmentId);
                list.add(windTowerCalculationData);
//                saveByEquipmentId(windTowerCalculationData, equipmentId);
                log.info("计算月平均空气密度完成");
            } else {
                log.info("月平均空气密度缺少数据，无法计算");
            }
        } catch (Exception e) {
            log.error("计算月平均空气密度失败");
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 计算日平均风速
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> wsDay(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        Long dayTime = 86400000L;

        //获取测风塔所有层高
        String heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
        String[] strings = heights.split(",");
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startTime) && w.getTime().before(endTime)).collect(Collectors.toList());
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //遍历测风塔所有层高
            for (String h : strings) {
                //获取小时风速表
                List<EquipmentAttribute> awsList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + "aws")).collect(Collectors.toList());
                //获取日风速表
                List<EquipmentAttribute> awsDayList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + "awsDay")).collect(Collectors.toList());
                //删除
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, awsDayList.get(0).getId());
                for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {
                    long start2 = start1 + dayTime - 1L;
                    //获取小时风速数据
                    long start = start1;
                    List<WindTowerCalculationData> wsCalDataList = windTowerCalculationDataList1.stream().filter(
                                    w -> w.getTime().after(new Date(start)) &&
                                            w.getTime().before(new Date(start2)) &&
                                            w.getEquipmentId().equals(equipmentId) &&
                                            w.getEbId().equals(awsList.get(0).getId()))
                            .collect(Collectors.toList()
                            );
                    //小时风功率总值
                    BigDecimal awsSum = BigDecimal.ZERO;
                    for (WindTowerCalculationData ws : wsCalDataList) {
                        awsSum = awsSum.add(ws.getValue()).setScale(4, RoundingMode.HALF_UP);
                    }
                    if (!wsCalDataList.isEmpty()) {
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setEquipmentId(equipmentId);
                        windTowerCalculationData.setValue(awsSum.divide(new BigDecimal(wsCalDataList.size()), 2, RoundingMode.HALF_UP));
                        windTowerCalculationData.setEbId(awsDayList.get(0).getId());
                        windTowerCalculationData.setTime(new Date(start1));
                        windTowerCalculationDataList.add(windTowerCalculationData);
                        list.add(windTowerCalculationData);

                    } else {
                        log.info("设备编号{}，{}，{}米层高日平均风速计算失败，缺少数据^ ^", equipmentId, DateTimeUtil.dateToStrLong(new Date(start1)), h);
                    }

                }
            }
        } catch (Exception e) {
            log.error("设备编号{}日平均风速计算失败^ ^", equipmentId);
            e.printStackTrace();
        }

//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}米层高日平均风速计算成功^ ^", equipmentId);
        return list;
    }


    /**
     * 计算月平均风速
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备编号
     * @return
     */
    public ArrayList<WindTowerCalculationData> wsMonth(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        //获取时间段所有统计数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startHour) && w.getTime().before(endTime)).collect(Collectors.toList());

        //获取所有层高
        String[] height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        //遍历层高
        try {
            for (String h : height) {
                //获取对应层高的月平均风速字段
                String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "awsMonth")).collect(Collectors.toList()).get(0).getId();
                String ebIdDay = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "awsDay")).collect(Collectors.toList()).get(0).getId();
                //删除时间段所有数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startHour, endTime, equipmentId, ebIdMonth);

                //获取所有日平均风速
                List<WindTowerCalculationData> windTowerCalculationDatas = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(ebIdDay) && w.getTime().after(startHour) && w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId)).collect(Collectors.toList());
                BigDecimal wsSum = new BigDecimal(0);

                for (WindTowerCalculationData w : windTowerCalculationDatas) {
                    wsSum = wsSum.add(w.getValue());
                }

                if (!windTowerCalculationDatas.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebIdMonth);
                    windTowerCalculationData.setTime(startTime);
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(wsSum.divide(new BigDecimal(windTowerCalculationDatas.size()), 2, RoundingMode.HALF_UP).setScale(2, RoundingMode.HALF_UP));
                    list.add(windTowerCalculationData);
                } else {
                    log.info("设备编号{}，{}月，{}米层高月平均风速计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1, h);
                }
            }
        } catch (Exception e) {
            log.error("设备编号{}月平均风速计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("{}设备月平均风速统计完成", equipmentId);
        return list;

    }

    /**
     * 计算日平均风功率密度
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> wpdDay(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        long dayTime = 86400000L;
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startTime) && w.getTime().before(endTime)).collect(Collectors.toList());
        //获取所有层高
        String heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
        String[] strings = heights.split(",");
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //遍历层高
            for (String h : strings) {
                //获取所有小时风功率表
                List<EquipmentAttribute> wpdList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + "wpd")).collect(Collectors.toList());
                //获取所有日风功率表
                List<EquipmentAttribute> wpdDayList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + "wpdDay")).collect(Collectors.toList());
                //删除
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, wpdDayList.get(0).getId());
                for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {
                    long start2 = start1 + dayTime - 1L;

                    //获取所有小时风功率数据
                    long start = start1;
                    List<WindTowerCalculationData> wpdCalDataList = windTowerCalculationDataList1.stream().filter(w -> w.getTime().after(new Date(start)) &&
                            w.getTime().before(new Date(start2)) && w.getEquipmentId().equals(equipmentId) && w.getEbId().equals(wpdList.get(0).getId())).collect(Collectors.toList());
                    //小时风功率总值
                    BigDecimal wpdSum = BigDecimal.ZERO;
                    for (WindTowerCalculationData wpd : wpdCalDataList) {
                        wpdSum = wpdSum.add(wpd.getValue());
                    }
                    if (!wpdCalDataList.isEmpty()) {
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setEquipmentId(equipmentId);
                        windTowerCalculationData.setValue(wpdSum.divide(new BigDecimal(wpdCalDataList.size()), 2, RoundingMode.HALF_UP));
                        windTowerCalculationData.setEbId(wpdDayList.get(0).getId());
                        windTowerCalculationData.setTime(new Date(start1));
                        windTowerCalculationDataList.add(windTowerCalculationData);
                        list.add(windTowerCalculationData);

                    } else {
                        log.info("设备编号{}，{}，{}米层高日平均风功率计算失败，缺少数据^ ^", equipmentId, DateTimeUtil.dateToStrLong(new Date(start1)), h);
                    }

                }
            }
        } catch (Exception e) {
            log.error("设备编号{}日平均风功率计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}日平均风功率计算成功^ ^", equipmentId);
        return list;
    }

    /**
     * 计算月平均风功率密度
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    @Transactional
    public ArrayList<WindTowerCalculationData> wpdMonth(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        //获取时间段所有统计数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startHour) && w.getTime().before(endTime)).collect(Collectors.toList());

        //获取所有层高
        String[] height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            for (String h : height) {
                //获取对应层高的月平均风速字段
                String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "wpdMonth")).collect(Collectors.toList()).get(0).getId();
                String ebIdDay = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "wpdDay")).collect(Collectors.toList()).get(0).getId();
                //删除时间段所有数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startHour, endTime, equipmentId, ebIdMonth);

                //获取所有日平均风功率密度
                List<WindTowerCalculationData> windTowerCalculationDatas = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(ebIdDay) && w.getTime().after(startHour) && w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId)).collect(Collectors.toList());
                BigDecimal sum = new BigDecimal(0);

                for (WindTowerCalculationData w : windTowerCalculationDatas) {
                    sum = sum.add(w.getValue());
                }

                if (!windTowerCalculationDatas.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebIdMonth);
                    windTowerCalculationData.setTime(startTime);
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(sum.divide(new BigDecimal(windTowerCalculationDatas.size()), 2, RoundingMode.HALF_UP).setScale(2, RoundingMode.HALF_UP));
                    list.add(windTowerCalculationData);
                } else {
                    log.info("设备编号{}，{}月，{}米层高月平均风功率密度计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1, h);
                }

            }

        } catch (Exception e) {
            log.error("设备编号{}月平均风功率计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}高月平均风功率计算成功^ ^", equipmentId);
        return list;
    }


    /**
     * 计算日平均风速标差
     *
     * @param startTime              开始时间
     * @param endTime                结束时间
     * @param equipmentId            测风塔编号
     * @param equipmentAttributeList 属性表
     * @param windTowerInfoList      测风塔数据
     * @return
     */
    public ArrayList<WindTowerCalculationData> calculateStaDay(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList, List<WindTowerCalculationData> windTowerCalculationDataList) {
        ArrayList<WindTowerCalculationData> dataList = new ArrayList<>();
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        long Hour = 86400000;
        String[] heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        try {
            for (String h : heights) {
                //获取对应层高的属性
                List<EquipmentAttribute> equipmentAttributes = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "staDay")).collect(Collectors.toList());
                //删除数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, equipmentAttributes.get(0).getId());
                //每天循环
                for (long time = startHour; time < endHour; time = time + Hour) {
                    long startDate = time;
                    //过滤一天的数据
                    List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startDate && p.getTs().getTime() < startDate + Hour && p.getLayerHeight().equals(h)).collect(Collectors.toList());
                    BigDecimal staSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getWsSta() != null && c.getWsSta() != 0).mapToDouble(ProphaseAnemometryData::getWsSta).sum());
                    if (collect.size() > 0) {
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setEquipmentId(equipmentId);
                        windTowerCalculationData.setTime(new Date(startDate));
                        windTowerCalculationData.setValue(staSum.divide(CalculationUtil.getBigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                        windTowerCalculationData.setEbId(equipmentAttributes.get(0).getId());
                        windTowerCalculationDataList.add(windTowerCalculationData);
                        dataList.add(windTowerCalculationData);
                    }
                }
            }
        } catch (Exception e) {
            log.error("设备编号{}日平均风速标差计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(dataList);
        log.info("设备编号{},风速标差数据计算完成", equipmentId);
        return dataList;

    }


    /**
     * 计算日平均湍流
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> turbulenceDay(Date startTime, Date endTime, String equipmentId, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList, List<WindTowerCalculationData> windTowerCalculationDataList) {
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        long dayTime = 86400000L;
        String heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
        String[] heightAll = heights.split(",");
        //获取对应测风塔数据
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            for (String h : heightAll) {

                List<EquipmentAttribute> turList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + turbulenceDay)).collect(Collectors.toList());
                List<EquipmentAttribute> staList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + staDay)).collect(Collectors.toList());
                List<EquipmentAttribute> wsList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(h + "awsDay")).collect(Collectors.toList());

                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, turList.get(0).getId());
                for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {

                    long finalStart = start1;
                    List<WindTowerCalculationData> staDay = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(staList.get(0).getId()) && w.getTime().getTime() == finalStart).collect(Collectors.toList());
                    List<WindTowerCalculationData> wsDay = windTowerCalculationDataList.stream().filter(w -> w.getEbId().equals(wsList.get(0).getId()) && w.getTime().getTime() == finalStart).collect(Collectors.toList());

                    if (!staDay.isEmpty() && !wsDay.isEmpty()) {

                        //数据入库
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setTime(new Date(start1));
                        windTowerCalculationData.setEbId(turList.get(0).getId());
                        windTowerCalculationData.setEquipmentId(equipmentId);
                        windTowerCalculationData.setValue(CalculationUtil.caTurbulenceIntensity(staDay.get(0).getValue(), wsDay.get(0).getValue()));
                        windTowerCalculationDataList.add(windTowerCalculationData);
                        list.add(windTowerCalculationData);
                    } else {
                        log.info("设备编号{}，{}，{}米层高日平均湍流计算失败,缺少数据^ ^", equipmentId, DateTimeUtil.dateToStrLong(new Date(start1)), h);
                    }
                }


            }
        } catch (NumberFormatException e) {
            log.error("设备编号{}日平均湍流计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}日平均湍流计算成功^ ^", equipmentId);
        return list;
    }

    /**
     * 月平均湍流
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备编号
     * @return
     */
    public ArrayList<WindTowerCalculationData> turbulenceMonth(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        //获取时间段所有统计数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startHour) && w.getTime().before(endTime)).collect(Collectors.toList());

        //获取所有层高
        String[] height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            for (String h : height) {
                //获取对应层高的月平均风速字段
                String ebIdDay = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "turbulenceDay")).collect(Collectors.toList()).get(0).getId();
                String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "turbulenceMonth")).collect(Collectors.toList()).get(0).getId();
                //删除时间段所有数据
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startHour, endTime, equipmentId, ebIdMonth);

                //获取所有日平均湍流风速
                List<WindTowerCalculationData> windTowerCalculationDatas = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(ebIdDay) && w.getTime().after(startHour) && w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId)).collect(Collectors.toList());
                BigDecimal sum = new BigDecimal(0);

                for (WindTowerCalculationData w : windTowerCalculationDatas) {
                    sum = sum.add(w.getValue());
                }

                if (!windTowerCalculationDatas.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebIdMonth);
                    windTowerCalculationData.setTime(startTime);
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(sum.divide(new BigDecimal(windTowerCalculationDatas.size()), 2, RoundingMode.HALF_UP).setScale(2, RoundingMode.HALF_UP));
                    list.add(windTowerCalculationData);
                } else {
                    log.info("设备编号{}，{}月，{}米层高月平均湍流计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1, h);
                }


            }

        } catch (Exception e) {
            log.error("设备编号{}月平均湍流计算失败^ ^", equipmentId);
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}月平均湍流计算成功^ ^", equipmentId);
        return list;
    }

    /**
     * 计算日风切变入库
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> shearDay(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        long dayTime = 86400000L;
        //日平均所需要的集合
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startTime) && w.getTime().before(endTime)).collect(Collectors.toList());
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //遍历层高

            //获取所有小时综合风切变
            List<EquipmentAttribute> shearList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(windShearFiledName)).collect(Collectors.toList());
            //获取日综合风切变
            List<EquipmentAttribute> shearDayList = equipmentAttributeList.stream().filter(equipmentAttribute -> equipmentAttribute.getFieldName().equals(windShearDayFiledName)).collect(Collectors.toList());
            //删除统计时间段所有数据
            removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, shearDayList.get(0).getId());

            for (long start1 = startHour; start1 < endHour; start1 = start1 + dayTime) {
                long start2 = start1 + dayTime - 1L;

                //获取所有小时风切变数据
                long start = start1;
                List<WindTowerCalculationData> shearCalDataList = windTowerCalculationDataList1.stream().filter(w -> w.getTime().after(new Date(start)) &&
                        w.getTime().before(new Date(start2)) && w.getEquipmentId().equals(equipmentId) && w.getEbId().equals(shearList.get(0).getId())).collect(Collectors.toList());
                //小时风切变总值
                BigDecimal shearSum = BigDecimal.ZERO;
                for (WindTowerCalculationData shear : shearCalDataList) {
                    shearSum = shearSum.add(shear.getValue());
                }
                if (!shearCalDataList.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(shearSum.divide(new BigDecimal(shearCalDataList.size()), 2, RoundingMode.HALF_UP));
                    windTowerCalculationData.setEbId(shearDayList.get(0).getId());
                    windTowerCalculationData.setTime(new Date(start1));
                    windTowerCalculationDataList.add(windTowerCalculationData);
                    list.add(windTowerCalculationData);
                } else {
                    log.info("设备编号{}，{}，{}米层高日平均风切变计算失败，缺少数据^ ^", equipmentId, DateTimeUtil.dateToStrLong(new Date(start1)));
                }

            }

        } catch (Exception e) {
            log.error("设备编号{}日平均风切变计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}日平均风切变计算成功^ ^", equipmentId);
        return list;
    }

    /**
     * 计算月风切变入库
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> shearMonth(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        //获取时间段所有统计数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = windTowerCalculationDataList.stream().filter(w -> w.getEquipmentId().equals(equipmentId) && w.getTime().after(startHour) && w.getTime().before(endTime)).collect(Collectors.toList());
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //获取月平均综合风切变字段
            String ebIdMonth = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("windShearMonth")).collect(Collectors.toList()).get(0).getId();
            String ebIdDay = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("windShearDay")).collect(Collectors.toList()).get(0).getId();
            //删除时间段所有数据
            removeByStartTimeBetweenAndEquipmentIdAndEbId(startHour, endTime, equipmentId, ebIdMonth);
            //获取所有日平均风切变
            List<WindTowerCalculationData> windTowerCalculationDatas = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(ebIdDay) && w.getTime().after(startHour) && w.getTime().before(endTime) && w.getEquipmentId().equals(equipmentId))
                    .collect(Collectors.toList());
            BigDecimal sum = new BigDecimal(0);

            for (WindTowerCalculationData w : windTowerCalculationDatas) {
                sum = sum.add(w.getValue());
            }

            if (!windTowerCalculationDatas.isEmpty()) {
                WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                windTowerCalculationData.setEbId(ebIdMonth);
                windTowerCalculationData.setTime(startTime);
                windTowerCalculationData.setEquipmentId(equipmentId);
                windTowerCalculationData.setValue(sum.divide(new BigDecimal(windTowerCalculationDatas.size()), 2, RoundingMode.HALF_UP).setScale(2, RoundingMode.HALF_UP));
                list.add(windTowerCalculationData);
            } else {
                log.info("设备编号{}，{}月平均风切变指数计算失败，缺少数据^ ^", equipmentId, startTime.getMonth() + 1);
            }


        } catch (Exception e) {
            log.error("设备编号{}月平均风月切变计算失败^ ^", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}月平均风切变计算成功^ ^", equipmentId);
        return list;
    }

    /**
     * 威布尔AK计算
     *
     * @param startTime                    开始时间
     * @param endTime                      结束时间
     * @param equipmentId                  测风塔Id
     * @param windTowerCalculationDataList 统计库数据
     * @param equipmentAttributeList       统计表数据
     * @param windTowerInfoList            测风塔表数据
     */
    public void statisticsWeiBullForAKForYear(Date startTime, Date endTime, String equipmentId, List<WindTowerCalculationData> windTowerCalculationDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //获取时间段测风塔数据
        List<WindTowerCalculationData> windTowerCalculationDataList1 = getByBetweenTimeAndEquipmentId(startTime, endTime, equipmentId);
        String[] heights = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights().split(",");
        //存数据用的集合
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        //遍历层高
        try {
            for (String h : heights) {
                ArrayList<Object> wsList = new ArrayList<>();
                //获取AK的ebId 以及小时风速id
                String ebIdA = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(h + "weibullA")).collect(Collectors.toList()).get(0).getId();
                String ebIdK = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(h + "weibullK")).collect(Collectors.toList()).get(0).getId();
                String id = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(h + "aws")).collect(Collectors.toList()).get(0).getId();
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdK);
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebIdA);
                List<WindTowerCalculationData> windTowerCalculationDataWsList = windTowerCalculationDataList1.stream().filter(w -> w.getEbId().equals(id)).collect(Collectors.toList());
                for (WindTowerCalculationData w : windTowerCalculationDataWsList) {
                    if (w.getValue() != null) {
                        wsList.add(w.getValue());
                    }
                }
                if (!wsList.isEmpty()) {
                    //放入风速集合
                    ProbabilityPlot probabilityPlot = new ProbabilityPlot(wsList);
                    probabilityPlot.suppressDisplay();
                    //计算AK
                    double K = probabilityPlot.weibullTwoParGamma();
                    double A = probabilityPlot.weibullTwoParSigma();
                    WindTowerCalculationData windTowerCalculationDataK = new WindTowerCalculationData();
                    windTowerCalculationDataK.setValue(BigDecimal.valueOf(K));
                    windTowerCalculationDataK.setEbId(ebIdK);
                    windTowerCalculationDataK.setTime(DateUtil.beginOfDay(new Date(startTime.getTime() + 86400000 * 2)));
                    windTowerCalculationDataK.setEquipmentId(equipmentId);

                    WindTowerCalculationData windTowerCalculationDataA = new WindTowerCalculationData();
                    windTowerCalculationDataA.setValue(BigDecimal.valueOf(A));
                    windTowerCalculationDataA.setEbId(ebIdA);
                    windTowerCalculationDataA.setTime(DateUtil.beginOfDay(new Date(startTime.getTime() + 86400000 * 2)));
                    windTowerCalculationDataA.setEquipmentId(equipmentId);
                    list.add(windTowerCalculationDataK);
                    list.add(windTowerCalculationDataA);
                } else {
                    log.info("缺少风速数据，无法计算威布尔AK值");
                }
            }
        } catch (NumberFormatException e) {
            log.error("威布尔AK计算异常");
            e.printStackTrace();
        }

        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备{},威布尔AK计算成功", equipmentId);
    }

    /**
     * 日平均温度入库
     *
     * @param startTime              开始时间
     * @param endTime                结束时间
     * @param equipmentId            设备Id
     * @param equipmentAttributeList 属性集合
     */
    public ArrayList<WindTowerCalculationData> tDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
        String ebId = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("tDay")).collect(Collectors.toList()).get(0).getId();
        long day = 86400000L;
        ArrayList<WindTowerCalculationData> tList = new ArrayList<>();
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebId);
        try {
            for (long time = startTime.getTime(); time < endTime.getTime(); time += day) {
                long dayTime = time;
                //过滤一天数据
                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= dayTime && p.getTs().getTime() < dayTime + day).collect(Collectors.toList());
                //计算时间段内所有温度
                BigDecimal tSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getTAve() != null && c.getTAve() != 0).mapToDouble(ProphaseWeatherData::getTAve).sum());
                if (!collect.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebId);
                    windTowerCalculationData.setTime(new Date(dayTime));
                    windTowerCalculationData.setValue(tSum.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    tList.add(windTowerCalculationData);
                }
            }
        } catch (Exception e) {
            log.error("设备{}日平均温度统计异常", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("{}设备日平均温度计算完成", equipmentId);
        return tList;
    }

    /**
     * 日平均气压入库
     *
     * @param startTime              开始时间
     * @param endTime                结束时间
     * @param equipmentId            设备Id
     * @param equipmentAttributeList 属性集合
     */
    public ArrayList<WindTowerCalculationData> paDay(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
        String ebId = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("paDay")).collect(Collectors.toList()).get(0).getId();
        long day = 86400000L;
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebId);
        try {
            for (long time = startTime.getTime(); time < endTime.getTime(); time += day) {
                long dayTime = time;
                //过滤一天数据
                List<ProphaseWeatherData> collect = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= dayTime && p.getTs().getTime() < dayTime + day).collect(Collectors.toList());
                BigDecimal paSum = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getPaAve() != null && c.getPaAve() != 0).mapToDouble(ProphaseWeatherData::getTAve).sum());

                if (!collect.isEmpty()) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebId);
                    windTowerCalculationData.setTime(new Date(dayTime));
                    windTowerCalculationData.setValue(paSum.divide(BigDecimal.valueOf(collect.size()), 2, RoundingMode.HALF_UP));
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    list.add(windTowerCalculationData);
                }
            }
        } catch (Exception e) {
            log.error("设备{}日平均气压统计异常", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("{}设备日平均气压计算完成", equipmentId);
        return list;
    }


    /**
     * 计算上一个小时 每10分钟的风切变指数
     */
    public ArrayList<WindTowerCalculationData> calculateWindPowerShear(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<WindTowerCalculationData> windTowerCalculationDataList) {
        log.info("开始计算小时风切变指数");
        long startHour = startTime.getTime();
        long endHour = endTime.getTime();
        List<WindTowerInfo> windTowerInfoList = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, equipmentId).list();
        String[] heights = windTowerInfoList.get(0).getHeights().split(",");
        ArrayList<WindTowerCalculationData> listAll = new ArrayList<>();
        //时间段内所有风数据
        List<ProphaseAnemometryData> prophaseAnemometryData = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());
        EquipmentAttribute equipmentAttribute = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, windShearFiledName).list().get(0);
        //删除综合风切变
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, equipmentAttribute.getId());
        try {
            for (long start1 = startHour; start1 <= endHour; start1 = start1 + 3600000) {
                //开始时间--->start1  结束时间---->start2
                long start2 = start1 + 3600000L;
                BigDecimal oneHourWindShear = BigDecimal.ZERO;
                BigDecimal total = BigDecimal.ZERO;
                for (long i = start1; i < start2; i = i + 600000) {
                    long finalI = i;
                    List<ProphaseAnemometryData> collect = prophaseAnemometryData.stream().filter(p -> p.getTs().getTime() >= finalI && p.getTs().getTime() <= finalI + 600000 - 1).collect(Collectors.toList());
                    //计算十分钟综合风切变
                    BigDecimal windShear = CalculationUtil.getWindShear(collect, heights);
                    if (windShear.compareTo(BigDecimal.ZERO) != 0) {
                        oneHourWindShear = oneHourWindShear.add(windShear);
                        total = total.add(BigDecimal.ONE);
                    }
                }
                if (total.compareTo(BigDecimal.ZERO) > 0) {
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setTime(new Date(start1));
                    windTowerCalculationData.setValue(oneHourWindShear.divide(total, 2, RoundingMode.HALF_UP));
                    windTowerCalculationData.setEbId(equipmentAttribute.getId());
                    windTowerCalculationDataList.add(windTowerCalculationData);
                    listAll.add(windTowerCalculationData);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("设备{}小时风切变统计异常", equipmentId);
        }
        //保存风切变指数
//        saveBatchByEquipmentId(listAll, equipmentId);
        log.info("{}设备风切变指数计算完成", equipmentId);
        return listAll;
    }


    /**
     * 根据 时间，层高，设备id 查询风切变数据
     *
     * @param time   时间
     * @param height 层高
     * @param eqId   设备id
     * @return map: 一天一条
     */
    @Override
    public List<Map<String, Object>> getWindShearByEqidAndAverageAndTime(Long time, String height, String eqId) {
        List<Map<String, Object>> list = new ArrayList<>();
        List<Map<String, Object>> tableList = new ArrayList<>();
        Map<String, Object> map = new TreeMap<>();
        String shearFieldName = height + "shearDay";
        List<EquipmentAttribute> shearFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, shearFieldName).list();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date currentDate = new Date(time);
        if (!shearFieldNameList.isEmpty()) {
            String ebId = shearFieldNameList.get(0).getId(); //属性id
            //查询风切变 月平均数据 根据时间，层高，设备id 并根据时间升序排列
            List<WindTowerCalculationData> windTowerCalculationDataLists = getByBetweenTimeAndEquipmentId(SEDateUtil.getStartTimeOfCurrentMonth(currentDate), SEDateUtil.getEndTimeOfCurrentMonth(currentDate), eqId);
            List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataLists.stream().filter(w -> ebId.equals(w.getEbId())).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
            BigDecimal sum = BigDecimal.ZERO;
            BigDecimal avgShear = BigDecimal.ZERO;
            if (!windTowerCalculationDataList.isEmpty()) {
//                //月平均风切变数据放入map返回，key为整- 小时:00
//                long hour = 3600000L;
//                Date systemDate = new Date();
//                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
//                //获取昨日开始和结束时间
//                long startTime = DateMomentUtil.getDayStartTime(DateUtils.addDays(systemDate, -1).getTime());
//                long endTime = startTime + 86399000;
//                // 一个月或多个月数据 按照24小时分割
//                for (long hourStr = startTime; hourStr <= endTime; hourStr += hour) {
//                    Map<String, Object> tableMap = new TreeMap<>();
//                    String finalTime = simpleDateFormat.format(hourStr);
//                    List<BigDecimal> collect = windTowerCalculationDataList.stream().filter(w -> simpleDateFormat.format(w.getTime()).equals(finalTime) &&
//                            w.getValue().compareTo(new BigDecimal(-99)) != 0).map(WindTowerCalculationData::getValue).collect(Collectors.toList());
//                    BigDecimal avg = BigDecimal.ZERO;
//                    if (!collect.isEmpty()) {
//                        avg = collect.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(collect.size()), 4, RoundingMode.HALF_UP);
//                    }
//                    tableMap.put("time", finalTime + ":00");
//                    tableMap.put("windShear", avg);
//                    tableList.add(tableMap);
//                }

                for (WindTowerCalculationData windTowerCalculationData : windTowerCalculationDataList) {
                    Map<String, Object> tableMap = new TreeMap<>();
                    BigDecimal value = windTowerCalculationData.getValue().compareTo(new BigDecimal(-99)) != 0 ? windTowerCalculationData.getValue() : BigDecimal.ZERO;
                    tableMap.put("time", sdf.format(windTowerCalculationData.getTime()));
                    tableMap.put("windShear", value.setScale(2, RoundingMode.HALF_UP));
                    tableList.add(tableMap);
                    sum = sum.add(value);
                }
                if (sum.compareTo(new BigDecimal(0)) != 0) {
                    avgShear = sum.divide(new BigDecimal(windTowerCalculationDataList.size()), 2, RoundingMode.HALF_UP);
                }

            }
            map.put("tableList", tableList);
            map.put("avgShear", avgShear);
            list.add(map);
//            //计算月平均值
//            double sum = 0;
//            long count = 0;
//            for (WindTowerCalculationData windTowerCalculationData : windTowerCalculationDataList) {
//                double value = windTowerCalculationData.getValue().doubleValue();
//                sum += value;
//                count++;
//            }
//            BigDecimal avgShear = BigDecimal.valueOf(count > 0 ? sum / count : 0L).setScale(4, RoundingMode.HALF_UP);
//            map.put("tableList", tableList);
//            map.put("avgShear", avgShear);
//            list.add(map);
        }
        return list;
    }


    /**
     * 查询当前月的24个小时对应的风切变指数
     * 每月1号的0-1点之间查询上个月的
     *
     * @return Map<String, WindTowerCalculationData>
     */
    private Map<String, WindTowerCalculationData> queryHistoryWindTowerCalculationDatas(List<WindTowerCalculationData> windTowerCalculationDataList) {
        Map<String, WindTowerCalculationData> windTowerCalculationDataMap = new HashMap<>();
        //查询风切变 月平均数据 根据时间，层高，设备id 并根据时间升序排列
        windTowerCalculationDataList.forEach(windTowerCalculationData -> windTowerCalculationDataMap.put(windTowerCalculationData.getTime() + windTowerCalculationData.getEquipmentId() + windTowerCalculationData.getEbId(), windTowerCalculationData));
        return windTowerCalculationDataMap;
    }


    /**
     * 遍历查询到的风速数据，计算每隔10分钟的风切变指数
     *
     * @param map map
     * @return Map<String, List < BigDecimal>>
     */
    private Map<String, List<BigDecimal>> traverseWindDataListCalcuShear(Map<String, BigDecimal> map, Integer heightMin) {
        Map<String, List<BigDecimal>> windTowerShearMap = new HashMap<>();
        map.forEach((key, value) -> {
            String[] keys = key.split("-");//0:层高 1：整10分的时间点 2：设备ID 3：日
            //10米层高不计算，没有更低的
            if (!String.valueOf(heightMin).equals(keys[0]) && null != value) {
                calculateShearByHeight10(keys, value, windTowerShearMap, map, heightMin);
            }
        });
        return windTowerShearMap;
    }

    /**
     * 查询数据类型表，获取所有风切变指数参数
     *
     * @return Map<String, String>
     */
    private Map<String, String> queryEquipmentAttributeMap() {
        List<EquipmentAttribute> shearFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getAttributeFunction, shearFunction).list();
        return shearFieldNameList.stream().collect(Collectors.toMap(EquipmentAttribute::getFieldName, EquipmentAttribute::getId));
    }

    /**
     * 查询当前月份的风速数据，如果是1号0点-1点执行则查询上一个月的数据
     *
     * @return Map<String, BigDecimal>
     */
    private Map<String, BigDecimal> queryWindForShear(Date startTimeOfCurrentDay, Date endTimeOfCurrentDay, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryData, String[] heights) {

        Map<String, BigDecimal> windTowerStatusDataResult = new HashMap<>();
//        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTimeOfCurrentDay.getTime() && Long.parseLong(w.get("time").toString()) <= endTimeOfCurrentDay.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
        List<ProphaseAnemometryData> collect = prophaseAnemometryData.stream().filter(p -> p.getTs().getTime() >= startTimeOfCurrentDay.getTime() && p.getTs().getTime() <= endTimeOfCurrentDay.getTime()).collect(Collectors.toList());
        //只取上一个小时的数据
        int curentHour = startTimeOfCurrentDay.getHours();
        //构造当前小时的风速map 以层高和分钟，日为key,风速为value
        for (ProphaseAnemometryData map : collect) {
            for (String height : heights) {
                Date time = new Date(map.getTs().getTime());
                if (curentHour == time.getHours() && map.getLayerHeight().equals(height)) {
                    //获取 毫秒数
                    Integer minutes = time.getMinutes();
                    String keyEndStr = minutes + "-" + equipmentId + "-" + DateTimeUtil.getDay(time.getTime());
                    windTowerStatusDataResult.put(height + "-" + keyEndStr, CalculationUtil.getBigDecimal(map.getWsAve()));
                }
            }

        }
        return windTowerStatusDataResult;

    }


    /**
     * 查询当前月份的风速数据，如果是1号0点-1点执行则查询上一个月的数据
     *
     * @return Map<String, BigDecimal>
     */
    private Map<String, BigDecimal> queryWindForShear(Date startTimeOfCurrentDay, Date endTimeOfCurrentDay, String equipmentId, List<Map<String, Object>> mapList) {

        Map<String, BigDecimal> windTowerStatusDataResult = new HashMap<>();
        List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startTimeOfCurrentDay.getTime() && Long.parseLong(w.get("time").toString()) <= endTimeOfCurrentDay.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
        //只取上一个小时的数据
        int curentHour = startTimeOfCurrentDay.getHours();
        //构造当前小时的风速map 以层高和分钟，日为key,风速为value
        for (Map<String, Object> map : collect) {
            Date time = new Date(Long.parseLong(map.get("time").toString()));
            if (curentHour == time.getHours()) {
                //获取 毫秒数
                Integer minutes = time.getMinutes();
                String keyEndStr = minutes + "-" + equipmentId + "-" + DateTimeUtil.getDay(time.getTime());
                if (null != map.get("abnormal_data")) {
                    judgeWsDataIsError(windTowerStatusDataResult, map, keyEndStr);
                } else {
                    windTowerStatusDataResult.put("10-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave10")));
                    windTowerStatusDataResult.put("30-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave30")));
                    windTowerStatusDataResult.put("50-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave50")));
                    windTowerStatusDataResult.put("70-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave70")));
                    windTowerStatusDataResult.put("80-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave80")));
                    windTowerStatusDataResult.put("90-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave90")));
                    windTowerStatusDataResult.put("100-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave100")));
                    windTowerStatusDataResult.put("110-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave110")));
                    windTowerStatusDataResult.put("120-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave120")));
                    windTowerStatusDataResult.put("120A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave120A")));
                    windTowerStatusDataResult.put("140-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave140")));
                    windTowerStatusDataResult.put("140A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave140A")));
                    windTowerStatusDataResult.put("150-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave150")));
                    windTowerStatusDataResult.put("150A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave150A")));
                }
            }
        }
        return windTowerStatusDataResult;

    }

    /**
     * 异常风速值不进行计算，忽略处理
     *
     * @param windTowerStatusDataResult windTowerStatusDataResult
     * @param map                       map
     * @param keyEndStr                 keyEndStr
     */
    private void judgeWsDataIsError(Map<String, BigDecimal> windTowerStatusDataResult, Map<String, Object> map, String keyEndStr) {
        String abnormalType = map.get("abnormal_type").toString();
        if (!abnormalType.contains("Ave10")) {
            windTowerStatusDataResult.put("10-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave10")));
        }
        if (!abnormalType.contains("Ave30")) {
            windTowerStatusDataResult.put("30-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave30")));
        }
        if (!abnormalType.contains("Ave50")) {
            windTowerStatusDataResult.put("50-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave50")));
        }
        if (!abnormalType.contains("Ave70")) {
            windTowerStatusDataResult.put("70-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave70")));
        }
        if (!abnormalType.contains("Ave80")) {
            windTowerStatusDataResult.put("80-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave80")));
        }
        if (!abnormalType.contains("Ave90")) {
            windTowerStatusDataResult.put("90-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave90")));
        }
        if (!abnormalType.contains("Ave100")) {
            windTowerStatusDataResult.put("100-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave100")));
        }
        if (!abnormalType.contains("Ave110")) {
            windTowerStatusDataResult.put("110-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave110")));
        }
        if (!abnormalType.contains("Ave120")) {
            windTowerStatusDataResult.put("120-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave120")));
        }
        if (!abnormalType.contains("Ave120A")) {
            windTowerStatusDataResult.put("120A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave120A")));
        }
        if (!abnormalType.contains("Ave140")) {
            windTowerStatusDataResult.put("140-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave140")));
        }
        if (!abnormalType.contains("Ave150")) {
            windTowerStatusDataResult.put("150-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave150")));
        }
        if (!abnormalType.contains("Ave140A")) {
            windTowerStatusDataResult.put("140A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave140A")));
        }
        if (!abnormalType.contains("Ave150A")) {
            windTowerStatusDataResult.put("150A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave150A")));
        }
    }

    /**
     * 以10米风速为基准 计算层高风切变指数
     *
     * @param keys              keys
     * @param ws                ws
     * @param windTowerShearMap 各层高风切结果集
     * @param map
     */
    private void calculateShearByHeight10(String[] keys, BigDecimal ws, Map<String, List<BigDecimal>> windTowerShearMap, Map<String, BigDecimal> map, Integer heightMin) {

        String height = keys[0];
        String MINUTE = keys[1];
        String equipmentId = keys[2];
        String day = keys[3];
        String keyEndStr = MINUTE + "-" + equipmentId + "-" + day;
        String key = height + "-00-" + equipmentId;

        //10米风速
        BigDecimal wsMin = Convert.toBigDecimal(map.get(heightMin + "-" + keyEndStr));
        //计算各风速风切变
        BigDecimal shear = BigDecimal.ZERO;
        if (wsMin != null) {
            double z = new BigDecimal(getNumberFromString(height)).divide(new BigDecimal(heightMin), 4, RoundingMode.HALF_UP).doubleValue();
            double z1 = Math.log10(z);
            shear = Convert.toBigDecimal(Math.log10(Convert.toDouble(ws.divide(wsMin, 8, RoundingMode.HALF_UP))))
                    .divide(BigDecimal.valueOf(z1), 8, RoundingMode.HALF_UP);
        }
        //将计算的风切变结果放入结果集合中
        if (null != windTowerShearMap.get(key)) {
            List<BigDecimal> list = windTowerShearMap.get(key);
            list.add(shear);
        } else {
            List<BigDecimal> list = new ArrayList<>();
            list.add(shear);
            windTowerShearMap.put(key, list);
        }
    }


    /**
     * 计算月平均风速标差
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @return
     */
    public ArrayList<WindTowerCalculationData> staMonth(Date startTime, Date endTime, String equipmentId, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        //时间-1防止0点数据查不到
        Date startHour = new Date(startTime.getTime() - 1);
        List<ProphaseAnemometryData> collect = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startTime.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());

        ArrayList<WindTowerCalculationData> windTowerCalculationDataList = new ArrayList<>();
        String h = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
        String[] heights = h.split(",");
        //计算标差
        for (String height : heights) {
            List<EquipmentAttribute> equipmentAttributeList1 = equipmentAttributeList.stream().filter(e -> e.getFieldName().equals(height + "staMonth")).collect(Collectors.toList());
            if (!collect.isEmpty()) {
                BigDecimal sumSta = CalculationUtil.getBigDecimal(collect.stream().filter(c -> c.getWsSta() != null && c.getLayerHeight().equals(height)).mapToDouble(ProphaseAnemometryData::getWsSta).sum());
                WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                windTowerCalculationData.setEbId(equipmentAttributeList1.get(0).getId());
                windTowerCalculationData.setTime(startHour);
                windTowerCalculationData.setValue(sumSta.divide(new BigDecimal(collect.size()), 2, RoundingMode.HALF_UP));
                windTowerCalculationData.setEquipmentId(equipmentId);
                windTowerCalculationDataList.add(windTowerCalculationData);
            }
        }
        List<EquipmentAttribute> equipmentAttributeList1 = equipmentAttributeList.stream().filter(e -> "staMonth".equals(e.getAttributeFunction())).collect(Collectors.toList());
        for (EquipmentAttribute e : equipmentAttributeList1) {
            List<WindTowerCalculationData> windTowerCalculationDataList1 = getByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, e.getId());
            if (!windTowerCalculationDataList1.isEmpty()) {
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, e.getId());
            }
        }
//        saveBatchByEquipmentId(windTowerCalculationDataList, equipmentId);
        return windTowerCalculationDataList;
    }


    /**
     * @param startTime              开始时间
     * @param endTime                结束时间
     * @param equipmentId            设备id
     * @param equipmentAttributeList 属性集合
     * @return
     */
    public ArrayList<WindTowerCalculationData> environmentData(Date startTime, Date endTime, String equipmentId, List<ProphaseWeatherData> prophaseWeatherDataList, List<EquipmentAttribute> equipmentAttributeList) {
        ArrayList<WindTowerCalculationData> windTowerCalculationDataList = null;
        try {
            //时间-1防止0点数据查不到
            Date startHour = new Date(startTime.getTime() - 1);
//            List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour.getTime() && Long.parseLong(w.get("time").toString()) <= endTime.getTime() && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
            List<ProphaseWeatherData> prophaseWeatherData = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startHour.getTime() && p.getTs().getTime() <= endTime.getTime()).collect(Collectors.toList());

            equipmentAttributeList = equipmentAttributeList.stream().filter(w -> "environment".equals(w.getAttributeFunction())).collect(Collectors.toList());
            BigDecimal sumPa = new BigDecimal(0);
            BigDecimal avePa = new BigDecimal(0);
            BigDecimal sumRh = new BigDecimal(0);
            BigDecimal aveRh = new BigDecimal(0);
            BigDecimal sumT = new BigDecimal(0);
            BigDecimal aveT = new BigDecimal(0);
            windTowerCalculationDataList = new ArrayList<>();
            if (!prophaseWeatherData.isEmpty()) {
                List<BigDecimal> paList = new ArrayList<>();
                List<BigDecimal> rhList = new ArrayList<>();
                List<BigDecimal> tList = new ArrayList<>();
                /*计算平均值数值为null 不计算*/
                for (ProphaseWeatherData map : prophaseWeatherData) {
                    if (map.getPaAve() != null && map.getPaAve() != 0) {
                        paList.add(CalculationUtil.getBigDecimal(map.getPaAve()));
                    }
                    if (map.getRhAve() != null && map.getRhAve() != 0) {
                        rhList.add(CalculationUtil.getBigDecimal(map.getRhAve()));
                    }
                    if (map.getTAve() != null && map.getTAve() != 0) {
                        tList.add(CalculationUtil.getBigDecimal(map.getTAve()));
                    }
                }
                /*气压*/
                BigDecimal maxPa = new BigDecimal(0);
                BigDecimal minPa = new BigDecimal(0);
                if (!paList.isEmpty()) {
                    maxPa = paList.stream().max(BigDecimal::compareTo).get();
                    minPa = paList.stream().min(BigDecimal::compareTo).get();
                    for (BigDecimal pa : paList) {
                        sumPa = sumPa.add(pa);
                    }
                    avePa = sumPa.divide(new BigDecimal(paList.size()), 2, RoundingMode.HALF_UP);
                }

                /*温度*/
                BigDecimal maxT = new BigDecimal(0);
                BigDecimal minT = new BigDecimal(0);
                if (!tList.isEmpty()) {
                    maxT = tList.stream().max(BigDecimal::compareTo).get();
                    minT = tList.stream().min(BigDecimal::compareTo).get();
                    for (BigDecimal t : tList) {
                        sumT = sumT.add(t);
                    }
                    aveT = sumT.divide(new BigDecimal(tList.size()), 2, RoundingMode.HALF_UP);
                }


                /*湿度*/
                BigDecimal maxRh = new BigDecimal(0);
                BigDecimal minRh = new BigDecimal(0);
                if (!rhList.isEmpty()) {
                    maxRh = rhList.stream().max(BigDecimal::compareTo).get();
                    minRh = rhList.stream().min(BigDecimal::compareTo).get();
                    for (BigDecimal rh : rhList) {
                        sumRh = sumRh.add(rh);
                    }
                    aveRh = sumRh.divide(new BigDecimal(rhList.size()), 2, RoundingMode.HALF_UP);
                }

                List<EquipmentAttribute> paMax = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("paMAX")).collect(Collectors.toList());
                List<EquipmentAttribute> paMin = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("paMIN")).collect(Collectors.toList());
                List<EquipmentAttribute> paAve = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("paAVE")).collect(Collectors.toList());
                List<EquipmentAttribute> rhMax = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("rhMAX")).collect(Collectors.toList());
                List<EquipmentAttribute> rhMin = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("rhMIN")).collect(Collectors.toList());
                List<EquipmentAttribute> rhAve = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("rhAVE")).collect(Collectors.toList());
                List<EquipmentAttribute> tMax = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("tMAX")).collect(Collectors.toList());
                List<EquipmentAttribute> tMin = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("tMIN")).collect(Collectors.toList());
                List<EquipmentAttribute> tAve = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals("tAVE")).collect(Collectors.toList());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, paMax.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, paMin.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, paAve.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, rhMax.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, rhMin.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, rhAve.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, tMax.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, tMin.get(0).getId());
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, tAve.get(0).getId());
                WindTowerCalculationData paMaxData = new WindTowerCalculationData();
                paMaxData.setEbId(paMax.get(0).getId());
                paMaxData.setValue(maxPa);
                paMaxData.setTime(startTime);
                paMaxData.setEquipmentId(equipmentId);
                WindTowerCalculationData paMinData = new WindTowerCalculationData();
                paMinData.setEbId(paMin.get(0).getId());
                paMinData.setValue(minPa);
                paMinData.setTime(startTime);
                paMinData.setEquipmentId(equipmentId);
                WindTowerCalculationData paAveData = new WindTowerCalculationData();
                paAveData.setEbId(paAve.get(0).getId());
                paAveData.setValue(avePa);
                paAveData.setTime(startTime);
                paAveData.setEquipmentId(equipmentId);
                WindTowerCalculationData rhMaxData = new WindTowerCalculationData();
                rhMaxData.setEbId(rhMax.get(0).getId());
                rhMaxData.setValue(maxRh);
                rhMaxData.setTime(startTime);
                rhMaxData.setEquipmentId(equipmentId);
                WindTowerCalculationData rhMinData = new WindTowerCalculationData();
                rhMinData.setEbId(rhMin.get(0).getId());
                rhMinData.setValue(minRh);
                rhMinData.setTime(startTime);
                rhMinData.setEquipmentId(equipmentId);
                WindTowerCalculationData rhAveData = new WindTowerCalculationData();
                rhAveData.setEbId(rhAve.get(0).getId());
                rhAveData.setValue(aveRh);
                rhAveData.setTime(startTime);
                rhAveData.setEquipmentId(equipmentId);
                WindTowerCalculationData tMaxData = new WindTowerCalculationData();
                tMaxData.setEbId(tMax.get(0).getId());
                tMaxData.setValue(maxT);
                tMaxData.setTime(startTime);
                tMaxData.setEquipmentId(equipmentId);
                WindTowerCalculationData tMinData = new WindTowerCalculationData();
                tMinData.setEbId(tMin.get(0).getId());
                tMinData.setValue(minT);
                tMinData.setTime(startTime);
                tMinData.setEquipmentId(equipmentId);
                WindTowerCalculationData tAveData = new WindTowerCalculationData();
                tAveData.setEbId(tAve.get(0).getId());
                tAveData.setValue(aveT);
                tAveData.setTime(startTime);
                tAveData.setEquipmentId(equipmentId);

                windTowerCalculationDataList.add(paAveData);
                windTowerCalculationDataList.add(paMaxData);
                windTowerCalculationDataList.add(paMinData);
                windTowerCalculationDataList.add(rhAveData);
                windTowerCalculationDataList.add(rhMaxData);
                windTowerCalculationDataList.add(rhMinData);
                windTowerCalculationDataList.add(tAveData);
                windTowerCalculationDataList.add(tMaxData);
                windTowerCalculationDataList.add(tMinData);
//                saveBatchByEquipmentId(windTowerCalculationDataList, equipmentId);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return windTowerCalculationDataList;
    }

    /**
     * 湍流月逐时
     *
     * @param equipmentId            设备Id
     * @param startTime              开始时间
     * @param endTime                结束时间
     * @param equipmentAttributeList 属性集合
     * @param windTowerInfoList      测风塔信息
     * @return
     */
    public ArrayList<WindTowerCalculationData> turbulenceHourForMonth(String equipmentId, Date startTime, Date endTime, List<ProphaseAnemometryData> prophaseAnemometryDataList, List<EquipmentAttribute> equipmentAttributeList, List<WindTowerInfo> windTowerInfoList) {
        String height = windTowerInfoList.stream().filter(w -> w.getEquipmentNo().equals(equipmentId)).collect(Collectors.toList()).get(0).getHeights();
        String[] heights = height.split(",");
        long hour = 3600000L;
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        try {
            //遍历层高
            for (String h : heights) {
                //获取湍流年逐时ebId
                String ebId = equipmentAttributeList.stream().filter(w -> w.getFieldName().equals(h + "turDayForMonth")).collect(Collectors.toList()).get(0).getId();
                removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, endTime, equipmentId, ebId);
                HashMap<Integer, BigDecimal> timeAndTurMap = new HashMap<>();
                HashMap<Integer, BigDecimal> totalAndTurMap = new HashMap<>();

                //循环开始时间到时间一小时为间隔
                for (long time = startTime.getTime(); time <= endTime.getTime(); time = time + hour) {

                    long startHour = time;
                    long endHour = time + hour;
                    //筛选小时数据
//                    List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
                    List<ProphaseAnemometryData> anemometryDataList = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= startHour && p.getTs().getTime() <= endHour && p.getLayerHeight().equals(h)).collect(Collectors.toList());


                    if (anemometryDataList.size() > 0) {
                        BigDecimal turAve = BigDecimal.ZERO;
                        //循环实时数据计算总风速和标差
                        BigDecimal wsSun = CalculationUtil.getBigDecimal(anemometryDataList.stream().filter(a -> a.getWsAve() != null).mapToDouble(ProphaseAnemometryData::getWsAve).sum());
                        BigDecimal staSun = CalculationUtil.getBigDecimal(anemometryDataList.stream().filter(a -> a.getWsSta() != null).mapToDouble(ProphaseAnemometryData::getWsSta).sum());
                        //除以一小时的个数 求小时的平均值
                        BigDecimal wsAve = wsSun.divide(BigDecimal.valueOf(anemometryDataList.size()), 2, RoundingMode.HALF_UP);
                        BigDecimal staAve = staSun.divide(BigDecimal.valueOf(anemometryDataList.size()), 2, RoundingMode.HALF_UP);
                        //如果除数等于0就跳过本次循环
                        if (wsAve.compareTo(BigDecimal.ZERO) == 0 || staAve.compareTo(BigDecimal.ZERO) == 0) {
                            continue;
                        }
                        turAve = staAve.divide(wsAve, 2, RoundingMode.HALF_UP);
                        //判断map中是否存在此小时的key 如果存在就把数值相加 个数加一
                        if (timeAndTurMap.get(new Date(startHour).getHours()) != null) {

                            BigDecimal Average = timeAndTurMap.get(new Date(startHour).getHours()).add(turAve);
                            BigDecimal total = totalAndTurMap.get(new Date(startHour).getHours()).add(BigDecimal.ONE);

                            timeAndTurMap.put(new Date(startHour).getHours(), Average);
                            totalAndTurMap.put(new Date(startHour).getHours(), total);
                        } else {
                            //如果map中不存在这个key则直接把平均值加入 个数加一
                            timeAndTurMap.put(new Date(startHour).getHours(), turAve);
                            totalAndTurMap.put(new Date(startHour).getHours(), BigDecimal.ONE);
                        }
                    }

                }
                if (!timeAndTurMap.entrySet().isEmpty()) {
                    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyMMdd");
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHH");
                    //设置数据时间为开始时间
                    String start = sdf1.format(new Date(startTime.getTime()));
                    for (Map.Entry<Integer, BigDecimal> a : timeAndTurMap.entrySet()) {
                        Date timeMonth = sdf.parse(start + String.valueOf(a.getKey()));
                        BigDecimal airAve = a.getValue().divide(totalAndTurMap.get(a.getKey()), 2, RoundingMode.HALF_UP);
                        WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                        windTowerCalculationData.setEbId(ebId);
                        windTowerCalculationData.setTime(timeMonth);
                        windTowerCalculationData.setEquipmentId(equipmentId);
                        windTowerCalculationData.setValue(airAve);
                        list.add(windTowerCalculationData);
                    }
                }

            }
        } catch (ParseException e) {
            log.error("设备编号{}，湍流年逐时计算错误", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}，湍流年逐时，计算完成", equipmentId);
        return list;
    }


    /**
     * 空气密度月逐时入库
     *
     * @param equipmentId 设备id
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @return
     */
    public ArrayList<WindTowerCalculationData> airDensityMonth(String equipmentId, Date startTime, Date endTime, List<ProphaseWeatherData> prophaseWeatherDataList) {
        //获取ebId
        String ebId = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, "airDensityDayForYear").list().get(0).getId();
        removeByStartTimeBetweenAndEquipmentIdAndEbId(startTime, new Date(endTime.getTime() + 86400000L), equipmentId, ebId);
        ArrayList<WindTowerCalculationData> list = new ArrayList<>();
        long hour = 3600000L;
        try {
            HashMap<Integer, BigDecimal> timeAndAirMap = new HashMap<>();
            HashMap<Integer, BigDecimal> totalAndAirMap = new HashMap<>();

            for (long time = startTime.getTime(); time <= endTime.getTime(); time = time + hour) {
                BigDecimal airSun = BigDecimal.ZERO;
                long startHour = time;
                long endHour = time + hour;
//                List<Map<String, Object>> collect = mapList.stream().filter(w -> Long.parseLong(w.get("time").toString()) >= startHour && Long.parseLong(w.get("time").toString()) <= endHour && w.get("equipment_id").equals(equipmentId)).collect(Collectors.toList());
                List<ProphaseWeatherData> weatherDataList = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= startHour && p.getTs().getTime() <= endHour).collect(Collectors.toList());
                for (ProphaseWeatherData map : weatherDataList) {
                    //过滤异常数据

                    airSun = airSun.add(CalculationUtil.getBigDecimal(map.getAirDensity()));

                }
                if (weatherDataList.size() > 0) {
                    BigDecimal airAve = airSun.divide(BigDecimal.valueOf(weatherDataList.size()), 2, RoundingMode.HALF_UP);
                    //判断map的key是否包含此小时  不包含直接加入value中 包含则相加
                    if (timeAndAirMap.get(new Date(startHour).getHours()) != null) {

                        BigDecimal Average = timeAndAirMap.get(new Date(startHour).getHours()).add(airAve);
                        BigDecimal total = totalAndAirMap.get(new Date(startHour).getHours()).add(BigDecimal.ONE);

                        timeAndAirMap.put(new Date(startHour).getHours(), Average);
                        totalAndAirMap.put(new Date(startHour).getHours(), total);
                    } else {
                        //如果map中不存在这个key则直接把平均值加入个数加一
                        timeAndAirMap.put(new Date(startHour).getHours(), airAve);
                        totalAndAirMap.put(new Date(startHour).getHours(), BigDecimal.ONE);
                    }
                }
            }
            if (!timeAndAirMap.entrySet().isEmpty()) {
                SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyMMdd");
                SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHH");
                //设置数据时间为开始时间
                String start = sdf1.format(new Date(startTime.getTime()));
                for (Map.Entry<Integer, BigDecimal> a : timeAndAirMap.entrySet()) {
                    //拼接时间
                    Date time = sdf.parse(start + String.valueOf(a.getKey()));
                    BigDecimal airAve = a.getValue().divide(totalAndAirMap.get(a.getKey()), 2, RoundingMode.HALF_UP);
                    WindTowerCalculationData windTowerCalculationData = new WindTowerCalculationData();
                    windTowerCalculationData.setEbId(ebId);
                    windTowerCalculationData.setTime(time);
                    windTowerCalculationData.setEquipmentId(equipmentId);
                    windTowerCalculationData.setValue(airAve);
                    list.add(windTowerCalculationData);
                }
            }

        } catch (Exception e) {
            log.error("设备编号{}，空气密度月逐时计算错误", equipmentId);
            e.printStackTrace();
        }
//        saveBatchByEquipmentId(list, equipmentId);
        log.info("设备编号{}，空气密度月逐时，计算完成", equipmentId);
        return list;

    }

    /**
     * 根据时间范围 设备id 属性id删除
     *
     * @param equipmentId 设备id
     * @param ebId        属性id
     * @return List<WindTowerCalculationData>
     */
    public List<WindTowerCalculationData> findByEquipmentIdAndEbId(String equipmentId, String ebId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        QueryWrapper<WindTowerCalculationData> wrapper = new QueryWrapper();
        if (equipmentId != null && !equipmentId.equals("")) {
            wrapper.eq("equipment_id", equipmentId);
        }
        if (ebId != null && !ebId.equals("")) {
            wrapper.eq("eb_id", ebId);
        }
        return baseMapper.selectList(wrapper);
    }

    /**
     * 根据时间范围和设备id查询数据
     *
     * @param equipmentId 设备属性id
     * @return List<WindTowerCalculationData>
     */
    public List<WindTowerCalculationData> getByBetweenTimeAndEquipmentId(Date startTime, Date endTime, String equipmentId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        QueryWrapper<WindTowerCalculationData> wrapper = new QueryWrapper();
        if (startTime != null && endTime != null) {
            wrapper.between("time", startTime, endTime);
        }
        if (equipmentId != null && !equipmentId.equals("")) {
            wrapper.eq("equipment_id", equipmentId);
        }
        return baseMapper.selectList(wrapper);
    }

    public void saveByEquipmentId(WindTowerCalculationData windTowerCalculationData, String equipmentId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        this.save(windTowerCalculationData);
    }

    public void saveBatchByEquipmentId(List<WindTowerCalculationData> windTowerCalculationDataList, String equipmentId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        this.saveBatch(windTowerCalculationDataList);
    }

    /**
     * 根据时间范围 设备id 属性id删除
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @param ebId        属性id
     */
    public void removeByStartTimeBetweenAndEquipmentIdAndEbId(Date startTime, Date endTime, String equipmentId, String ebId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        QueryWrapper<WindTowerCalculationData> wrapper = new QueryWrapper();
        if (startTime != null && endTime != null) {
            wrapper.between("time", startTime, endTime);
        }
        if (equipmentId != null && !equipmentId.equals("")) {
            wrapper.eq("equipment_id", equipmentId);
        }
        if (ebId != null && !ebId.equals("")) {
            wrapper.eq("eb_id", ebId);
        }
        remove(wrapper);
    }


    /**
     * 根据时间范围 设备id 属性id查询
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备id
     * @param ebId        属性id
     * @return List<WindTowerCalculationData>
     */
    public List<WindTowerCalculationData> getByStartTimeBetweenAndEquipmentIdAndEbId(Date startTime, Date endTime, String equipmentId, String ebId) {
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        QueryWrapper<WindTowerCalculationData> wrapper = new QueryWrapper();
        if (startTime != null && endTime != null) {
            wrapper.between("time", startTime, endTime);
        }
        if (equipmentId != null && !equipmentId.equals("")) {
            wrapper.eq("equipment_id", equipmentId);
        }
        if (ebId != null && !ebId.equals("")) {
            wrapper.eq("eb_id", ebId);
        }

        return baseMapper.selectList(wrapper);
    }

    /**
     * 从 String 中提取数字
     *
     * @param string
     * @return
     */
    public static String getNumberFromString(String string) {
        String str = string;
        str = str.trim();
        StringBuffer str2 = new StringBuffer();
        if (str != null && !"".equals(str)) {
            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
                    String s = String.valueOf(str.charAt(i));
                    str2.append(s);
                }
            }
        }
        return str2.toString();
    }

    /**
     * 根据设备编号获取该设备的最后一条统计数据
     *
     * @param equipmentId 设备编号
     * @return WindTowerCalculationData
     */
    public WindTowerCalculationData getLastDataCalculation(String equipmentId) {

        return baseMapper.getLastData(equipmentId);
    }

}