neim/neim-biz/src/main/java/com/jiayue/biz/util/CalculationUtil.java

package com.jiayue.biz.util;

import cn.hutool.core.convert.Convert;
import com.jiayue.biz.domain.*;
import com.jiayue.biz.eunms.WindDirectionEnum;
import com.jiayue.common.utils.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateUtils;

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

@Slf4j
public class CalculationUtil {


    /**
     * 根据设备属性风向获取数据
     *
     * @param filterList 过滤出的风数据
     * @param height     属性名（层高）
     * @return
     */
    public static List<Map<String, Object>> getForHeightAndWindDirectionEnum(List<Map<String, Object>> filterList, String height, WindDirectionEnum windDirectionEnum) {
        List<Map<String, Object>> collect = new ArrayList<>();
        if (windDirectionEnum.name().equals("N")) {
            // N的范围为 348.75<wd<360 + 0<wd<11.25
            filterList.stream().filter(w -> w.get("wd_ave" + height) != null && (getBigDecimal(w.get("wd_ave" + height)).compareTo(windDirectionEnum.getLower()) >= 0 && getBigDecimal(w.get("wd_ave" + height)).compareTo(new BigDecimal(360)) <= 0) || (getBigDecimal(w.get("wd_ave" + height)).compareTo(windDirectionEnum.getUpper()) < 0 && getBigDecimal(w.get("wd_ave" + height)).compareTo(new BigDecimal(0)) > 0)).collect(Collectors.toList());
        } else {
            collect = filterList.stream().filter(w -> w.get("wd_ave" + height) != null && getBigDecimal(w.get("wd_ave" + height)).compareTo(windDirectionEnum.getLower()) >= 0 && getBigDecimal(w.get("wd_ave" + height)).compareTo(windDirectionEnum.getUpper()) < 0).collect(Collectors.toList());
        }
        return collect;
    }

    /**
     * 根据设备属性风向获取数据 Todo 新数据库格式
     *
     * @param List 过滤出的风数据
     * @return
     */
    public static List<ProphaseAnemometryData> getForHeightAndWindDirectionEnum(List<ProphaseAnemometryData> List, WindDirectionEnum windEnum) {
        List<ProphaseAnemometryData> collect = new ArrayList<>();
        if (windEnum.name().equals("N")) {
            // N的范围为 348.75<wd<360 + 0<wd<11.25
            collect = List.stream().filter(e -> e.getWdAve() != null).filter(w -> (getBigDecimal(w.getWdAve()).compareTo(windEnum.getLower()) >= 0 && getBigDecimal(w.getWdAve()).compareTo(new BigDecimal(360)) <= 0) || (getBigDecimal(w.getWdAve()).compareTo(windEnum.getUpper()) < 0 && getBigDecimal(w.getWdAve()).compareTo(new BigDecimal(0)) > 0)).collect(Collectors.toList());
        } else {
            collect = List.stream().filter(w -> w.getWdAve() != null && getBigDecimal(w.getWdAve()).compareTo(windEnum.getLower()) >= 0 && getBigDecimal(w.getWdAve()).compareTo(windEnum.getUpper()) < 0).collect(Collectors.toList());
        }
        return collect;
    }


    /**
     * 根据层高获取风速数据 todo 旧
     *
     * @param filterList 过滤出的风数据
     * @param fieldName  属性名（层高）
     * @return
     */
    public static List<BigDecimal> getWsForHeight(List<ProphaseAnemometryData> filterList, String fieldName) {
        return filterList.stream().filter(f -> f.getLayerHeight().equals(fieldName)).map(p -> {
            return new BigDecimal(p.getWsAve());
        }).collect(Collectors.toList());
    }


    /**
     * 计算平均风速
     *
     * @param bigDecimalList 风速数据
     * @return
     */
    public static BigDecimal getAvgWind(List<BigDecimal> bigDecimalList) {
        return new BigDecimal(bigDecimalList.stream().collect(Collectors.averagingDouble(BigDecimal::doubleValue))).setScale(2, RoundingMode.HALF_UP);
    }


    /**
     * 计算风能密度(风功率玫瑰图)
     *
     * @return 风能密度
     */
    public static BigDecimal windEnergyDensity(List<ProphaseAnemometryData> anemometryData, Map<String, ProphaseWeatherData> prophaseWeatherDataMap) {

        BigDecimal density = new BigDecimal(-99);
        try {
            if (anemometryData.size() != 0) {
                BigDecimal wpdSum = new BigDecimal(0);
                for (ProphaseAnemometryData anemometryDatum : anemometryData) {
                    ProphaseWeatherData prophaseWeatherData = prophaseWeatherDataMap.get(anemometryDatum.getTs().getTime() + "");

                    if (null != prophaseWeatherData) {
                        wpdSum = wpdSum.add(getWpdCalculate(getBigDecimal(prophaseWeatherData.getAirDensity()), getBigDecimal(anemometryDatum.getWsAve())));
                    }
                }
                density = wpdSum.divide(BigDecimal.valueOf(anemometryData.size()), 2, RoundingMode.HALF_UP);
            }
        } catch (Exception e) {
            log.error("计算风风能密度时发生错误:{}", e);
        } finally {
            return density;
        }
    }

    //计算风功率密度公式
    public static BigDecimal getWpdCalculate(BigDecimal airAve, BigDecimal wsAve) {
        return airAve.multiply(power(getBigDecimal(wsAve), 3)).multiply(BigDecimal.valueOf(0.5));
    }

    /**
     * @param x     参数
     * @param total 指数
     * @return x的total次方
     */
    public static BigDecimal power(BigDecimal x, Integer total) {
        BigDecimal power = x;
        for (int i = 1; i < total; i++) {
            power = power.multiply(x);
        }
        return power;
    }

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

    //获取字符串中数字 附带小数点
    public static String getNumberFromStringForDian(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) || str.charAt(i) == 46) {
                    String s = String.valueOf(str.charAt(i));
                    str2.append(s);
                }
            }
        }
        return str2.toString();
    }

    /**
     * 计算风切变指数
     *
     * @param v2 高度 Z2 的风速
     * @param v1 高度 Z1 的风速
     * @param z2 高度
     * @param z1 高度
     * @return 风切变指数
     */
    public static BigDecimal caWindShear(BigDecimal v2, BigDecimal v1, BigDecimal z2, BigDecimal z1) {

        v2 = v2.setScale(4, BigDecimal.ROUND_HALF_UP);
        z2 = z2.setScale(4, BigDecimal.ROUND_HALF_UP);
        BigDecimal result = new BigDecimal(-99);
        try {

            double v = v2.divide(v1, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
            double v3 = 0;
            if (v != 0) {
                v3 = Math.log10(v);
            }

            double z = z2.divide(z1, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
            double z3 = 0;
            if (z != 0) {
                z3 = Math.log10(z);
            }

            if (z3 != 0) {
                result = new BigDecimal(v3).divide(new BigDecimal(z3), 2, BigDecimal.ROUND_HALF_UP);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            return result;
        }

    }


    /**
     * 计算湍流强度
     *
     * @param wsSta 风速标准差
     * @param ws    风速
     * @return 湍流强度
     */
    public static BigDecimal caTurbulenceIntensity(BigDecimal wsSta, BigDecimal ws) {


        BigDecimal result = new BigDecimal(-99);
        try {
            if (ws.compareTo(new BigDecimal(0)) > 0) {
                result = wsSta.divide(ws, 2, BigDecimal.ROUND_HALF_UP);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            return result;
        }

    }


    /**
     * 封装逐小时数据集合
     *
     * @param awsList 数据
     * @return
     */
    public static List<BigDecimal> getData24(List<WindTowerCalculationData> awsList) {

        Long hour = 3600000L;

        Date systemDate = new Date();

        List<BigDecimal> results = new ArrayList<>();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
        //获取昨日开始和结束时间
        Long startTime = DateMomentUtil.getDayStartTime(DateUtils.addDays(systemDate, -1).getTime());
        Long endTime = startTime + 86399000;
        for (Long time = startTime; time <= endTime; time += hour) {


            Long finalTime = time;

            String format = simpleDateFormat.format(finalTime);
            List<BigDecimal> collect = awsList.stream().filter(s -> simpleDateFormat.format(s.getTime())
                            .equals(format) && s.getValue().compareTo(new BigDecimal(-99)) != 0)
                    .map(WindTowerCalculationData::getValue).collect(Collectors.toList());
            BigDecimal avg = BigDecimal.ZERO;
            if (collect.size() > 0) {
                avg = collect.stream().reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(collect.size()), 4, RoundingMode.HALF_UP);
            }

            results.add(avg);
        }

        return results;
    }


    /**
     * Object转BigDecimal类型
     *
     * @param value 要转的object类型
     * @return 转成的BigDecimal类型数据
     */
    public static BigDecimal getBigDecimal(Object value) {
        BigDecimal ret = null;
        if (value != null) {
            if (value instanceof BigDecimal) {
                ret = (BigDecimal) value;
            } else if (value instanceof String) {
                ret = new BigDecimal((String) value);
            } else if (value instanceof BigInteger) {
                ret = new BigDecimal((BigInteger) value);
            } else if (value instanceof Number) {
                ret = BigDecimal.valueOf(((Number) value).doubleValue());
            } else {
                throw new ClassCastException("不能将数据 [" + value + "] 从 " + value.getClass() + "类型转为BigDecimal类型.");
            }
        }
        return ret;
    }

    /**
     * 机型：WH6.25N-182
     *
     * @param ws 风速
     * @return 拟合功率 BigDecimal
     */
    public static BigDecimal getBattery(BigDecimal ws) {
        BigDecimal battery = new BigDecimal(0);
        if (ws.compareTo(BigDecimal.valueOf(3)) > 0 && ws.compareTo(BigDecimal.valueOf(12.5)) < 0) {
            //拟合功率 = (-9.066 * e^-5 * ws^8)+ (0.01055 * ws^7) - (0.5109 * ws^6) + (13.29 * ws^5) - (200.3 * ws^4) + (1755 * ws^3) - (8549 * ws^2) + (2.152 * e^4 * ws) - (2.153 * e^4)
            battery = (BigDecimal.valueOf(-9.006).multiply(BigDecimal.valueOf(Math.pow(10, -5)).multiply(CalculationUtil.power(ws, 8)))
                    .add(BigDecimal.valueOf(0.01055).multiply(CalculationUtil.power(ws, 7)))
                    .subtract(BigDecimal.valueOf(0.5109).multiply(CalculationUtil.power(ws, 6)))
                    .add(BigDecimal.valueOf(13.29).multiply(CalculationUtil.power(ws, 5)))
                    .subtract(BigDecimal.valueOf(200.3).multiply(CalculationUtil.power(ws, 4)))
                    .add(BigDecimal.valueOf(1755).multiply(CalculationUtil.power(ws, 3)))
                    .subtract(BigDecimal.valueOf(8549).multiply(CalculationUtil.power(ws, 2)))
                    .add(BigDecimal.valueOf(2.152).multiply(BigDecimal.valueOf(Math.pow(10, 4)).multiply(ws)))
                    .subtract(BigDecimal.valueOf(2.153).multiply(BigDecimal.valueOf(Math.pow(10, 4)))))
                    .setScale(4, RoundingMode.HALF_UP);
        } else if (ws.compareTo(BigDecimal.valueOf(12)) >= 0) {
            battery = BigDecimal.valueOf(6250);
        }
        //单个风速功率
        return battery;

    }

    /**
     * 机型：WH6.25N-182
     *
     * @param ws 风速
     * @return 拟合功率 BigDecimal
     */
    public static BigDecimal getBatteryDome(BigDecimal ws) {
        BigDecimal battery = new BigDecimal(0);
        if (ws.compareTo(BigDecimal.valueOf(3)) > 0 && ws.compareTo(BigDecimal.valueOf(12)) < 0) {
            //拟合功率 = (-9.066 * e^-5 * ws^8)+ (0.01055 * ws^7) - (0.5109 * ws^6) + (13.29 * ws^5) - (200.3 * ws^4) + (1755 * ws^3) - (8549 * ws^2) + (2.152 * e^4 * ws) - (2.153 * e^4)
            battery = BigDecimal.valueOf(0.7593).multiply(CalculationUtil.power(ws, 5))
                    .subtract(BigDecimal.valueOf(29.67).multiply(CalculationUtil.power(ws, 4)))
                    .add(BigDecimal.valueOf(421).multiply(CalculationUtil.power(ws, 3)))
                    .subtract(BigDecimal.valueOf(2646).multiply(CalculationUtil.power(ws, 2)))
                    .add(BigDecimal.valueOf(7918).multiply(ws))
                    .subtract(BigDecimal.valueOf(8948));
        } else if (ws.compareTo(BigDecimal.valueOf(12)) >= 0 && ws.compareTo(BigDecimal.valueOf(18)) <= 0) {
            battery = BigDecimal.valueOf(6250);
        }
        //单个风速功率
        return battery;

    }

    /**
     * 计算威布尔值
     *
     * @param e e
     * @param d 风速
     * @param K K
     * @param A A
     * @return weibull
     */
    public static BigDecimal getBigDecimal(double e, double d, double K, double A) {

        BigDecimal value = BigDecimal.ZERO;
        //e的-(U/K)次方的K次方
        if (A != 0.0 && K != 0.0) {
            // U/A
            BigDecimal UAK1 = BigDecimal.valueOf(d).divide(BigDecimal.valueOf(A), 4, RoundingMode.HALF_UP);
            double UAK2 = UAK1.doubleValue();
            //U/A 的k次方
            double UAK = Math.pow(UAK2, K);
            //e的负 UAK次方
            double EUAK = Math.pow(e, -UAK);
            //K/A
            BigDecimal KA = BigDecimal.valueOf(K).divide(BigDecimal.valueOf(A), 4, RoundingMode.HALF_UP);
            BigDecimal UA1 = BigDecimal.valueOf(d).divide(BigDecimal.valueOf(A), 4, RoundingMode.HALF_UP);
            double v = UA1.doubleValue();
            double pow = Math.pow(v, (K - 1));
            BigDecimal pow1 = BigDecimal.valueOf(pow).multiply(BigDecimal.valueOf(EUAK));
            value = pow1.multiply(KA).setScale(4, BigDecimal.ROUND_HALF_UP);

        }


        return value;
    }

    /**
     * 计算综合风切变
     */

    public static BigDecimal getWindShear(List<ProphaseAnemometryData> prophaseAnemometryData, String[] heights) {
        BigDecimal sumWShear = BigDecimal.ZERO;
        BigDecimal total = BigDecimal.ZERO;

        for (String maxHeight : heights) {
            if (maxHeight.contains("A")) {
                continue;
            }
            BigDecimal wsAveForMax = new BigDecimal(prophaseAnemometryData.stream().filter(p -> p.getLayerHeight().equals(maxHeight)).map(p -> {
                return getBigDecimal(p.getWsAve());
            }).collect(Collectors.averagingDouble(BigDecimal::doubleValue))).setScale(8, RoundingMode.HALF_UP);
            //筛选低层高
            List<String> heightList = new ArrayList<>(Arrays.asList(heights)).stream()
                    .filter(s -> Integer.valueOf(CalculationUtil.getNumberFromString(maxHeight)) > Integer.valueOf(CalculationUtil.getNumberFromString(s))).collect(Collectors.toList());
            //计算风切变
            for (String minHeight : heightList) {
                if (minHeight.contains("A")) {
                    continue;
                }
                //计算平均风速
                BigDecimal wsAveMin = new BigDecimal(prophaseAnemometryData.stream().filter(p -> p.getLayerHeight().equals(minHeight)).map(p -> {
                    return getBigDecimal(p.getWsAve());
                }).collect(Collectors.averagingDouble(BigDecimal::doubleValue))).setScale(8, RoundingMode.HALF_UP);

                double z = new BigDecimal(getNumberFromString(maxHeight)).divide(new BigDecimal(getNumberFromString(minHeight)), 8, RoundingMode.HALF_UP).doubleValue();
                //计算log 层高
                double z1 = Math.log10(z);
                if (wsAveForMax.compareTo(BigDecimal.ZERO) > 0 && wsAveMin.compareTo(BigDecimal.ZERO) > 0 && z1 != 0) {
                    BigDecimal shear = Convert.toBigDecimal(Math.log10(Convert.toDouble(wsAveForMax.divide(wsAveMin, 8, RoundingMode.HALF_UP))))
                            .divide(BigDecimal.valueOf(z1), 8, RoundingMode.HALF_UP);
                    sumWShear = sumWShear.add(shear);
                    total = total.add(BigDecimal.ONE);

                }
            }
        }

        if (total.compareTo(BigDecimal.ZERO) != 0) {
            sumWShear = sumWShear.divide(total, 4, RoundingMode.HALF_UP);
        }
        return sumWShear;
    }

    //测风塔mysql与mongo转换
    public static List<Equipment> getEquipment(List<WindTowerInfo> windTowerInfoList, String equipmentStr) {
        List<Equipment> equipmentList = new ArrayList<>();
        String[] equipmentArr = equipmentStr.split(",");
        for (String equipmentName : equipmentArr) {
            List<WindTowerInfo> collect = windTowerInfoList.stream().filter(w -> w.getName().equals(equipmentName) || w.getEquipmentNo().equals(CalculationUtil.getNumberFromString(equipmentName))).collect(Collectors.toList());
            if (collect.size() > 0) {
                WindTowerInfo windTowerInfo = collect.get(0);
                Equipment equipment = new Equipment();
                equipment.setEquipmentNo(windTowerInfo.getEquipmentNo());
                equipment.setId(windTowerInfo.getId());
                equipment.setLatitude(windTowerInfo.getLatitude().toString());
                equipment.setLongitude(windTowerInfo.getLongitude().toString());
                equipment.setAltitude(windTowerInfo.getAltitude());
                equipment.setHeights(windTowerInfo.getHeights());
                equipment.setDisplayHeight(windTowerInfo.getDisplayHeight());
                equipment.setInstallationTime(windTowerInfo.getInstallationTime() != null ? DateUtil.format(windTowerInfo.getInstallationTime(), "yyyy-MM-dd") : "");
                equipment.setManufacturer(windTowerInfo.getManufacturer());
                equipment.setModelNumber(windTowerInfo.getModelNumber());
                equipment.setWdHeights(windTowerInfo.getWdHeights());
                equipment.setType(windTowerInfo.getType());
                equipment.setStatus(windTowerInfo.getStatus());
                equipment.setPassword(windTowerInfo.getPassword());
                equipment.setName(windTowerInfo.getName());
                equipment.setRecorderNo(windTowerInfo.getRecorderNo());
                equipment.setTerrainComplexity(windTowerInfo.getTerrainComplexity());
                equipmentList.add(equipment);
            }
        }
        return equipmentList;

    }

}