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 cn.hutool.core.date.DateTime;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jiayue.biz.conf.RequestDataHelper;
import com.jiayue.biz.domain.EquipmentAttribute;
import com.jiayue.biz.domain.ProphaseAnemometryData;
import com.jiayue.biz.domain.WindTowerCalculationData;
import com.jiayue.biz.domain.WindTowerInfo;
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 java.math.BigDecimal;
import java.math.RoundingMode;
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;


    /**
     * 威布尔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);
    }


    /**
     * 根据 时间，层高，设备id 查询风切变数据
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param height    层高
     * @param eqId      设备id
     * @return map: 一天一条
     */
    @Override
    public List<Map<String, Object>> getWindShearByEqidAndAverageAndTime(Long startTime, Long endTime, 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 = "windShearDay";
        List<EquipmentAttribute> shearFieldNameList = equipmentAttributeService.lambdaQuery().eq(EquipmentAttribute::getFieldName, shearFieldName).list();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if (!shearFieldNameList.isEmpty()) {
            String ebId = shearFieldNameList.get(0).getId(); //属性id
            //查询风切变 月平均数据 根据时间，层高，设备id 并根据时间升序排列
            List<WindTowerCalculationData> windTowerCalculationDataLists = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);
            List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataLists.stream().filter(w -> null != w.getValue() && w.getValue().doubleValue() >= 0 && ebId.equals(w.getEbId())).sorted(Comparator.comparing(WindTowerCalculationData::getTime)).collect(Collectors.toList());
            BigDecimal sum = BigDecimal.ZERO;
            BigDecimal avgShear = BigDecimal.ZERO;
            if (!windTowerCalculationDataList.isEmpty()) {

                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);
        }
        return list;
    }


    /**
     * 空气密度曲线图
     *
     * @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（昨天）
            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));
                //获取所有空气密度数据
                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();

        DateTime startTimeYear = DateUtil.beginOfYear(new Date(startTime));
        DateTime endTimeYear = DateUtil.endOfYear(new Date(endTime));
        List<WindTowerCalculationData> byBetweenTimeAndEquipmentId = getByStartTimeBetweenAndEquipmentIdAndEbId(startTimeYear, endTimeYear, eqId, densityTypeList.get(0).getId());
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");
        ArrayList<Object> PDataList = new ArrayList<>();
        for (long i = startTimeYear.getTime(); i <= endTimeYear.getTime(); i = DateUtil.offsetMonth(new Date(i), 12).getTime()) {
            //开始时间
            Date startTimeOfCurrentMonth = DateUtil.beginOfYear(new Date(i));
            //结束时间
            Date endTimeOfCurrentMonth = DateUtil.offsetMonth(new Date(i), 12);
            List<WindTowerCalculationData> densityDataList = byBetweenTimeAndEquipmentId.stream().filter(w -> w.getTime().getTime() >= startTimeOfCurrentMonth.getTime() && w.getTime().getTime() <= endTimeOfCurrentMonth.getTime() &&
                    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(simpleDateFormat.format(new Date(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<>();


        List<WindTowerInfo> windTowerInfos = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, eqId).list();
        if (height == null || height.equals("")) {
            height = windTowerInfos.get(0).getHeights();
        }

        //获取查询的年份
        DateTime startTimeYear = DateUtil.beginOfYear(new Date(startTime));
        DateTime endTimeYear = DateUtil.endOfYear(new Date(endTime));


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

        List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.lambdaQuery().likeLeft(EquipmentAttribute::getFieldName, "awsMonth").or().likeLeft(EquipmentAttribute::getFieldName, "awsMonth").list();
        List<EquipmentAttribute> equipmentAttributeList1 = equipmentAttributeService.lambdaQuery().likeLeft(EquipmentAttribute::getFieldName, "wpdMonth").or().likeLeft(EquipmentAttribute::getFieldName, "awsMonth").list();
        equipmentAttributeList.addAll(equipmentAttributeList1);
//        List<WindTowerCalculationData> windTowerCalculationDataList = getByBetweenTimeAndEquipmentId(new Date(startTime), new Date(endTime), eqId);
        List<WindTowerCalculationData> windTowerCalculationDataList = this.getByBetweenTimeAndEquipmentIdAndEbId(new Date(startTime), new Date(endTime), eqId, equipmentAttributeList);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");
        //遍历层高
        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
            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 (long l = startTimeYear.getTime(); l <= endTimeYear.getTime(); l = DateUtil.offsetMonth(new Date(l), 12).getTime()) {

                //开始时间
                Date startTimeOfCurrentMonth = DateUtil.beginOfYear(new Date(l));
                //结束时间
                Date endTimeOfCurrentMonth = DateUtil.offsetMonth(new Date(l), 12);


                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(simpleDateFormat.format(new Date(l)), wsYearData.divide(BigDecimal.valueOf(allDataWsList.size()), 2, RoundingMode.HALF_UP));
                    }

                    //给时间和年平均数值添加标识
                    for (Map.Entry<Object, Object> ws1 : wsMap.entrySet()) {
                        HashMap<String, 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(simpleDateFormat.format(new Date(l)), 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<>();
        //装所有风速数据
        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<>();
        //装所有风功率密度数据
        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();
        }
        String[] heightAll = height.split(",");
        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<>();
        //给前端用的日期格式
        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;

    }


    /**
     * 查询当前月的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")));
                    windTowerStatusDataResult.put("160-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave160")));
                    windTowerStatusDataResult.put("160A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave160A")));
                }
            }
        }
        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("Ave160")) {
            windTowerStatusDataResult.put("160-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave160")));
        }
        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")));
        }
        if (!abnormalType.contains("Ave160A")) {
            windTowerStatusDataResult.put("160A-" + keyEndStr, CalculationUtil.getBigDecimal(map.get("ws_ave160A")));
        }
    }

    /**
     * 以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);
        }
    }


    /**
     * 根据时间范围 设备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);
    }

    //根据ebId集合、时间、设备编号查询
    public List<WindTowerCalculationData> getByBetweenTimeAndEquipmentIdAndEbId(Date startTime, Date endTime, String equipmentId, List<EquipmentAttribute> equipmentAttributeList) {
        LambdaQueryWrapper<WindTowerCalculationData> wrapper = Wrappers.lambdaQuery();
        Map<String, Object> map = new HashMap<>();
        map.put("equipment_id", equipmentId);
        RequestDataHelper.setRequestData(map);
        wrapper.eq(WindTowerCalculationData::getEquipmentId, equipmentId);
        wrapper.between(WindTowerCalculationData::getTime, startTime, endTime);
        for (EquipmentAttribute equipmentAttribute : equipmentAttributeList) {
            wrapper.eq(WindTowerCalculationData::getEbId, equipmentAttribute.getId()).or();

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

}