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

package com.jiayue.biz.service.impl;

import cn.hutool.db.Entity;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jiayue.biz.domain.*;
import com.jiayue.biz.eunms.WindDirectionEnum;
import com.jiayue.biz.mapper.ProphaseAnemometryDataMapper;
import com.jiayue.biz.mapper.ProphaseWeatherDataMapper;
import com.jiayue.biz.mapper.WindTowerDataParentTableMapper;
import com.jiayue.biz.service.*;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Array;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Service
@AllArgsConstructor
public class RealTimeDisplayServiceImpl implements RealTimeDisplayService {


    private WindTowerDataParentTableService windTowerDataParentTableService;
    private WindTowerDataParentTableMapper windTowerDataParentTableMapper;
    private WindTowerInfoService windTowerInfoService;
    private StatisticsSituationService statisticsSituationService;

    private ProphaseAnemometryDataMapper prophaseAnemometryDataMapper;

    private ProphaseWeatherDataMapper prophaseWeatherDataMapper;

    private final double e = 2.71828183;


    /**
     * 实时查询 (湍流)
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备编号
     * @param height      层高
     * @return List<Map < String, Object>>  湍流集合
     */
    public List<Map<String, Object>> turbulence(Long startTime, Long endTime, String equipmentId, String height) {
        //查询所有数据
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectAveAndSta(equipmentId, new Timestamp(startTime), new Timestamp(endTime));
        ArrayList densityList = new ArrayList<>();
        ArrayList<HashMap<String, Object>> densityList2 = new ArrayList<>();
        ArrayList<HashMap<String, Object>> densityList3 = new ArrayList<>();
        //用于遍历数据
        TreeMap<String, Object> map = new TreeMap<>();
        if (height == null || height.equals("")) {
            //获取测风塔数据获取层高
            String wsHeights = windTowerInfoService.getWsHeights(equipmentId);
            height = wsHeights;
        }
        String[] split = height.split(",");
        for (String h : split) {
            //根据层高获取对应数据
            List<ProphaseAnemometryData> dataList = prophaseAnemometryDataList.stream().filter(p -> p.getLayerHeight().equals(h)).collect(Collectors.toList());
            BigDecimal content;
            //根据风速段进行分组
            Map<BigDecimal, List<BigDecimal>> speedLevel_turbulenceMap = new HashMap<>();
            BigDecimal speedLevel;
            for (ProphaseAnemometryData p : dataList) {

                BigDecimal ave = p.getWsAve() != null ? BigDecimal.valueOf(p.getWsAve()) : BigDecimal.ZERO;
                BigDecimal sta = p.getWsSta() != null ? BigDecimal.valueOf(p.getWsSta()) : BigDecimal.ZERO;
                if (ave.compareTo(BigDecimal.ZERO) != 0 && sta.compareTo(BigDecimal.ZERO) != 0) {
                    //湍流
                    content = sta.divide(ave, 2, RoundingMode.HALF_UP);
                    //风速段 按着风速的正负0.5取值
                    speedLevel = ave.setScale(0, RoundingMode.HALF_UP);
                    if (speedLevel_turbulenceMap.containsKey((speedLevel))) {
                        speedLevel_turbulenceMap.get(speedLevel).add(content);
                    } else {

                        speedLevel_turbulenceMap.put(speedLevel, new ArrayList<>());
                        speedLevel_turbulenceMap.get(speedLevel).add(content);
                    }
                    speedLevel_turbulenceMap.remove(BigDecimal.valueOf(0));
                }
            }
            /*
             * 风速段-----湍流平均值
             */
            TreeMap<Object, Object> treeMap = new TreeMap();
            Map<BigDecimal, BigDecimal> speedLevel_turbulenceAvgMap = new HashMap<>();
            BigDecimal avgContent;
            for (Map.Entry<BigDecimal, List<BigDecimal>> e : speedLevel_turbulenceMap.entrySet()) {
                avgContent = BigDecimal.ZERO;
                if (e.getValue().size() != 0) {
                    for (BigDecimal a : e.getValue()) {
                        avgContent = avgContent.add(a);
                    }
                    avgContent = avgContent.divide((BigDecimal.valueOf(e.getValue().size())), 2, RoundingMode.HALF_UP);

                }
                speedLevel_turbulenceAvgMap.put(e.getKey().setScale(0, BigDecimal.ROUND_UP), avgContent);
            }

            treeMap.putAll(speedLevel_turbulenceAvgMap);

            ArrayList<Object> densityList1 = new ArrayList<>();
            densityList2 = new ArrayList<>();
            BigDecimal TurCount = BigDecimal.ZERO;
            BigDecimal TurSum = BigDecimal.ZERO;
            BigDecimal TurAve = BigDecimal.ZERO;
            int i1 = treeMap.entrySet().size();
            TurCount = TurCount.add(BigDecimal.valueOf(i1));


            //拼接返回给前台
            for (Map.Entry<Object, Object> o1 : treeMap.entrySet()) {
                Map<String, Object> map2 = new HashMap();

                map2.put("ws", o1.getKey());
                map2.put("tur", o1.getValue());
                densityList1.add(map2);
                if (o1.getValue() != null) {
                    TurSum = TurSum.add(BigDecimal.valueOf(Double.parseDouble(o1.getValue().toString())));
                }
            }
            //如果不等于0
            if (!TurCount.equals(BigDecimal.ZERO)) {
                TurAve = TurSum.divide(TurCount, 2, RoundingMode.HALF_UP);
            }
            //放入风速和湍流值
            map.put(h, densityList1);
            HashMap<String, BigDecimal> TurAveMap = new HashMap<>();
            TurAveMap.put(h, TurAve);

            for (Map.Entry<String, BigDecimal> s1 : TurAveMap.entrySet()) {
                HashMap<String, Object> map1 = new HashMap<>();
                map1.put("height", s1.getKey());
                map1.put("TurAve", s1.getValue());
                densityList3.add(map1);

            }
        }
        for (Map.Entry<String, Object> m1 : map.entrySet()) {
            HashMap<String, Object> map1 = new HashMap<>();
            map1.put("height", m1.getKey());
            map1.put("arr", m1.getValue());
            densityList2.add(map1);
        }
        densityList.add(densityList2);

        densityList.add(densityList3);

        return densityList;

    }


    /**
     * 实时查询 (风速/风向折线图)
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备Id
     * @param height      层高
     * @return Map
     */
    public Map<String, Object> selectWsAndWd(Long startTime, Long endTime, String equipmentId, String height) {
        //注释跟下边的一样 这个只是风速的
        HashMap<String, Object> map = new HashMap<>();
        ArrayList<Object> finalWsList = new ArrayList<>();
        ArrayList<Object> finalWdList = new ArrayList<>();
        ArrayList<Object> wsChartsData = new ArrayList<>();
        ArrayList<Object> wdChartsData = new ArrayList<>();
        ArrayList<Object> wsAveList = new ArrayList<>();
        ArrayList<Object> wdAveList = new ArrayList<>();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 日期集合
        ArrayList<String> timeList = new ArrayList<>();
        for (long i = startTime; i < endTime; i = i + 1000 * 60 * 10L) {
            timeList.add(sdf.format(new Date(i)));
        }
        // 测风塔数据集合
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectAve(equipmentId, new Timestamp(startTime), new Timestamp(endTime));
        List<WindTowerInfo> windTowerInfoList = windTowerInfoService.lambdaQuery().eq(WindTowerInfo::getEquipmentNo, equipmentId).list();
        String[] wdHeight = windTowerInfoList.get(0).getWdHeights().split(",");
        if (height == null || height.equals("")) {
            height = windTowerInfoService.getWsHeights(equipmentId);
        }
        //拆分层高
        String[] split = height.split(",");

        for (String h : split) {
            List<ProphaseAnemometryData> dataList = prophaseAnemometryDataList.stream().filter(p -> p.getLayerHeight().equals(h)).collect(Collectors.toList());
            ArrayList<Object> wslist = new ArrayList<>(); // 风速时间集合
            ArrayList<Object> wdlist = new ArrayList<>(); // 风速时间集合
            BigDecimal wsSum = new BigDecimal(0); // 风速总和
            BigDecimal wsAve = BigDecimal.ZERO; // 平均风速
            BigDecimal wdSum = new BigDecimal(0); // 风向总和
            BigDecimal wdAve = BigDecimal.ZERO; // 平均风向
            boolean flag = false;//判断风向层高中是否包含此层高
            if (Arrays.asList(wdHeight).contains(h)) {
                flag = true;
            }

            for (ProphaseAnemometryData p : dataList) {
                HashMap<Object, Object> wsMap = new HashMap<>();
                String sDate = sdf.format(p.getTs());
                String wsStr = p.getWsAve() == null ? "0" : p.getWsAve().toString();
                // 时间-风速 / 时间-风向
                wsMap.put("time", sDate);
                wsMap.put("ws", wsStr);
                wslist.add(wsMap);
                // 平均值
                wsSum = wsSum.add(CalculationUtil.getBigDecimal(wsStr));
                // 判断风向层高中是否包含此层高
                if (flag) {
                    HashMap<Object, Object> wdmap = new HashMap<>();
                    String wdStr = p.getWdAve() == null ? "0" : p.getWdAve().toString();
                    wdmap.put("time", sDate);
                    wdmap.put("wd", wdStr);
                    wdSum = wdSum.add(CalculationUtil.getBigDecimal(wdStr));
                    wdlist.add(wdmap);
                }

            }

            if (!dataList.isEmpty()) {
                wsAve = wsSum.divide(BigDecimal.valueOf(dataList.size()), 2, RoundingMode.HALF_UP);
                wdAve = wdSum.divide(BigDecimal.valueOf(dataList.size()), 2, RoundingMode.HALF_UP);
            }
            // 曲线Map
            HashMap<Object, Object> finalWsMap = new HashMap<>();
            finalWsMap.put("height", h);
            finalWsMap.put("arr", wslist);
            wsChartsData.add(finalWsMap);

            // 平均值Map
            HashMap<Object, Object> aveWsMap = new HashMap<>();
            aveWsMap.put("height", h);
            aveWsMap.put("wsave", wsAve);
            wsAveList.add(aveWsMap);
            // 若此层高有风向
            if (!wdlist.isEmpty()) {
                HashMap<Object, Object> finalWdMap = new HashMap<>();
                finalWdMap.put("height", h);
                finalWdMap.put("arr", wdlist);
                wdChartsData.add(finalWdMap);
                HashMap<Object, Object> aveWdMap = new HashMap<>();
                aveWdMap.put("height", h);
                aveWdMap.put("wdave", wdAve);
                wdAveList.add(aveWdMap);
            }

        }
        finalWdList.add(wdChartsData);
        finalWdList.add(wdAveList);
        finalWsList.add(wsChartsData);
        finalWsList.add(wsAveList);
        map.put("ws", finalWsList);
        map.put("wd", finalWdList);
        map.put("time", timeList);
        return map;
    }


    /**
     * 实时查询 (威布尔)
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 测风塔id
     * @param height      层高
     * @return 威布尔
     */
    public List<Object> weibull(Long startTime, Long endTime, String equipmentId, String height) {
        //查询实时数据
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectWsAve(equipmentId, new Timestamp(startTime), new Timestamp(endTime));
        List<ProphaseAnemometryData> dataList = prophaseAnemometryDataList.stream().filter(p -> p.getLayerHeight().equals(height)).collect(Collectors.toList());


        ArrayList<Object> densityList1 = new ArrayList<>();
        ArrayList<Object> densityList = new ArrayList<>();
        //key：风速区间 val：风速
        Map<BigDecimal, List<BigDecimal>> wsMap = new HashMap<>();
        //A K 平均风速map
        HashMap<String, Double> map2 = new HashMap<>();
        //风速频率map
        TreeMap<BigDecimal, Object> map1 = new TreeMap<>();
        // 风速频率集合
        ArrayList<Object> wsFreList = new ArrayList<>();
        //平均风速
        BigDecimal avgWs = BigDecimal.ZERO;
        //过滤风速集合
        List<Float> floatList = dataList.stream().map(ProphaseAnemometryData::getWsAve).collect(Collectors.toList());
        //求风速总值
        double sum = floatList.stream().mapToDouble(p -> p).sum();
        double[] doubles = floatList.stream().mapToDouble(p -> p).toArray();
        if (!floatList.isEmpty()) {
            //平均风速
            avgWs = BigDecimal.valueOf(sum).divide(BigDecimal.valueOf(floatList.size()), 4, RoundingMode.HALF_UP);
        }
        //威布尔Map
        TreeMap<BigDecimal, Object> weibullMap = new TreeMap<>();
        if (doubles.length > 0) {
            //把风速集合传入，计算A、K
            ProbabilityPlot probabilityPlot = new ProbabilityPlot(doubles);
            probabilityPlot.suppressDisplay();
            double K = probabilityPlot.weibullTwoParGamma();
            double A = probabilityPlot.weibullTwoParSigma();
            //放入AK 平均风速返回给前台
            map2.put("K", K);
            map2.put("A", A);
            map2.put("avgWs", avgWs.doubleValue());

            for (double ws : doubles) {
                //四舍五入取风速段
                BigDecimal speedLevel = BigDecimal.valueOf(Math.ceil(BigDecimal.valueOf(ws).subtract(BigDecimal.valueOf(0.5)).doubleValue()));
                //判断map中是否包含风速段的key 不包含创建list放入风速
                if (wsMap.containsKey((speedLevel))) {
                    wsMap.get(speedLevel).add(BigDecimal.valueOf(ws));
                } else {
                    wsMap.put(speedLevel, new ArrayList<>());
                    wsMap.get(speedLevel).add(BigDecimal.valueOf(ws));
                }
                //获得威布尔集合的size，用作风速频率
                map1.put(speedLevel.setScale(0), wsMap.get(speedLevel).size());

            }
            //循环风速map获取风速区间的平均风速用于计算weibull
            for (Map.Entry<BigDecimal, List<BigDecimal>> entry : wsMap.entrySet()) {
                //求出风速区间的平均风速
                BigDecimal wsAve = entry.getValue().stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(entry.getValue().size()), 2, RoundingMode.HALF_UP);
                //计算威布尔值
                BigDecimal weibull = CalculationUtil.getBigDecimal(e, wsAve.doubleValue(), K, A);
                weibullMap.put(entry.getKey(), weibull);

            }

            //循环风速区间 风速频率
            map1.forEach((key, val) -> {
                Map<String, Object> map = new HashMap<String, Object>();
                //风速区间
                map.put("ws", key);
                /*风速频率*/
                map.put("cont", new BigDecimal(val.toString()).divide(new BigDecimal(doubles.length), 4, RoundingMode.HALF_UP).multiply(new BigDecimal(100)));
                wsFreList.add(map);
            });
            weibullMap.forEach((key, val) -> {
                HashMap<String, Object> map = new HashMap<String, Object>();
                map.put("ws", key);
                map.put("Weibull", val);
                densityList1.add(map);
            });

            densityList.add(densityList1);
            densityList.add(wsFreList);
            densityList.add(map2);
        }

        return densityList;
    }


    /**
     * 获取测风塔数据最后一条数据时间到前一周数据 时间段内所有时间点
     *
     * @return 时间点集合
     */
    public List<Map<String, Object>> getStartTimeAndEndTime() {
        List<Map<String, Object>> list = new ArrayList<>();
        List<WindTowerInfo> windTowerInfoList = windTowerInfoService.list();
        for (WindTowerInfo windTowerInfo : windTowerInfoList) {
            HashMap<String, Object> hashMap = new HashMap<>();
            //获取最后一条数据
            List<Entity> lastData = prophaseWeatherDataMapper.getLastData(windTowerInfo.getEquipmentNo());
            if(lastData.size() > 0){
                Timestamp timeEnd = (Timestamp) lastData.get(0).get("last (ts)");
                long lastDataTime = timeEnd.getTime();
                long startTime = DateTimeUtil.getDayStartTime(lastDataTime - 86400000 * 7).getTime();
                long endTime = DateTimeUtil.getDayLastTime(lastDataTime).getTime();
                hashMap.put("equipmentId", windTowerInfo.getEquipmentNo());
                hashMap.put("startTime", startTime);
                hashMap.put("endTime", endTime);
                list.add(hashMap);
            }

        }
        return list;
    }


    /*根据时间范围和设备id查询温度气压对比图，空气密度数据*/
    public Map<String, Object> queryTPAndAirDensity(Long startTime, Long endTime, String equipmentId) {

        Map<String, Object> map = new HashMap<>();

        List dataList = new ArrayList();
        List tList = new ArrayList();
        List paList = new ArrayList();
        List timeList = new ArrayList();
        //所有数据
        List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectTAveAndPaAveAndAir(equipmentId, new Timestamp(startTime), new Timestamp(endTime));
        if (prophaseWeatherDataList.size() > 0) {

            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            for (long i = startTime; i < endTime; i = i + 1000 * 60 * 10L) {
                timeList.add(formatter.format(new Date(i)));
            }
            /*平均数据*/
            BigDecimal avgT = new BigDecimal(0);
            BigDecimal avgPa = new BigDecimal(0);
            BigDecimal avgAirDensity = new BigDecimal(0);
            BigDecimal sumT = new BigDecimal(0);
            BigDecimal sumPa = new BigDecimal(0);
            BigDecimal sumAirDensity = new BigDecimal(0);


            for (ProphaseWeatherData p : prophaseWeatherDataList) {
                /*温度曲线*/
                Map<String, Object> tMap = new HashMap<>();
                /*压强曲线*/
                Map<String, Object> paMap = new HashMap<>();
                tMap.put("time", formatter.format(p.getTs()));
                tMap.put("t", p.getTAve());
                paMap.put("time", formatter.format(p.getTs()));
                paMap.put("pa", p.getPaAve());
                tList.add(tMap);
                paList.add(paMap);


                // 判断数据是否为空 ,空计算为0
                sumT = sumT.add(p.getTAve() == null ? new BigDecimal(0) : BigDecimal.valueOf(p.getTAve()));
                sumPa = sumPa.add(p.getPaAve() == null ? new BigDecimal(0) : BigDecimal.valueOf(p.getPaAve()));
                sumAirDensity = sumAirDensity.add(p.getAirDensity() == null ? new BigDecimal(0) : BigDecimal.valueOf(p.getAirDensity()));
                /*表格数据*/
                Map<String, Object> dataMap = new HashMap<>();
                dataMap.put("time", formatter.format(p.getTs()));
                dataMap.put("t", BigDecimal.valueOf(p.getTAve()).setScale(2, RoundingMode.HALF_UP));
                dataMap.put("pa", BigDecimal.valueOf(p.getPaAve()).setScale(2, RoundingMode.HALF_UP));
                dataMap.put("airDensity", BigDecimal.valueOf(p.getAirDensity()).setScale(2, RoundingMode.HALF_UP));
                dataList.add(dataMap);
            }
            /*计算平均值*/
            if (sumT.compareTo(BigDecimal.ZERO) != 0) {
                avgT = sumT.divide(new BigDecimal(prophaseWeatherDataList.size()), 3, RoundingMode.HALF_UP);
            }
            if (sumPa.compareTo(BigDecimal.ZERO) != 0) {
                avgPa = sumPa.divide(new BigDecimal(prophaseWeatherDataList.size()), 3, RoundingMode.HALF_UP);
            }
            if (sumAirDensity.compareTo(BigDecimal.ZERO) != 0) {
                avgAirDensity = sumAirDensity.divide(new BigDecimal(prophaseWeatherDataList.size()), 3, RoundingMode.HALF_UP);
            }
            map.put("time", timeList);
            map.put("t", tList);
            map.put("pa", paList);
            map.put("data", dataList);
            map.put("avgT", avgT);
            map.put("avgPa", avgPa);
            map.put("avgAirDensity", avgAirDensity);
        }
        return map;
    }


    /*
     * 时间段风功率密度曲线图 风况
     *
     * @param startTime  开始时间
     * @param endTime  结束时间
     * @param eqId   设备编号
     * @param height  层高
     * @return
     */
    public Map<String, Object> getWindPowerDensityAndAverageWindSpeed(Long startTime, Long endTime, String height, String equipmentId) {
        startTime = DateUtil.beginOfDay(new Date(startTime)).getTime();
        List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectAir(equipmentId, new Timestamp(startTime), new Timestamp(endTime));
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectWsAveForHeight(equipmentId, new Timestamp(startTime), new Timestamp(endTime), height);
        SimpleDateFormat sdf = new SimpleDateFormat("HH");
        SimpleDateFormat sdfHour = new SimpleDateFormat("yyyy-MM-dd HH");
        //曲线图
        LinkedHashMap<String, ArrayList<BigDecimal>> wpdOneHourMap = new LinkedHashMap<>();
        LinkedHashMap<String, ArrayList<BigDecimal>> wsOneHourMap = new LinkedHashMap<>();
        //表格
        LinkedHashMap<String, ArrayList<BigDecimal>> wpdOneHourSdfMap = new LinkedHashMap<>();
        LinkedHashMap<String, ArrayList<BigDecimal>> wsOneHourSdfMap = new LinkedHashMap<>();

        Map<String, Object> map = new LinkedHashMap<>();

        BigDecimal sumWpd = BigDecimal.ZERO;
        BigDecimal sumWs = BigDecimal.ZERO;
        BigDecimal total = BigDecimal.ZERO;
        for (long i = startTime; i < endTime; i = i + 3600000) {

            long finalI = i;
            List<ProphaseWeatherData> prophaseWeatherData = prophaseWeatherDataList.stream().filter(p -> p.getTs().getTime() >= finalI && p.getTs().getTime() < finalI + 3600000 - 1).collect(Collectors.toList());
            List<ProphaseAnemometryData> prophaseAnemometryData = prophaseAnemometryDataList.stream().filter(p -> p.getTs().getTime() >= finalI && p.getTs().getTime() < finalI + 3600000 - 1).collect(Collectors.toList());
            BigDecimal tenMinuteWpdSum = BigDecimal.ZERO;
            BigDecimal tenMinuteWsSum = BigDecimal.ZERO;

            //计算小时风速和风功率密度的总值
            for (ProphaseWeatherData prophaseWeatherDatum : prophaseWeatherData) {
                List<ProphaseAnemometryData> anemometryData = prophaseAnemometryData.stream().filter(p -> p.getTs().getTime() == prophaseWeatherDatum.getTs().getTime()).collect(Collectors.toList());
                if (anemometryData.size() > 0) {
                    tenMinuteWpdSum = tenMinuteWpdSum.add(BigDecimal.valueOf(0.5).multiply(CalculationUtil.power(BigDecimal.valueOf(anemometryData.get(0).getWsAve()), 3)).multiply(BigDecimal.valueOf(prophaseWeatherDatum.getAirDensity())));
                    tenMinuteWsSum = tenMinuteWsSum.add(BigDecimal.valueOf(anemometryData.get(0).getWsAve()));
                }
            }
            BigDecimal oneHourWpd = BigDecimal.ZERO;
            BigDecimal oneHourWs = BigDecimal.ZERO;
            //计算小时平均值
            if (prophaseAnemometryData.size() > 0) {
                oneHourWpd = tenMinuteWpdSum.divide(BigDecimal.valueOf(prophaseAnemometryData.size()), 2, RoundingMode.HALF_UP);
                oneHourWs = tenMinuteWsSum.divide(BigDecimal.valueOf(prophaseAnemometryData.size()), 2, RoundingMode.HALF_UP);
                //计算风功率密度总和
                sumWpd = sumWpd.add(oneHourWpd);
                //计算风速总和
                sumWs = sumWs.add(oneHourWs);
                //计算数据个数
                total = total.add(BigDecimal.ONE);


            }
            //风功率密度曲线图
            this.getMapForData(i, oneHourWpd, sdf, wpdOneHourMap);
            //风速密度曲线图
            this.getMapForData(i, oneHourWs, sdf, wsOneHourMap);
            //风功率密度表格
            this.getMapForData(i, oneHourWpd, sdfHour, wpdOneHourSdfMap);
            //风速表格
            this.getMapForData(i, oneHourWs, sdfHour, wsOneHourSdfMap);

        }

        ArrayList<ArrayList> windPowerDensity = getListEntry(wpdOneHourMap);
        ArrayList<ArrayList> averageWindSpeed = getListEntry(wsOneHourMap);
        ArrayList<HashMap<String, Object>> wpdList = getMapEntry(wpdOneHourSdfMap);
        ArrayList<HashMap<String, Object>> awsList = getMapEntry(wsOneHourSdfMap);
        //风功率平均值
        BigDecimal aveWpd = sumWpd.divide(total, 2, RoundingMode.HALF_UP);
        //风速平均值
        BigDecimal aveWs = sumWs.divide(total, 2, RoundingMode.HALF_UP);
        map.put("awsList", awsList);
        map.put("wpdList", wpdList);
        map.put("WindPowerDensity", windPowerDensity);
        map.put("AverageWindSpeed", averageWindSpeed);
        map.put("avgWs", aveWs);
        map.put("avgWpd", aveWpd);


        return map;

    }

    public void getMapForData(Long time, BigDecimal data, SimpleDateFormat sdf, HashMap<String, ArrayList<BigDecimal>> dataMap) {
        if (dataMap.containsKey(sdf.format(new Date(time)))) {
            //判断是否为0  0为无效数据 防止getListEntry方法除0 问题
            if (data.compareTo(BigDecimal.ZERO) != 0) {
                dataMap.get(sdf.format(new Date(time))).add(data);
            }
        } else {
            dataMap.put(sdf.format(new Date(time)), new ArrayList<>());
            if (data.compareTo(BigDecimal.ZERO) != 0) {
                dataMap.get(sdf.format(new Date(time))).add(data);
            }
        }
    }

    public ArrayList<ArrayList> getListEntry(HashMap<String, ArrayList<BigDecimal>> dataMap) {
        ArrayList<ArrayList> arrayList = new ArrayList<>();
        for (Map.Entry<String, ArrayList<BigDecimal>> entry : dataMap.entrySet()) {
            ArrayList<Object> arrayList1 = new ArrayList<>();
            BigDecimal divide = BigDecimal.ZERO;
            //如果集合为空 value就为0
            if (entry.getValue().size() > 0) {
                divide = entry.getValue().stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(entry.getValue().size()), 2, RoundingMode.HALF_UP);
            }
            arrayList1.add(entry.getKey() + ":00");
            arrayList1.add(divide);
            arrayList.add(arrayList1);
        }

        return arrayList;
    }

    public ArrayList<HashMap<String, Object>> getMapEntry(HashMap<String, ArrayList<BigDecimal>> dataMap) {
        ArrayList<HashMap<String, Object>> mapList = new ArrayList<>();
        for (Map.Entry<String, ArrayList<BigDecimal>> entry : dataMap.entrySet()) {
            HashMap<String, Object> hashMap = new HashMap<>();
            BigDecimal divide = BigDecimal.ZERO;
            //如果集合为空 value就为0
            if (entry.getValue().size() > 0) {
                divide = entry.getValue().stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(entry.getValue().size()), 2, RoundingMode.HALF_UP);
            }
            hashMap.put("time", entry.getKey() + ":00");
            hashMap.put("value", divide);
            mapList.add(hashMap);
        }

        return mapList;
    }

    /**
     * 数据完整性
     *
     * @param equipmentNo 设备编号
     * @return
     */
    public List<Map> dataIntegrity(String equipmentNo) {
        List list = new ArrayList();
        try {
            long yesterday = new Date().getTime() - 1000 * 60 * 60 * 24;
            Date endTime = DateTimeUtil.getDayLastTime(yesterday);
            //获取该塔的数据起止时间
            List<StatisticsSituation> statisticsSituationList = statisticsSituationService.list();
            List<StatisticsSituation> collectStatisticsSituationList = statisticsSituationList.stream().filter(s -> s.getEquipmentId().equals(equipmentNo)).collect(Collectors.toList());
            String[] startTimeAndEndTime = collectStatisticsSituationList.get(0).getStartTimeAndEndTime().split(",");
            Date startTime = DateTimeUtil.beginOfMonth(new Date(Long.parseLong(startTimeAndEndTime[0])));

            List<Entity> entities = prophaseWeatherDataMapper.selectCount(equipmentNo);
            Map<Object, Object> formatMap = new HashMap<>();
            for (Entity entity : entities) {
                // td engine 取出的时间需要截取字段
                String wstart = entity.get("_wstart").toString().substring(0,10);
                formatMap.put(wstart,entity.get("count(*)"));

            }
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM");
            SimpleDateFormat dayFormatter = new SimpleDateFormat("dd");
            //前一天
            Date nowDate = new Date(DateTimeUtil.getMillisecondsSubDay() - 1000);
            //当月第一天时间
            Date mouthOneDayTime = DateTimeUtil.beginOfMonth(DateTimeUtil.getCurrentTimeForMinute());
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            // 当天时间
            Date date = DateTimeUtil.getDayStartTime(new Date().getTime());
            // 循环月份的最终变量变量
            //int endMonthCount = 12;
            List<Long> interval = DateTimeUtil.getIntervalTimeByMonth(startTime, endTime);
            int endMonthCount = interval.size();
            //如果今天不是当月第一天，有今月得完整性
            if (date.compareTo(mouthOneDayTime) != 0) {
                //当月的完整性
                Map nowMouthMap = new HashMap();
                nowMouthMap.put("mouth", formatter.format(nowDate));

                for (Long i = mouthOneDayTime.getTime(); i <= nowDate.getTime(); i = i + 1000 * 60 * 60 * 24L) {
                    if (null != formatMap.get(format.format(i))) {
                        nowMouthMap.put(dayFormatter.format(new Date(i)), formatMap.get(format.format(i)));
                    } else {
                        nowMouthMap.put(dayFormatter.format(new Date(i)), 0);
                    }
                }
                list.add(nowMouthMap);
            } else {
                endMonthCount = interval.size() + 1;
            }
            for (int i = 1; i < endMonthCount; i++) {
                //前i月的第一天0点
                Date mouthOneDay = DateTimeUtil.getDayStartTime(DateTimeUtil.mouthOneDay(i).getTime());
                //前i月的最后一天的23:59:59
                Date mouthLastDay = DateTimeUtil.getDayLastTime(DateTimeUtil.mouthLastDay(i).getTime());
                Map map1 = new HashMap();
                map1.put("mouth", formatter.format(mouthOneDay));
                //查询整月的数据
                for (Long j = mouthOneDay.getTime(); j <= mouthLastDay.getTime(); j = j + 1000 * 60 * 60 * 24L) {
                    if (null != formatMap.get(format.format(j))) {
                        map1.put(dayFormatter.format(new Date(j)), formatMap.get(format.format(j)));
                    } else {
                        map1.put(dayFormatter.format(new Date(j)), 0);
                    }
                }
                list.add(map1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 获取风切变指数（风向玫瑰图）
     *
     * @param startTime
     * @param endTime
     * @param eqId
     * @param height
     */
    public List<Map<String, Object>> getWindShear(Long startTime, Long endTime, String eqId, String height) {
        List<Map<String, Object>> maps = windTowerDataParentTableService.selectDataByBetweenTimeAndEquipmetId(new Date(startTime), new Date(endTime), eqId);

        String[] heights = windTowerInfoService.getByEquipmentNo(eqId).get(0).getHeights().split(",");
        Integer heightMin = 100;
        String finalHeight = height;
        if (height.contains("A")) {
            finalHeight = height.substring(0, height.length() - 1);
        }
        // 找出最小层高
        for (String h : heights) {
            Integer tempHeight = null;
            // 若是此层高是第二同层高
            if (!h.contains("A")) {
                tempHeight = Integer.parseInt(h);
            } else {
                tempHeight = Integer.parseInt(h.substring(0, h.length() - 1));
            }
            if (tempHeight < heightMin) {
                heightMin = Integer.parseInt(h);
            }
        }
        BigDecimal zero = new BigDecimal(0);
        List<Map<String, Object>> list = new ArrayList<>();
        for (WindDirectionEnum value : WindDirectionEnum.values()) {
            Map<String, Object> map = new HashMap<>();

            List<Map<String, Object>> mapList = CalculationUtil.getForHeightAndWindDirectionEnum(maps, height, value);
            //获取平均风速
            BigDecimal avgWindSpeed = CalculationUtil.getAvgWind(CalculationUtil.getWsForHeight(mapList, height));

            BigDecimal avgWindSpeed10 = CalculationUtil.getAvgWind(CalculationUtil.getWsForHeight(mapList, heightMin.toString()));
            BigDecimal bigDecimal = new BigDecimal(-99);
            if (avgWindSpeed10.compareTo(BigDecimal.ZERO) != 0) {
                bigDecimal = CalculationUtil.caWindShear(avgWindSpeed, avgWindSpeed10, new BigDecimal(finalHeight), new BigDecimal(heightMin));
            }

            map.put(value.name(), bigDecimal.equals(new BigDecimal(-99)) ? zero : bigDecimal);

            list.add(map);
        }
        return list;

    }

    /**
     * 获取湍流（风向玫瑰图）
     *
     * @param startTime
     * @param endTime
     * @param eqId
     * @param height
     */
    public List<Map<String, Object>> getTurbulenceIntensity(Long startTime, Long endTime, String eqId, String height) {
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectWdAveAndWdAveAndWsStaForHeight(eqId, new Timestamp(startTime), new Timestamp(endTime), height);
        BigDecimal zero = new BigDecimal(0);
        List<Map<String, Object>> list = new ArrayList<>();
        for (WindDirectionEnum value : WindDirectionEnum.values()) {
            Map<String, Object> map = new HashMap<>();
            List<ProphaseAnemometryData> heightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(prophaseAnemometryDataList, value);
            //总风速
            double wsSum = heightAndWindDirectionEnum.stream().mapToDouble(ProphaseAnemometryData::getWsAve).sum();
            //总方差
            double wsSts = heightAndWindDirectionEnum.stream().mapToDouble(ProphaseAnemometryData::getWsSta).sum();
            BigDecimal wsAve = BigDecimal.ZERO;
            BigDecimal staAve = BigDecimal.ZERO;
            if (heightAndWindDirectionEnum.size() > 0) {
                //风速平均值
                wsAve = BigDecimal.valueOf(wsSum).divide(BigDecimal.valueOf(heightAndWindDirectionEnum.size()), 2, RoundingMode.HALF_UP);
                //方差平均值
                staAve = BigDecimal.valueOf(wsSts).divide(BigDecimal.valueOf(heightAndWindDirectionEnum.size()), 2, RoundingMode.HALF_UP);
            }

            BigDecimal bigDecimal = CalculationUtil.caTurbulenceIntensity(staAve, wsAve);

            map.put(value.name(), bigDecimal.equals(new BigDecimal(-99)) ? zero : bigDecimal);

            list.add(map);
        }
        return list;

    }

    /**
     * 获取风能密度（风向玫瑰图）
     *
     * @param startTime
     * @param endTime
     * @param eqId
     * @param height
     */
    public List<Map<String, Object>> getWindEnergyDensity(Long startTime, Long endTime, String eqId, String height) {
        //查询风速数据
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectWdAveAndWdAveAndWsStaForHeight(eqId, new Timestamp(startTime), new Timestamp(endTime), height);
        //查询空气密度
        List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectAir(eqId, new Timestamp(startTime), new Timestamp(endTime));

        List<Map<String, Object>> list = new ArrayList<>();
        for (WindDirectionEnum value : WindDirectionEnum.values()) {
            Map<String, Object> map = new HashMap<>();

            List<ProphaseAnemometryData> heightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(prophaseAnemometryDataList, value);
            BigDecimal wpdSum = BigDecimal.ZERO;
            for (ProphaseAnemometryData p : heightAndWindDirectionEnum) {
                List<ProphaseWeatherData> prophaseWeatherData = prophaseWeatherDataList.stream().filter(w -> w.getTs().getTime() == p.getTs().getTime()).collect(Collectors.toList());
                if(prophaseWeatherData.size() > 0 ){
                    wpdSum = wpdSum.add(BigDecimal.valueOf(prophaseWeatherData.get(0).getAirDensity()).multiply(BigDecimal.valueOf(0.5)).multiply(CalculationUtil.power(BigDecimal.valueOf(p.getWsAve()), 3)));
                }

            }
            if(prophaseWeatherDataList.size() > 0 ){
                BigDecimal wpdAve = wpdSum.divide(BigDecimal.valueOf(prophaseWeatherDataList.size()),2,RoundingMode.HALF_UP);
                map.put(value.name(), wpdAve);
                list.add(map);
            }
        }
        return list;

    }

    /**
     * 风向玫瑰图
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentId 设备编号
     * @param height      层高
     * @return
     * @throws Exception
     */
    public List queryCharts(Long startTime, Long endTime, String equipmentId, String height) {
        List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectWdAveForHeight(equipmentId, new Timestamp(startTime), new Timestamp(endTime), height);

        List list = new ArrayList();
        BigDecimal total = BigDecimal.ZERO;
        for (WindDirectionEnum value : WindDirectionEnum.values()) {
            Map<String, Object> map = new HashMap<>();
            //根据设备属性风向获取数据
            List<ProphaseAnemometryData> forHeightAndWindDirectionEnum = CalculationUtil.getForHeightAndWindDirectionEnum(prophaseAnemometryDataList, value);
            total = total.add(BigDecimal.valueOf(forHeightAndWindDirectionEnum.size()));
            if (forHeightAndWindDirectionEnum.size() > 0) {
                map.put(value.name(), BigDecimal.valueOf(100).multiply(BigDecimal.valueOf(forHeightAndWindDirectionEnum.size())).divide(BigDecimal.valueOf(prophaseAnemometryDataList.size()), 2, RoundingMode.HALF_UP));
            } else {
                map.put(value.name(), BigDecimal.ZERO);
            }
            list.add(map);
        }
        return list;
    }


}